agentwire-dev 1.20.0__tar.gz → 1.22.0__tar.gz

{agentwire_dev-1.20.0 → agentwire_dev-1.22.0}/.github/ISSUE_TEMPLATE/bug_report.md

@@ -29,7 +29,7 @@ What actually happens.
 - **OS:** (e.g., macOS 14.2, Ubuntu 22.04)
 - **Python:** (e.g., 3.11.5)
 - **AgentWire version:** (run `agentwire --version`)
-- **Agent:** (Claude Code / claudeGLM / Other)
+- **Agent:** (Claude Code)
 
 ## Logs
 

{agentwire_dev-1.20.0 → agentwire_dev-1.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.20.0
+Version: 1.22.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.20.0 → agentwire_dev-1.22.0}/agentwire/__init__.py

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

{agentwire_dev-1.20.0 → agentwire_dev-1.22.0}/agentwire/__main__.py

@@ -2,7 +2,7 @@
 
 import argparse
 import base64
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 import datetime
 import importlib.resources
 import json
@@ -81,15 +81,75 @@ class AgentCommand:
     """Result of building an agent command."""
     command: str  # The shell command to execute
     temp_file: str | None = None  # Temp file to clean up after agent starts
+    env: dict[str, str] = field(default_factory=dict)  # Secrets to inject via tmux set-environment (keeps keys out of `ps`)
+
+
+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.
+
+    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).
+    """
+    if not env:
+        return
+    for key, value in env.items():
+        if remote_host:
+            subprocess.run(
+                ["ssh", remote_host, "tmux", "set-environment", "-t",
+                 shlex.quote(session), shlex.quote(key), shlex.quote(value)],
+                check=False,
+            )
+        else:
+            subprocess.run(
+                ["tmux", "set-environment", "-t", session, key, value],
+                check=False,
+            )
+
+
+def parse_env_args(env_args: list[str] | None) -> dict[str, str]:
+    """Parse repeated `--env KEY=VAL` flags into a dict.
+
+    Raises SystemExit via argparse pattern if an entry lacks `=`.
+    """
+    if not env_args:
+        return {}
+    result: dict[str, str] = {}
+    for entry in env_args:
+        if "=" not in entry:
+            print(f"Error: --env expects KEY=VAL, got {entry!r}", file=sys.stderr)
+            sys.exit(2)
+        key, value = entry.split("=", 1)
+        if not key:
+            print(f"Error: --env KEY cannot be empty (got {entry!r})", file=sys.stderr)
+            sys.exit(2)
+        result[key] = value
+    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", "claudeglm-bypass", "bare")
+        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")
+        model: Optional model override (e.g., "haiku", "sonnet", "opus", "glm-5")
 
     Returns:
         AgentCommand with the command string and metadata
@@ -101,60 +161,47 @@ def build_agent_command(session_type: str, roles: list[RoleConfig] | None = None
     # Merge roles if provided
     merged = merge_roles(roles) if roles else None
 
-    # === Claude Code via Z.AI GLM (must check before "claude" since "claudeglm" starts with "claude") ===
-    if session_type.startswith("claudeglm"):
+    # === Pi coding agent via Z.AI GLM ===
+    if session_type.startswith("pi-zai"):
         config = load_config()
         zai = config.get("zai", {})
+        pi_config = config.get("pi", {})
 
-        # Build env var prefix for command line (inline, so the running shell picks them up)
-        env_prefix = (
-            f"ANTHROPIC_AUTH_TOKEN={shlex.quote(zai.get('api_key', ''))} "
-            f"ANTHROPIC_BASE_URL={shlex.quote(zai.get('base_url', 'https://api.z.ai/api/anthropic'))} "
-            f"ANTHROPIC_DEFAULT_OPUS_MODEL={shlex.quote(zai.get('opus_model', 'glm-5'))} "
-            f"ANTHROPIC_DEFAULT_SONNET_MODEL={shlex.quote(zai.get('sonnet_model', 'glm-5'))} "
-            f"ANTHROPIC_DEFAULT_HAIKU_MODEL={shlex.quote(zai.get('haiku_model', 'glm-4.7-flash'))} "
-            f"API_TIMEOUT_MS={shlex.quote(str(zai.get('timeout_ms', 3000000)))} "
-        )
+        # 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")
 
-        parts = [env_prefix + "claude"]
+        parts = [pi_binary, "--provider", "zai"]
+        parts.extend(["--model", model or default_model])
 
-        # Permission flags (same as claude-*)
-        if session_type == "claudeglm-bypass":
-            parts.append("--dangerously-skip-permissions")
-        elif session_type == "claudeglm-restricted":
-            parts.append("--tools Bash")
-
-        # Model override
-        if model:
-            parts.append(f"--model {model}")
-
-        # GLM-5 system prompt — replaces Claude's default identity with GLM-5 identity
-        # while preserving all tool usage, safety, and behavioral instructions
-        glm_prompt_path = Path(__file__).parent / "glm_system_prompt.md"
-        glm_prompt = glm_prompt_path.read_text()
-
-        # Append role instructions to the system prompt (not for restricted mode)
+        # Permission variants (pi has no permission system to bypass; variants
+        # translate to pi's --tools whitelist instead)
         temp_file = None
-        if merged and session_type != "claudeglm-restricted":
-            if merged.tools:
-                parts.append(f"--tools {','.join(merged.tools)}")
-
-            if merged.disallowed_tools:
-                parts.append(f"--disallowedTools {','.join(merged.disallowed_tools)}")
-
-            if merged.instructions:
-                glm_prompt += "\n\n" + merged.instructions
-
-        # Write combined system prompt to temp file
-        f = tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False)
-        f.write(glm_prompt)
-        f.close()
-        temp_file = f.name
-        parts.append(f'--system-prompt "$(<{temp_file})"')
+        if session_type == "pi-zai-restricted":
+            parts.extend(["--tools", "read,grep,find,bash"])
+        elif session_type == "pi-zai-readonly":
+            parts.extend(["--tools", "read,grep,find"])
+        elif merged and merged.tools:
+            # Translate Claude tool names to pi's lowercase tool names.
+            # Pi only supports: read, bash, edit, write, grep, find, ls
+            pi_valid = {"read", "bash", "edit", "write", "grep", "find", "ls"}
+            pi_tools = [t.lower() for t in merged.tools if t.lower() in pi_valid]
+            if pi_tools:
+                parts.extend(["--tools", ",".join(pi_tools)])
+
+        # Role-based system prompt (skipped for restricted/readonly — those are curated contexts)
+        if merged and merged.instructions and session_type not in ("pi-zai-restricted", "pi-zai-readonly"):
+            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,
+            env={"ZAI_API_KEY": zai.get("api_key", "")},
         )
 
     # === Claude Code ===
@@ -333,6 +380,27 @@ def tmux_session_exists(name: str) -> bool:
     return result.returncode == 0
 
 
+def wait_for_shell_prompt(target: str, timeout: float = 2.0) -> None:
+    """Poll tmux capture-pane until the shell has drawn a prompt.
+
+    Prevents a race where send-keys fires before the shell is ready, causing
+    the command to appear in the pre-prompt buffer and again after the prompt
+    renders (looks like it ran twice).
+    """
+    import time
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        result = subprocess.run(
+            ["tmux", "capture-pane", "-t", target, "-p"],
+            capture_output=True, text=True,
+        )
+        if result.returncode == 0 and any(
+            c in result.stdout for c in ("$", "%", "#", "❯", "➜", ">")
+        ):
+            return
+        time.sleep(0.05)
+
+
 def _get_session_project_path(session: str) -> Path | None:
     """Get a session's project path from its tmux working directory.
 
@@ -3459,8 +3527,7 @@ def cmd_new(args) -> int:
 
         # Build agent command
         agent = build_agent_command(session_type, roles if roles else None)
-
-    
+        agent.env.update(parse_env_args(getattr(args, 'env', None)))
 
         agent_cmd = agent.command
 
@@ -3481,12 +3548,15 @@ 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)
+
         # Create session - Agent starts immediately if not bare
         if agent_cmd:
             create_cmd = (
                 f"tmux new-session -d -s {shlex.quote(session_name)} -c {shlex.quote(remote_path)} && "
                 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:
@@ -3627,9 +3697,13 @@ def cmd_new(args) -> int:
     # Build agent command
     model_override = getattr(args, 'model', None)
     agent = build_agent_command(session_type, roles if roles else None, model=model_override)
+    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(session_name, agent.env)
+
     # Start agent command if not bare
     if agent_cmd:
         subprocess.run(
@@ -4127,10 +4201,17 @@ def cmd_spawn(args) -> int:
 
     # Build agent command
     agent = build_agent_command(session_type_str, roles if roles else None)
+    agent.env.update(parse_env_args(getattr(args, 'env', None)))
 
     agent_cmd = agent.command
 
     try:
+        # Inject secrets onto the parent session before spawning the pane so the
+        # new pane inherits them from tmux (avoids putting keys in `ps`).
+        parent_session = session or pane_manager.get_current_session()
+        if parent_session:
+            inject_session_env(parent_session, agent.env)
+
         # Spawn pane first to get the pane index
         pane_index = pane_manager.spawn_worker_pane(
             session=session,
@@ -4507,12 +4588,15 @@ def cmd_recreate(args) -> int:
 
         # Build agent command using the standard function
         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)
 
         create_cmd = (
             f"tmux new-session -d -s {shlex.quote(session_name)} -c {shlex.quote(session_path)} && "
             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"
         )
 
@@ -4609,6 +4693,7 @@ def cmd_recreate(args) -> int:
 
     # Build agent command
     agent = build_agent_command(session_type_str, roles)
+    agent.env.update(parse_env_args(getattr(args, 'env', None)))
 
     agent_cmd = agent.command
 
@@ -4625,6 +4710,9 @@ 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(
@@ -4689,6 +4777,7 @@ def cmd_worktree(args) -> int:
             'force': False, 'bare': False, 'restricted': False, 'prompted': False,
             'type': getattr(args, 'type', None), 'roles': getattr(args, 'roles', None),
             'instructions': None, 'persist': False,
+            'env': getattr(args, 'env', None),
         })())
 
     # If worktree already exists, reattach
@@ -4881,13 +4970,16 @@ def cmd_fork(args) -> int:
 
         # Build agent command
         agent = build_agent_command(session_type_str, roles)
+        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)
 
         create_session_cmd = (
             f"tmux new-session -d -s {shlex.quote(target_session)} -c {shlex.quote(target_path)} && "
             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"
         )
 
@@ -5034,6 +5126,10 @@ def cmd_fork(args) -> int:
 
         # Build agent command
         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)
 
         agent_cmd = agent.command
         if agent_cmd:
@@ -5147,7 +5243,12 @@ def cmd_fork(args) -> int:
 
     # Build agent command
     agent = build_agent_command(session_type_str, roles)
+    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)
+
     if agent_cmd:
         subprocess.run(
             ["tmux", "send-keys", "-t", target_session, agent_cmd, "Enter"],
@@ -5745,8 +5846,12 @@ def cmd_dev(args) -> int:
         "tmux", "new-session", "-d", "-s", session_name, "-c", str(project_dir),
     ])
 
+    # 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)
         subprocess.run([
             "tmux", "send-keys", "-t", session_name, agent_cmd, "Enter",
         ])
@@ -6103,6 +6208,23 @@ def cmd_doctor(args) -> int:
         print("  [..] claude: not found (optional, use --bare sessions or other agents)")
         print("     Install: https://github.com/anthropics/claude-code")
 
+    # Check Pi coding agent (optional, for pi-zai session types)
+    pi_path = shutil.which("pi")
+    if pi_path:
+        try:
+            # Pi prints --version to stderr, so merge with stdout
+            result = subprocess.run(
+                [pi_path, "--version"],
+                capture_output=True, text=True, timeout=5,
+            )
+            pi_version = (result.stdout + result.stderr).strip()
+            print(f"  [ok] pi: {pi_path} (v{pi_version})")
+        except Exception:
+            print(f"  [ok] pi: {pi_path}")
+    else:
+        print("  [..] pi: not found (optional, required for pi-zai session types)")
+        print("     Install: npm install -g @mariozechner/pi-coding-agent")
+
     # 3. Check AgentWire scripts
     print("\nChecking AgentWire scripts...")
 
@@ -9888,11 +10010,12 @@ def main() -> int:
     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, claudeglm-bypass, claudeglm-prompted, claudeglm-restricted, 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, 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)")
     new_parser.add_argument("--persist", action="store_true", help="Write --type/--roles to .agentwire.yml (default: session-level override only)")
+    new_parser.add_argument("--env", action="append", metavar="KEY=VAL", help="Inject env var via `tmux set-environment` (repeatable, keeps secrets out of `ps`)")
     new_parser.add_argument("--json", action="store_true", help="Output as JSON")
     new_parser.set_defaults(func=cmd_new)
 
@@ -9923,10 +10046,11 @@ def main() -> int:
     spawn_parser.add_argument("-s", "--session", help="Target session (default: auto-detect)")
     spawn_parser.add_argument("--cwd", help="Working directory (default: current)")
     spawn_parser.add_argument("--branch", "-b", help="Create worktree on this branch for isolated commits")
-    spawn_parser.add_argument("--type", help="Session type (claude-bypass, claude-prompted, claude-restricted, claudeglm-bypass, claudeglm-prompted, claudeglm-restricted)")
+    spawn_parser.add_argument("--type", help="Session type (claude-bypass, claude-prompted, claude-restricted, pi-zai, pi-zai-restricted, pi-zai-readonly)")
     spawn_parser.add_argument("--roles", default="worker", help="Comma-separated roles (default: worker)")
     spawn_parser.add_argument("--no-wait", action="store_true", help="Don't wait for worker to be ready (default: wait up to 30s)")
     spawn_parser.add_argument("--timeout", type=int, default=30, help="Seconds to wait for worker ready (default: 30)")
+    spawn_parser.add_argument("--env", action="append", metavar="KEY=VAL", help="Inject env var onto parent session (repeatable)")
     spawn_parser.add_argument("--json", action="store_true", help="Output as JSON")
     spawn_parser.set_defaults(func=cmd_spawn)
 
@@ -9961,7 +10085,8 @@ def main() -> int:
     recreate_parser = subparsers.add_parser("recreate", help="Destroy and recreate session with fresh worktree")
     recreate_parser.add_argument("-s", "--session", required=True, help="Session name (project/branch or project/branch@machine)")
     # Session type
-    recreate_parser.add_argument("--type", help="Session type (bare, claude-bypass, claude-prompted, claude-restricted, claudeglm-bypass, claudeglm-prompted, claudeglm-restricted, standard, worker, voice)")
+    recreate_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)")
+    recreate_parser.add_argument("--env", action="append", metavar="KEY=VAL", help="Inject env var via `tmux set-environment` (repeatable)")
     recreate_parser.add_argument("--json", action="store_true", help="Output as JSON")
     recreate_parser.set_defaults(func=cmd_recreate)
 
@@ -9970,8 +10095,9 @@ def main() -> int:
     fork_parser.add_argument("-s", "--source", required=True, help="Source session (project or project/branch)")
     fork_parser.add_argument("-t", "--target", required=True, help="Target session (must include branch: project/new-branch)")
     # Session type
-    fork_parser.add_argument("--type", help="Session type (bare, claude-bypass, claude-prompted, claude-restricted, claudeglm-bypass, claudeglm-prompted, claudeglm-restricted, standard, worker, voice)")
+    fork_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)")
     fork_parser.add_argument("--commit", metavar="REF", help="Fork from this commit/ref instead of HEAD (e.g. abc123, main~5)")
+    fork_parser.add_argument("--env", action="append", metavar="KEY=VAL", help="Inject env var via `tmux set-environment` (repeatable)")
     fork_parser.add_argument("--json", action="store_true", help="Output as JSON")
     fork_parser.set_defaults(func=cmd_fork)
 
@@ -9985,6 +10111,7 @@ def main() -> int:
     wt_parser.add_argument("--project", "-p", help="Path to git repo (default: from config or cwd)")
     wt_parser.add_argument("--type", help="Session type override")
     wt_parser.add_argument("--roles", help="Comma-separated role names")
+    wt_parser.add_argument("--env", action="append", metavar="KEY=VAL", help="Inject env var via `tmux set-environment` (repeatable)")
     wt_parser.add_argument("--json", action="store_true", help="Output as JSON")
     wt_parser.set_defaults(func=cmd_worktree)
 
@@ -9994,6 +10121,70 @@ def main() -> int:
     )
     dev_parser.set_defaults(func=cmd_dev)
 
+    # === workflow command group ===
+    from agentwire.workflows.cli import (
+        cmd_workflow_history,
+        cmd_workflow_list,
+        cmd_workflow_run,
+        cmd_workflow_show,
+        cmd_workflow_validate,
+    )
+
+    workflow_parser = subparsers.add_parser("workflow", help="Pi workflow engine")
+    workflow_subparsers = workflow_parser.add_subparsers(dest="workflow_command")
+
+    wf_list = workflow_subparsers.add_parser("list", help="List discoverable workflows")
+    wf_list.add_argument("--json", action="store_true", help="Output as JSON")
+    wf_list.set_defaults(func=cmd_workflow_list)
+
+    wf_validate = workflow_subparsers.add_parser(
+        "validate", help="Validate a workflow YAML without running it"
+    )
+    wf_validate.add_argument("workflow", help="Workflow name or path to YAML")
+    wf_validate.set_defaults(func=cmd_workflow_validate)
+
+    wf_run = workflow_subparsers.add_parser("run", help="Execute a workflow")
+    wf_run.add_argument("workflow", help="Workflow name or path to YAML")
+    wf_run.add_argument(
+        "--input", action="append", metavar="KEY=VALUE",
+        help="Workflow input (repeatable). Overrides --input-file."
+    )
+    wf_run.add_argument(
+        "--input-file", metavar="PATH",
+        help="JSON file with inputs (object mapping name → value)"
+    )
+    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")
+    wf_run.set_defaults(func=cmd_workflow_run)
+
+    wf_history = workflow_subparsers.add_parser(
+        "history", help="List past workflow runs"
+    )
+    wf_history.add_argument(
+        "--workflow", metavar="NAME", help="Filter by workflow name"
+    )
+    wf_history.add_argument(
+        "--limit", type=int, default=20, help="Max runs to show (default: 20)"
+    )
+    wf_history.add_argument("--json", action="store_true", help="Output as JSON")
+    wf_history.set_defaults(func=cmd_workflow_history)
+
+    wf_show = workflow_subparsers.add_parser(
+        "show", help="Inspect a past workflow run"
+    )
+    wf_show.add_argument("run_id", help="Run ID (from `workflow history`)")
+    wf_show.add_argument(
+        "--events", action="store_true",
+        help="Dump raw event JSONL for all nodes",
+    )
+    wf_show.add_argument(
+        "--node", metavar="ID",
+        help="Filter events to one node id (implies --events)",
+    )
+    wf_show.add_argument("--json", action="store_true", help="Output as JSON")
+    wf_show.set_defaults(func=cmd_workflow_show)
+
     # === listen command group ===
     listen_parser = subparsers.add_parser("listen", help="Voice input recording")
     listen_parser.add_argument(

{agentwire_dev-1.20.0 → agentwire_dev-1.22.0}/agentwire/config.py

@@ -74,6 +74,7 @@ class ProjectsConfig:
 
     dir: Path = field(default_factory=lambda: Path.home() / "projects")
     worktrees: WorktreesConfig = field(default_factory=WorktreesConfig)
+    extra: list = field(default_factory=list)
 
     def __post_init__(self):
         self.dir = _expand_path(self.dir) or Path.home() / "projects"
@@ -355,6 +356,7 @@ def _dict_to_config(data: dict) -> Config:
     projects = ProjectsConfig(
         dir=projects_data.get("dir", "~/projects"),
         worktrees=worktrees,
+        extra=projects_data.get("extra", []),
     )
 
     # TTS