agentwire-dev 1.47.0__tar.gz → 1.48.0__tar.gz

agentwire_dev-1.48.0/.claude/commands/handoff.md

@@ -0,0 +1,142 @@
+---
+description: Distill this conversation into a shareable handoff bundle (ai-handoff.md + show-the-story.html)
+---
+
+# /handoff
+
+You are about to compile this conversation into a **shareable handoff bundle**. The output is two artifacts:
+
+1. **`ai-handoff.md`** — XML-tagged markdown a teammate can paste into another LLM (Opus 4.7) to roughly continue the conversation.
+2. **`show-the-story.html`** — single-file presentation a human can open in a browser.
+
+You are uniquely positioned to do this well: you already have full conversation context. Don't ask the user clarifying questions unless something is genuinely ambiguous — distill what you know.
+
+## Workflow
+
+### 1. Initialize the bundle
+
+Call the MCP tool to create the bundle dir and pre-fill the template with git state and the CLAUDE.md/rules/memory chain:
+
+```
+mcp__agentwire__handoff_init(title="<short slug>")
+```
+
+The tool returns a `bundle_dir` and an `ai_handoff_path`. The pre-filled template at `ai_handoff_path` already has:
+- `<metadata>` populated with cwd, branch, commit, repo url
+- `<instructions>` populated with the full CLAUDE.md chain (verbatim)
+- `<project_state>` populated with `git status`, `git log`, and uncommitted diff
+
+You **must not touch** the `<instructions>` section unless redacting something sensitive — it's what makes the bundle portable across machines.
+
+### 2. Read the pre-filled template
+
+Use Read on `ai_handoff_path` to see exactly what got pre-filled.
+
+### 3. Fill in the rest
+
+Use Write (or Edit) on `ai_handoff_path` to replace every `{{ ... }}` placeholder with real content. Specifically:
+
+#### `<title>`
+One short line summarizing the session — what it was about, not what was decided. Roughly 4-8 words.
+
+#### `<metadata>` extras
+Fill `started_at` / `ended_at` if you can estimate them, `user_identity` (if mentioned), and `mcp_servers` (the ones actually used in this conversation).
+
+#### `<environment>`
+What the receiver can't see from `cwd` alone. Active panes, channels (Slack/Discord/email), scheduler state if relevant. If nothing notable, write a one-line "no special environment" note.
+
+#### `<conversation_summary>`
+This is the most load-bearing section. Be dense and structured.
+
+- `<goal>` — one sentence: what this session set out to do.
+- `<tldr>` — one paragraph the receiver reads first. Convey decisions made, current state, and what's next.
+- `<decisions>` — every meaningful decision. For each: `<title>` (short name), `<rationale>` (why), `<alternatives>` (what was considered and not picked). If a user message confirmed a choice, that's a decision.
+- `<dead_ends>` — things tried and rejected. Critical: this saves the receiver from retracing your steps.
+- `<open_threads>` — what's unresolved. Be specific. "tests/handoff/test_parser.py needs malformed-input cases" beats "tests pending".
+- `<stats>` — turns, files_touched, tools_used, duration_minutes. Estimates are fine.
+
+#### `<journey>`
+3-7 narrative beats — the *story* of the session, not the transcript. For each beat:
+- `<beat title="...">` — short headline.
+- `<quote>...</quote>` — optional verbatim line from the conversation that captured the turn (user or assistant).
+- `<what_happened>...</what_happened>` — what actually changed.
+
+This drives the visual presentation in show-the-story.html. Aim for memorable beats: turning points, surprises, decisions, blockers.
+
+#### `<recent_turns>`
+The last ~10-20 turns, **filtered**:
+- Drop tool noise (file reads, searches) unless the result drove a decision.
+- Keep all user turns verbatim — they're the signal of intent.
+- Keep assistant turns that made decisions, asked questions, or summarized.
+- Use markdown: `**user:**` / `**assistant:**` labels, blockquotes for quoted content.
+
+#### `<handoff>`
+Direct instructions to the next agent.
+- `<one_sentence>` — what they should do first.
+- `<resume_at>` — concrete file path / TODO id / step number.
+- `<caveats>` — permission boundaries ("don't push", "don't edit X without asking"), env-specific notes, anything the receiver could trip on.
+
+#### `<theme>`
+Pick a palette and vibe that matches the **emotional tone** of the session. A debugging crisis at 2am gets different colors than a clean greenfield design pass. Be honest in `mood`. The shape:
+
+```json
+{
+  "name": "short-slug",
+  "mood": "honest read of the session's emotional tone — 1 short sentence",
+  "palette": {
+    "bg": "#hex",
+    "surface": "#hex",
+    "fg": "#hex",
+    "muted": "#hex",
+    "accent": "#hex",
+    "accent_2": "#hex",
+    "border": "#hex"
+  },
+  "fonts": {
+    "heading": "css font-family stack",
+    "body": "css font-family stack"
+  },
+  "motion": "subtle"
+}
+```
+
+Tips:
+- Dark backgrounds work better in this template — `bg` should be deep.
+- `accent` is the dominant interactive color (tabs, headlines, highlights). Pick something that signals the mood.
+- `accent_2` is for warnings / dead-ends. Often a warm color.
+- Keep `fonts.heading` monospace-leaning, `fonts.body` sans-serif. Override only if the mood justifies it.
+- `motion`: `"subtle"` (default), `"playful"` (longer transitions), `"none"` (instant).
+
+### 4. Render the HTML
+
+After writing `ai-handoff.md`, render the HTML:
+
+```
+mcp__agentwire__handoff_render(bundle_dir="<from step 1>", story=true)
+```
+
+If render fails, the parser will tell you which tag is missing or malformed — fix and re-run.
+
+### 5. Report
+
+Give the user:
+- The bundle dir path
+- A one-sentence summary of what you produced
+- An explicit pointer to open `show-the-story.html` in a browser
+
+Don't paste the full ai-handoff.md back — it's long. Just confirm it's saved and mention the highlights you captured (number of decisions, dead ends, journey beats, theme name/mood).
+
+## Quality bar
+
+The receiver's first impression is everything. A great handoff:
+- Reads cold — the receiver doesn't need to be in this folder.
+- Is honest about dead ends. Hiding what didn't work wastes the receiver's tokens.
+- Names specific files and line numbers, not vague pointers.
+- Picks a theme that captures the session's actual feel. Don't pick "professional blue" for a chaotic debug session.
+
+## Don't
+
+- Don't ask the user "should I include X?" — make the call yourself.
+- Don't paste the entire conversation as `<recent_turns>` — filter aggressively.
+- Don't over-design the theme. The structure is fixed; you're picking colors and vibes, not a layout.
+- Don't edit `<instructions>` (the CLAUDE.md chain) unless redacting secrets.

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/.gitignore

@@ -57,3 +57,6 @@ htmlcov/
 
 # pytest-textual-snapshot diff page (regenerated each run)
 snapshot_report.html
+
+# Node
+node_modules/

agentwire_dev-1.48.0/AGENTS.md

@@ -0,0 +1,5 @@
+# AgentWire
+
+Voice interface for AI coding agents. Push-to-talk from any device to tmux sessions running Claude Code.
+
+Agent instructions, conventions, and architecture live in [CLAUDE.md](CLAUDE.md).

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/CONTRIBUTING.md

@@ -144,7 +144,7 @@ def validate_config(config: Config) -> tuple[list[ConfigError], list[ConfigWarni
 
 ## CLI First
 
-All session/machine logic lives in CLI commands (`__main__.py`). The web portal is a thin wrapper that:
+All session/machine logic lives in the CLI. The command tree is split per-domain (#495): shared helpers (machine config, SSH, JSON output, session resolution, etc.) live in `core.py`; each command group lives in its own `agentwire/<domain>_cli.py` exposing a `register_<domain>_parser(subparsers)` registrar, and `build_parser()` imports them and runs the `_REGISTRARS` loop. `__main__.py` is just the entry point. Adding a command means writing a new `*_cli.py` + appending its registrar, not editing a god-file. The web portal is a thin wrapper that:
 
 1. Calls CLI via `run_agentwire_cmd(["command", "args"])`
 2. Parses JSON output (`--json` flag)
@@ -159,7 +159,9 @@ When adding new functionality:
 
 ```
 agentwire/
-├── __main__.py      # CLI commands (entry point)
+├── __main__.py      # CLI entry point (imports + runs the registrar loop)
+├── core.py          # Shared CLI helpers (machine config, SSH, JSON, session resolution)
+├── *_cli.py         # Per-domain command groups, each with a register_<domain>_parser()
 ├── server.py        # WebSocket server
 ├── config.py        # Configuration dataclasses
 ├── errors.py        # Structured error classes

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.47.0
+Version: 1.48.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
@@ -256,7 +256,6 @@ Requires-Dist: fastapi>=0.104.0; extra == 'tts'
 Requires-Dist: faster-whisper>=1.0.0; extra == 'tts'
 Requires-Dist: pydantic>=2.0.0; extra == 'tts'
 Requires-Dist: python-multipart>=0.0.6; extra == 'tts'
-Requires-Dist: runpod>=1.6.0; extra == 'tts'
 Requires-Dist: torch>=2.0.0; extra == 'tts'
 Requires-Dist: torchaudio>=2.0.0; extra == 'tts'
 Requires-Dist: uvicorn>=0.24.0; extra == 'tts'
@@ -295,9 +294,9 @@ structurally can't match:
   the machine.
 - **Voice-native, not voice-bolted-on.** Push-to-talk in, **neural TTS out on plain
   CPU** (Kokoro, no GPU). Want your agents to talk back in a **cloned voice**? Run a
-  self-hosted GPU shim (Chatterbox / Qwen / Zonos) — same machine, still your keys.
+  self-hosted GPU shim (Chatterbox / Zonos) — same machine, still your keys.
 - **Built to orchestrate _many_ agents, not watch one.** Council (multi-soul
-  deliberation), an overnight scheduler, briefing mode, and worktree-parallel
+  deliberation), a recurring scheduler, briefing mode, and worktree-parallel
   workers — tmux- and Claude-Code-native from the ground up.
 
 > **Use the official app to watch one session; use AgentWire to orchestrate many,
@@ -388,7 +387,7 @@ pip install agentwire-dev
 | **Voice Control** | Push-to-talk from any device on your network |
 | **Neural Voice + Cloning** | Kokoro neural TTS on CPU out of the box; voice cloning via a self-hosted GPU shim |
 | **Council** | Fan a prompt to multiple "soul" sessions (brain, conscience, critic…), synthesize with attribution |
-| **Scheduler** | Overnight / recurring autonomous tasks with gates, priorities, and usage-limit recovery |
+| **Scheduler** | Recurring autonomous tasks with gates, priorities, and usage-limit recovery |
 | **Briefing Mode** | A terse human-facing anchor fans out verbose worktree correspondents, then briefs you on cue |
 | **Multi-Session** | Run multiple agents on different projects simultaneously |
 | **Git Worktrees** | Same project, multiple branches, parallel agents |
@@ -474,7 +473,7 @@ Two tiers, both sides:
 # ~/.agentwire/config.yaml
 tts:
   backend: "custom"
-  url: "http://localhost:8100"     # agentwire tts start (kokoro CPU / chatterbox GPU / qwen / zonos)
+  url: "http://localhost:8100"     # agentwire tts start (kokoro CPU / chatterbox GPU / zonos)
   options:
     backend: kokoro
 stt:

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/README.md

@@ -31,9 +31,9 @@ structurally can't match:
   the machine.
 - **Voice-native, not voice-bolted-on.** Push-to-talk in, **neural TTS out on plain
   CPU** (Kokoro, no GPU). Want your agents to talk back in a **cloned voice**? Run a
-  self-hosted GPU shim (Chatterbox / Qwen / Zonos) — same machine, still your keys.
+  self-hosted GPU shim (Chatterbox / Zonos) — same machine, still your keys.
 - **Built to orchestrate _many_ agents, not watch one.** Council (multi-soul
-  deliberation), an overnight scheduler, briefing mode, and worktree-parallel
+  deliberation), a recurring scheduler, briefing mode, and worktree-parallel
   workers — tmux- and Claude-Code-native from the ground up.
 
 > **Use the official app to watch one session; use AgentWire to orchestrate many,
@@ -124,7 +124,7 @@ pip install agentwire-dev
 | **Voice Control** | Push-to-talk from any device on your network |
 | **Neural Voice + Cloning** | Kokoro neural TTS on CPU out of the box; voice cloning via a self-hosted GPU shim |
 | **Council** | Fan a prompt to multiple "soul" sessions (brain, conscience, critic…), synthesize with attribution |
-| **Scheduler** | Overnight / recurring autonomous tasks with gates, priorities, and usage-limit recovery |
+| **Scheduler** | Recurring autonomous tasks with gates, priorities, and usage-limit recovery |
 | **Briefing Mode** | A terse human-facing anchor fans out verbose worktree correspondents, then briefs you on cue |
 | **Multi-Session** | Run multiple agents on different projects simultaneously |
 | **Git Worktrees** | Same project, multiple branches, parallel agents |
@@ -210,7 +210,7 @@ Two tiers, both sides:
 # ~/.agentwire/config.yaml
 tts:
   backend: "custom"
-  url: "http://localhost:8100"     # agentwire tts start (kokoro CPU / chatterbox GPU / qwen / zonos)
+  url: "http://localhost:8100"     # agentwire tts start (kokoro CPU / chatterbox GPU / zonos)
   options:
     backend: kokoro
 stt:

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/RELEASING.md

@@ -34,10 +34,13 @@ unzip -l dist/agentwire_dev-{VERSION}-py3-none-any.whl | grep -E "templates/|sta
 
 ### 4. Publish to PyPI
 
-The `PYPI_TOKEN` lives in `~/.agentwire/.env`. Pass it explicitly:
+The `PYPI_TOKEN` lives in `~/.agentwire/.env`. Don't `source` the file — it can
+contain unquoted `&` in other values (e.g. a URL with query params), which makes
+the shell hit a parse error before `uv publish` ever runs. Grep the token out
+directly:
 
 ```bash
-source ~/.agentwire/.env && uv publish --token "$PYPI_TOKEN" dist/agentwire_dev-{VERSION}*
+uv publish --token "$(grep '^PYPI_TOKEN=' ~/.agentwire/.env | cut -d= -f2-)" dist/agentwire_dev-{VERSION}*
 ```
 
 ### 5. Create GitHub release

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/agentwire/__init__.py

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

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/agentwire/agents/base.py

@@ -1,26 +1,11 @@
 """Abstract base class for agent backends."""
 
 from abc import ABC, abstractmethod
-from pathlib import Path
 
 
 class AgentBackend(ABC):
     """Abstract base for managing AI coding agent sessions."""
 
-    @abstractmethod
-    def create_session(self, name: str, path: Path, options: dict | None = None) -> bool:
-        """Create a new agent session.
-
-        Args:
-            name: Session name (e.g., "api", "auth")
-            path: Working directory for the session
-            options: Optional backend-specific options
-
-        Returns:
-            True if session was created successfully
-        """
-        pass
-
     @abstractmethod
     def session_exists(self, name: str) -> bool:
         """Check if a session exists.
@@ -74,18 +59,6 @@ class AgentBackend(ABC):
         """
         pass
 
-    @abstractmethod
-    def kill_session(self, name: str) -> bool:
-        """Terminate a session.
-
-        Args:
-            name: Session name
-
-        Returns:
-            True if session was terminated successfully
-        """
-        pass
-
     @abstractmethod
     def list_sessions(self) -> list[str]:
         """List all active sessions.

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/agentwire/agents/tmux.py

@@ -3,7 +3,6 @@
 import json
 import logging
 import os
-import re
 import shlex
 import subprocess
 from pathlib import Path
@@ -13,30 +12,10 @@ from .base import AgentBackend
 
 logger = logging.getLogger(__name__)
 
-# Pattern to match env var prefix: VAR='value' or VAR="value" or VAR=value
-ENV_VAR_PREFIX_PATTERN = re.compile(r'^([A-Z_][A-Z0-9_]*)=([\'"]?)(.+?)\2\s+(.+)$')
-
 # Base command without permission flags - flags added based on bypass_permissions option
 DEFAULT_AGENT_COMMAND = "claude"
 
 
-def parse_env_var_prefix(command: str) -> tuple[str | None, str | None, str]:
-    """Parse env var prefix from a command string.
-
-    Handles commands like: VAR='value' some_command --args
-    Returns: (var_name, var_value, remaining_command)
-
-    If no env var prefix, returns (None, None, original_command)
-    """
-    match = ENV_VAR_PREFIX_PATTERN.match(command)
-    if match:
-        var_name = match.group(1)
-        var_value = match.group(3)  # The value without quotes
-        remaining = match.group(4)
-        return var_name, var_value, remaining
-    return None, None, command
-
-
 def _tmux_path() -> str:
     """Resolve tmux binary path, with fallback to common locations."""
     import shutil
@@ -183,107 +162,6 @@ class TmuxAgent(AgentBackend):
             return name, None
         return name, None
 
-    def _format_agent_command(self, name: str, path: Path, options: dict | None = None) -> str:
-        """Format the agent command with placeholders.
-
-        Args:
-            name: Session name
-            path: Working directory
-            options: Additional options including:
-                - model: Model to use
-                - session_id: Claude Code session UUID
-                - fork_from: Session ID to fork from (uses --resume --fork-session)
-                - bypass_permissions: If True, add --dangerously-skip-permissions flag
-
-        Returns:
-            Formatted command string
-        """
-        options = options or {}
-        model = options.get("model", self.default_model)
-        session_id = options.get("session_id")
-        fork_from = options.get("fork_from")
-        bypass_permissions = options.get("bypass_permissions", True)
-
-        cmd = self.agent_command
-        cmd = cmd.replace("{name}", name)
-        cmd = cmd.replace("{path}", str(path))
-        cmd = cmd.replace("{model}", model)
-
-        # Add permission bypass flag if requested
-        if bypass_permissions:
-            cmd = f"{cmd} --dangerously-skip-permissions"
-
-        # Add session ID if provided (for new sessions)
-        if session_id and not fork_from:
-            cmd = f"{cmd} --session-id {session_id}"
-
-        # Fork from existing session
-        if fork_from:
-            cmd = f"{cmd} --resume {fork_from} --fork-session"
-            # Also set the new session ID if provided
-            if session_id:
-                cmd = f"{cmd} --session-id {session_id}"
-
-        return cmd
-
-    def create_session(self, name: str, path: Path, options: dict | None = None) -> bool:
-        """Create a new tmux session and start the agent."""
-        options = options or {}
-        session_name, machine = self._parse_session_name(name)
-        agent_cmd = self._format_agent_command(session_name, path, options)
-
-        if machine:
-            projects_dir = machine.get("projects_dir", "~/projects")
-            remote_path = f"{projects_dir}/{path.name}" if not str(path).startswith("/") else str(path)
-
-            # Parse env var prefix (e.g., ANTHROPIC_AUTH_TOKEN='...' claude)
-            # Must use tmux set-environment for remote sessions since shlex.quote
-            # would break the env var assignment
-            env_var, env_val, actual_cmd = parse_env_var_prefix(agent_cmd)
-
-            cmd_parts = [
-                f"tmux new-session -d -s {shlex.quote(session_name)} -c {shlex.quote(remote_path)}"
-            ]
-
-            if env_var:
-                # Set env var in tmux session environment
-                cmd_parts.append(
-                    f"tmux set-environment -t {shlex.quote(session_name)} {env_var} {shlex.quote(env_val)}"
-                )
-
-            # Send the actual command (without env var prefix if it was extracted)
-            cmd_parts.append(
-                f"tmux send-keys -t {shlex.quote(session_name)} {shlex.quote(actual_cmd)} Enter"
-            )
-
-            cmd = " && ".join(cmd_parts)
-            result = self._run_remote(machine, cmd)
-        else:
-            # Create session
-            result = self._run_local([
-                "tmux", "new-session", "-d",
-                "-s", session_name,
-                "-c", str(path),
-            ])
-
-            if result.returncode != 0:
-                logger.error(f"Failed to create session: {result.stderr}")
-                return False
-
-            # Start agent
-            result = self._run_local([
-                "tmux", "send-keys",
-                "-t", session_name,
-                agent_cmd, "Enter",
-            ])
-
-        if result.returncode != 0:
-            logger.error(f"Failed to start agent: {result.stderr}")
-            return False
-
-        logger.info(f"Created session '{name}' at {path}")
-        return True
-
     def session_exists(self, name: str) -> bool:
         """Check if a tmux session exists."""
         session_name, machine = self._parse_session_name(name)
@@ -416,25 +294,6 @@ class TmuxAgent(AgentBackend):
 
         return True
 
-    def kill_session(self, name: str) -> bool:
-        """Terminate a tmux session."""
-        session_name, machine = self._parse_session_name(name)
-
-        if machine:
-            cmd = f"tmux kill-session -t {shlex.quote(session_name)}"
-            result = self._run_remote(machine, cmd)
-        else:
-            result = self._run_local([
-                "tmux", "kill-session", "-t", session_name,
-            ])
-
-        if result.returncode != 0:
-            logger.error(f"Failed to kill session: {result.stderr}")
-            return False
-
-        logger.info(f"Killed session '{name}'")
-        return True
-
     def list_sessions(self) -> list[str]:
         """List all tmux sessions (from configured machines via SSH)."""
         sessions = []

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/agentwire/channels/email.py

@@ -160,7 +160,7 @@ def _render_email_template(
 
 
 def _get_email_config() -> EmailConfig:
-    """Get email config from channels registry or legacy path."""
+    """Get email config from channels registry."""
     from agentwire.config import get_config
 
     config = get_config()

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/agentwire/channels/quo.py

@@ -30,8 +30,8 @@ class QuoConfigError(NotificationError):
 class QuoConfig:
     """Quo (OpenPhone) SMS configuration.
 
-    The API key is env-only: QUO_API_KEY (or legacy OPENPHONE_API_KEY),
-    normally a line in ~/.agentwire/.env (docs/wiki/security/secrets.md).
+    The API key is env-only: QUO_API_KEY, normally a line in
+    ~/.agentwire/.env (docs/wiki/security/secrets.md).
     It is never read from config.yaml.
     """
 
@@ -40,7 +40,7 @@ class QuoConfig:
     api_key: str = field(init=False, default="")
 
     def __post_init__(self):
-        self.api_key = os.environ.get("QUO_API_KEY", "") or os.environ.get("OPENPHONE_API_KEY", "")
+        self.api_key = os.environ.get("QUO_API_KEY", "")
 
 
 API_URL = "https://api.openphone.com/v1/messages"

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/agentwire/channels_cli.py

@@ -534,7 +534,7 @@ def register_channels_parser(subparsers) -> None:
     say_parser.add_argument("-s", "--session", type=str, help="Session name (auto-detected from .agentwire.yml or tmux)")
     say_parser.add_argument("--exaggeration", type=float, help="Voice exaggeration (0-1, Chatterbox)")
     say_parser.add_argument("--cfg", type=float, help="CFG weight (0-1, Chatterbox)")
-    say_parser.add_argument("--backend", type=str, help="TTS backend (chatterbox, qwen-base-1.7b, qwen-design, qwen-custom)")
+    say_parser.add_argument("--backend", type=str, help="TTS backend (chatterbox, zonos-hybrid, zonos-transformer, kokoro)")
     say_parser.add_argument("--instructions", type=str, help="Free-text style instructions passed to the TTS shim (e.g. 'speak warmly')")
     say_parser.add_argument("--language", type=str, default="English", help="Language (default: English)")
     say_parser.add_argument("--stream", action="store_true", help="Use streaming mode (if backend supports)")

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/agentwire/completion.py

@@ -220,13 +220,10 @@ def clear_task_context(session: str) -> None:
         session: tmux session name
     """
     context_file = TASKS_DIR / f"{session}.json"
-    complete_file = TASKS_DIR / f"{session}.complete"
-
-    for f in [context_file, complete_file]:
-        try:
-            f.unlink(missing_ok=True)
-        except OSError:
-            pass
+    try:
+        context_file.unlink(missing_ok=True)
+    except OSError:
+        pass
 
 
 def wait_for_completion_signal(
@@ -253,8 +250,6 @@ def wait_for_completion_signal(
     Raises:
         CompletionTimeout: If session dies before task completed
     """
-    complete_file = TASKS_DIR / f"{session}.complete"
-
     # Build glob pattern for fuzzy summary detection (agents sometimes
     # invent their own timestamp instead of using the provided filename).
     summary_glob = None
@@ -305,14 +300,6 @@ def wait_for_completion_signal(
             except CompletionError:
                 pass  # File may be partially written, retry
 
-        # Fallback: check for legacy .complete signal file
-        if complete_file.exists():
-            try:
-                signal = json.loads(complete_file.read_text())
-                return signal
-            except (json.JSONDecodeError, OSError):
-                pass  # File may be partially written, retry
-
         # Usage-limit dialog: park deterministically (zero-LLM) and report a
         # distinct status — the watchdog resumes the session after reset.
         # Also honors a park the watchdog performed first.

{agentwire_dev-1.47.0 → agentwire_dev-1.48.0}/agentwire/config.py

@@ -607,9 +607,8 @@ def _dict_to_config(data: dict) -> Config:
         extra=projects_data.get("extra", []),
     )
 
-    # Worktree-session orchestration (`worktree:` key). `quicktask:` is a
-    # documented legacy alias — the canonical key is `worktree:`.
-    worktree_data = data.get("worktree", data.get("quicktask", {})) or {}
+    # Worktree-session orchestration (`worktree:` key).
+    worktree_data = data.get("worktree", {}) or {}
     worktree = WorktreeConfig(
         default_base=worktree_data.get("default_base"),
         default_project=worktree_data.get("default_project"),