juno-code 1.0.46 → 1.0.49

package/dist/templates/services/README.md

@@ -87,6 +87,7 @@ A wrapper for OpenAI Codex CLI with configurable options.
 #### Default Configuration
 
 The script comes with these default codex configurations:
+
 - `include_apply_patch_tool=true`
 - `use_experimental_streamable_shell_tool=true`
 - `sandbox_mode=danger-full-access`
@@ -168,6 +169,7 @@ A wrapper for Anthropic Claude CLI with configurable options.
 #### Default Configuration
 
 The script comes with these default allowed tools:
+
 - Read, Write, Edit, MultiEdit
 - Bash, Glob, Grep
 - WebFetch, WebSearch
@@ -222,6 +224,63 @@ Headless wrapper for Gemini CLI with shorthand model support and JSON/text outpu
 - `--debug`: Enable Gemini CLI debug output
 - `--verbose`: Print the constructed command before execution
 
+### pi.py
+
+A wrapper for the Pi coding agent CLI -- a multi-provider coding agent that supports Anthropic, OpenAI, Google, Groq, xAI, and more.
+
+#### Prerequisites
+
+Pi requires separate installation of the pi-coding-agent CLI:
+
+```bash
+npm install -g @mariozechner/pi-coding-agent
+```
+
+#### Features
+
+- Multi-provider support (Anthropic, OpenAI, Google, Groq, xAI, etc.)
+- Model shorthand aliases (`:pi`, `:sonnet`, `:opus`, `:gpt-5`, `:gemini-pro`, etc.)
+- Support for inline prompts or prompt files
+- JSON/text output normalization
+- Verbose mode for debugging
+
+#### Usage
+
+```bash
+# Basic usage with Anthropic model
+~/.juno_code/services/pi.py -p "Write a hello world function" -m :sonnet
+
+# Use with OpenAI model
+~/.juno_code/services/pi.py -p "Refactor code" -m :gpt-5
+
+# Use with Gemini model
+~/.juno_code/services/pi.py -p "Add tests" -m :gemini-pro
+
+# Specify project directory
+~/.juno_code/services/pi.py -p "Fix bugs" --cd /path/to/project
+
+# Enable verbose output
+~/.juno_code/services/pi.py -p "Analyze code" --verbose
+```
+
+#### Arguments
+
+- `-p, --prompt <text>`: Prompt text (required, mutually exclusive with --prompt-file)
+- `-pp, --prompt-file <path>`: Path to prompt file (required if no --prompt)
+- `--cd <path>`: Project path (default: current directory)
+- `-m, --model <name>`: Model name (supports shorthand aliases)
+- `--verbose`: Enable verbose output
+
+#### Via juno-code
+
+```bash
+# Run Pi through juno-code
+juno-code -b shell -s pi -m :sonnet -i 1 -v -p "your task"
+
+# Quick shortcut
+juno-code pi "your task"
+```
+
 ## Customization
 
 All service scripts installed in `~/.juno_code/services/` can be modified to suit your needs. This directory is designed for user customization.
@@ -281,6 +340,7 @@ Service scripts require Python 3.6+ to be installed on your system. Individual s
 - **codex.py**: Requires OpenAI Codex CLI to be installed
 - **claude.py**: Requires Anthropic Claude CLI to be installed (see https://docs.anthropic.com/en/docs/agents-and-tools/claude-code)
 - **gemini.py**: Requires Gemini CLI to be installed (see https://geminicli.com/docs/cli/headless/)
+- **pi.py**: Requires Pi coding agent CLI to be installed (`npm install -g @mariozechner/pi-coding-agent`)
 
 ## Troubleshooting
 
@@ -311,4 +371,4 @@ python3 --version
 ## Support
 
 For issues or feature requests related to service scripts, please visit:
-https://github.com/owner/juno-code/issues
+https://github.com/askbudi/juno-code/issues

package/dist/templates/services/claude.py

@@ -9,6 +9,8 @@ import json
 import os
 import subprocess
 import sys
+import threading
+import time
 from datetime import datetime
 from pathlib import Path
 from typing import Optional, List, Dict, Any
@@ -18,7 +20,7 @@ class ClaudeService:
     """Service wrapper for Anthropic Claude CLI"""
 
     # Default configuration
-    DEFAULT_MODEL = "claude-sonnet-4-5-20250929"
+    DEFAULT_MODEL = "claude-sonnet-4-6"
     DEFAULT_PERMISSION_MODE = "default"
     DEFAULT_AUTO_INSTRUCTION = """"""
 
@@ -26,11 +28,12 @@ class ClaudeService:
     MODEL_SHORTHANDS = {
         ":claude-haiku-4-5": "claude-haiku-4-5-20251001",
         ":claude-sonnet-4-5": "claude-sonnet-4-5-20250929",
+        ":claude-sonnet-4-6": "claude-sonnet-4-6",
         ":claude-opus-4-5": "claude-opus-4-5-20251101",
         ":claude-opus-4-6": "claude-opus-4-6",
         ":claude-opus-4": "claude-opus-4-20250514",
         ":haiku": "claude-haiku-4-5-20251001",
-        ":sonnet": "claude-sonnet-4-5-20250929",
+        ":sonnet": "claude-sonnet-4-6",
         ":opus": "claude-opus-4-6",
     }
 
@@ -64,7 +67,7 @@ class ClaudeService:
         Examples:
             :claude-haiku-4-5 -> claude-haiku-4-5-20251001
             :haiku -> claude-haiku-4-5-20251001
-            claude-sonnet-4-5-20250929 -> claude-sonnet-4-5-20250929 (unchanged)
+            claude-sonnet-4-6 -> claude-sonnet-4-6 (unchanged)
         """
         if model.startswith(':'):
             return self.MODEL_SHORTHANDS.get(model, model)
@@ -106,7 +109,7 @@ Default Tools (enabled by default when no --allowed-tools specified):
 
 Environment Variables:
   CLAUDE_PROJECT_PATH                  Project path (default: current directory)
-  CLAUDE_MODEL                         Model name (default: claude-sonnet-4-5-20250929)
+  CLAUDE_MODEL                         Model name (default: claude-sonnet-4-6)
   CLAUDE_AUTO_INSTRUCTION              Auto instruction to prepend to prompt
   CLAUDE_PERMISSION_MODE               Permission mode (default: default)
   CLAUDE_PRETTY                        Pretty print JSON output (default: true)
@@ -139,7 +142,7 @@ Environment Variables:
             "-m", "--model",
             type=str,
             default=os.environ.get("CLAUDE_MODEL", self.DEFAULT_MODEL),
-            help=f"Model name. Supports shorthand (e.g., ':haiku', ':sonnet', ':opus', ':claude-haiku-4-5') or full model ID (e.g., 'claude-haiku-4-5-20251001'). Default: {self.DEFAULT_MODEL} (env: CLAUDE_MODEL)"
+            help=f"Model name. Supports shorthand (e.g., ':haiku', ':sonnet', ':opus', ':claude-sonnet-4-6') or full model ID (e.g., 'claude-sonnet-4-6'). Default: {self.DEFAULT_MODEL} (env: CLAUDE_MODEL)"
         )
 
         parser.add_argument(
@@ -575,12 +578,29 @@ Environment Variables:
 
     def run_claude(self, cmd: List[str], verbose: bool = False, pretty: bool = True) -> int:
         """Execute the claude command and stream output"""
-        if verbose:
-            print(f"Executing: {' '.join(cmd)}", file=sys.stderr)
-            print("-" * 80, file=sys.stderr)
-
         capture_path = os.environ.get("JUNO_SUBAGENT_CAPTURE_PATH")
 
+        if verbose and not capture_path:
+            # Truncate prompt in display to avoid confusing multi-line output
+            display_cmd = []
+            skip_next = False
+            for i, part in enumerate(cmd):
+                if skip_next:
+                    skip_next = False
+                    continue
+                if part == "-p" and i + 1 < len(cmd):
+                    prompt_val = cmd[i + 1]
+                    if len(prompt_val) > 80 or "\n" in prompt_val:
+                        first_line = prompt_val.split("\n")[0][:60]
+                        display_cmd.append(f'-p "{first_line}..." ({len(prompt_val)} chars)')
+                    else:
+                        display_cmd.append(f"-p {prompt_val}")
+                    skip_next = True
+                else:
+                    display_cmd.append(part)
+            print(f"Executing: {' '.join(display_cmd)}", file=sys.stderr)
+            print("-" * 80, file=sys.stderr)
+
         def write_capture_file():
             """Persist the final result event for programmatic capture without affecting screen output."""
             if not capture_path or not self.last_result_event:
@@ -609,31 +629,100 @@ Environment Variables:
                 universal_newlines=True
             )
 
+            # Watchdog thread: handles two scenarios where the stdout loop blocks:
+            # 1. Process exits but its stdout pipe stays open (inherited FDs)
+            # 2. Process itself never exits (hung Node.js event loop)
+            # The watchdog waits for the "result received" signal from the main
+            # thread (set when a type=result event is parsed). Once signaled, it
+            # gives the process a grace period to exit, then terminates it.
+            wait_timeout = int(os.environ.get("CLAUDE_WAIT_TIMEOUT", "30"))
+            result_received = threading.Event()
+
+            def _stdout_watchdog():
+                """Terminate process and close stdout pipe if it hangs after result."""
+                # Wait until the main thread signals that the result event was received,
+                # OR until the process exits on its own (poll every second).
+                while not result_received.is_set():
+                    if process.poll() is not None:
+                        # Process exited on its own before result event
+                        break
+                    result_received.wait(timeout=1)
+
+                if result_received.is_set():
+                    # Result was received — give process grace period to exit cleanly.
+                    try:
+                        process.wait(timeout=wait_timeout)
+                    except subprocess.TimeoutExpired:
+                        print(
+                            f"Warning: Claude process did not exit within {wait_timeout}s after result. Terminating.",
+                            file=sys.stderr
+                        )
+                        process.terminate()
+                        try:
+                            process.wait(timeout=5)
+                        except subprocess.TimeoutExpired:
+                            print("Warning: Claude process did not respond to SIGTERM. Killing.", file=sys.stderr)
+                            process.kill()
+                            try:
+                                process.wait(timeout=5)
+                            except subprocess.TimeoutExpired:
+                                pass
+
+                # Process has exited (naturally or forcefully).
+                # Grace period for remaining pipe data to flush, then close stdout.
+                time.sleep(2)
+                try:
+                    if process.stdout and not process.stdout.closed:
+                        process.stdout.close()
+                except Exception:
+                    pass
+
+            watchdog = threading.Thread(target=_stdout_watchdog, daemon=True)
+            watchdog.start()
+
             # Stream stdout line by line (each line is a JSON object when using stream-json)
             # This allows users to pipe to jq and see output as it streams
             if process.stdout:
-                for line in process.stdout:
-                    raw_line = line.strip()
-                    # Capture the raw final result event for programmatic consumption
-                    try:
-                        parsed_raw = json.loads(raw_line)
-                        if isinstance(parsed_raw, dict) and parsed_raw.get("type") == "result":
-                            self.last_result_event = parsed_raw
-                    except json.JSONDecodeError:
-                        # Ignore non-JSON lines here; pretty formatter will handle them
-                        pass
-
-                    # Apply pretty formatting if enabled
-                    if pretty:
-                        formatted_line = self.pretty_format_json(raw_line)
-                        if formatted_line:
-                            print(formatted_line, flush=True)
-                    else:
-                        # Raw output without formatting
-                        print(line, end='', flush=True)
-
-            # Wait for process to complete
-            process.wait()
+                try:
+                    for line in process.stdout:
+                        raw_line = line.strip()
+                        # Capture the raw final result event for programmatic consumption
+                        try:
+                            parsed_raw = json.loads(raw_line)
+                            if isinstance(parsed_raw, dict) and parsed_raw.get("type") == "result":
+                                self.last_result_event = parsed_raw
+                                # Signal the watchdog that the result has been received.
+                                # The CLI is done; if it doesn't exit soon, watchdog
+                                # will terminate it.
+                                result_received.set()
+                        except json.JSONDecodeError:
+                            # Ignore non-JSON lines here; pretty formatter will handle them
+                            pass
+
+                        # Apply pretty formatting if enabled
+                        if pretty:
+                            formatted_line = self.pretty_format_json(raw_line)
+                            if formatted_line:
+                                print(formatted_line, flush=True)
+                        else:
+                            # Raw output without formatting
+                            print(line, end='', flush=True)
+                except ValueError:
+                    # Watchdog closed stdout because the process exited but the
+                    # pipe stayed open (inherited FDs from child processes).
+                    # This is expected — all output has been consumed.
+                    pass
+
+            # Signal watchdog in case stdout closed without a result event
+            # (e.g., process crashed or was killed externally).
+            result_received.set()
+
+            # Ensure process has exited. The watchdog thread handles termination
+            # if the process hangs, so by this point it should already be dead.
+            try:
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                pass  # Watchdog thread will handle cleanup
 
             # Print stderr if there were errors
             if process.stderr and process.returncode != 0:
@@ -653,7 +742,11 @@ Environment Variables:
             print("\nInterrupted by user", file=sys.stderr)
             if process:
                 process.terminate()
-                process.wait()
+                try:
+                    process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait(timeout=5)
             write_capture_file()
             # Restore original working directory
             if 'original_cwd' in locals():
@@ -661,6 +754,12 @@ Environment Variables:
             return 130
         except Exception as e:
             print(f"Error executing claude: {e}", file=sys.stderr)
+            if process and process.poll() is None:
+                process.terminate()
+                try:
+                    process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    process.kill()
             write_capture_file()
             # Restore original working directory
             if 'original_cwd' in locals():
@@ -689,7 +788,7 @@ Environment Variables:
             print("\nRun 'claude.py --help' for usage information.", file=sys.stderr)
             print("\nAvailable Environment Variables:", file=sys.stderr)
             print("  CLAUDE_PROJECT_PATH                  Project path (default: current directory)", file=sys.stderr)
-            print("  CLAUDE_MODEL                         Model name (default: claude-sonnet-4-5-20250929)", file=sys.stderr)
+            print("  CLAUDE_MODEL                         Model name (default: claude-sonnet-4-6)", file=sys.stderr)
             print("  CLAUDE_AUTO_INSTRUCTION              Auto instruction to prepend to prompt", file=sys.stderr)
             print("  CLAUDE_PERMISSION_MODE               Permission mode (default: default)", file=sys.stderr)
             print("  CLAUDE_PRETTY                        Pretty print JSON output (default: true)", file=sys.stderr)

package/dist/templates/services/codex.py

@@ -9,7 +9,10 @@ import os
 import subprocess
 import sys
 import json
+import threading
+import time
 from datetime import datetime
+from pathlib import Path
 from typing import List, Optional
 
 
@@ -411,9 +414,43 @@ Environment Variables:
         - Falls back to string suppression for known noisy types if JSON parsing fails
         - Never emits token_count or exec_command_output_delta even on malformed lines
         """
+        # Capture file support for structured output (parity with claude.py/pi.py)
+        capture_path = os.environ.get("JUNO_SUBAGENT_CAPTURE_PATH")
+
         if verbose:
-            print(f"Executing: {' '.join(cmd)}", file=sys.stderr)
-            print("-" * 80, file=sys.stderr)
+            # Truncate prompt in display to avoid confusing multi-line output
+            display_cmd = []
+            skip_next = False
+            for i, part in enumerate(cmd):
+                if skip_next:
+                    skip_next = False
+                    continue
+                if part == "-p" and i + 1 < len(cmd):
+                    prompt_val = cmd[i + 1]
+                    if len(prompt_val) > 80 or "\n" in prompt_val:
+                        first_line = prompt_val.split("\n")[0][:60]
+                        display_cmd.append(f'-p "{first_line}..." ({len(prompt_val)} chars)')
+                    else:
+                        display_cmd.append(f"-p {prompt_val}")
+                    skip_next = True
+                else:
+                    display_cmd.append(part)
+            if not capture_path:
+                print(f"Executing: {' '.join(display_cmd)}", file=sys.stderr)
+                print("-" * 80, file=sys.stderr)
+        self.last_result_event = None
+
+        def write_capture_file():
+            """Persist the final result event for programmatic capture without affecting screen output."""
+            if not capture_path or not self.last_result_event:
+                return
+            try:
+                Path(capture_path).write_text(
+                    json.dumps(self.last_result_event, ensure_ascii=False),
+                    encoding="utf-8"
+                )
+            except Exception as e:
+                print(f"Warning: Failed to write capture file: {e}", file=sys.stderr)
 
         # Resolve hidden stream types (ENV configurable)
         default_hidden = {"turn_diff", "token_count", "exec_command_output_delta"}
@@ -442,6 +479,57 @@ Environment Variables:
                 universal_newlines=True
             )
 
+            # Watchdog thread: handles two scenarios where the stdout loop blocks:
+            # 1. Process exits but its stdout pipe stays open (inherited FDs)
+            # 2. Process itself never exits (hung event loop)
+            # The watchdog waits for an "output done" signal from the main thread
+            # (set when the stdout loop finishes or a completion event is received).
+            # Once signaled, it gives the process a grace period to exit, then
+            # terminates it and closes stdout.
+            wait_timeout = int(os.environ.get("CODEX_WAIT_TIMEOUT", "30"))
+            output_done = threading.Event()
+
+            def _stdout_watchdog():
+                """Terminate process and close stdout pipe if it hangs after output."""
+                # Wait until the main thread signals output is done,
+                # OR until the process exits on its own (poll every second).
+                while not output_done.is_set():
+                    if process.poll() is not None:
+                        break
+                    output_done.wait(timeout=1)
+
+                if output_done.is_set() and process.poll() is None:
+                    # Output is done but process hasn't exited — give it grace period.
+                    try:
+                        process.wait(timeout=wait_timeout)
+                    except subprocess.TimeoutExpired:
+                        print(
+                            f"Warning: Codex process did not exit within {wait_timeout}s after output. Terminating.",
+                            file=sys.stderr
+                        )
+                        process.terminate()
+                        try:
+                            process.wait(timeout=5)
+                        except subprocess.TimeoutExpired:
+                            print("Warning: Codex process did not respond to SIGTERM. Killing.", file=sys.stderr)
+                            process.kill()
+                            try:
+                                process.wait(timeout=5)
+                            except subprocess.TimeoutExpired:
+                                pass
+
+                # Process has exited (naturally or forcefully).
+                # Grace period for remaining pipe data to flush, then close stdout.
+                time.sleep(2)
+                try:
+                    if process.stdout and not process.stdout.closed:
+                        process.stdout.close()
+                except Exception:
+                    pass
+
+            watchdog = threading.Thread(target=_stdout_watchdog, daemon=True)
+            watchdog.start()
+
             def split_json_stream(text: str):
                 objs = []
                 buf: List[str] = []
@@ -495,6 +583,10 @@ Environment Variables:
                 ):
                     obj_dict["item"]["id"] = item_id_inner
 
+                # Track last agent_message for capture file (structured output)
+                if msg_type_inner in ("agent_message", "message", "assistant_message", "assistant"):
+                    self.last_result_event = obj_dict
+
                 if msg_type_inner == "token_count":
                     last_token_count = obj_dict
                     return  # suppress
@@ -517,49 +609,59 @@ Environment Variables:
             pending = ""
 
             if process.stdout:
-                for raw_line in process.stdout:
-                    combined = pending + raw_line
-                    if not combined.strip():
-                        pending = ""
-                        continue
-
-                    # If no braces present at all, treat as plain text (with suppression)
-                    if "{" not in combined and "}" not in combined:
-                        lower = combined.lower()
-                        if (
-                            '"token_count"' in lower
-                            or '"exec_command_output_delta"' in lower
-                            or '"turn_diff"' in lower
-                        ):
+                try:
+                    for raw_line in process.stdout:
+                        combined = pending + raw_line
+                        if not combined.strip():
                             pending = ""
                             continue
-                        print(combined, end="" if combined.endswith("\n") else "\n", flush=True)
-                        pending = ""
-                        continue
 
-                    # Preserve and emit any prefix before the first brace
-                    first_brace = combined.find("{")
-                    if first_brace > 0:
-                        prefix = combined[:first_brace]
-                        lower_prefix = prefix.lower()
-                        if (
-                            '"token_count"' not in lower_prefix
-                            and '"exec_command_output_delta"' not in lower_prefix
-                            and '"turn_diff"' not in lower_prefix
-                            and prefix.strip()
-                        ):
-                            print(prefix, end="" if prefix.endswith("\n") else "\n", flush=True)
-                        combined = combined[first_brace:]
-
-                    parts, pending = split_json_stream(combined)
+                        # If no braces present at all, treat as plain text (with suppression)
+                        if "{" not in combined and "}" not in combined:
+                            lower = combined.lower()
+                            if (
+                                '"token_count"' in lower
+                                or '"exec_command_output_delta"' in lower
+                                or '"turn_diff"' in lower
+                            ):
+                                pending = ""
+                                continue
+                            print(combined, end="" if combined.endswith("\n") else "\n", flush=True)
+                            pending = ""
+                            continue
 
-                    if parts:
-                        for part in parts:
-                            try:
-                                sub = json.loads(part)
-                                if isinstance(sub, dict):
-                                    handle_obj(sub)
-                                else:
+                        # Preserve and emit any prefix before the first brace
+                        first_brace = combined.find("{")
+                        if first_brace > 0:
+                            prefix = combined[:first_brace]
+                            lower_prefix = prefix.lower()
+                            if (
+                                '"token_count"' not in lower_prefix
+                                and '"exec_command_output_delta"' not in lower_prefix
+                                and '"turn_diff"' not in lower_prefix
+                                and prefix.strip()
+                            ):
+                                print(prefix, end="" if prefix.endswith("\n") else "\n", flush=True)
+                            combined = combined[first_brace:]
+
+                        parts, pending = split_json_stream(combined)
+
+                        if parts:
+                            for part in parts:
+                                try:
+                                    sub = json.loads(part)
+                                    if isinstance(sub, dict):
+                                        handle_obj(sub)
+                                    else:
+                                        low = part.lower()
+                                        if (
+                                            '"token_count"' in low
+                                            or '"exec_command_output_delta"' in low
+                                            or '"turn_diff"' in low
+                                        ):
+                                            continue
+                                        print(part, flush=True)
+                                except Exception:
                                     low = part.lower()
                                     if (
                                         '"token_count"' in low
@@ -568,30 +670,29 @@ Environment Variables:
                                     ):
                                         continue
                                     print(part, flush=True)
-                            except Exception:
-                                low = part.lower()
-                                if (
-                                    '"token_count"' in low
-                                    or '"exec_command_output_delta"' in low
-                                    or '"turn_diff"' in low
-                                ):
-                                    continue
-                                print(part, flush=True)
-                        continue
+                            continue
 
-                    # No complete object found yet; keep buffering if likely in the middle of one
-                    if pending:
-                        continue
+                        # No complete object found yet; keep buffering if likely in the middle of one
+                        if pending:
+                            continue
 
-                    # Fallback for malformed/non-JSON lines that still contain braces
-                    lower = combined.lower()
-                    if (
-                        '"token_count"' in lower
-                        or '"exec_command_output_delta"' in lower
-                        or '"turn_diff"' in lower
-                    ):
-                        continue
-                    print(combined, end="" if combined.endswith("\n") else "\n", flush=True)
+                        # Fallback for malformed/non-JSON lines that still contain braces
+                        lower = combined.lower()
+                        if (
+                            '"token_count"' in lower
+                            or '"exec_command_output_delta"' in lower
+                            or '"turn_diff"' in lower
+                        ):
+                            continue
+                        print(combined, end="" if combined.endswith("\n") else "\n", flush=True)
+                except ValueError:
+                    # Watchdog closed stdout because the process exited but the
+                    # pipe stayed open (inherited FDs from child processes).
+                    # This is expected — all output has been consumed.
+                    pass
+
+            # Signal watchdog that output is done (stdout loop has exited).
+            output_done.set()
 
             # Flush any pending buffered content after the stream ends
             if pending.strip():
@@ -610,8 +711,13 @@ Environment Variables:
                     ):
                         print(pending, flush=True)
 
-            # Wait for process completion
-            process.wait()
+            # Ensure process has exited. The watchdog thread handles termination
+            # if the process hangs, so by this point it should already be dead.
+            # Use a short timeout as a safety net.
+            try:
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                pass  # Watchdog thread will handle cleanup
 
             # Do not emit token_count summary; fully suppressed per user feedback
 
@@ -621,18 +727,25 @@ Environment Variables:
                 if stderr_output:
                     print(stderr_output, file=sys.stderr)
 
+            write_capture_file()
             return process.returncode
 
         except KeyboardInterrupt:
             print("\nInterrupted by user", file=sys.stderr)
+            write_capture_file()
             try:
                 process.terminate()
-                process.wait()
+                try:
+                    process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait(timeout=5)
             except Exception:
                 pass
             return 130
         except Exception as e:
             print(f"Error executing codex: {e}", file=sys.stderr)
+            write_capture_file()
             return 1
 
     def run(self) -> int: