duet-cli 0.2.6__tar.gz → 0.2.7__tar.gz

{duet_cli-0.2.6/duet_cli.egg-info → duet_cli-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duet-cli
-Version: 0.2.6
+Version: 0.2.7
 Summary: Two CLI agents in conversation. One Python file. Stdlib only.
 Author: Volkan Altan
 License-Expression: MIT
@@ -166,6 +166,8 @@ duet --reasoning high --codex-fast \
     --task "Fix the issue" --cwd ~/workspace/project
 ```
 
+Use `--no-codex-fast` to override a config or continued run that enabled it.
+
 **Verify gate** — a convergence proposal only counts if `make test` exits 0;
 any failure feeds back into the next turn:
 

{duet_cli-0.2.6 → duet_cli-0.2.7}/README.md

@@ -145,6 +145,8 @@ duet --reasoning high --codex-fast \
     --task "Fix the issue" --cwd ~/workspace/project
 ```
 
+Use `--no-codex-fast` to override a config or continued run that enabled it.
+
 **Verify gate** — a convergence proposal only counts if `make test` exits 0;
 any failure feeds back into the next turn:
 

{duet_cli-0.2.6 → duet_cli-0.2.7}/duet.py

@@ -58,16 +58,22 @@ import sys
 import textwrap
 import threading
 import time
+import traceback
 from typing import Callable, Optional
 
 # ---------- defaults ----------
 
 DEFAULT_SENTINEL = "<<<LGTM>>>"
+DEFAULT_SANDBOX = "workspace-write"
+DEFAULT_PERMISSION_MODE = "acceptEdits"
+SAFE_CONTINUE_SANDBOXES = {"read-only", DEFAULT_SANDBOX}
+SAFE_CONTINUE_PERMISSION_MODES = {"default", DEFAULT_PERMISSION_MODE, "plan"}
 DEFAULT_TURNS = 2
 DEFAULT_TIMEOUT = 60 * 15
 TASK_MAX_CHARS = 512 * 1024
 CONVERGENCE_RATIONALE_MIN_CHARS = 20
 VERIFY_OUTPUT_TAIL_CHARS = 4000
+AGENT_ERROR_TRANSCRIPT_MAX_CHARS = 12_000
 VERIFY_LIVE_PREFIX = "  │ [verify] "
 WORKTREE_FOR_CHOICES = {"lead", "partner"}
 FINISHED_CONVERGED = "converged"
@@ -317,8 +323,8 @@ class DuetConfig:
     sentinel: str = DEFAULT_SENTINEL
     per_turn_timeout: int = DEFAULT_TIMEOUT
     runs_dir: pathlib.Path = pathlib.Path("runs")
-    sandbox: str = "workspace-write"          # codex
-    permission_mode: str = "acceptEdits"      # claude/gemini
+    sandbox: str = DEFAULT_SANDBOX            # codex
+    permission_mode: str = DEFAULT_PERMISSION_MODE  # claude/gemini
     dry_run: bool = False
     recap: bool = False
     verify_cmd: Optional[str] = None          # shell command that must pass before
@@ -514,7 +520,8 @@ def is_git_repo(path: pathlib.Path) -> bool:
     try:
         r = subprocess.run(
             ["git", "-C", str(path), "rev-parse", "--is-inside-work-tree"],
-            capture_output=True, text=True, timeout=5,
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=5,
         )
         return r.returncode == 0 and r.stdout.strip() == "true"
     except (FileNotFoundError, subprocess.TimeoutExpired):
@@ -540,6 +547,8 @@ def setup_worktree(repo_path: pathlib.Path, branch_name: str,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             text=True,
+            encoding="utf-8",
+            errors="replace",
             start_new_session=True,
         )
     except FileNotFoundError:
@@ -568,15 +577,18 @@ def git_diff_summary(wt_path: pathlib.Path, max_chars: int = 8000) -> str:
     try:
         status = subprocess.run(
             ["git", "-C", str(wt_path), "status", "--short"],
-            capture_output=True, text=True, timeout=10,
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=10,
         ).stdout.rstrip()
         diff = subprocess.run(
             ["git", "-C", str(wt_path), "diff", "HEAD", "--stat"],
-            capture_output=True, text=True, timeout=10,
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=10,
         ).stdout.rstrip()
         full = subprocess.run(
             ["git", "-C", str(wt_path), "diff", "HEAD"],
-            capture_output=True, text=True, timeout=10,
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=10,
         ).stdout
         if len(full) > max_chars:
             full = full[:max_chars] + f"\n…[truncated, {len(full)-max_chars} more chars]"
@@ -837,7 +849,8 @@ def _run(cmd: list[str], *, cwd: pathlib.Path, stdin: Optional[str], timeout: in
             proc = subprocess.Popen(
                 cmd, cwd=str(cwd),
                 stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                text=True, bufsize=1,  # line-buffered
+                text=True, encoding="utf-8", errors="replace",
+                bufsize=1,  # line-buffered
                 start_new_session=True,
             )
         except FileNotFoundError:
@@ -848,7 +861,7 @@ def _run(cmd: list[str], *, cwd: pathlib.Path, stdin: Optional[str], timeout: in
                 pid_file_path.parent.mkdir(parents=True, exist_ok=True)
                 # Write atomically so a poller never reads a half-written PID.
                 tmp = pid_file_path.with_name(pid_file_path.name + ".tmp")
-                tmp.write_text(f"{proc.pid}\n")
+                tmp.write_text(f"{proc.pid}\n", encoding="utf-8")
                 os.replace(tmp, pid_file_path)
             except OSError as e:
                 print(f"[duet] warn: pid file write failed ({pid_file_path}): {e}",
@@ -1158,31 +1171,46 @@ def call_claude(agent: Agent, system_prompt: str, message: str,
 # Codex's `codex exec` prints a line like `session id: 019e12ad-0b1b-7732-bd7b-6acbbd04ab46`
 # to stderr near startup; modern builds also re-emit it on resume. We pin to that
 # UUID for subsequent resumes so duet doesn't depend on `--last`'s cwd-keyed
-# lookup. Anchored to "session id" to avoid false-positives on stray UUIDs in
-# tracebacks or path strings; case-insensitive because the label has varied.
+# lookup. Match only line-start session labels so a stray inline UUID or tool
+# trace does not become a resume pin; case-insensitive because the label has
+# varied.
 _CODEX_UUID_PATTERN = (
     r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
 )
 _CODEX_SESSION_ID_RE = re.compile(
-    r"session[ _-]?id\s*[:=]\s*(" + _CODEX_UUID_PATTERN + r")",
-    re.IGNORECASE,
+    r"^\s*session[ _-]?id\s*[:=]\s*(" + _CODEX_UUID_PATTERN + r")",
+    re.IGNORECASE | re.MULTILINE,
 )
 _CODEX_UUID_RE = re.compile(r"\A" + _CODEX_UUID_PATTERN + r"\Z", re.IGNORECASE)
 
 
 def _parse_codex_session_id(stderr: str) -> Optional[str]:
-    """Return the last `session id: <uuid>` UUID found in Codex's stderr.
+    """Return the first line-start `session id: <uuid>` from Codex stderr.
 
-    The last match wins so a resume that emits both the inherited id and a
-    rotated id (if a future Codex build does that) ends up pinned to the
-    rotated one. Returns the UUID lowercased; None if no match. We never parse
-    stdout — Codex puts the assistant reply there and a UUID inside the reply
-    must not be confused for the harness's session pin.
+    Prefer the startup line over later stderr content from tools. Returns the
+    UUID lowercased; None if no match. We never parse stdout — Codex puts the
+    assistant reply there and a UUID inside the reply must not be confused for
+    the harness's session pin.
     """
     if not stderr:
         return None
-    matches = _CODEX_SESSION_ID_RE.findall(stderr)
-    return matches[-1].lower() if matches else None
+    match = _CODEX_SESSION_ID_RE.search(stderr)
+    return match.group(1).lower() if match else None
+
+
+def _resolve_codex_session_pin(agent: Agent, parsed_sid: Optional[str]) -> Optional[str]:
+    """Merge a parsed Codex session id with the agent's existing resume pin."""
+    if not parsed_sid:
+        return agent.session_id
+    if agent.session_id and _CODEX_UUID_RE.match(agent.session_id):
+        if parsed_sid != agent.session_id.lower():
+            print(
+                "[duet] WARNING: codex stderr reported a different session id "
+                f"({parsed_sid}); keeping established pin {agent.session_id}",
+                file=sys.stderr,
+            )
+            return agent.session_id
+    return parsed_sid
 
 
 def call_codex(agent: Agent, system_prompt: str, message: str,
@@ -1235,10 +1263,10 @@ def call_codex(agent: Agent, system_prompt: str, message: str,
     # `["--full-auto"]` or `["--yolo"]`) and config overrides (`-c …`).
     #
     # IMPORTANT: `codex exec resume` accepts a SUBSET of `codex exec`'s
-    # flags. In particular, `--sandbox` and `--cd` are exec-only — they
-    # carry over from the resumed session and codex's clap parser rejects
-    # them on resume with "unexpected argument '--sandbox' found". So we
-    # split: exec_only_opts are passed only on the first call.
+    # flags. In particular, `--sandbox` and `--cd` are exec-only, and codex's
+    # clap parser rejects them on resume with "unexpected argument '--sandbox'
+    # found". Resume does accept config overrides, so reassert the sandbox via
+    # `sandbox_mode` instead of relying on the resumed invocation's defaults.
     shared_opts = ["--skip-git-repo-check"]
     if agent.model:
         shared_opts += ["--model", agent.model]
@@ -1250,9 +1278,16 @@ def call_codex(agent: Agent, system_prompt: str, message: str,
         cmd = ["codex", "exec", *options, full_prompt]
     else:
         # cwd is set via subprocess.Popen(cwd=…) so codex inherits the right
-        # directory regardless of how we resume. `--sandbox` and `--cd` are
-        # exec-only; sandbox carries over from the resumed session.
-        options = [*shared_opts, *reasoning_args, *agent.extra_args]
+        # directory regardless of how we resume. Keep the supported config
+        # override before the positional prompt so saved or explicitly narrowed
+        # continuation policies are enforced on the resumed turn.
+        resume_sandbox_opts = ["-c", f"sandbox_mode={json.dumps(sandbox)}"]
+        options = [
+            *shared_opts,
+            *reasoning_args,
+            *agent.extra_args,
+            *resume_sandbox_opts,
+        ]
         if _CODEX_UUID_RE.match(agent.session_id):
             # Pin to the UUID we parsed from a prior turn's stderr. This is
             # robust to parallel codex sessions sharing the cwd because
@@ -1286,7 +1321,8 @@ def call_codex(agent: Agent, system_prompt: str, message: str,
     # were already carrying; finally fall back to the "codex-current"
     # sentinel so the next turn at least knows a prior turn happened.
     parsed_sid = _parse_codex_session_id(err)
-    return out.rstrip(), parsed_sid or agent.session_id or "codex-current"
+    session_pin = _resolve_codex_session_pin(agent, parsed_sid)
+    return out.rstrip(), session_pin or "codex-current"
 
 
 def _parse_gemini_session_id(stdout: str) -> Optional[str]:
@@ -1803,6 +1839,50 @@ def call_agent(agent: Agent, message: str, cfg: DuetConfig, first_turn_for_agent
     return text
 
 
+def _bounded_agent_error_excerpt(
+    text: str,
+    max_chars: int = AGENT_ERROR_TRANSCRIPT_MAX_CHARS,
+) -> str:
+    """Keep the useful edges of an error without bloating the transcript."""
+    if max_chars <= 0:
+        return ""
+    if len(text) <= max_chars:
+        return text
+
+    omitted = len(text)
+    while True:
+        marker = (
+            f"\n\n[duet] error text truncated: {omitted} characters omitted; "
+            "full subprocess stderr remains in the log below.\n\n"
+        )
+        excerpt_chars = max_chars - len(marker)
+        if excerpt_chars <= 0:
+            fallback = (
+                f"[duet] error text truncated: {len(text)} characters omitted"
+            )
+            return fallback[:max_chars]
+        head_chars = (excerpt_chars + 1) // 2
+        tail_chars = excerpt_chars // 2
+        new_omitted = len(text) - head_chars - tail_chars
+        if new_omitted == omitted:
+            tail = text[-tail_chars:] if tail_chars else ""
+            return text[:head_chars] + marker + tail
+        omitted = new_omitted
+
+
+def format_agent_error_for_transcript(
+    exc: Exception,
+    stderr_log_path: pathlib.Path,
+    max_chars: int = AGENT_ERROR_TRANSCRIPT_MAX_CHARS,
+) -> str:
+    """Format bounded error context while pointing at the complete stderr."""
+    excerpt = _bounded_agent_error_excerpt(str(exc), max_chars)
+    return "\n".join([
+        f"[duet] error: {excerpt}",
+        f"[duet] stderr log: {stderr_log_path}",
+    ])
+
+
 def _agent_failure_block(reason: str, exc: Exception, turn_label: str,
                          agent: Agent, run_dir: pathlib.Path) -> str:
     kind = "TIMEOUT" if reason == FINISHED_TIMEOUT else "AGENT ERROR"
@@ -1811,8 +1891,7 @@ def _agent_failure_block(reason: str, exc: Exception, turn_label: str,
         f"[duet] {kind}: turn {turn_label} failed for "
         f"{agent.name} ({agent.backend}/{agent.role})",
         f"[duet] finished_reason: {reason}",
-        f"[duet] error: {exc}",
-        f"[duet] stderr log: {log_path}",
+        format_agent_error_for_transcript(exc, log_path),
     ])
 
 # ---------- loop ----------
@@ -2078,7 +2157,8 @@ def _setup_run_worktree(
         try:
             r = subprocess.run(
                 ["git", "-C", str(existing), "rev-parse", "--abbrev-ref", "HEAD"],
-                capture_output=True, text=True, timeout=5,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5,
             )
             wt_branch = r.stdout.strip() if r.returncode == 0 else None
         except Exception:
@@ -2135,11 +2215,18 @@ def _build_run_state(cfg: DuetConfig, *, turns_used: int, history: list,
         "history": history,
         "finished_reason": finished_reason,
         "transcript_path": str(transcript_path),
+        "sentinel": cfg.sentinel,
+        "sandbox": cfg.sandbox,
+        "permission_mode": cfg.permission_mode,
+        "per_turn_timeout": cfg.per_turn_timeout,
         "verify_cmd": cfg.verify_cmd,
         "last_verify": last_verify,
         "worktree": str(wt_path) if wt_path else None,
         "worktree_branch": wt_branch,
         "worktree_for": cfg.worktree_for,
+        "add_dirs": [str(d) for d in cfg.add_dirs],
+        "reasoning": cfg.reasoning,
+        "codex_fast": cfg.codex_fast,
         "continue_from": cfg.continue_from,
         "duet_pid": os.getpid(),
     }
@@ -2702,6 +2789,121 @@ def normalize_verify_cmd(value, parser: argparse.ArgumentParser) -> Optional[str
     return cmd
 
 
+def _state_int_or_arg(arg_value: Optional[int],
+                      state: dict,
+                      key: str,
+                      default: int,
+                      parser: argparse.ArgumentParser,
+                      option_name: str) -> int:
+    if arg_value is not None:
+        return arg_value
+    value = state.get(key, default)
+    if isinstance(value, bool):
+        parser.error(f"{option_name}: state.json field {key!r} must be an integer")
+    if isinstance(value, float) and not value.is_integer():
+        parser.error(f"{option_name}: state.json field {key!r} must be an integer")
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        parser.error(f"{option_name}: state.json field {key!r} must be an integer")
+    raise AssertionError("parser.error should have exited")
+
+
+def _state_str_or_arg(arg_value: Optional[str],
+                      state: dict,
+                      key: str,
+                      default: str,
+                      parser: argparse.ArgumentParser,
+                      option_name: str) -> str:
+    if arg_value is not None:
+        return arg_value
+    value = state.get(key, default)
+    if not isinstance(value, str):
+        parser.error(f"{option_name}: state.json field {key!r} must be a string")
+    return value
+
+
+def _state_list_or_arg(arg_value: Optional[list[str]],
+                       state: dict,
+                       key: str,
+                       parser: argparse.ArgumentParser,
+                       option_name: str) -> list[str]:
+    if arg_value is not None:
+        return arg_value
+    value = state.get(key, [])
+    if not isinstance(value, list):
+        parser.error(f"{option_name}: state.json field {key!r} must be a list")
+    return [str(item) for item in value]
+
+
+def _state_extra_args(agents: list[Agent]) -> list[tuple[str, list[str]]]:
+    return [(a.name, list(a.extra_args)) for a in agents if a.extra_args]
+
+
+def _state_authority_replays(args: argparse.Namespace,
+                             sandbox: str,
+                             permission_mode: str,
+                             add_dirs: list[str]) -> list[tuple[str, object]]:
+    """Return state-sourced settings that can widen a continued agent's authority."""
+    restored: list[tuple[str, object]] = []
+    if args.sandbox is None and sandbox not in SAFE_CONTINUE_SANDBOXES:
+        restored.append(("sandbox", sandbox))
+    if (args.permission_mode is None
+            and permission_mode not in SAFE_CONTINUE_PERMISSION_MODES):
+        restored.append(("permission_mode", permission_mode))
+    if args.add_dirs is None and add_dirs:
+        restored.append(("add_dirs", add_dirs))
+    return restored
+
+
+def _guard_continue_state_replay(state: dict,
+                                 agents: list[Agent],
+                                 args: argparse.Namespace,
+                                 parser: argparse.ArgumentParser,
+                                 *,
+                                 sandbox: str,
+                                 permission_mode: str,
+                                 add_dirs: list[str]) -> None:
+    """Require trust for executable or authority-widening state.json fields."""
+    restored_verify = args.verify_cmd is None and bool(state.get("verify_cmd"))
+    restored_extra_args = _state_extra_args(agents)
+    authority_replays = _state_authority_replays(
+        args, sandbox, permission_mode, add_dirs
+    )
+    protected_fields: list[str] = []
+    if restored_verify:
+        protected_fields.append("verify_cmd")
+    if restored_extra_args:
+        protected_fields.append("agent extra_args")
+    protected_fields.extend(name for name, _ in authority_replays)
+    if not protected_fields:
+        return
+    if not args.trust_state and not args.dry_run:
+        parser.error(
+            "--continue: refusing to replay state-sourced "
+            + ", ".join(protected_fields)
+            + "; pass --trust-state after inspecting state.json, or provide "
+              "fresh CLI overrides for the saved settings"
+        )
+    if args.trust_state:
+        if restored_verify:
+            print(
+                f"[duet] trusting verify_cmd from state.json: {state.get('verify_cmd')}",
+                file=sys.stderr,
+            )
+        for name, extra_args in restored_extra_args:
+            print(
+                f"[duet] trusting extra_args from state.json for {name}: "
+                f"{shlex.join(extra_args)}",
+                file=sys.stderr,
+            )
+        for name, value in authority_replays:
+            print(
+                f"[duet] trusting {name} from state.json: {value!r}",
+                file=sys.stderr,
+            )
+
+
 def _slot_name(backend: str, idx: int) -> str:
     slot = "lead" if idx == 0 else "partner"
     return f"{backend}-{slot}"
@@ -2831,7 +3033,7 @@ def apply_resume_overrides(
 
 
 def load_yaml_or_json(path: pathlib.Path) -> dict:
-    text = path.read_text()
+    text = path.read_text(encoding="utf-8")
     if path.suffix in {".yaml", ".yml"}:
         try:
             import yaml  # type: ignore
@@ -2989,6 +3191,31 @@ def _pid_alive(pid: int) -> bool:
         return True
 
 
+def _coerce_pid(value: object) -> Optional[int]:
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, float) and not value.is_integer():
+        return None
+    try:
+        pid = int(value)  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return None
+    return pid if pid > 0 else None
+
+
+def _pid_file_snapshot(pid_file: pathlib.Path) -> Optional[tuple[Optional[int], dt.datetime]]:
+    """Read a transient pid file; return None if it disappears mid-status."""
+    try:
+        text = pid_file.read_text(encoding="utf-8").strip()
+        stat = pid_file.stat()
+    except FileNotFoundError:
+        return None
+    except OSError as e:
+        print(f"[duet] unable to read pid file {pid_file}: {e}", file=sys.stderr)
+        return None
+    return _coerce_pid(text), dt.datetime.fromtimestamp(stat.st_mtime)
+
+
 def _proc_cmdline(pid: int) -> Optional[str]:
     """Best-effort read of a PID's full cmdline. Returns None on any failure.
 
@@ -3004,8 +3231,11 @@ def _proc_cmdline(pid: int) -> Optional[str]:
             return None
     # macOS / BSD: shell out to ps. Cheap, ~5ms.
     try:
-        r = subprocess.run(["ps", "-o", "command=", "-p", str(pid)],
-                           capture_output=True, text=True, timeout=2)
+        r = subprocess.run(
+            ["ps", "-o", "command=", "-p", str(pid)],
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=2,
+        )
         if r.returncode == 0 and r.stdout.strip():
             return r.stdout.strip()
     except (subprocess.TimeoutExpired, OSError):
@@ -3050,7 +3280,7 @@ def print_run_status(arg: str) -> int:
     state: dict = {}
     if state_path.exists():
         try:
-            state = json.loads(state_path.read_text())
+            state = json.loads(state_path.read_text(encoding="utf-8"))
         except json.JSONDecodeError as e:
             print(f"[duet] state.json malformed: {e}", file=sys.stderr)
             return 3
@@ -3069,31 +3299,33 @@ def print_run_status(arg: str) -> int:
     pid_files = sorted(run_dir.glob("turn-*.pid"))
     if pid_files:
         pid_file = pid_files[-1]
-        try:
-            pid = int(pid_file.read_text().strip())
-        except (OSError, ValueError):
-            pid = None
-        # Filename: turn-<label>-<agent>.pid
-        stem = pid_file.stem  # turn-02-claude-planner
-        started_at = dt.datetime.fromtimestamp(pid_file.stat().st_mtime)
-        elapsed = (dt.datetime.now() - started_at).total_seconds()
-        alive = _pid_alive(pid) if pid is not None else False
-        print(f"  in-flight turn: {stem}")
-        print(f"    pid:          {pid}  (alive: {alive})")
-        print(f"    started:      {started_at.isoformat(timespec='seconds')}  "
-              f"({int(elapsed)}s ago)")
-        # Heartbeat from the matching stderr log
-        log = run_dir / f"{stem}.stderr.log"
-        if log.exists():
-            log_age = (dt.datetime.now()
-                       - dt.datetime.fromtimestamp(log.stat().st_mtime)).total_seconds()
-            print(f"    last stderr:  {int(log_age)}s ago "
-                  f"({log.stat().st_size} bytes)")
-        if not alive:
-            print("    ⚠ pid file present but process is gone — turn likely "
-                  "crashed or was killed without cleanup")
-            return 2
-        return 1
+        snapshot = _pid_file_snapshot(pid_file)
+        if snapshot is not None:
+            pid, started_at = snapshot
+            # Filename: turn-<label>-<agent>.pid
+            stem = pid_file.stem  # turn-02-claude-planner
+            elapsed = (dt.datetime.now() - started_at).total_seconds()
+            alive = _pid_alive(pid) if pid is not None else False
+            print(f"  in-flight turn: {stem}")
+            print(f"    pid:          {pid}  (alive: {alive})")
+            print(f"    started:      {started_at.isoformat(timespec='seconds')}  "
+                  f"({int(elapsed)}s ago)")
+            # Heartbeat from the matching stderr log
+            log = run_dir / f"{stem}.stderr.log"
+            try:
+                log_stat = log.stat()
+            except OSError:
+                log_stat = None
+            if log_stat is not None:
+                log_age = (dt.datetime.now()
+                           - dt.datetime.fromtimestamp(log_stat.st_mtime)).total_seconds()
+                print(f"    last stderr:  {int(log_age)}s ago "
+                      f"({log_stat.st_size} bytes)")
+            if not alive:
+                print("    ⚠ pid file present but process is gone — turn likely "
+                      "crashed or was killed without cleanup")
+                return 2
+            return 1
     # No pid files. Either run hasn't started, has finished, or is between
     # turns (in particular, sitting at the post-loop `force>` prompt).
     if finished:
@@ -3104,7 +3336,12 @@ def print_run_status(arg: str) -> int:
     # duet_pid recorded in state.json.
     duet_pid = state.get("duet_pid")
     if duet_pid is not None:
-        if _is_duet_process(int(duet_pid)):
+        pid = _coerce_pid(duet_pid)
+        if pid is None:
+            print(f"  ⚠ invalid duet_pid {duet_pid!r}; no valid liveness "
+                  "proof recorded")
+            return 2
+        if _is_duet_process(pid):
             print(f"  state:           between turns / awaiting force> prompt")
             print(f"  duet pid:        {duet_pid} (alive)")
             history = state.get("history") or []
@@ -3128,6 +3365,18 @@ def print_run_status(arg: str) -> int:
     return 2
 
 
+def print_run_status_safe(arg: str) -> int:
+    try:
+        return print_run_status(arg)
+    except Exception as e:
+        print(
+            f"[duet] status failed ({type(e).__name__}): {e}",
+            file=sys.stderr,
+        )
+        traceback.print_exc(file=sys.stderr)
+        return 3
+
+
 # ---------- run-list (`duet --list [PATH]`) ----------
 
 # Status glyphs — same vocabulary as print_run_status, packed for table cols.
@@ -3214,7 +3463,7 @@ def _load_run_state(run_dir: pathlib.Path,
     if not state_path.is_file():
         parser.error(f"{option_name}: missing state.json in {run_dir}")
     try:
-        return json.loads(state_path.read_text())
+        return json.loads(state_path.read_text(encoding="utf-8"))
     except json.JSONDecodeError as e:
         parser.error(f"{option_name}: state.json malformed: {e}")
     except OSError as e:
@@ -3348,6 +3597,28 @@ def build_continue_config(run_arg: str,
         parser.error(f"--continue: no such run dir or id: {run_arg}")
     state = _load_run_state(run_dir, parser, "--continue")
     agents = _agents_from_state(state, parser, "--continue")
+    sentinel = _state_str_or_arg(
+        args.sentinel, state, "sentinel", DEFAULT_SENTINEL, parser, "--continue"
+    )
+    sandbox = _state_str_or_arg(
+        args.sandbox, state, "sandbox", DEFAULT_SANDBOX, parser, "--continue"
+    )
+    permission_mode = _state_str_or_arg(
+        args.permission_mode, state, "permission_mode", DEFAULT_PERMISSION_MODE,
+        parser, "--continue",
+    )
+    add_dirs = _state_list_or_arg(
+        args.add_dirs, state, "add_dirs", parser, "--continue"
+    )
+    _guard_continue_state_replay(
+        state,
+        agents,
+        args,
+        parser,
+        sandbox=sandbox,
+        permission_mode=permission_mode,
+        add_dirs=add_dirs,
+    )
     # Older runs (or runs that crashed before the first state.json roll) may
     # have Codex agents that already spoke but have no saved session_id. Without
     # a marker, run_duet would treat the next turn as a fresh `codex exec` and
@@ -3363,7 +3634,10 @@ def build_continue_config(run_arg: str,
                     and agent.name in codex_speakers):
                 agent.session_id = "codex-current"
     cwd = pathlib.Path(state.get("cwd") or ".").expanduser().resolve()
-    timeout = args.timeout
+    timeout = _state_int_or_arg(
+        args.timeout, state, "per_turn_timeout", DEFAULT_TIMEOUT,
+        parser, "--continue",
+    )
     user_note = _continue_note_from_args(args, cwd, timeout, parser, stdin_cache)
     next_idx = _next_speaker_idx_from_state(agents, state)
 
@@ -3385,11 +3659,11 @@ def build_continue_config(run_arg: str,
         task=state.get("task"),
         kickoff=kickoff,
         max_turns=args.turns,
-        sentinel=args.sentinel,
+        sentinel=sentinel,
         per_turn_timeout=timeout,
         runs_dir=runs_dir,
-        sandbox=args.sandbox,
-        permission_mode=args.permission_mode,
+        sandbox=sandbox,
+        permission_mode=permission_mode,
         dry_run=args.dry_run,
         recap=args.recap or bool(state.get("recap_path")),
         verify_cmd=normalize_verify_cmd(
@@ -3399,9 +3673,15 @@ def build_continue_config(run_arg: str,
         worktree=False,
         worktree_for=worktree_for,
         worktree_path=worktree_path,
-        add_dirs=[pathlib.Path(d).expanduser().resolve() for d in args.add_dirs],
-        reasoning=args.reasoning,
-        codex_fast=bool(args.codex_fast),
+        add_dirs=[
+            pathlib.Path(d).expanduser().resolve()
+            for d in add_dirs
+        ],
+        reasoning=args.reasoning if args.reasoning is not None else state.get("reasoning"),
+        codex_fast=bool(
+            args.codex_fast
+            if args.codex_fast is not None else state.get("codex_fast", False)
+        ),
         start_speaker_idx=next_idx,
         continue_from=str(run_dir),
     )
@@ -3434,7 +3714,7 @@ def _classify_run(run_dir: pathlib.Path) -> tuple[str, str, dict]:
     if not state_path.is_file():
         return ("❓", "no state.json", {})
     try:
-        state = json.loads(state_path.read_text())
+        state = json.loads(state_path.read_text(encoding="utf-8"))
     except json.JSONDecodeError:
         return ("❓", "malformed state", {})
     finished = state.get("finished_reason")
@@ -3445,9 +3725,12 @@ def _classify_run(run_dir: pathlib.Path) -> tuple[str, str, dict]:
     if list(run_dir.glob("turn-*.pid")):
         return ("🟢", "in-flight", state)
     pid = state.get("duet_pid")
-    if pid is not None and _is_duet_process(int(pid)):
-        return ("🟢", "between turns", state)
     if pid is not None:
+        coerced = _coerce_pid(pid)
+        if coerced is None:
+            return ("⚠", "invalid pid", state)
+        if _is_duet_process(coerced):
+            return ("🟢", "between turns", state)
         return ("⚠", "duet died", state)
     return ("⚠", "stuck (no pid)", state)
 
@@ -3557,18 +3840,19 @@ def _build_arg_parser() -> argparse.ArgumentParser:
                     help="model name to pass to the partner agent's backend via --model")
     ap.add_argument("--cwd", default=".", help="working dir for both agents")
     ap.add_argument("--turns", type=int, default=DEFAULT_TURNS, help=f"max turns (default {DEFAULT_TURNS})")
-    ap.add_argument("--sentinel", default=DEFAULT_SENTINEL,
+    ap.add_argument("--sentinel", default=None,
                     help="convergence sentinel; requires an LGTM rationale and "
                          "back-to-back proposals from both agents")
-    ap.add_argument("--timeout", type=int, default=DEFAULT_TIMEOUT, help="per-turn timeout seconds")
+    ap.add_argument("--timeout", type=int, default=None,
+                    help=f"per-turn timeout seconds (default {DEFAULT_TIMEOUT})")
     ap.add_argument("--verify-cmd", metavar="CMD", default=None,
                     help="shell command that must exit 0 before a convergence "
                          "proposal can count. Runs only for valid LGTM+rationale "
                          "proposals; YAML key: `verify_cmd:`.")
     ap.add_argument("--runs-dir", default=None, help="where to save transcripts")
-    ap.add_argument("--sandbox", default="workspace-write",
+    ap.add_argument("--sandbox", default=None,
                     help="codex --sandbox: read-only|workspace-write|danger-full-access. No-op for claude/gemini/copilot/opencode.")
-    ap.add_argument("--permission-mode", default="acceptEdits",
+    ap.add_argument("--permission-mode", default=None,
                     help="claude --permission-mode; gemini maps default/acceptEdits/plan/bypassPermissions to --approval-mode. No-op for copilot/opencode.")
     ap.add_argument("--config", help="optional YAML/JSON config (overrides flags except --resume-*)")
     ap.add_argument("--worktree", action="store_true",
@@ -3586,7 +3870,7 @@ def _build_arg_parser() -> argparse.ArgumentParser:
                          "Each run lands at <PATH>/<run_id>/. Default: <runs_dir>/<run_id>/wt/, "
                          "which is durable across reboots and OS temp-dir cleaners. "
                          "Pass /tmp or $TMPDIR to mimic the pre-fix throwaway behavior.")
-    ap.add_argument("--add-dir", action="append", metavar="PATH", default=[],
+    ap.add_argument("--add-dir", action="append", metavar="PATH", default=None,
                     dest="add_dirs",
                     help="extra path claude/gemini/copilot may access outside cwd. "
                          "Repeatable. Claude and Copilot receive --add-dir; "
@@ -3599,14 +3883,24 @@ def _build_arg_parser() -> argparse.ArgumentParser:
                          "(minimal → low) and adds high/xhigh/max prompt nudges. "
                          "Copilot: passes `--effort <v>` (minimal → none). "
                          "Gemini: no effort flag; high/xhigh/max are prompt nudges only.")
-    ap.add_argument("--codex-fast", action="store_true", dest="codex_fast",
-                    help="Codex-only fast mode: pin codex coder turns to "
-                         "`model_reasoning_effort=low` and "
-                         "`model_reasoning_summary=concise`, regardless of "
-                         "--reasoning / per-agent reasoning_effort. Trades "
-                         "depth for latency on codex coder turns; claude is "
-                         "unaffected, so `--reasoning high --codex-fast` is "
-                         "a real and useful combo. YAML key: `codex_fast: true`.")
+    codex_fast_group = ap.add_mutually_exclusive_group()
+    codex_fast_group.add_argument(
+        "--codex-fast", action="store_true", dest="codex_fast",
+        help="Codex-only fast mode: pin codex coder turns to "
+             "`model_reasoning_effort=low` and "
+             "`model_reasoning_summary=concise`, regardless of --reasoning / "
+             "per-agent reasoning_effort. YAML key: `codex_fast: true`.",
+    )
+    codex_fast_group.add_argument(
+        "--no-codex-fast", action="store_false", dest="codex_fast",
+        help="disable codex fast mode, including a value restored by "
+             "--continue or enabled by a YAML/JSON config",
+    )
+    ap.set_defaults(codex_fast=None)
+    ap.add_argument("--trust-state", action="store_true", dest="trust_state",
+                    help="with --continue, allow state.json-sourced commands "
+                         "and authority-widening sandbox, permission, or "
+                         "add-dir settings after inspecting the run directory")
     ap.add_argument("--status", metavar="RUN_DIR_OR_ID", default=None,
                     help="don't run a duet — instead print a one-shot health "
                          "summary of an existing run and exit. Accepts a path "
@@ -3647,10 +3941,13 @@ def _build_cfg_from_yaml(args: argparse.Namespace, ap: argparse.ArgumentParser,
     """Build a DuetConfig from a --config YAML/JSON file. CLI flags only fill
     seed inputs (task/kickoff) when the file specifies none, and a handful of
     flags (runs_dir, verify_cmd, worktree*, recap, reasoning, codex_fast)
-    override or OR with their file values; --resume-* still apply on top."""
+    override or combine with file values; --resume-* still apply on top."""
     raw = load_yaml_or_json(pathlib.Path(args.config))
     cfg_cwd = pathlib.Path(raw.get("cwd", ".")).expanduser().resolve()
-    cfg_timeout = int(raw.get("per_turn_timeout", DEFAULT_TIMEOUT))
+    cfg_timeout = int(raw.get(
+        "per_turn_timeout",
+        args.timeout if args.timeout is not None else DEFAULT_TIMEOUT,
+    ))
     raw_task = raw.get("task")
     raw_kickoff = raw.get("kickoff")
     raw_task_from_cmd = raw.get("task_from_cmd")
@@ -3681,11 +3978,21 @@ def _build_cfg_from_yaml(args: argparse.Namespace, ap: argparse.ArgumentParser,
         task=task,
         kickoff=kickoff,
         max_turns=int(raw.get("max_turns", DEFAULT_TURNS)),
-        sentinel=raw.get("sentinel", DEFAULT_SENTINEL),
+        sentinel=raw.get(
+            "sentinel",
+            args.sentinel if args.sentinel is not None else DEFAULT_SENTINEL,
+        ),
         per_turn_timeout=cfg_timeout,
         runs_dir=choose_runs_dir(raw_runs_dir, cfg_cwd),
-        sandbox=raw.get("sandbox", "workspace-write"),
-        permission_mode=raw.get("permission_mode", "acceptEdits"),
+        sandbox=raw.get(
+            "sandbox",
+            args.sandbox if args.sandbox is not None else DEFAULT_SANDBOX,
+        ),
+        permission_mode=raw.get(
+            "permission_mode",
+            args.permission_mode
+            if args.permission_mode is not None else DEFAULT_PERMISSION_MODE,
+        ),
         dry_run=bool(raw.get("dry_run", False)),
         recap=bool(raw.get("recap", False)) or args.recap,
         verify_cmd=verify_cmd,
@@ -3695,10 +4002,16 @@ def _build_cfg_from_yaml(args: argparse.Namespace, ap: argparse.ArgumentParser,
         worktree_root=_resolve_opt_path(args.worktree_root, raw.get("worktree_root")),
         add_dirs=[
             pathlib.Path(d).expanduser().resolve()
-            for d in (args.add_dirs or raw.get("add_dirs", []))
+            for d in (
+                args.add_dirs if args.add_dirs is not None
+                else raw.get("add_dirs", [])
+            )
         ],
         reasoning=args.reasoning or raw.get("reasoning"),
-        codex_fast=bool(args.codex_fast or raw.get("codex_fast", False)),
+        codex_fast=bool(
+            args.codex_fast
+            if args.codex_fast is not None else raw.get("codex_fast", False)
+        ),
     )
     cfg.agents = apply_resume_overrides(
         cfg.agents,
@@ -3717,12 +4030,13 @@ def _build_cfg_from_cli(args: argparse.Namespace, ap: argparse.ArgumentParser,
     agent in the "wrong" slot still routes its session id correctly.
     """
     cfg_cwd = pathlib.Path(args.cwd).expanduser().resolve()
+    timeout = args.timeout if args.timeout is not None else DEFAULT_TIMEOUT
     task, kickoff = resolve_seed_inputs(
         task=args.task,
         kickoff=args.kickoff,
         task_from_cmd=args.task_from_cmd,
         cwd=cfg_cwd,
-        timeout=args.timeout,
+        timeout=timeout,
         parser=ap,
         stdin_cache=stdin_cache,
     )
@@ -3748,11 +4062,14 @@ def _build_cfg_from_cli(args: argparse.Namespace, ap: argparse.ArgumentParser,
         task=task,
         kickoff=kickoff,
         max_turns=args.turns,
-        sentinel=args.sentinel,
-        per_turn_timeout=args.timeout,
+        sentinel=args.sentinel if args.sentinel is not None else DEFAULT_SENTINEL,
+        per_turn_timeout=timeout,
         runs_dir=choose_runs_dir(args.runs_dir, cfg_cwd),
-        sandbox=args.sandbox,
-        permission_mode=args.permission_mode,
+        sandbox=args.sandbox if args.sandbox is not None else DEFAULT_SANDBOX,
+        permission_mode=(
+            args.permission_mode
+            if args.permission_mode is not None else DEFAULT_PERMISSION_MODE
+        ),
         dry_run=args.dry_run,
         recap=args.recap,
         verify_cmd=normalize_verify_cmd(args.verify_cmd, ap),
@@ -3760,7 +4077,10 @@ def _build_cfg_from_cli(args: argparse.Namespace, ap: argparse.ArgumentParser,
         worktree_for=args.worktree_for or "partner",
         worktree_path=_resolve_opt_path(args.worktree_path),
         worktree_root=_resolve_opt_path(args.worktree_root),
-        add_dirs=[pathlib.Path(d).expanduser().resolve() for d in args.add_dirs],
+        add_dirs=[
+            pathlib.Path(d).expanduser().resolve()
+            for d in (args.add_dirs or [])
+        ],
         reasoning=args.reasoning,
         codex_fast=bool(args.codex_fast),
     )
@@ -3804,7 +4124,7 @@ def main() -> int:
 
     # `--status` is read-only: print run health and exit. Skip everything below.
     if args.status:
-        return print_run_status(args.status)
+        return print_run_status_safe(args.status)
 
     # `--list` is read-only: print the run-dir table and exit.
     if args.list_runs is not None:

{duet_cli-0.2.6 → duet_cli-0.2.7/duet_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duet-cli
-Version: 0.2.6
+Version: 0.2.7
 Summary: Two CLI agents in conversation. One Python file. Stdlib only.
 Author: Volkan Altan
 License-Expression: MIT
@@ -166,6 +166,8 @@ duet --reasoning high --codex-fast \
     --task "Fix the issue" --cwd ~/workspace/project
 ```
 
+Use `--no-codex-fast` to override a config or continued run that enabled it.
+
 **Verify gate** — a convergence proposal only counts if `make test` exits 0;
 any failure feeds back into the next turn:
 

{duet_cli-0.2.6 → duet_cli-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "duet-cli"
-version = "0.2.6"
+version = "0.2.7"
 description = "Two CLI agents in conversation. One Python file. Stdlib only."
 readme = "README.md"
 requires-python = ">=3.9"

{duet_cli-0.2.6 → duet_cli-0.2.7}/tests/test_duet.py

@@ -3,8 +3,9 @@
 These tests cover the correctness-critical helpers that `scripts/smoke.sh`
 can't observe through exit codes alone: convergence detection, codex/copilot
 session-id parsing, recap header parsing, file-path heuristics, reasoning
-mappings, partner-spec parsing, markdown-fence sizing, and the age
-formatter. They are pure-function tests — no subprocesses, no filesystem
+mappings, partner-spec parsing, markdown-fence sizing, age formatting, and
+bounded agent-error transcript formatting, continuation-state validation, and
+status fallbacks. They are pure-function tests — no subprocesses, no filesystem
 writes, no agent CLIs.
 
 Run via:
@@ -17,6 +18,7 @@ from __future__ import annotations
 import contextlib
 import io
 import pathlib
+import re
 import subprocess
 import sys
 import unittest
@@ -261,6 +263,30 @@ class TestVerifyHelpers(unittest.TestCase):
 # ---------- agent finish reasons ----------
 
 
+class TestAgentFailureTranscript(unittest.TestCase):
+    def test_small_error_is_preserved_with_stderr_link(self) -> None:
+        log_path = pathlib.Path("/repo/runs/1/turn-01-codex.stderr.log")
+        block = duet.format_agent_error_for_transcript(
+            RuntimeError("backend failed"), log_path
+        )
+
+        self.assertIn("[duet] error: backend failed", block)
+        self.assertIn(f"[duet] stderr log: {log_path}", block)
+        self.assertNotIn("characters omitted", block)
+
+    def test_large_error_keeps_head_and_tail_with_omitted_count(self) -> None:
+        text = "HEAD-" + ("x" * 2000) + "-TAIL"
+        excerpt = duet._bounded_agent_error_excerpt(text, max_chars=240)
+
+        self.assertLessEqual(len(excerpt), 240)
+        self.assertTrue(excerpt.startswith("HEAD-"))
+        self.assertTrue(excerpt.endswith("-TAIL"))
+        match = re.search(r"(\d+) characters omitted", excerpt)
+        self.assertIsNotNone(match)
+        self.assertGreater(int(match.group(1)), 0)
+        self.assertNotIn("x" * 500, excerpt)
+
+
 class TestAgentFinishReasons(unittest.TestCase):
     def test_codex_rc_124_maps_to_timeout(self) -> None:
         def fake_run(cmd, **kwargs):
@@ -625,7 +651,12 @@ class TestParseCodexSessionId(unittest.TestCase):
             duet._parse_codex_session_id(f"see {self.UUID} for details")
         )
 
-    def test_last_match_wins(self) -> None:
+    def test_inline_session_id_label_rejected(self) -> None:
+        self.assertIsNone(
+            duet._parse_codex_session_id(f"trace: session id: {self.UUID}\n")
+        )
+
+    def test_first_line_start_match_wins(self) -> None:
         first = "11111111-1111-1111-1111-111111111111"
         second = "22222222-2222-2222-2222-222222222222"
         stderr = (
@@ -633,7 +664,19 @@ class TestParseCodexSessionId(unittest.TestCase):
             "...\n"
             f"session id: {second}\n"
         )
-        self.assertEqual(duet._parse_codex_session_id(stderr), second)
+        self.assertEqual(duet._parse_codex_session_id(stderr), first)
+
+    def test_existing_uuid_pin_not_replaced_by_different_parse(self) -> None:
+        existing = "11111111-1111-1111-1111-111111111111"
+        parsed = "22222222-2222-2222-2222-222222222222"
+        agent = duet.Agent(
+            name="codex-partner",
+            backend="codex",
+            role="coder",
+            session_id=existing,
+        )
+        with contextlib.redirect_stderr(io.StringIO()):
+            self.assertEqual(duet._resolve_codex_session_pin(agent, parsed), existing)
 
     def test_uuid_re_pattern_round_trip(self) -> None:
         # Sanity: _CODEX_UUID_RE matches a parsed UUID; rejects the
@@ -1092,6 +1135,18 @@ class TestBuildCfgFromCli(unittest.TestCase):
         self.assertIsNone(cfg.agents[0].model)
         self.assertIsNone(cfg.agents[1].model)
 
+    def test_codex_fast_flags_are_tristate_and_mutually_exclusive(self) -> None:
+        _, omitted = self._parse("--task", "x")
+        _, enabled = self._parse("--task", "x", "--codex-fast")
+        _, disabled = self._parse("--task", "x", "--no-codex-fast")
+
+        self.assertIsNone(omitted.codex_fast)
+        self.assertIs(enabled.codex_fast, True)
+        self.assertIs(disabled.codex_fast, False)
+        with self.assertRaises(SystemExit), \
+                contextlib.redirect_stderr(io.StringIO()):
+            self._parse("--task", "x", "--codex-fast", "--no-codex-fast")
+
 
 # ---------- apply_resume_overrides ----------
 
@@ -1470,6 +1525,140 @@ class TestFormatByteSize(unittest.TestCase):
         self.assertEqual(duet._format_byte_size(1536), "1.5KB")
 
 
+# ---------- continuation state helpers ----------
+
+
+class TestContinueStateHelpers(unittest.TestCase):
+    def setUp(self) -> None:
+        self.parser = duet.argparse.ArgumentParser()
+
+    def test_state_int_prefers_cli_then_parses_saved_value(self) -> None:
+        self.assertEqual(
+            duet._state_int_or_arg(
+                11, {"timeout": "bad"}, "timeout", 7,
+                self.parser, "--continue",
+            ),
+            11,
+        )
+        self.assertEqual(
+            duet._state_int_or_arg(
+                None, {"timeout": "13"}, "timeout", 7,
+                self.parser, "--continue",
+            ),
+            13,
+        )
+
+    def test_state_int_rejects_malformed_saved_value(self) -> None:
+        with self.assertRaises(SystemExit), \
+                contextlib.redirect_stderr(io.StringIO()):
+            duet._state_int_or_arg(
+                None, {"timeout": "not-an-int"}, "timeout", 7,
+                self.parser, "--continue",
+            )
+
+    def test_state_str_prefers_cli_and_rejects_non_string_state(self) -> None:
+        self.assertEqual(
+            duet._state_str_or_arg(
+                "plan", {"permission_mode": 42}, "permission_mode",
+                duet.DEFAULT_PERMISSION_MODE, self.parser, "--continue",
+            ),
+            "plan",
+        )
+        with self.assertRaises(SystemExit), \
+                contextlib.redirect_stderr(io.StringIO()):
+            duet._state_str_or_arg(
+                None, {"permission_mode": 42}, "permission_mode",
+                duet.DEFAULT_PERMISSION_MODE, self.parser, "--continue",
+            )
+
+    def test_state_list_prefers_cli_and_rejects_non_list_state(self) -> None:
+        self.assertEqual(
+            duet._state_list_or_arg(
+                ["fresh"], {"add_dirs": "not-a-list"}, "add_dirs",
+                self.parser, "--continue",
+            ),
+            ["fresh"],
+        )
+        with self.assertRaises(SystemExit), \
+                contextlib.redirect_stderr(io.StringIO()):
+            duet._state_list_or_arg(
+                None, {"add_dirs": "not-a-list"}, "add_dirs",
+                self.parser, "--continue",
+            )
+
+    def test_authority_widening_state_requires_trust(self) -> None:
+        args = duet.argparse.Namespace(
+            verify_cmd=None,
+            trust_state=False,
+            dry_run=False,
+            sandbox=None,
+            permission_mode=None,
+            add_dirs=None,
+        )
+        with self.assertRaises(SystemExit), \
+                contextlib.redirect_stderr(io.StringIO()):
+            duet._guard_continue_state_replay(
+                {}, [], args, self.parser,
+                sandbox="danger-full-access",
+                permission_mode="bypassPermissions",
+                add_dirs=["/"],
+            )
+
+    def test_safe_or_explicit_authority_values_do_not_require_trust(self) -> None:
+        safe_args = duet.argparse.Namespace(
+            verify_cmd=None,
+            trust_state=False,
+            dry_run=False,
+            sandbox=None,
+            permission_mode=None,
+            add_dirs=None,
+        )
+        duet._guard_continue_state_replay(
+            {}, [], safe_args, self.parser,
+            sandbox="read-only",
+            permission_mode="plan",
+            add_dirs=[],
+        )
+        override_args = duet.argparse.Namespace(
+            verify_cmd=None,
+            trust_state=False,
+            dry_run=False,
+            sandbox="workspace-write",
+            permission_mode="acceptEdits",
+            add_dirs=["fresh"],
+        )
+        duet._guard_continue_state_replay(
+            {}, [], override_args, self.parser,
+            sandbox="workspace-write",
+            permission_mode="acceptEdits",
+            add_dirs=["fresh"],
+        )
+
+
+# ---------- status helpers ----------
+
+
+class TestStatusHelpers(unittest.TestCase):
+    def test_coerce_pid_accepts_positive_integers_only(self) -> None:
+        self.assertEqual(duet._coerce_pid(42), 42)
+        self.assertEqual(duet._coerce_pid("42"), 42)
+        self.assertEqual(duet._coerce_pid(42.0), 42)
+        for value in (None, "bad", True, False, 0, -1, 1.5):
+            with self.subTest(value=value):
+                self.assertIsNone(duet._coerce_pid(value))
+
+    def test_status_safe_reports_traceback_and_returns_three(self) -> None:
+        stderr = io.StringIO()
+        with mock.patch.object(
+                duet, "print_run_status", side_effect=RuntimeError("boom")), \
+                contextlib.redirect_stderr(stderr):
+            rc = duet.print_run_status_safe("run")
+
+        self.assertEqual(rc, 3)
+        self.assertIn("status failed (RuntimeError): boom", stderr.getvalue())
+        self.assertIn("Traceback (most recent call last)", stderr.getvalue())
+
+
 # ---------- normalize_verify_cmd ----------