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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.21.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.21.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.21.0"
+__version__ = "1.22.0"

{agentwire_dev-1.21.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", "claude-auto", "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,6 +161,49 @@ def build_agent_command(session_type: str, roles: list[RoleConfig] | None = None
     # Merge roles if provided
     merged = merge_roles(roles) if roles else None
 
+    # === 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", {})
+
+        # 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 = [pi_binary, "--provider", "zai"]
+        parts.extend(["--model", model or default_model])
+
+        # Permission variants (pi has no permission system to bypass; variants
+        # translate to pi's --tools whitelist instead)
+        temp_file = None
+        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 ===
     if session_type.startswith("claude"):
         parts = ["claude"]
@@ -277,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.
 
@@ -3403,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
 
@@ -3425,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:
@@ -3571,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(
@@ -4071,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,
@@ -4451,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"
         )
 
@@ -4553,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
 
@@ -4569,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(
@@ -4633,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
@@ -4825,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"
         )
 
@@ -4978,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:
@@ -5091,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"],
@@ -5689,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",
         ])
@@ -6047,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...")
 
@@ -9832,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, 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)
 
@@ -9867,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)")
+    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)
 
@@ -9905,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, 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)
 
@@ -9914,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, 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)
 
@@ -9929,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)
 
@@ -9938,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.21.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

{agentwire_dev-1.21.0 → agentwire_dev-1.22.0}/agentwire/mcp_server.py

@@ -2457,6 +2457,141 @@ def desktop_layout(windows: list[dict]) -> str:
     return f"Failed to apply layout: {data.get('error', 'Unknown error')}"
 
 
+@mcp.tool()
+def portal_notify(text: str, session: str | None = None, priority: str = "normal") -> str:
+    """Post a toast notification to the portal desktop.
+
+    Creates a persistent visual notification in the bottom-right of the portal.
+    Clicking the toast opens the notifications session for interactive chat.
+
+    Args:
+        text: Notification message text.
+        session: Session name this notification relates to (shown as badge).
+        priority: 'normal' or 'high' (high gets accent border).
+
+    Returns:
+        Notification ID or error description.
+    """
+    body = {"text": text, "priority": priority}
+    if session:
+        body["session"] = session
+    data = _portal_request("POST", "/api/desktop/notification", body)
+    if data.get("success"):
+        return f"Notification posted (id: {data.get('id')})."
+    return f"Failed to post notification: {data.get('error', 'Unknown error')}"
+
+
+
+# =============================================================================
+# Workflow engine tools
+# =============================================================================
+
+
+@mcp.tool()
+def workflow_list() -> str:
+    """List discoverable pi workflows.
+
+    Returns workflow names, descriptions, and node counts. Workflows live in
+    ~/.agentwire/workflows/defs/ or the bundled examples dir.
+    """
+    data = run_agentwire_cmd(["workflow", "list"])
+    if not data.get("success"):
+        return f"Failed to list workflows: {data.get('error', 'Unknown error')}"
+
+    items = data.get("items", [])
+    if not items:
+        return "No workflows found."
+
+    lines = ["Available workflows:"]
+    for wf in items:
+        name = wf.get("name", "?")
+        desc = wf.get("description", "")
+        count = len(wf.get("nodes", []))
+        lines.append(f"  - {name} ({count} node{'s' if count != 1 else ''})"
+                     + (f" — {desc}" if desc else ""))
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def workflow_validate(name_or_path: str) -> str:
+    """Parse + validate a workflow YAML without running it.
+
+    Args:
+        name_or_path: Workflow name (e.g. "echo-chain") or path to YAML file.
+    """
+    data = run_agentwire_cmd(["workflow", "validate", name_or_path])
+    if data.get("success"):
+        return data.get("output", f"Workflow {name_or_path!r} is valid.")
+    return f"Validation failed: {data.get('output', data.get('error', 'Unknown error'))}"
+
+
+@mcp.tool()
+def workflow_run(
+    name: str,
+    inputs: dict | None = None,
+    dry_run: bool = False,
+) -> dict:
+    """Execute a pi workflow end-to-end.
+
+    Args:
+        name: Workflow name or path to YAML.
+        inputs: Optional map of input name → value, forwarded as --input KEY=VAL.
+        dry_run: If true, print the execution plan without invoking pi.
+
+    Returns:
+        Full run result as a dict: workflow, run_id, status
+        (success|partial|failure), duration_ms, error, nodes[].
+    """
+    args = ["workflow", "run", name]
+    for key, value in (inputs or {}).items():
+        args.extend(["--input", f"{key}={value}"])
+    if dry_run:
+        args.append("--dry-run")
+    # pi calls routinely take minutes; default 30s is not enough.
+    return run_agentwire_cmd(args, timeout=600)
+
+
+@mcp.tool()
+def workflow_history(workflow: str | None = None, limit: int = 20) -> str:
+    """List past workflow runs, newest first.
+
+    Args:
+        workflow: Filter to a single workflow name (optional).
+        limit: Max runs to return (default 20).
+    """
+    args = ["workflow", "history", "--limit", str(limit)]
+    if workflow:
+        args.extend(["--workflow", workflow])
+    data = run_agentwire_cmd(args)
+    if not data.get("success"):
+        return f"Failed to list runs: {data.get('error', 'Unknown error')}"
+
+    runs = data.get("items", [])
+    if not runs:
+        return "No past runs found."
+
+    lines = ["Past runs:"]
+    for run in runs:
+        rid = run.get("run_id", "?")
+        name = run.get("workflow", "?")
+        status = run.get("status", "?")
+        duration_ms = run.get("duration_ms", 0)
+        lines.append(f"  - {rid}  [{name}]  {status}  {duration_ms}ms")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def workflow_show(run_id: str) -> dict:
+    """Fetch metadata for a single past workflow run.
+
+    Args:
+        run_id: Run identifier from `workflow_history`.
+
+    Returns:
+        The run's metadata.json contents (workflow, status, inputs, node
+        summaries with timing + tokens + errors).
+    """
+    return run_agentwire_cmd(["workflow", "show", run_id])
 
 
 # =============================================================================

{agentwire_dev-1.21.0 → agentwire_dev-1.22.0}/agentwire/overnight.py

@@ -498,7 +498,7 @@ def dispatch_item(item: OvernightItem, config) -> bool:
 
     Returns True if dispatch succeeded.
     """
-    from .__main__ import build_agent_command, _wait_for_agent_ready
+    from .__main__ import build_agent_command, _wait_for_agent_ready, inject_session_env
 
     project = item.project_path
     session = item.session
@@ -538,6 +538,9 @@ def dispatch_item(item: OvernightItem, config) -> bool:
         _log_event("dispatch_failed", item_id=item.id, error=item.error)
         return False
 
+    # Inject secrets via tmux set-environment (keeps keys out of `ps`)
+    inject_session_env(session, agent.env)
+
     # Inject --resume <id> --fork-session
     if item.resume_session_id:
         claude_pos = agent_cmd.rfind("claude")