agentwire-dev 1.40.0__tar.gz → 1.42.0__tar.gz

{agentwire_dev-1.40.0 → agentwire_dev-1.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.40.0
+Version: 1.42.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.40.0 → agentwire_dev-1.42.0}/agentwire/__init__.py

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

{agentwire_dev-1.40.0 → agentwire_dev-1.42.0}/agentwire/__main__.py

@@ -103,6 +103,31 @@ class AgentCommand:
     env: dict[str, str] = field(default_factory=dict)  # Secrets to inject via tmux set-environment (keeps keys out of `ps`)
 
 
+_UNATTENDED_ENV_KEYS = ("AGENTWIRE_UNATTENDED", "AGENTWIRE_UNATTENDED_ALLOW")
+
+
+def _with_unattended_env(env: dict[str, str]) -> dict[str, str]:
+    """Propagate the unattended marker into a session being created.
+
+    The scheduler is the single place that decides a dispatch is unattended —
+    it seeds ``AGENTWIRE_UNATTENDED[=1]`` (and any per-task
+    ``AGENTWIRE_UNATTENDED_ALLOW``) into the dispatch subprocess environment.
+    Every session-creation path funnels its env through here on the way to
+    ``tmux new-session -e K=V``, so the marker lands in the new session BEFORE
+    the agent launches and the damage-control hook can read it. A child session
+    an unattended agent spawns inherits the marker too (defense in depth).
+
+    No leak into interactive sessions: a human's ``agentwire new`` has no such
+    var in its environment, so nothing is propagated.
+    """
+    merged = dict(env)
+    for key in _UNATTENDED_ENV_KEYS:
+        val = os.environ.get(key)
+        if val and key not in merged:
+            merged[key] = val
+    return merged
+
+
 def _build_tmux_env_flags(env: dict[str, str]) -> list[str]:
     """Build `-e KEY=VAL` flag pairs for `tmux new-session`.
 
@@ -114,16 +139,17 @@ def _build_tmux_env_flags(env: dict[str, str]) -> list[str]:
     the var — and the agent command runs in that initial shell.
     """
     flags: list[str] = []
-    for key, value in env.items():
+    for key, value in _with_unattended_env(env).items():
         flags.extend(["-e", f"{key}={value}"])
     return flags
 
 
 def _build_tmux_env_flags_shell(env: dict[str, str]) -> str:
     """Shell-quoted `-e 'K=V' …` fragment for inlining via SSH. Trailing space when non-empty."""
-    if not env:
+    merged = _with_unattended_env(env)
+    if not merged:
         return ""
-    parts = [f"-e {shlex.quote(f'{k}={v}')}" for k, v in env.items()]
+    parts = [f"-e {shlex.quote(f'{k}={v}')}" for k, v in merged.items()]
     return " ".join(parts) + " "
 
 
@@ -543,6 +569,12 @@ def get_stt_session_name() -> str:
     return config.get("services", {}).get("stt", {}).get("session_name", "agentwire-stt")
 
 
+def get_kokoro_session_name() -> str:
+    """Get default-tier Kokoro TTS shim tmux session name from config."""
+    config = load_config()
+    return config.get("services", {}).get("kokoro", {}).get("session_name", "agentwire-kokoro")
+
+
 # === Wave 2: Remote Infrastructure Helpers ===
 
 
@@ -1929,6 +1961,148 @@ def cmd_stt_status(args) -> int:
     return 1
 
 
+# === Kokoro (default-tier TTS shim) Commands ===
+
+def cmd_kokoro_start(args) -> int:
+    """Start the default-tier Kokoro TTS shim in tmux (idempotent).
+
+    Mirrors ``agentwire stt start``: the portal's ``ensure_managed_tts`` calls
+    this on startup, and the early-return on an existing session means a
+    user-started shim is reused with no port clash."""
+    session_name = get_kokoro_session_name()
+
+    if tmux_session_exists(session_name):
+        print(f"Kokoro TTS shim already running in tmux session '{session_name}'")
+        print(f"  Attach: tmux attach -t {session_name}")
+        return 0
+
+    port = args.port or 8102
+    host = args.host or "0.0.0.0"
+
+    # Find agentwire source directory (for running from source venv)
+    source_dir = get_source_dir()
+    if not (source_dir / ".venv" / "bin" / "python").exists():
+        print("Error: Cannot find agentwire source directory with .venv", file=sys.stderr)
+        print(f"Configure dev.source_dir in ~/.agentwire/config.yaml (current: {source_dir})", file=sys.stderr)
+        return 1
+    agentwire_dir = source_dir
+
+    python_path = agentwire_dir / ".venv" / "bin" / "python"
+    cmd = f"cd {agentwire_dir} && KOKORO_PORT={port} KOKORO_HOST={host} {python_path} -m agentwire.tts.kokoro_server"
+
+    subprocess.run([
+        "tmux", "new-session", "-d", "-s", session_name, "-c", str(agentwire_dir)
+    ], check=True)
+
+    subprocess.run([
+        "tmux", "send-keys", "-t", session_name, cmd, "Enter"
+    ], check=True)
+
+    print(f"Kokoro TTS shim starting in tmux session '{session_name}'")
+    print(f"  Port: {port}")
+    print(f"  Attach: tmux attach -t {session_name}")
+    return 0
+
+
+def cmd_kokoro_serve(args) -> int:
+    """Run the Kokoro TTS shim directly (foreground)."""
+    import uvicorn
+
+    port = args.port or 8102
+    host = args.host or "0.0.0.0"
+
+    os.environ["KOKORO_PORT"] = str(port)
+    os.environ["KOKORO_HOST"] = host
+
+    print(f"Starting Kokoro TTS shim on {host}:{port}...")
+    uvicorn.run(
+        "agentwire.tts.kokoro_server:app",
+        host=host,
+        port=port,
+        log_level="info",
+    )
+    return 0
+
+
+def cmd_kokoro_stop(args) -> int:
+    """Stop the Kokoro TTS shim."""
+    session_name = get_kokoro_session_name()
+
+    if not tmux_session_exists(session_name):
+        print("Kokoro TTS shim is not running.")
+        return 1
+
+    subprocess.run(["tmux", "kill-session", "-t", session_name])
+    print("Kokoro TTS shim stopped.")
+    return 0
+
+
+def cmd_kokoro_status(args) -> int:
+    """Check Kokoro TTS shim status."""
+    json_mode = getattr(args, 'json', False)
+    session_name = get_kokoro_session_name()
+    config = load_config()
+    kokoro_url = config.get("tts", {}).get("url") or "http://localhost:8102"
+
+    probe_error = None
+    try:
+        req = urllib.request.Request(f"{kokoro_url}/health")
+        with urllib.request.urlopen(req, timeout=3) as resp:
+            data = json.loads(resp.read().decode())
+            if json_mode:
+                _output_json({
+                    "success": True,
+                    "running": True,
+                    "url": kokoro_url,
+                    "healthy": data.get("status") == "ok",
+                    "status": data.get("status", "unknown"),
+                    "percent": data.get("percent", 0),
+                    "session": session_name if tmux_session_exists(session_name) else None,
+                })
+            else:
+                print("Kokoro TTS shim is running")
+                print(f"  State: {data.get('status', 'unknown')} ({data.get('percent', 0)}%)")
+                print(f"  URL: {kokoro_url}")
+                if tmux_session_exists(session_name):
+                    print(f"  Attach: tmux attach -t {session_name}")
+            return 0
+    except Exception as e:
+        probe_error = _describe_probe_error(e)
+
+    if tmux_session_exists(session_name):
+        if json_mode:
+            _output_json({
+                "success": True,
+                "running": True,
+                "url": kokoro_url,
+                "healthy": False,
+                "error": probe_error,
+                "session": session_name,
+                "starting": True,
+            })
+        else:
+            print(f"Kokoro TTS shim is starting in tmux session '{session_name}'")
+            if probe_error:
+                print(f"  Probe: {probe_error}")
+            print(f"  Attach: tmux attach -t {session_name}")
+        return 0
+
+    if json_mode:
+        _output_json({
+            "success": True,
+            "running": False,
+            "url": kokoro_url,
+            "healthy": False,
+            "error": probe_error,
+        })
+    else:
+        print("Kokoro TTS shim is not running.")
+        if probe_error:
+            print(f"  Probe: {probe_error}")
+        print("  Start: agentwire kokoro start")
+    return 1
+
+
 # === Telegram Commands ===
 
 
@@ -6830,6 +7004,15 @@ def cmd_safety_status(args) -> int:
     return cli_safety.safety_status_cmd()
 
 
+def cmd_safety_notify_unattended_block(args) -> int:
+    """CLI command: agentwire safety notify-unattended-block (hook-invoked)"""
+    return cli_safety.safety_notify_unattended_block_cmd(
+        getattr(args, "reason", "") or "",
+        getattr(args, "rule_id", "") or "",
+        getattr(args, "command", "") or "",
+    )
+
+
 def cmd_safety_logs(args) -> int:
     """CLI command: agentwire safety logs"""
     tail = getattr(args, 'tail', None)
@@ -6854,6 +7037,29 @@ def cmd_safety_tooldefs_show(args) -> int:
     return cli_safety.safety_tooldefs_show_cmd(args.tool)
 
 
+def _render_voice_loop_section(config, ctx) -> int:
+    """Print the voice-loop (push-to-talk) preflight. Returns failures found.
+
+    Read-only pass/fail per stage with an actionable fix line when red — the
+    existing infra sections keep the auto-fix prompts.
+    """
+    from .doctor_voice import run_voice_loop_checks
+
+    print("\nChecking voice loop (push-to-talk)...")
+    failures = 0
+    for stage in run_voice_loop_checks(config, ctx):
+        if stage.status == "ok":
+            print(f"  [ok] {stage.name}: {stage.detail}")
+        elif stage.status == "info":
+            print(f"  [..] {stage.name}: {stage.detail}")
+        else:
+            print(f"  [!!] {stage.name}: {stage.detail}")
+            for fix in stage.fixes:
+                print(f"       Fix: {fix}")
+            failures += 1
+    return failures
+
+
 def cmd_doctor(args) -> int:
     """Auto-diagnose and fix common issues."""
     from .network import NetworkContext
@@ -6862,6 +7068,7 @@ def cmd_doctor(args) -> int:
 
     dry_run = getattr(args, 'dry_run', False)
     auto_confirm = getattr(args, 'yes', False)
+    voice_only = getattr(args, 'voice', False)
 
     print("AgentWire Doctor")
     print("=" * 60)
@@ -6869,6 +7076,27 @@ def cmd_doctor(args) -> int:
     issues_found = 0
     issues_fixed = 0
 
+    # --voice: run ONLY the end-to-end push-to-talk preflight (fast, no SSH
+    # waits) — for tight first-run / break-a-dependency verification loops.
+    if voice_only:
+        try:
+            from .config import load_config as load_config_typed
+            config = load_config_typed()
+        except Exception as e:
+            print(f"\n  [!!] Config file error: {e}")
+            print("     Run: agentwire init")
+            return 1
+        try:
+            ctx = NetworkContext.from_config()
+        except Exception:
+            ctx = None
+        issues_found = _render_voice_loop_section(config, ctx)
+        print()
+        print("-" * 60)
+        print("Voice loop ready!" if issues_found == 0
+              else f"Voice loop: {issues_found} stage(s) need attention")
+        return 0 if issues_found == 0 else 1
+
     # 1. Check Python version
     print("\nChecking Python version...")
     py_version = sys.version_info
@@ -7158,34 +7386,12 @@ def cmd_doctor(args) -> int:
             else:
                 print(f"     -> Service is remote, start it on {service_config.machine}")
 
-    # 8b. Check STT shim. STT isn't a `services.*` entry — it's configured via
-    # `stt.url`, so the loop above can't see it. Without this check, a crashed
-    # STT shim is invisible and every custom-tier push-to-talk fails at request
-    # time. Probe it explicitly. (Default tier transcribes in the browser — no
-    # service to check.)
-    stt_cfg = getattr(ctx.config, "stt", None)
-    if getattr(stt_cfg, "backend", "default") == "custom":
-        from agentwire.stt.server_backend import STTServerBackend
-
-        stt_url = stt_cfg.url
-        if STTServerBackend.is_available(stt_url):
-            print(f"  [ok] Stt: responding on {stt_url}")
-        else:
-            print(f"  [!!] Stt: not responding on {stt_url}")
-            print("       Custom-tier push-to-talk will fail until it's back.")
-            print("       Fix: agentwire stt start")
-            print("       If it won't boot: uv pip install --python .venv/bin/python -e '.[stt]'")
-            issues_found += 1
-    elif getattr(stt_cfg, "backend", "default") == "cloud":
-        cloud_cfg = getattr(stt_cfg, "cloud", None) or {}
-        key_env = cloud_cfg.get("api_key_env", "OPENAI_API_KEY")
-        if os.environ.get(key_env):
-            print(f"  [ok] Stt: cloud tier ({key_env} is set)")
-        else:
-            print(f"  [!!] Stt: cloud tier but {key_env} is not set")
-            print("       The portal will refuse to start until the key is in its environment.")
-            print("       Fix: add the key to ~/.agentwire/.env (docs/wiki/security/secrets.md)")
-            issues_found += 1
+    # 8b. Voice loop (push-to-talk) — walk the live PTT path end to end and
+    # report each stage pass/fail with a fix line when red: mic/audio capture,
+    # the STT shim (incl. the default-tier Moonshine :8101 shim, invisible to
+    # the services loop), portal/tunnel reachability, and tmux+PTT wiring. This
+    # subsumes the old standalone STT probe — the STT stage covers all tiers.
+    issues_found += _render_voice_loop_section(config, ctx)
 
     # 8c. Secrets — for each configured feature that needs a key, report
     # whether its env var is present. Names only, never values. Keys live in
@@ -10767,6 +10973,33 @@ def main() -> int:
     stt_status.add_argument("--json", action="store_true", help="Output JSON")
     stt_status.set_defaults(func=cmd_stt_status)
 
+    # === kokoro command group (default-tier TTS shim) ===
+    kokoro_parser = subparsers.add_parser(
+        "kokoro", help="Manage the default-tier Kokoro TTS shim (process-isolated)"
+    )
+    kokoro_subparsers = kokoro_parser.add_subparsers(dest="kokoro_command")
+
+    # kokoro start
+    kokoro_start = kokoro_subparsers.add_parser("start", help="Start Kokoro shim in tmux")
+    kokoro_start.add_argument("--port", type=int, help="Server port (default: 8102)")
+    kokoro_start.add_argument("--host", type=str, help="Server host (default: 0.0.0.0)")
+    kokoro_start.set_defaults(func=cmd_kokoro_start)
+
+    # kokoro serve
+    kokoro_serve = kokoro_subparsers.add_parser("serve", help="Run Kokoro shim in foreground")
+    kokoro_serve.add_argument("--port", type=int, help="Server port (default: 8102)")
+    kokoro_serve.add_argument("--host", type=str, help="Server host (default: 0.0.0.0)")
+    kokoro_serve.set_defaults(func=cmd_kokoro_serve)
+
+    # kokoro stop
+    kokoro_stop = kokoro_subparsers.add_parser("stop", help="Stop Kokoro shim")
+    kokoro_stop.set_defaults(func=cmd_kokoro_stop)
+
+    # kokoro status
+    kokoro_status = kokoro_subparsers.add_parser("status", help="Check Kokoro shim status")
+    kokoro_status.add_argument("--json", action="store_true", help="Output JSON")
+    kokoro_status.set_defaults(func=cmd_kokoro_status)
+
     # === quo command ===
     from agentwire.channels.quo import cmd_quo
     quo_parser = subparsers.add_parser("quo", help="Send SMS via Quo (OpenPhone)")
@@ -11357,6 +11590,16 @@ def main() -> int:
     )
     safety_status.set_defaults(func=cmd_safety_status)
 
+    # safety notify-unattended-block (hook-invoked, not for humans)
+    safety_notify = safety_subparsers.add_parser(
+        "notify-unattended-block",
+        help="Email the owner that an unattended action was blocked (hook-internal)",
+    )
+    safety_notify.add_argument("--reason", default="", help="Why the command was blocked")
+    safety_notify.add_argument("--rule-id", dest="rule_id", default="", help="Matched rule id")
+    safety_notify.add_argument("--command", default="", help="The blocked command")
+    safety_notify.set_defaults(func=cmd_safety_notify_unattended_block)
+
     # safety logs
     safety_logs = safety_subparsers.add_parser(
         "logs", help="Query audit logs"
@@ -11406,6 +11649,10 @@ def main() -> int:
         "-y", "--yes", action="store_true",
         help="Auto-confirm all fixes without prompting"
     )
+    doctor_parser.add_argument(
+        "--voice", action="store_true",
+        help="Run only the voice loop (push-to-talk) preflight — fast, no SSH waits"
+    )
     doctor_parser.set_defaults(func=cmd_doctor)
 
     # === generate-certs (top-level shortcut) ===

{agentwire_dev-1.40.0 → agentwire_dev-1.42.0}/agentwire/cli_safety.py

@@ -8,6 +8,7 @@ stay in sync.
 """
 
 import json
+import os
 import shutil
 import sys
 from datetime import datetime
@@ -342,6 +343,48 @@ def safety_status_cmd() -> int:
     return 0
 
 
+def safety_notify_unattended_block_cmd(
+    reason: str, rule_id: str, command: str
+) -> int:
+    """CLI command: ``agentwire safety notify-unattended-block``.
+
+    Invoked fire-and-forget by the bash damage-control hook when an
+    unattended (scheduler) run hits an ``ask``-tier command that isn't on the
+    allowlist. Emails the owner via the shared Resend wiring so the blocked
+    action surfaces immediately instead of silently disappearing.
+    """
+    session = os.environ.get("AGENTWIRE_SESSION_NAME") or os.environ.get(
+        "AGENTWIRE_SESSION_ID", "unknown"
+    )
+    cwd = os.environ.get("PWD", "")
+    subject = f"[agentwire] Unattended action blocked: {reason[:80]}"
+    body = (
+        f"An unattended (scheduled) agent attempted an action that requires "
+        f"human confirmation, so it was **blocked** (fail-closed).\n\n"
+        f"- **Session:** {session}\n"
+        f"- **Working dir:** {cwd or 'unknown'}\n"
+        f"- **Rule:** {rule_id or 'unknown'}\n"
+        f"- **Reason:** {reason}\n"
+        f"- **Command:** `{command}`\n"
+        f"- **When:** {datetime.now().isoformat(timespec='seconds')}\n\n"
+        f"Nothing was executed. To permit this specific action for the task in "
+        f"future, add rule id `{rule_id}` to that task's `unattended_allow` in "
+        f"its `.agentwire.yml` (or to `safety.unattended_allow` globally)."
+    )
+    try:
+        from agentwire.channels.email import send_email
+
+        result = send_email(subject=subject, body=body)
+        if getattr(result, "success", False):
+            return 0
+        print(f"notify-unattended-block: email failed: "
+              f"{getattr(result, 'error', 'unknown')}", file=sys.stderr)
+        return 1
+    except Exception as e:  # email not configured, etc. — never crash the notifier
+        print(f"notify-unattended-block: {e}", file=sys.stderr)
+        return 1
+
+
 def safety_logs_cmd(
     tail: Optional[int] = None,
     session: Optional[str] = None,

{agentwire_dev-1.40.0 → agentwire_dev-1.42.0}/agentwire/config.py

@@ -164,13 +164,20 @@ def _validate_voice_backend(
 class TTSConfig:
     """Text-to-speech configuration.
 
-    Two tiers: ``default`` speaks via the browser (speechSynthesis) with an
-    OS-voice fallback when no browser is connected; ``custom`` POSTs to any
-    HTTP shim implementing the contract (docs/wiki/voice/shim-contract.md).
+    Two tiers: ``default`` speaks via Kokoro running in the portal-managed shim
+    **subprocess** (tmux ``agentwire-kokoro``, default ``:8102``) — the portal
+    ensures it's running on startup and talks to it over HTTP, with process
+    isolation keeping the ~200 MB download + ONNX warm-up off the event loop
+    (#398, mirroring the STT shim). Browser speechSynthesis (and an OS-voice
+    fallback when no browser is connected) covers speech while the model loads
+    or when Kokoro can't load (py3.14+). For this tier ``url`` is optional and
+    resolves to ``http://localhost:8102``; if an operator overrides the shim
+    port (``KOKORO_PORT``) or ``url``, the two must agree. ``custom`` POSTs to
+    any HTTP shim implementing the contract (docs/wiki/voice/shim-contract.md).
     """
 
     backend: str = "default"  # default | custom
-    url: str | None = None  # shim URL (required for custom backend)
+    url: str | None = None  # shim URL (required for custom; optional override for default :8102)
     default_voice: str = "default"
     voices_dir: Path = field(default_factory=lambda: Path.home() / ".agentwire" / "voices")
     # Session-default knobs; sent to custom shims inside `options`

{agentwire_dev-1.40.0 → agentwire_dev-1.42.0}/agentwire/council/state.py

@@ -69,6 +69,11 @@ def sitting_path(name: str) -> Path:
     return council_dir(name) / "sitting.json"
 
 
+def archive_path(name: str) -> Path:
+    """Preserved record of a dismissed sitting (kept so threads stay browsable)."""
+    return council_dir(name) / "archive.json"
+
+
 def workspace_dir(name: str) -> Path:
     return council_dir(name) / "workspace"
 
@@ -195,13 +200,62 @@ def write_sitting(name: str, sitting: Sitting) -> None:
 
 
 def clear_sitting(name: str) -> None:
-    """End the sitting. Prompt history under ``prompts/`` is kept."""
+    """End the sitting. A thread that deliberated something is preserved to
+    ``archive.json`` (so it stays browsable/re-askable from the UI), and the
+    ``prompts/`` history is kept; only the live ``sitting.json`` is removed."""
+    sitting = read_sitting(name)
+    if sitting is not None and prompts_dir(name).is_dir():
+        data = sitting.to_dict()
+        data["dismissed_at"] = now_iso()
+        try:
+            _atomic_write(archive_path(name), data)
+        except OSError:
+            pass
     try:
         sitting_path(name).unlink()
     except FileNotFoundError:
         pass
 
 
+def read_archive_dict(name: str) -> dict | None:
+    """Raw archive record (incl. ``dismissed_at``), or None if not archived."""
+    path = archive_path(name)
+    if not path.exists():
+        return None
+    try:
+        with open(path) as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def read_archived(name: str) -> Sitting | None:
+    """The preserved record of a dismissed sitting as a ``Sitting``, or None."""
+    data = read_archive_dict(name)
+    return Sitting.from_dict(data) if data is not None else None
+
+
+def _has_rounds(name: str) -> bool:
+    pdir = prompts_dir(name)
+    if not pdir.is_dir():
+        return False
+    return any(p.is_dir() and p.name.isdigit() for p in pdir.iterdir())
+
+
+def list_archive() -> list[str]:
+    """Dismissed threads: have prompt history but no live ``sitting.json``."""
+    if not COUNCIL_ROOT.is_dir():
+        return []
+    out = []
+    for child in COUNCIL_ROOT.iterdir():
+        if not child.is_dir() or (child / "sitting.json").exists():
+            continue  # absent or still live
+        if _has_rounds(child.name):
+            out.append(child.name)
+    return out
+
+
 def allocate_prompt_id(name: str) -> int:
     """Bump and persist the sitting's prompt counter; return the new id.
 

{agentwire_dev-1.40.0 → agentwire_dev-1.42.0}/agentwire/council/view.py

@@ -143,13 +143,31 @@ def snapshot(
     the sitting ``name``; the per-prompt ``meta.json.roster`` (falling back to
     the sitting roster) fixes both soul order and grid size — nothing is
     hardcoded to a roster of six.
+
+    The thread artifact outlives the compute: a dismissed sitting (no live
+    ``sitting.json``) is still a fully readable thread, derived from the
+    preserved ``archive.json`` or, failing that, reconstructed from the
+    ``prompts/`` tree. ``archived`` flags which case the caller is looking at.
     """
     sitting = state.read_sitting(name)
+    archived = sitting is None
     if sitting is None:
-        return None
-
+        sitting = state.read_archived(name)
+    if sitting is None:
+        if not available_prompt_ids(name):
+            return None
+        sitting = state.Sitting(
+            orchestrator=state.orchestrator_for(name),
+            roster=[],
+            sessions={},
+            started_at="",
+        )
+
+    # available_prompt_ids (disk-derived) works for live and archived alike —
+    # the sitting.json prompt counter is gone once dismissed.
     if prompt_id is None:
-        prompt_id = state.latest_prompt_id(name)
+        ids = available_prompt_ids(name)
+        prompt_id = ids[-1] if ids else None
 
     dead_souls = dead_souls or set()
 
@@ -178,6 +196,7 @@ def snapshot(
         "tiles": tiles,
         "total": len(tiles),
         "final": final,
+        "archived": archived,
     }