agentwire-dev 1.23.0__tar.gz → 1.24.0__tar.gz

{agentwire_dev-1.23.0 → agentwire_dev-1.24.0}/.gitignore

@@ -51,3 +51,6 @@ Thumbs.db
 test_*.wav
 test_output*.wav
 .agentwire/
+
+# pytest-textual-snapshot diff page (regenerated each run)
+snapshot_report.html

{agentwire_dev-1.23.0 → agentwire_dev-1.24.0}/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- **Anthropic workflow runner** — `runner: anthropic` alongside the existing pi runner (Phase 6, PRs 1–6)
+  - Pluggable runner registry (`agentwire/workflows/runners/`) with a shared `NodeRunner` Protocol; pi kept byte-for-byte identical behind a thin shim
+  - `AnthropicRunner` uses `claude-agent-sdk>=0.1.43` with subscription auth — no `ANTHROPIC_API_KEY` required, inherits `~/.claude/.credentials.json` (subscription-covered, no per-run billing)
+  - Tool execution is owned by Claude Code itself: `setting_sources=["user"]` loads `~/.claude/settings.json` so AgentWire's damage-control PreToolUse hooks fire on every Bash call (verified end-to-end by a live integration test that chmod 777's a sentinel file — hook blocks, file mode unchanged)
+  - Per-runner tool namespaces: pi stays lowercase (`read`, `bash`, `edit`, …), anthropic uses CamelCase (`Read`, `Bash`, `Edit`, …); parse-time validation rejects cross-namespace mixups
+  - Anthropic-only fields validated at parse time: `model` (required), `effort` (low|medium|high|max|xhigh — with Opus/Opus-4.7 gating), `thinking_config` (adaptive|enabled|disabled), `task_budget_tokens` (Opus 4.7 beta, min 20000), `max_thinking_tokens`, `max_budget_usd`
+  - Error classification: anthropic runner tags `NodeResult.error` with `transient:` / `permanent:` / `invalid:` / `error:` prefixes so rate-limited runs are distinguishable from genuine bugs
+- **Live event streaming under `--verbose`** — `agentwire workflow run … -v` now streams per-event output for anthropic nodes: `[node] → tool_use Read …`, `← tool_result (ok/err)`, `▓ text`, `✓ turn 42+18 tok`, `■ agent_end 3.1s`
+- **Runner recorded in metadata** — `metadata.json` bumped to `schema_version: 2` with run-level and per-node `runner` fields; `workflow show` renders a `Runner:` line + per-node tag + `Totals:` aggregation; `workflow history` gains a `runner` column
+- **`--runner {pi,anthropic}` CLI override** — `agentwire workflow run` accepts `--runner` to flip every node's runner for one invocation; runner/field mismatches surface as normal validation errors
+- **Canary live** — `daily-book-report` (daily 13:30) flipped to anthropic on 2026-04-17 (Sonnet 4.6 for fetch, Opus 4.7 for compose_and_send). Findings tracked in `docs/missions/anthropic-sdk-runner.md`
+- **Damage-control honors session bypass modes** — `permission_mode: "bypassPermissions"` and `"auto"` now skip `ask:true` escalations for write-tier commands; hard blocks still fire. Fixes `--dangerously-skip-permissions` and autonomous-mode sessions being prompted per Bash call
+
+### Documentation
+
+- New "Runners" section in `docs/workflows.md` covering per-runner fields, `--runner` usage, and live-event output
+- `agentwire-workflows` skill updated — no longer claims pi-only; links to full Runners reference
+
 ## [1.23.0] - 2026-04-16
 
 ### Added

{agentwire_dev-1.23.0 → agentwire_dev-1.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.23.0
+Version: 1.24.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
@@ -694,8 +694,11 @@ Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: requests>=2.28.0
 Requires-Dist: resend>=2.0.0
+Requires-Dist: rich>=13.0
+Requires-Dist: textual>=0.80
 Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-textual-snapshot>=1.0.0; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: ruff>=0.1.0; extra == 'dev'
 Provides-Extra: stt

{agentwire_dev-1.23.0 → agentwire_dev-1.24.0}/agentwire/__init__.py

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

{agentwire_dev-1.23.0 → agentwire_dev-1.24.0}/agentwire/__main__.py

@@ -84,11 +84,42 @@ class AgentCommand:
     env: dict[str, str] = field(default_factory=dict)  # Secrets to inject via tmux set-environment (keeps keys out of `ps`)
 
 
+def _build_tmux_env_flags(env: dict[str, str]) -> list[str]:
+    """Build `-e KEY=VAL` flag pairs for `tmux new-session`.
+
+    Prefer this over post-creation `inject_session_env` when creating a fresh
+    session with secrets: `tmux new-session -e K=V` places the var in the
+    session environment BEFORE the initial shell starts, so that shell sees
+    it. `tmux set-environment` on an existing session only affects shells
+    spawned AFTER the call, which leaves the initial pane's shell without
+    the var — and the agent command runs in that initial shell.
+    """
+    flags: list[str] = []
+    for key, value in env.items():
+        flags.extend(["-e", f"{key}={value}"])
+    return flags
+
+
+def _build_tmux_env_flags_shell(env: dict[str, str]) -> str:
+    """Shell-safe `-e 'K=V' -e 'K2=V2' ` fragment for inlining in remote SSH chained commands.
+
+    Returns empty string when env is empty. Trailing space when non-empty so
+    the caller can concatenate directly into a `tmux new-session ... && ...`
+    string without extra glue.
+    """
+    if not env:
+        return ""
+    parts = [f"-e {shlex.quote(f'{k}={v}')}" for k, v in env.items()]
+    return " ".join(parts) + " "
+
+
 def inject_session_env(session: str, env: dict[str, str], remote_host: str | None = None) -> None:
-    """Set env vars on a tmux session so panes inherit them without exposing secrets.
+    """Set env vars on an existing tmux session for FUTURE shells in that session.
 
-    Using `tmux set-environment -t <session>` keeps API keys out of the command
-    string (which would otherwise be visible in `ps auxwww` and shell history).
+    Does NOT update the initial pane's shell — that shell was already started
+    when the session was created and has a fixed env. Use
+    `_build_tmux_env_flags(env)` with `tmux new-session -e K=V` instead if
+    the agent command runs in the initial shell.
     """
     if not env:
         return
@@ -126,30 +157,13 @@ def parse_env_args(env_args: list[str] | None) -> dict[str, str]:
     return result
 
 
-def build_session_env_shell_fragment(session: str, env: dict[str, str]) -> str:
-    """Build a shell fragment of `tmux set-environment` calls for chained remote commands.
-
-    Returns a trailing `&& ` string ready to splice into an ssh-executed compound
-    command. Empty string if no env.
-    """
-    if not env:
-        return ""
-    parts = []
-    for key, value in env.items():
-        parts.append(
-            f"tmux set-environment -t {shlex.quote(session)} "
-            f"{shlex.quote(key)} {shlex.quote(value)}"
-        )
-    return " && ".join(parts) + " && "
-
-
 def build_agent_command(session_type: str, roles: list[RoleConfig] | None = None, model: str | None = None) -> AgentCommand:
     """Build the agent command for a session.
 
     Args:
         session_type: Session type (e.g., "claude-bypass", "claude-auto", "pi-zai", "bare")
         roles: Optional list of roles to apply
-        model: Optional model override (e.g., "haiku", "sonnet", "opus", "glm-5")
+        model: Optional model override (e.g., "haiku", "sonnet", "opus", "glm-5.1")
 
     Returns:
         AgentCommand with the command string and metadata
@@ -170,7 +184,7 @@ def build_agent_command(session_type: str, roles: list[RoleConfig] | None = None
         # Pi reads ZAI_API_KEY from env. We inject it via `tmux set-environment`
         # (see inject_session_env) so the key never appears in `ps auxwww`.
         pi_binary = pi_config.get("binary", "pi")
-        default_model = pi_config.get("default_model", "glm-5")
+        default_model = pi_config.get("default_model", "glm-5.1")
 
         parts = [pi_binary, "--provider", "zai"]
         parts.extend(["--model", model or default_model])
@@ -204,6 +218,38 @@ def build_agent_command(session_type: str, roles: list[RoleConfig] | None = None
             env={"ZAI_API_KEY": zai.get("api_key", "")},
         )
 
+    # === Agentwire REPL (claude-agent-sdk) ===
+    # sdk-bypass / sdk-prompted / sdk-restricted — Python REPL running in a
+    # tmux pane, auth via Claude subscription. See docs/missions/agentwire-repl.md.
+    if session_type.startswith("sdk-"):
+        # Permission mode maps to SDK's permission_mode parameter
+        mode_map = {
+            "sdk-bypass": "bypass",
+            "sdk-prompted": "prompted",
+            "sdk-restricted": "restricted",
+        }
+        mode = mode_map.get(session_type, "bypass")
+
+        parts = ["agentwire", "repl", "--mode", mode]
+        if model:
+            parts.extend(["--model", model])
+
+        # Role-based system prompt (same temp-file pattern as claude-* / pi-zai
+        # to avoid shell escaping on multiline content; --append-system-prompt
+        # must be last).
+        temp_file = None
+        if merged and merged.instructions:
+            f = tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False)
+            f.write(merged.instructions)
+            f.close()
+            temp_file = f.name
+            parts.append(f'--append-system-prompt "$(<{temp_file})"')
+
+        return AgentCommand(
+            command=" ".join(parts),
+            temp_file=temp_file,
+        )
+
     # === Claude Code ===
     if session_type.startswith("claude"):
         parts = ["claude"]
@@ -3381,6 +3427,31 @@ def cmd_list(args) -> int:
     return 0
 
 
+def cmd_repl(args) -> int:
+    """Agentwire REPL — interactive harness built on claude-agent-sdk.
+
+    Invoked by build_agent_command when a session is spawned with --type sdk-*.
+    Interactive mode auto-persists every turn under
+    `~/.agentwire/sessions/repl/<session-name>/`; `--resume NAME` continues a
+    prior session by reusing its sdk_session_id.
+    """
+    from agentwire.repl.app import run_repl
+    return run_repl(
+        mode=args.mode,
+        model=args.model,
+        print_prompt=args.print,
+        system_prompt=args.append_system_prompt,
+        session_name=getattr(args, "session_name", None),
+        resume=getattr(args, "resume", None),
+        roles=getattr(args, "roles", None),
+        view=getattr(args, "view", "chat"),
+        cols=getattr(args, "cols", 3),
+        col_models=getattr(args, "col_models", None),
+        col_efforts=getattr(args, "col_efforts", None),
+        col_roles=getattr(args, "col_roles", None),
+    )
+
+
 def cmd_new(args) -> int:
     """Create a new agent session.
 
@@ -3548,21 +3619,22 @@ def cmd_new(args) -> int:
             except Exception as e:
                 print(f"Warning: Failed to write system prompt to remote: {e}", file=sys.stderr)
 
-        env_fragment = build_session_env_shell_fragment(session_name, agent.env)
+        env_flags = _build_tmux_env_flags_shell(agent.env)
 
-        # Create session - Agent starts immediately if not bare
+        # Create session - Agent starts immediately if not bare.
+        # `-e K=V` on new-session places env in the session environment BEFORE
+        # the initial shell starts, so send-keys'd agent command sees it.
         if agent_cmd:
             create_cmd = (
-                f"tmux new-session -d -s {shlex.quote(session_name)} -c {shlex.quote(remote_path)} && "
+                f"tmux new-session -d -s {shlex.quote(session_name)} -c {shlex.quote(remote_path)} {env_flags}&& "
                 f"tmux send-keys -t {shlex.quote(session_name)} 'cd {shlex.quote(remote_path)}' Enter && "
                 f"sleep 0.1 && "
-                f"{env_fragment}"
                 f"tmux send-keys -t {shlex.quote(session_name)} {shlex.quote(agent_cmd)} Enter"
             )
         else:
             # Bare session - just create tmux
             create_cmd = (
-                f"tmux new-session -d -s {shlex.quote(session_name)} -c {shlex.quote(remote_path)} && "
+                f"tmux new-session -d -s {shlex.quote(session_name)} -c {shlex.quote(remote_path)} {env_flags}&& "
                 f"tmux send-keys -t {shlex.quote(session_name)} 'cd {shlex.quote(remote_path)}' Enter"
             )
 
@@ -3650,20 +3722,10 @@ def cmd_new(args) -> int:
         else:
             return _output_result(False, json_mode, f"Session '{session_name}' already exists. Use -f to replace.")
 
-    # Create new tmux session
-    subprocess.run(
-        ["tmux", "new-session", "-d", "-s", session_name, "-c", str(session_path)],
-        check=True
-    )
-
-    # Ensure Claude starts in correct directory
-    subprocess.run(
-        ["tmux", "send-keys", "-t", session_name, f"cd {shlex.quote(str(session_path))}", "Enter"],
-        check=True
-    )
-    time.sleep(0.1)
-
-    # Determine agent type and normalize session type
+    # Determine agent type and normalize session type BEFORE creating the
+    # tmux session, so we can inject secrets via `tmux new-session -e K=V`
+    # (the only way to make the initial pane's shell see them — post-hoc
+    # `tmux set-environment` only affects shells spawned AFTER the call).
     agent_type = detect_default_agent_type()
 
     # Determine session type from CLI --type flag or existing config
@@ -3701,8 +3763,21 @@ def cmd_new(args) -> int:
 
     agent_cmd = agent.command
 
-    # Inject secrets via tmux set-environment (keeps keys out of `ps`)
-    inject_session_env(session_name, agent.env)
+    # Create new tmux session with env vars injected at creation time.
+    # `-e K=V` places vars in the session environment before the initial
+    # shell starts, so the agent command (run via send-keys below) sees them.
+    subprocess.run(
+        ["tmux", "new-session", "-d", "-s", session_name, "-c", str(session_path),
+         *_build_tmux_env_flags(agent.env)],
+        check=True
+    )
+
+    # Ensure Claude starts in correct directory
+    subprocess.run(
+        ["tmux", "send-keys", "-t", session_name, f"cd {shlex.quote(str(session_path))}", "Enter"],
+        check=True
+    )
+    time.sleep(0.1)
 
     # Start agent command if not bare
     if agent_cmd:
@@ -4590,13 +4665,12 @@ def cmd_recreate(args) -> int:
         agent = build_agent_command(session_type_str)
         agent.env.update(parse_env_args(getattr(args, 'env', None)))
         agent_cmd = agent.command
-        env_fragment = build_session_env_shell_fragment(session_name, agent.env)
+        env_flags = _build_tmux_env_flags_shell(agent.env)
 
         create_cmd = (
-            f"tmux new-session -d -s {shlex.quote(session_name)} -c {shlex.quote(session_path)} && "
+            f"tmux new-session -d -s {shlex.quote(session_name)} -c {shlex.quote(session_path)} {env_flags}&& "
             f"tmux send-keys -t {shlex.quote(session_name)} 'cd {shlex.quote(session_path)}' Enter && "
             f"sleep 0.1 && "
-            f"{env_fragment}"
             f"tmux send-keys -t {shlex.quote(session_name)} {shlex.quote(agent_cmd)} Enter"
         )
 
@@ -4697,9 +4771,12 @@ def cmd_recreate(args) -> int:
 
     agent_cmd = agent.command
 
-    # Step 5: Create new session
+    # Step 5: Create new session with env vars injected at creation time so
+    # the initial shell sees them (post-hoc set-environment doesn't reach the
+    # already-running shell — see _build_tmux_env_flags docstring).
     subprocess.run(
-        ["tmux", "new-session", "-d", "-s", session_name, "-c", str(session_path)],
+        ["tmux", "new-session", "-d", "-s", session_name, "-c", str(session_path),
+         *_build_tmux_env_flags(agent.env)],
         check=True
     )
 
@@ -4710,9 +4787,6 @@ def cmd_recreate(args) -> int:
     )
     time.sleep(0.1)
 
-    # Inject secrets via tmux set-environment (keeps keys out of `ps`)
-    inject_session_env(session_name, agent.env)
-
     # Start the agent with appropriate command
     if agent_cmd:
         subprocess.run(
@@ -4973,13 +5047,12 @@ def cmd_fork(args) -> int:
         agent.env.update(parse_env_args(getattr(args, 'env', None)))
 
         agent_cmd = agent.command
-        env_fragment = build_session_env_shell_fragment(target_session, agent.env)
+        env_flags = _build_tmux_env_flags_shell(agent.env)
 
         create_session_cmd = (
-            f"tmux new-session -d -s {shlex.quote(target_session)} -c {shlex.quote(target_path)} && "
+            f"tmux new-session -d -s {shlex.quote(target_session)} -c {shlex.quote(target_path)} {env_flags}&& "
             f"tmux send-keys -t {shlex.quote(target_session)} 'cd {shlex.quote(target_path)}' Enter && "
             f"sleep 0.1 && "
-            f"{env_fragment}"
             f"tmux send-keys -t {shlex.quote(target_session)} {shlex.quote(agent_cmd)} Enter"
         )
 
@@ -5039,20 +5112,8 @@ def cmd_fork(args) -> int:
         if check_target.returncode == 0:
             return _output_result(False, json_mode, f"Target session '{target_session}' already exists")
 
-        # Create new tmux session in same directory
-        subprocess.run(
-            ["tmux", "new-session", "-d", "-s", target_session, "-c", str(fork_path)],
-            check=True
-        )
-
-        # Ensure Claude starts in correct directory
-        subprocess.run(
-            ["tmux", "send-keys", "-t", target_session, f"cd {shlex.quote(str(fork_path))}", "Enter"],
-            check=True
-        )
-        time.sleep(0.1)
-
-        # Determine session type from --type flag or source config
+        # Determine session type from --type flag or source config (before
+        # session creation, so we can inject env via `tmux new-session -e K=V`).
         agent_type = detect_default_agent_type()
         type_arg = getattr(args, 'type', None)
         source_project_config = load_project_config(fork_path)
@@ -5128,8 +5189,20 @@ def cmd_fork(args) -> int:
         agent = build_agent_command(session_type_str, roles)
         agent.env.update(parse_env_args(getattr(args, 'env', None)))
 
-        # Inject secrets via tmux set-environment (keeps keys out of `ps`)
-        inject_session_env(target_session, agent.env)
+        # Create new tmux session with env injected at creation time so the
+        # initial shell sees the vars (see _build_tmux_env_flags docstring).
+        subprocess.run(
+            ["tmux", "new-session", "-d", "-s", target_session, "-c", str(fork_path),
+             *_build_tmux_env_flags(agent.env)],
+            check=True
+        )
+
+        # Ensure Claude starts in correct directory
+        subprocess.run(
+            ["tmux", "send-keys", "-t", target_session, f"cd {shlex.quote(str(fork_path))}", "Enter"],
+            check=True
+        )
+        time.sleep(0.1)
 
         agent_cmd = agent.command
         if agent_cmd:
@@ -5205,20 +5278,8 @@ def cmd_fork(args) -> int:
     if not success:
         return _output_result(False, json_mode, f"Failed to create worktree for branch '{target_branch}'")
 
-    # Create new session
-    subprocess.run(
-        ["tmux", "new-session", "-d", "-s", target_session, "-c", str(target_path)],
-        check=True
-    )
-
-    # Ensure agent starts in correct directory
-    subprocess.run(
-        ["tmux", "send-keys", "-t", target_session, f"cd {shlex.quote(str(target_path))}", "Enter"],
-        check=True
-    )
-    time.sleep(0.1)
-
-    # Determine session type from --type flag or source config
+    # Determine session type from --type flag or source config (before
+    # session creation, so we can inject env via `tmux new-session -e K=V`).
     agent_type = detect_default_agent_type()
     type_arg = getattr(args, 'type', None)
     config_path = source_path if source_path != project_path else project_path
@@ -5246,8 +5307,20 @@ def cmd_fork(args) -> int:
     agent.env.update(parse_env_args(getattr(args, 'env', None)))
     agent_cmd = agent.command
 
-    # Inject secrets via tmux set-environment (keeps keys out of `ps`)
-    inject_session_env(target_session, agent.env)
+    # Create new session with env injected at creation time so the initial
+    # shell sees the vars (see _build_tmux_env_flags docstring).
+    subprocess.run(
+        ["tmux", "new-session", "-d", "-s", target_session, "-c", str(target_path),
+         *_build_tmux_env_flags(agent.env)],
+        check=True
+    )
+
+    # Ensure agent starts in correct directory
+    subprocess.run(
+        ["tmux", "send-keys", "-t", target_session, f"cd {shlex.quote(str(target_path))}", "Enter"],
+        check=True
+    )
+    time.sleep(0.1)
 
     if agent_cmd:
         subprocess.run(
@@ -5840,15 +5913,14 @@ def cmd_dev(args) -> int:
 
     agent_cmd = agent.command
 
-    # Create session
+    # Create session with env injected at creation time so the initial
+    # shell sees the vars (see _build_tmux_env_flags docstring).
     print(f"Creating dev session '{session_name}' in {project_dir}...")
     subprocess.run([
         "tmux", "new-session", "-d", "-s", session_name, "-c", str(project_dir),
+        *_build_tmux_env_flags(agent.env),
     ])
 
-    # Inject secrets via tmux set-environment (keeps keys out of `ps`)
-    inject_session_env(session_name, agent.env)
-
     # Start agent with agentwire config
     if agent_cmd:
         wait_for_shell_prompt(session_name)
@@ -10025,7 +10097,10 @@ def main() -> int:
     # === email command ===
     from agentwire.channels.email import cmd_email
     email_parser = subparsers.add_parser("email", help="Send branded email notification via Resend")
-    email_parser.add_argument("--to", type=str, help="Recipient email (default: from config)")
+    email_parser.add_argument(
+        "--to", action="append", default=None,
+        help="Recipient email. Repeat or pass comma-separated for multiple recipients (default: from config).",
+    )
     email_parser.add_argument("--subject", "-s", type=str, help="Email subject")
     email_parser.add_argument("--body", "-b", type=str, help="Email body - markdown supported (or pipe via stdin)")
     email_parser.add_argument("--attach", "-a", type=str, action="append", help="Attach file (can use multiple times)")
@@ -10033,6 +10108,22 @@ def main() -> int:
     email_parser.add_argument("-q", "--quiet", action="store_true", help="Suppress success output")
     email_parser.set_defaults(func=cmd_email)
 
+    # === brave command ===
+    from agentwire.search import cmd_brave
+    brave_parser = subparsers.add_parser(
+        "brave",
+        help="Brave Search helper — run a web search and print results optimized for LLM consumption.",
+    )
+    brave_parser.add_argument("query", nargs="+", help="Search query (all remaining args joined with spaces)")
+    brave_parser.add_argument("--count", "-n", type=int, default=10, help="Max results (1-20, default 10)")
+    brave_parser.add_argument(
+        "--freshness", "-f", type=str, default="pd",
+        choices=["pd", "pw", "pm", "py"],
+        help="Time window: pd=past day (default), pw=past week, pm=past month, py=past year",
+    )
+    brave_parser.add_argument("--json", action="store_true", help="Output raw JSON instead of compact text")
+    brave_parser.set_defaults(func=cmd_brave)
+
     # === notify command ===
     notify_parser = subparsers.add_parser("notify", help="Notify portal of session/pane state changes")
     notify_parser.add_argument(
@@ -10074,12 +10165,66 @@ def main() -> int:
     list_parser.set_defaults(func=cmd_list)
 
     # === new command (top-level) ===
+    # === repl command (top-level, internal — invoked by build_agent_command) ===
+    # Users spawn it via `agentwire new -s <name> --type sdk-bypass`; this is
+    # the process that runs inside the tmux pane. See docs/missions/agentwire-repl.md.
+    repl_parser = subparsers.add_parser(
+        "repl",
+        help="Agentwire REPL (internal — runs inside tmux pane for sdk-* session types)",
+    )
+    repl_parser.add_argument(
+        "--mode", choices=["bypass", "prompted", "restricted"], default="bypass",
+        help="Permission mode (bypass=run tools without asking, prompted=ask, restricted=read-only)",
+    )
+    repl_parser.add_argument("--model", default=None, help="Model override (default: claude-opus-4-7)")
+    repl_parser.add_argument(
+        "-p", "--print", dest="print", default=None, metavar="PROMPT",
+        help="One-shot mode: run PROMPT, emit output, exit (no interactive loop)",
+    )
+    repl_parser.add_argument(
+        "--append-system-prompt", dest="append_system_prompt", default=None, metavar="TEXT",
+        help="Additional system prompt content (appended after base prompt)",
+    )
+    repl_parser.add_argument(
+        "--session-name", dest="session_name", default=None, metavar="NAME",
+        help="Transcript directory name under ~/.agentwire/sessions/repl/ (default: auto-generated timestamp+hash)",
+    )
+    repl_parser.add_argument(
+        "--resume", dest="resume", default=None, metavar="NAME",
+        help="Resume the saved session NAME (reuses its sdk_session_id to continue the prior conversation)",
+    )
+    repl_parser.add_argument(
+        "--role", dest="roles", action="append", metavar="NAME",
+        help="Role name to compose into the system prompt (repeatable). Overrides .agentwire.yml roles.",
+    )
+    repl_parser.add_argument(
+        "--view", choices=["chat", "fanout"], default="chat",
+        help="UI view: 'chat' (default, single conversation) or 'fanout' (N parallel columns).",
+    )
+    repl_parser.add_argument(
+        "--cols", type=int, default=3, metavar="N",
+        help="Column count for --view fanout (2-6, default 3).",
+    )
+    repl_parser.add_argument(
+        "--col-model", dest="col_models", action="append", metavar="N=MODEL",
+        help="Per-column model override for --view fanout (e.g. --col-model 0=claude-opus-4-7 --col-model 1=claude-sonnet-4-6). Repeatable.",
+    )
+    repl_parser.add_argument(
+        "--col-effort", dest="col_efforts", action="append", metavar="N=EFFORT",
+        help="Per-column effort override for --view fanout (e.g. --col-effort 0=max --col-effort 1=high). Repeatable.",
+    )
+    repl_parser.add_argument(
+        "--col-role", dest="col_roles", action="append", metavar="N=ROLE[,ROLE...]",
+        help="Per-column role override for --view fanout (e.g. --col-role 0=skeptic --col-role 1=optimist,explainer). Repeatable.",
+    )
+    repl_parser.set_defaults(func=cmd_repl)
+
     new_parser = subparsers.add_parser("new", help="Create new Claude Code session")
     new_parser.add_argument("-s", "--session", required=True, help="Session name (project, project/branch, or project/branch@machine)")
     new_parser.add_argument("-p", "--path", help="Working directory (default: ~/projects/<name>)")
     new_parser.add_argument("-f", "--force", action="store_true", help="Replace existing session")
     # Session type
-    new_parser.add_argument("--type", help="Session type (bare, claude-bypass, claude-prompted, claude-restricted, pi-zai, pi-zai-restricted, pi-zai-readonly, standard, worker, voice)")
+    new_parser.add_argument("--type", help="Session type (bare, claude-bypass, claude-prompted, claude-restricted, pi-zai, pi-zai-restricted, pi-zai-readonly, sdk-bypass, sdk-prompted, sdk-restricted, standard, worker, voice)")
     # Roles
     new_parser.add_argument("--roles", help="Comma-separated list of roles (preserves existing config, defaults to agentwire for new projects)")
     new_parser.add_argument("--model", help="Model override (e.g., haiku, sonnet, opus)")
@@ -10222,6 +10367,10 @@ def main() -> int:
         "--input-file", metavar="PATH",
         help="JSON file with inputs (object mapping name → value)"
     )
+    wf_run.add_argument(
+        "--runner", choices=["pi", "anthropic"], default=None,
+        help="Override runner for every node in this run (YAML declarations ignored)."
+    )
     wf_run.add_argument("--dry-run", action="store_true", help="Print plan without running")
     wf_run.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
     wf_run.add_argument("--json", action="store_true", help="Output as JSON")

{agentwire_dev-1.23.0 → agentwire_dev-1.24.0}/agentwire/channels/email.py

@@ -166,8 +166,34 @@ def _get_email_config() -> EmailConfig:
     return EmailConfig()
 
 
+def _normalize_recipients(to: Optional[str | list[str]], default_to: str) -> list[str]:
+    """Flatten `to` (str | list[str]) into a deduped list, splitting on commas.
+
+    Accepts: None, "a@x.com", "a@x.com,b@y.com", ["a@x.com"], ["a,b", "c"].
+    Falls back to `default_to` (also comma-split) when `to` is None/empty.
+    Preserves order, drops duplicates and empty entries.
+    """
+    raw: list[str] = []
+    if not to:
+        raw = [default_to] if default_to else []
+    elif isinstance(to, str):
+        raw = [to]
+    else:
+        raw = list(to)
+
+    out: list[str] = []
+    seen: set[str] = set()
+    for entry in raw:
+        for part in str(entry).split(","):
+            addr = part.strip()
+            if addr and addr not in seen:
+                seen.add(addr)
+                out.append(addr)
+    return out
+
+
 def send_email(
-    to: Optional[str] = None,
+    to: Optional[str | list[str]] = None,
     subject: str = "",
     body: str = "",
     attachments: Optional[list[Path | str]] = None,
@@ -178,7 +204,8 @@ def send_email(
     """Send a branded email via Resend.
 
     Args:
-        to: Recipient email address. Uses config default_to if not specified.
+        to: Recipient email(s). Accepts a single address, a comma-separated
+            string, or a list of either. Uses config default_to if not specified.
         subject: Email subject line.
         body: Email body (markdown supported, converted to HTML).
         attachments: List of file paths to attach.
@@ -202,9 +229,9 @@ def send_email(
             "or set channels.email.api_key in ~/.agentwire/config.yaml"
         )
 
-    # Determine recipient
-    recipient = to or email_config.default_to
-    if not recipient:
+    # Determine recipients (list form — Resend's `to` field accepts an array)
+    recipients = _normalize_recipients(to, email_config.default_to)
+    if not recipients:
         raise EmailConfigError(
             "No recipient specified and no default_to configured in "
             "channels.email.default_to"
@@ -247,7 +274,7 @@ def send_email(
 
     params: dict = {
         "from": sender,
-        "to": [recipient],
+        "to": recipients,
         "subject": email_subject,
     }