juno-code 1.0.50 → 1.0.51

package/dist/templates/services/pi.py

@@ -10,11 +10,12 @@ import os
 import re
 import subprocess
 import sys
+import tempfile
 import threading
 import time
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Dict, List, Optional, Set, TextIO, Tuple
 
 
 class PiService:
@@ -38,6 +39,8 @@ class PiService:
         ":o3": "openai/o3",
         ":codex": "openai-codex/gpt-5.3-codex",
         ":api-codex": "openai/gpt-5.3-codex",
+        ":codex-spark": "openai-codex/gpt-5.3-codex-spark",
+        ":api-codex-spark": "openai/gpt-5.3-codex-spark",
         # Google
         ":gemini-pro": "google/gemini-2.5-pro",
         ":gemini-flash": "google/gemini-2.5-flash",
@@ -284,6 +287,8 @@ Model shorthands:
   :o3              -> openai/o3
   :codex           -> openai-codex/gpt-5.3-codex
   :api-codex       -> openai/gpt-5.3-codex
+  :codex-spark     -> openai-codex/gpt-5.3-codex-spark
+  :api-codex-spark -> openai/gpt-5.3-codex-spark
   :gemini-pro      -> google/gemini-2.5-pro
   :gemini-flash    -> google/gemini-2.5-flash
   :groq            -> groq/llama-4-scout-17b-16e-instruct
@@ -395,6 +400,13 @@ Model shorthands:
             help="Space-separated additional pi CLI arguments to append.",
         )
 
+        parser.add_argument(
+            "--live",
+            action="store_true",
+            default=os.environ.get("PI_LIVE", "false").lower() == "true",
+            help="Run Pi in interactive/live mode (no --mode json). Uses an auto-exit extension to capture agent_end and shutdown cleanly. (env: PI_LIVE)",
+        )
+
         parser.add_argument(
             "--pretty",
             type=str,
@@ -423,15 +435,21 @@ Model shorthands:
             print(f"Error reading prompt file: {e}", file=sys.stderr)
             sys.exit(1)
 
-    def build_pi_command(self, args: argparse.Namespace) -> Tuple[List[str], Optional[str]]:
-        """Construct the Pi CLI command for headless JSON streaming execution.
+    def build_pi_command(
+        self,
+        args: argparse.Namespace,
+        live_extension_path: Optional[str] = None,
+    ) -> Tuple[List[str], Optional[str]]:
+        """Construct the Pi CLI command.
 
-        Returns (cmd, stdin_prompt): cmd is the argument list, stdin_prompt is
-        the prompt text to pipe via stdin (or None to pass as positional arg).
-        For multiline or large prompts we pipe via stdin so Pi reads it
-        naturally without command-line quoting issues.
+        Non-live mode keeps the existing headless JSON contract.
+        Live mode switches to Pi interactive defaults (no --mode json, no -p)
+        and passes the initial prompt positionally.
         """
-        cmd = ["pi", "--mode", "json"]
+        is_live_mode = bool(getattr(args, "live", False))
+        cmd = ["pi"]
+        if not is_live_mode:
+            cmd.extend(["--mode", "json"])
 
         # Model: if provider/model format, split and pass separately
         model = self.model_name
@@ -476,16 +494,33 @@ Model shorthands:
         elif args.no_session:
             cmd.append("--no-session")
 
+        # Attach live auto-exit extension when requested.
+        if is_live_mode and live_extension_path:
+            cmd.extend(["-e", live_extension_path])
+
         # Build prompt with optional auto-instruction
         full_prompt = self.prompt
         if args.auto_instruction:
             full_prompt = f"{args.auto_instruction}\n\n{full_prompt}"
 
+        stdin_prompt: Optional[str] = None
+
+        if is_live_mode:
+            # Live mode uses positional prompt input (no -p and no stdin piping).
+            cmd.append(full_prompt)
+
+            # Additional raw arguments should still be honored; place before the
+            # positional prompt so flags remain flags.
+            if args.additional_args:
+                extra = args.additional_args.strip().split()
+                if extra:
+                    cmd = cmd[:-1] + extra + [cmd[-1]]
+            return cmd, None
+
         # For multiline or large prompts, pipe via stdin to avoid command-line
         # argument issues. Pi CLI reads stdin when isTTY is false and
         # automatically prepends it to messages in print mode.
         # For simple single-line prompts, pass as positional arg + -p flag.
-        stdin_prompt: Optional[str] = None
         if "\n" in full_prompt or len(full_prompt) > 4096:
             # Pipe via stdin — Pi auto-enables print mode when stdin has data
             stdin_prompt = full_prompt
@@ -2210,6 +2245,157 @@ Model shorthands:
 
         return None
 
+    @staticmethod
+    def _is_error_result_event(event: Optional[dict]) -> bool:
+        """Return True when event represents a terminal error payload."""
+        if not isinstance(event, dict):
+            return False
+
+        if event.get("is_error") is True:
+            return True
+
+        subtype = event.get("subtype")
+        if isinstance(subtype, str) and subtype.lower() == "error":
+            return True
+
+        event_type = event.get("type")
+        if isinstance(event_type, str) and event_type.lower() in {"error", "turn.failed", "turn_failed"}:
+            return True
+
+        return False
+
+    @staticmethod
+    def _is_success_result_event(event: Optional[dict]) -> bool:
+        """Return True when event is an explicit successful result envelope."""
+        if not isinstance(event, dict):
+            return False
+
+        if PiService._is_error_result_event(event):
+            return False
+
+        subtype = event.get("subtype")
+        if isinstance(subtype, str) and subtype.lower() == "success":
+            return True
+
+        event_type = event.get("type")
+        if isinstance(event_type, str) and event_type.lower() == "result" and event.get("is_error") is False:
+            result_value = event.get("result")
+            if isinstance(result_value, str):
+                return bool(result_value.strip())
+            if result_value not in (None, "", [], {}):
+                return True
+
+        return False
+
+    @staticmethod
+    def _extract_error_message_from_event(event: dict) -> Optional[str]:
+        """Extract a human-readable message from Pi/Codex error event shapes."""
+        if not isinstance(event, dict):
+            return None
+
+        if not PiService._is_error_result_event(event):
+            return None
+
+        def _stringify_error(value: object) -> Optional[str]:
+            if isinstance(value, str):
+                text = value.strip()
+                return text if text else None
+            if isinstance(value, dict):
+                nested_message = value.get("message")
+                if isinstance(nested_message, str) and nested_message.strip():
+                    return nested_message.strip()
+                nested_error = value.get("error")
+                if isinstance(nested_error, str) and nested_error.strip():
+                    return nested_error.strip()
+                try:
+                    return json.dumps(value, ensure_ascii=False)
+                except Exception:
+                    return str(value)
+            if value is not None:
+                return str(value)
+            return None
+
+        for key in ("error", "message", "errorMessage", "result"):
+            extracted = _stringify_error(event.get(key))
+            if extracted:
+                return extracted
+
+        return "Unknown Pi error"
+
+    @staticmethod
+    def _extract_error_message_from_text(raw_text: str) -> Optional[str]:
+        """Extract an error message from stderr/plaintext lines."""
+        if not isinstance(raw_text, str):
+            return None
+
+        text = raw_text.strip()
+        if not text:
+            return None
+
+        # Direct JSON line
+        try:
+            parsed = json.loads(text)
+            extracted = PiService._extract_error_message_from_event(parsed)
+            if extracted:
+                return extracted
+        except Exception:
+            pass
+
+        # Prefix + JSON payload pattern (e.g. "Error: Codex error: {...}")
+        json_start = text.find("{")
+        if json_start > 0:
+            json_candidate = text[json_start:]
+            try:
+                parsed = json.loads(json_candidate)
+                extracted = PiService._extract_error_message_from_event(parsed)
+                if extracted:
+                    return extracted
+            except Exception:
+                pass
+
+        lowered = text.lower()
+        if lowered.startswith("error:"):
+            message = text.split(":", 1)[1].strip()
+            return message or text
+
+        if "server_error" in lowered or "codex error" in lowered:
+            return text
+
+        return None
+
+    @staticmethod
+    def _extract_provider_error_from_result_text(result_text: str) -> Optional[str]:
+        """Detect provider-level failures that leaked into assistant result text."""
+        if not isinstance(result_text, str):
+            return None
+
+        text = result_text.strip()
+        if not text:
+            return None
+
+        normalized = " ".join(text.split())
+        lowered = normalized.lower()
+
+        provider_signatures = (
+            "chatgpt usage limit",
+            "usage limit",
+            "rate limit",
+            "insufficient_quota",
+            "too many requests",
+            "codex error",
+            "server_error",
+        )
+
+        if lowered.startswith("error:"):
+            payload = normalized.split(":", 1)[1].strip() if ":" in normalized else ""
+            if any(signature in lowered for signature in provider_signatures) or "try again in" in lowered:
+                return payload or normalized
+
+        if any(signature in lowered for signature in provider_signatures):
+            return normalized
+
+        return None
+
     def _build_success_result_event(self, text: str, event: dict) -> dict:
         """Build standardized success envelope for shell-backend capture."""
         usage = self._extract_usage_from_event(event)
@@ -2237,18 +2423,321 @@ Model shorthands:
 
         return result_event
 
+    def _build_error_result_event(self, error_message: str, event: Optional[dict] = None) -> dict:
+        """Build standardized error envelope for shell-backend capture."""
+        message = error_message.strip() if isinstance(error_message, str) else str(error_message)
+
+        result_event: Dict = {
+            "type": "result",
+            "subtype": "error",
+            "is_error": True,
+            "result": message,
+            "error": message,
+            "session_id": self.session_id,
+        }
+
+        if isinstance(event, dict):
+            result_event["sub_agent_response"] = self._sanitize_sub_agent_response(event)
+
+        return result_event
+
     def _write_capture_file(self, capture_path: Optional[str]) -> None:
         """Write final result event to capture file for shell backend."""
         if not capture_path or not self.last_result_event:
             return
+
+        payload = dict(self.last_result_event)
+
+        if not payload.get("session_id"):
+            existing_capture: Optional[dict] = None
+            try:
+                capture_file = Path(capture_path)
+                if capture_file.exists():
+                    raw_existing = capture_file.read_text(encoding="utf-8").strip()
+                    if raw_existing:
+                        parsed_existing = json.loads(raw_existing)
+                        if isinstance(parsed_existing, dict):
+                            existing_capture = parsed_existing
+            except Exception:
+                existing_capture = None
+
+            existing_session_id: Optional[str] = None
+            if isinstance(existing_capture, dict):
+                candidate = existing_capture.get("session_id")
+                if isinstance(candidate, str) and candidate.strip():
+                    existing_session_id = candidate.strip()
+                elif isinstance(existing_capture.get("sub_agent_response"), dict):
+                    nested = existing_capture["sub_agent_response"].get("session_id")
+                    if isinstance(nested, str) and nested.strip():
+                        existing_session_id = nested.strip()
+
+            if existing_session_id:
+                payload["session_id"] = existing_session_id
+                if not self.session_id:
+                    self.session_id = existing_session_id
+
+        self.last_result_event = payload
+
         try:
             Path(capture_path).write_text(
-                json.dumps(self.last_result_event, ensure_ascii=False),
+                json.dumps(payload, ensure_ascii=False),
                 encoding="utf-8",
             )
         except Exception as e:
             print(f"Warning: Could not write capture file: {e}", file=sys.stderr)
 
+    def _build_live_auto_exit_extension_source(self, capture_path: Optional[str]) -> str:
+        """Build a temporary Pi extension source used by --live mode.
+
+        The extension listens for agent_end, writes a compact result envelope to
+        JUNO_SUBAGENT_CAPTURE_PATH-compatible location, then requests
+        graceful shutdown via ctx.shutdown().
+        """
+        capture_literal = json.dumps(capture_path or "")
+        source = """import type { ExtensionAPI } from \"@mariozechner/pi-coding-agent\";
+import * as fs from \"node:fs\";
+
+const capturePath = __CAPTURE_PATH__;
+
+function extractTextFromMessages(messages: any[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg || msg.role !== \"assistant\") continue;
+
+    const content = msg.content;
+    if (typeof content === \"string\") {
+      if (content.trim()) return content;
+      continue;
+    }
+
+    if (Array.isArray(content)) {
+      const parts: string[] = [];
+      for (const item of content) {
+        if (typeof item === \"string\" && item.trim()) {
+          parts.push(item);
+          continue;
+        }
+        if (item && item.type === \"text\" && typeof item.text === \"string\" && item.text.trim()) {
+          parts.push(item.text);
+        }
+      }
+      if (parts.length > 0) return parts.join(\"\\n\");
+    }
+  }
+  return \"\";
+}
+
+function isFiniteNumber(value: any): value is number {
+  return typeof value === \"number\" && Number.isFinite(value);
+}
+
+function normalizeUsage(usage: any): any | undefined {
+  if (!usage || typeof usage !== \"object\") return undefined;
+
+  const cost = usage.cost && typeof usage.cost === \"object\" ? usage.cost : {};
+
+  const input = isFiniteNumber(usage.input) ? usage.input : 0;
+  const output = isFiniteNumber(usage.output) ? usage.output : 0;
+  const cacheRead = isFiniteNumber(usage.cacheRead) ? usage.cacheRead : 0;
+  const cacheWrite = isFiniteNumber(usage.cacheWrite) ? usage.cacheWrite : 0;
+  const totalTokens = isFiniteNumber(usage.totalTokens)
+    ? usage.totalTokens
+    : input + output + cacheRead + cacheWrite;
+
+  const costInput = isFiniteNumber(cost.input) ? cost.input : 0;
+  const costOutput = isFiniteNumber(cost.output) ? cost.output : 0;
+  const costCacheRead = isFiniteNumber(cost.cacheRead) ? cost.cacheRead : 0;
+  const costCacheWrite = isFiniteNumber(cost.cacheWrite) ? cost.cacheWrite : 0;
+  const costTotal = isFiniteNumber(cost.total)
+    ? cost.total
+    : costInput + costOutput + costCacheRead + costCacheWrite;
+
+  const hasAnyValue =
+    isFiniteNumber(usage.input) ||
+    isFiniteNumber(usage.output) ||
+    isFiniteNumber(usage.cacheRead) ||
+    isFiniteNumber(usage.cacheWrite) ||
+    isFiniteNumber(usage.totalTokens) ||
+    isFiniteNumber(cost.input) ||
+    isFiniteNumber(cost.output) ||
+    isFiniteNumber(cost.cacheRead) ||
+    isFiniteNumber(cost.cacheWrite) ||
+    isFiniteNumber(cost.total);
+
+  if (!hasAnyValue) return undefined;
+
+  return {
+    input,
+    output,
+    cacheRead,
+    cacheWrite,
+    totalTokens,
+    cost: {
+      input: costInput,
+      output: costOutput,
+      cacheRead: costCacheRead,
+      cacheWrite: costCacheWrite,
+      total: costTotal,
+    },
+  };
+}
+
+function mergeUsage(base: any | undefined, delta: any | undefined): any | undefined {
+  if (!base) return delta;
+  if (!delta) return base;
+
+  const baseCost = base.cost && typeof base.cost === \"object\" ? base.cost : {};
+  const deltaCost = delta.cost && typeof delta.cost === \"object\" ? delta.cost : {};
+
+  return {
+    input: (base.input ?? 0) + (delta.input ?? 0),
+    output: (base.output ?? 0) + (delta.output ?? 0),
+    cacheRead: (base.cacheRead ?? 0) + (delta.cacheRead ?? 0),
+    cacheWrite: (base.cacheWrite ?? 0) + (delta.cacheWrite ?? 0),
+    totalTokens: (base.totalTokens ?? 0) + (delta.totalTokens ?? 0),
+    cost: {
+      input: (baseCost.input ?? 0) + (deltaCost.input ?? 0),
+      output: (baseCost.output ?? 0) + (deltaCost.output ?? 0),
+      cacheRead: (baseCost.cacheRead ?? 0) + (deltaCost.cacheRead ?? 0),
+      cacheWrite: (baseCost.cacheWrite ?? 0) + (deltaCost.cacheWrite ?? 0),
+      total: (baseCost.total ?? 0) + (deltaCost.total ?? 0),
+    },
+  };
+}
+
+function extractAssistantUsage(messages: any[]): any | undefined {
+  let totals: any | undefined;
+
+  for (const msg of messages) {
+    if (!msg || msg.role !== \"assistant\") {
+      continue;
+    }
+
+    const normalized = normalizeUsage(msg.usage);
+    if (!normalized) {
+      continue;
+    }
+
+    totals = mergeUsage(totals, normalized);
+  }
+
+  return totals;
+}
+
+function extractLatestAssistantStopReason(messages: any[]): string | undefined {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg || msg.role !== \"assistant\") {
+      continue;
+    }
+
+    const reason = msg.stopReason;
+    return typeof reason === \"string\" && reason ? reason : undefined;
+  }
+
+  return undefined;
+}
+
+function writeCapturePayload(payload: any): void {
+  if (!capturePath) {
+    return;
+  }
+
+  fs.writeFileSync(capturePath, JSON.stringify(payload), \"utf-8\");
+}
+
+function persistSessionSnapshot(sessionId: unknown): void {
+  if (typeof sessionId !== \"string\" || !sessionId) {
+    return;
+  }
+
+  try {
+    writeCapturePayload({
+      type: \"result\",
+      subtype: \"session\",
+      is_error: false,
+      session_id: sessionId,
+    });
+  } catch {
+    // Non-fatal: runtime capture should continue even if snapshot write fails.
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  let completed = false;
+
+  pi.on(\"session\", (event, ctx) => {
+    const eventSessionId = typeof event?.id === \"string\" ? event.id : undefined;
+    const managerSessionId =
+      typeof ctx?.sessionManager?.getSessionId === \"function\"
+        ? ctx.sessionManager.getSessionId()
+        : undefined;
+
+    persistSessionSnapshot(managerSessionId || eventSessionId);
+  });
+
+  pi.on(\"agent_end\", async (event, ctx) => {
+    const messages = Array.isArray(event?.messages) ? event.messages : [];
+    const stopReason = extractLatestAssistantStopReason(messages);
+
+    // Esc-aborted runs should keep Pi open for user interaction.
+    if (stopReason === \"aborted\") {
+      return;
+    }
+
+    if (completed) return;
+    completed = true;
+
+    try {
+      const usage = extractAssistantUsage(messages);
+      const totalCost = typeof usage?.cost?.total === \"number\" ? usage.cost.total : undefined;
+      const sessionId =
+        typeof ctx?.sessionManager?.getSessionId === \"function\"
+          ? ctx.sessionManager.getSessionId()
+          : undefined;
+      const payload: any = {
+        type: \"result\",
+        subtype: \"success\",
+        is_error: false,
+        result: extractTextFromMessages(messages),
+        usage,
+        total_cost_usd: totalCost,
+        sub_agent_response: event,
+      };
+
+      if (typeof sessionId === \"string\" && sessionId) {
+        payload.session_id = sessionId;
+      }
+
+      writeCapturePayload(payload);
+    } catch {
+      // Keep shutdown behavior even when capture writing fails.
+    } finally {
+      ctx.shutdown();
+    }
+  });
+}
+"""
+        return source.replace("__CAPTURE_PATH__", capture_literal)
+
+    def _create_live_auto_exit_extension_file(self, capture_path: Optional[str]) -> Optional[Path]:
+        """Create a temporary live-mode extension file and return its path."""
+        try:
+            fd, temp_path = tempfile.mkstemp(prefix="juno-pi-live-auto-exit-", suffix=".ts")
+            with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                handle.write(self._build_live_auto_exit_extension_source(capture_path))
+            return Path(temp_path)
+        except Exception as exc:
+            print(f"Warning: Failed to create live auto-exit extension: {exc}", file=sys.stderr)
+            return None
+
+    def _open_live_tty_stdin(self) -> Optional[TextIO]:
+        """Open /dev/tty for live-mode stdin fallback when stdin is redirected."""
+        try:
+            return open("/dev/tty", "r", encoding="utf-8", errors="ignore")
+        except OSError:
+            return None
+
     def run_pi(self, cmd: List[str], args: argparse.Namespace,
                stdin_prompt: Optional[str] = None) -> int:
         """Execute the Pi CLI and stream/format its JSON output.
@@ -2266,6 +2755,11 @@ Model shorthands:
         self._buffered_tool_stdout_lines.clear()
         self._reset_run_cost_tracking()
         cancel_delayed_toolcalls = lambda: None
+        stderr_error_messages: List[str] = []
+
+        resume_session = getattr(args, "resume", None)
+        if isinstance(resume_session, str) and resume_session.strip():
+            self.session_id = resume_session.strip()
 
         if verbose:
             # Truncate prompt in display to avoid confusing multi-line output
@@ -2297,7 +2791,80 @@ Model shorthands:
                 print(f"Executing: {' '.join(display_cmd)}", file=sys.stderr)
                 print("-" * 80, file=sys.stderr)
 
+        process: Optional[subprocess.Popen] = None
+        live_mode_requested = bool(getattr(args, "live", False))
+        stdin_has_tty = (
+            hasattr(sys.stdin, "isatty")
+            and sys.stdin.isatty()
+        )
+        stdout_has_tty = (
+            hasattr(sys.stdout, "isatty")
+            and sys.stdout.isatty()
+        )
+        live_tty_stdin: Optional[TextIO] = None
+        if live_mode_requested and stdout_has_tty and not stdin_has_tty:
+            live_tty_stdin = self._open_live_tty_stdin()
+
+        is_live_tty_passthrough = (
+            live_mode_requested
+            and stdout_has_tty
+            and (stdin_has_tty or live_tty_stdin is not None)
+        )
+
         try:
+            if is_live_tty_passthrough:
+                # Interactive live mode: attach Pi directly to the current terminal.
+                # Keep stdout inherited for full-screen TUI rendering/input, but
+                # capture stderr so terminal provider errors can still propagate.
+                popen_kwargs = {
+                    "cwd": self.project_path,
+                    "stderr": subprocess.PIPE,
+                    "text": True,
+                    "universal_newlines": True,
+                }
+                if live_tty_stdin is not None:
+                    popen_kwargs["stdin"] = live_tty_stdin
+
+                try:
+                    process = subprocess.Popen(cmd, **popen_kwargs)
+
+                    def _live_tty_stderr_reader():
+                        """Read stderr during live TTY mode and capture terminal failures."""
+                        try:
+                            if process.stderr:
+                                for stderr_line in process.stderr:
+                                    print(stderr_line, end="", file=sys.stderr, flush=True)
+                                    extracted_error = self._extract_error_message_from_text(stderr_line)
+                                    if extracted_error:
+                                        stderr_error_messages.append(extracted_error)
+                                        if not self._is_success_result_event(self.last_result_event):
+                                            self.last_result_event = self._build_error_result_event(extracted_error)
+                        except (ValueError, OSError):
+                            pass
+
+                    stderr_thread = threading.Thread(target=_live_tty_stderr_reader, daemon=True)
+                    stderr_thread.start()
+
+                    process.wait()
+                    stderr_thread.join(timeout=3)
+
+                    if stderr_error_messages and not self._is_success_result_event(self.last_result_event):
+                        self.last_result_event = self._build_error_result_event(stderr_error_messages[-1])
+
+                    self._write_capture_file(capture_path)
+
+                    final_return_code = process.returncode or 0
+                    if final_return_code == 0 and self._is_error_result_event(self.last_result_event):
+                        final_return_code = 1
+
+                    return final_return_code
+                finally:
+                    if live_tty_stdin is not None:
+                        try:
+                            live_tty_stdin.close()
+                        except OSError:
+                            pass
+
             process = subprocess.Popen(
                 cmd,
                 stdin=subprocess.PIPE if stdin_prompt else subprocess.DEVNULL,
@@ -2360,11 +2927,16 @@ Model shorthands:
 
             # Stream stderr in a separate thread so Pi diagnostic output is visible
             def _stderr_reader():
-                """Read stderr and forward to our stderr for visibility."""
+                """Read stderr, forward to stderr, and capture terminal error signals."""
                 try:
                     if process.stderr:
                         for stderr_line in process.stderr:
                             print(stderr_line, end="", file=sys.stderr, flush=True)
+                            extracted_error = self._extract_error_message_from_text(stderr_line)
+                            if extracted_error:
+                                stderr_error_messages.append(extracted_error)
+                                if not self._is_success_result_event(self.last_result_event):
+                                    self.last_result_event = self._build_error_result_event(extracted_error)
                 except (ValueError, OSError):
                     pass
 
@@ -2487,6 +3059,18 @@ Model shorthands:
                     # Capture session ID from the session event (sent at stream start)
                     if event_type == "session":
                         self.session_id = parsed_event.get("id")
+                        if (
+                            isinstance(self.last_result_event, dict)
+                            and not self.last_result_event.get("session_id")
+                            and isinstance(self.session_id, str)
+                            and self.session_id.strip()
+                        ):
+                            self.last_result_event["session_id"] = self.session_id
+
+                    # Capture terminal error events even when upstream exits with code 0.
+                    error_message = self._extract_error_message_from_event(parsed_event)
+                    if error_message:
+                        self.last_result_event = self._build_error_result_event(error_message, parsed_event)
 
                     # Track per-run assistant usage from stream events.
                     self._track_assistant_usage_from_event(parsed_event)
@@ -2512,8 +3096,12 @@ Model shorthands:
                                     if text:
                                         break
                         if text:
-                            self.last_result_event = self._build_success_result_event(text, parsed_event)
-                        else:
+                            provider_error = self._extract_provider_error_from_result_text(text)
+                            if provider_error:
+                                self.last_result_event = self._build_error_result_event(provider_error, parsed_event)
+                            else:
+                                self.last_result_event = self._build_success_result_event(text, parsed_event)
+                        elif not self._is_error_result_event(self.last_result_event):
                             self.last_result_event = parsed_event
                     elif event_type == "message":
                         # OpenAI-compatible format: capture last assistant message
@@ -2521,14 +3109,22 @@ Model shorthands:
                         if isinstance(msg, dict) and msg.get("role") == "assistant":
                             text = self._extract_text_from_message(msg)
                             if text:
-                                self.last_result_event = self._build_success_result_event(text, parsed_event)
+                                provider_error = self._extract_provider_error_from_result_text(text)
+                                if provider_error:
+                                    self.last_result_event = self._build_error_result_event(provider_error, parsed_event)
+                                else:
+                                    self.last_result_event = self._build_success_result_event(text, parsed_event)
                     elif event_type == "turn_end":
                         # turn_end may contain the final assistant message
                         msg = parsed_event.get("message", {})
                         if isinstance(msg, dict):
                             text = self._extract_text_from_message(msg)
                             if text:
-                                self.last_result_event = self._build_success_result_event(text, parsed_event)
+                                provider_error = self._extract_provider_error_from_result_text(text)
+                                if provider_error:
+                                    self.last_result_event = self._build_error_result_event(provider_error, parsed_event)
+                                else:
+                                    self.last_result_event = self._build_success_result_event(text, parsed_event)
 
                     # Filter hidden stream types (live mode handles its own filtering)
                     if event_type in hide_types and self.prettifier_mode != self.PRETTIFIER_LIVE:
@@ -2699,30 +3295,40 @@ Model shorthands:
             output_done.set()
             cancel_delayed_toolcalls()
 
-            # Write capture file for shell backend
-            self._write_capture_file(capture_path)
-
             # Wait for process cleanup
             try:
                 process.wait(timeout=5)
             except subprocess.TimeoutExpired:
                 pass
 
-            # Wait for stderr thread to finish
+            # Wait for stderr thread to finish before deriving fallback errors.
             stderr_thread.join(timeout=3)
 
-            return process.returncode or 0
+            # If stderr surfaced a terminal error and we do not already have an
+            # explicit success envelope, persist the failure for shell-backend consumers.
+            if stderr_error_messages and not self._is_success_result_event(self.last_result_event):
+                self.last_result_event = self._build_error_result_event(stderr_error_messages[-1])
+
+            # Write capture file for shell backend
+            self._write_capture_file(capture_path)
+
+            final_return_code = process.returncode or 0
+            if final_return_code == 0 and self._is_error_result_event(self.last_result_event):
+                final_return_code = 1
+
+            return final_return_code
 
         except KeyboardInterrupt:
             print("\nInterrupted by user", file=sys.stderr)
             cancel_delayed_toolcalls()
             try:
-                process.terminate()
-                try:
-                    process.wait(timeout=5)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    process.wait(timeout=5)
+                if process is not None:
+                    process.terminate()
+                    try:
+                        process.wait(timeout=5)
+                    except subprocess.TimeoutExpired:
+                        process.kill()
+                        process.wait(timeout=5)
             except Exception:
                 pass
             self._write_capture_file(capture_path)
@@ -2732,7 +3338,7 @@ Model shorthands:
             print(f"Error executing pi: {e}", file=sys.stderr)
             cancel_delayed_toolcalls()
             try:
-                if process.poll() is None:
+                if process is not None and process.poll() is None:
                     process.terminate()
                     process.wait(timeout=5)
             except Exception:
@@ -2783,8 +3389,30 @@ Model shorthands:
         else:
             self.prompt = prompt_value
 
-        cmd, stdin_prompt = self.build_pi_command(args)
-        return self.run_pi(cmd, args, stdin_prompt=stdin_prompt)
+        if args.live and args.no_extensions:
+            print("Error: --live requires extensions enabled (remove --no-extensions).", file=sys.stderr)
+            return 1
+
+        live_extension_file: Optional[Path] = None
+        if args.live:
+            capture_path = os.environ.get("JUNO_SUBAGENT_CAPTURE_PATH")
+            live_extension_file = self._create_live_auto_exit_extension_file(capture_path)
+            if not live_extension_file:
+                print("Error: Could not create live auto-exit extension.", file=sys.stderr)
+                return 1
+
+        try:
+            cmd, stdin_prompt = self.build_pi_command(
+                args,
+                live_extension_path=str(live_extension_file) if live_extension_file else None,
+            )
+            return self.run_pi(cmd, args, stdin_prompt=stdin_prompt)
+        finally:
+            if live_extension_file is not None:
+                try:
+                    live_extension_file.unlink(missing_ok=True)
+                except Exception as e:
+                    print(f"Warning: Failed to remove temp live extension: {e}", file=sys.stderr)
 
 
 def main():