juno-code 1.0.50 → 1.0.53

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,20 @@ 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(
+            "--live-manual",
+            action="store_true",
+            default=False,
+            help="Internal: live session start without an initial prompt (used by continue flows).",
+        )
+
         parser.add_argument(
             "--pretty",
             type=str,
@@ -423,15 +442,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 +501,44 @@ 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
+        live_manual = bool(getattr(args, "live_manual", False))
+
         if args.auto_instruction:
-            full_prompt = f"{args.auto_instruction}\n\n{full_prompt}"
+            if full_prompt:
+                full_prompt = f"{args.auto_instruction}\n\n{full_prompt}"
+            elif not (is_live_mode and live_manual):
+                full_prompt = args.auto_instruction
+
+        stdin_prompt: Optional[str] = None
+
+        if is_live_mode:
+            # Live mode uses positional prompt input (no -p and no stdin piping).
+            # For manual continue sessions we intentionally omit the prompt so Pi
+            # opens directly into interactive TUI input.
+            if full_prompt:
+                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:
+                    if full_prompt:
+                        cmd = cmd[:-1] + extra + [cmd[-1]]
+                    else:
+                        cmd.extend(extra)
+            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 +2263,287 @@ Model shorthands:
 
         return None
 
+    @staticmethod
+    def _extract_session_id_from_event(event: Optional[dict]) -> Optional[str]:
+        """Extract session id from common Pi/Codex payload shapes."""
+        if not isinstance(event, dict):
+            return None
+
+        candidates: List[object] = [
+            event.get("session_id"),
+            event.get("sessionId"),
+        ]
+
+        if event.get("type") == "session":
+            candidates.append(event.get("id"))
+
+        message = event.get("message")
+        if isinstance(message, dict):
+            candidates.extend(
+                [
+                    message.get("session_id"),
+                    message.get("sessionId"),
+                ]
+            )
+
+        nested = event.get("sub_agent_response")
+        if isinstance(nested, dict):
+            candidates.extend(
+                [
+                    nested.get("session_id"),
+                    nested.get("sessionId"),
+                ]
+            )
+            if nested.get("type") == "session":
+                candidates.append(nested.get("id"))
+
+        for candidate in candidates:
+            if isinstance(candidate, str) and candidate.strip():
+                return candidate.strip()
+
+        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 _is_assistant_text_success_result_event(event: Optional[dict]) -> bool:
+        """Return True when success came from assistant text-only stream events."""
+        if not PiService._is_success_result_event(event):
+            return False
+
+        if not isinstance(event, dict):
+            return False
+
+        response_type = event.get("sub_agent_response_type")
+        if isinstance(response_type, str):
+            return response_type.lower() in {"message", "turn_end", "agent_end"}
+
+        sub_agent_response = event.get("sub_agent_response")
+        if not isinstance(sub_agent_response, dict):
+            return False
+
+        response_type = sub_agent_response.get("type")
+        if not isinstance(response_type, str):
+            return False
+
+        return response_type.lower() in {"message", "turn_end", "agent_end"}
+
+    @staticmethod
+    def _should_promote_stderr_error(last_result_event: Optional[dict]) -> bool:
+        """Return True when stderr errors should override the current result event."""
+        if not PiService._is_success_result_event(last_result_event):
+            return True
+
+        # Assistant-text-derived success payloads are not authoritative when
+        # provider stderr already surfaced a terminal Codex/Pi error.
+        return PiService._is_assistant_text_success_result_event(last_result_event)
+
+    @staticmethod
+    def _normalize_error_text(raw_text: str) -> str:
+        """Normalize stderr/plaintext by stripping ANSI and carriage controls."""
+        if not isinstance(raw_text, str):
+            return ""
+
+        text = PiService._ANSI_ESCAPE_RE.sub("", raw_text)
+        text = text.replace("\x08", "")
+        text = text.replace("\r", "\n")
+        return text
+
+    @staticmethod
+    def _extract_error_message_from_stderr_output(stderr_output: str) -> Optional[str]:
+        """Extract terminal provider errors from full stderr output blocks."""
+        if not isinstance(stderr_output, str):
+            return None
+
+        text = PiService._normalize_error_text(stderr_output).strip()
+        if not text:
+            return None
+
+        extracted = PiService._extract_error_message_from_text(text)
+        if extracted:
+            return extracted
+
+        for line in text.splitlines():
+            extracted_line = PiService._extract_error_message_from_text(line)
+            if extracted_line:
+                return extracted_line
+
+        normalized = " ".join(text.split())
+        lowered = normalized.lower()
+        if "error: codex error" in lowered or "codex error" in lowered or "server_error" in lowered:
+            return normalized
+
+        return None
+
+    @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
+
+        event_type = event.get("type")
+        if event_type == "auto_retry_end" and event.get("success") is False:
+            final_error = event.get("finalError")
+            if isinstance(final_error, str) and final_error.strip():
+                return final_error.strip()
+            return "Auto-retry failed after maximum attempts"
+
+        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 = PiService._normalize_error_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()
+
+        # Sometimes progress spinners and carriage updates prefix the same line.
+        # Detect embedded `Error: Codex error:` signatures even when not line-start.
+        embedded_error_index = lowered.find("error:")
+        if embedded_error_index >= 0:
+            embedded_text = text[embedded_error_index:].strip()
+            embedded_lowered = embedded_text.lower()
+            if "codex error" in embedded_lowered or "server_error" in embedded_lowered:
+                message = embedded_text.split(":", 1)[1].strip() if embedded_lowered.startswith("error:") else embedded_text
+                return message or embedded_text
+
+        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",
+            "please retry this request later",
+            "occurred while processing your request",
+        )
+
+        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)
@@ -2230,6 +2564,10 @@ Model shorthands:
             "sub_agent_response": self._sanitize_sub_agent_response(event),
         }
 
+        event_type = event.get("type") if isinstance(event, dict) else None
+        if isinstance(event_type, str) and event_type.strip():
+            result_event["sub_agent_response_type"] = event_type
+
         if isinstance(usage, dict):
             result_event["usage"] = usage
         if total_cost_usd is not None:
@@ -2237,18 +2575,466 @@ 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)
 
+    @staticmethod
+    def _read_capture_result_event(capture_path: Optional[str]) -> Optional[dict]:
+        """Read current capture file payload if present."""
+        if not capture_path:
+            return None
+
+        try:
+            capture_file = Path(capture_path)
+            if not capture_file.exists():
+                return None
+            raw_payload = capture_file.read_text(encoding="utf-8").strip()
+            if not raw_payload:
+                return None
+            parsed = json.loads(raw_payload)
+            if isinstance(parsed, dict):
+                return parsed
+        except Exception:
+            return None
+
+        return None
+
+    def _apply_capture_result_event(self, capture_path: Optional[str]) -> Tuple[Optional[dict], bool]:
+        """Hydrate final state from capture payload and report stderr-promotion suppression."""
+        capture_event = self._read_capture_result_event(capture_path)
+        if not isinstance(capture_event, dict):
+            return None, False
+
+        capture_session_id = capture_event.get("session_id")
+        if isinstance(capture_session_id, str) and capture_session_id.strip() and not self.session_id:
+            self.session_id = capture_session_id.strip()
+
+        if self.last_result_event is None:
+            self.last_result_event = capture_event
+        elif (
+            isinstance(self.last_result_event, dict)
+            and not self.last_result_event.get("session_id")
+            and isinstance(capture_session_id, str)
+            and capture_session_id.strip()
+        ):
+            self.last_result_event["session_id"] = capture_session_id.strip()
+
+        capture_provider_error: Optional[str] = None
+        if self._is_success_result_event(capture_event):
+            capture_result = capture_event.get("result")
+            if isinstance(capture_result, str):
+                capture_provider_error = self._extract_provider_error_from_result_text(capture_result)
+                if capture_provider_error:
+                    self.last_result_event = self._build_error_result_event(capture_provider_error, capture_event)
+
+        suppress_stderr_promotion = self._is_success_result_event(capture_event) and not capture_provider_error
+        return capture_event, suppress_stderr_promotion
+
+    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__;
+const defaultShutdownDelayMs = 3000;
+const parsedShutdownDelayMs = Number(process.env.PI_LIVE_AGENT_END_DELAY_MS ?? defaultShutdownDelayMs);
+const shutdownDelayMs =
+  Number.isFinite(parsedShutdownDelayMs) && parsedShutdownDelayMs >= 0
+    ? parsedShutdownDelayMs
+    : defaultShutdownDelayMs;
+
+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;
+  let latestSessionId: string | undefined;
+  let pendingShutdownTimer: ReturnType<typeof setTimeout> | undefined;
+
+  // When agent_end fires with stopReason=error, Pi may be about to auto-retry
+  // internally. The Pi extension API does NOT expose auto_retry_start/end events
+  // (those go through session.subscribe(), not the extension runner). We therefore
+  // use a generous delay before treating an error agent_end as final, which gives
+  // Pi time to complete its retry and emit a subsequent non-error agent_end. If a
+  // successful agent_end arrives it cancels this timer via clearPendingShutdown().
+  const defaultErrorAgentEndDelayMs = 30000;
+  const parsedErrorDelayMs = Number(process.env.PI_LIVE_ERROR_AGENT_END_DELAY_MS ?? defaultErrorAgentEndDelayMs);
+  const errorAgentEndDelayMs =
+    Number.isFinite(parsedErrorDelayMs) && parsedErrorDelayMs >= 0
+      ? parsedErrorDelayMs
+      : defaultErrorAgentEndDelayMs;
+
+  function clearPendingShutdown(): void {
+    if (pendingShutdownTimer) {
+      clearTimeout(pendingShutdownTimer);
+      pendingShutdownTimer = undefined;
+    }
+  }
+
+  async function finalizeAndShutdown(event: any, ctx: any): Promise<void> {
+    try {
+      const messages = Array.isArray(event?.messages) ? event.messages : [];
+      const usage = extractAssistantUsage(messages);
+      const totalCost = typeof usage?.cost?.total === \"number\" ? usage.cost.total : undefined;
+      const stopReason = extractLatestAssistantStopReason(messages);
+      const managerSessionId =
+        typeof ctx?.sessionManager?.getSessionId === \"function\"
+          ? ctx.sessionManager.getSessionId()
+          : undefined;
+      const sessionId =
+        (typeof managerSessionId === \"string\" && managerSessionId ? managerSessionId : undefined) ||
+        latestSessionId;
+      const resultText = extractTextFromMessages(messages);
+      const isError = stopReason === \"error\";
+      const resolvedResult = isError
+        ? resultText || \"Request error\"
+        : resultText;
+      const payload: any = {
+        type: \"result\",
+        subtype: isError ? \"error\" : \"success\",
+        is_error: isError,
+        result: resolvedResult,
+        usage,
+        total_cost_usd: totalCost,
+        sub_agent_response: event,
+      };
+
+      if (isError) {
+        payload.error = resolvedResult;
+      }
+
+      if (typeof sessionId === \"string\" && sessionId) {
+        payload.session_id = sessionId;
+      }
+
+      writeCapturePayload(payload);
+    } catch {
+      // Keep shutdown behavior even when capture writing fails.
+    } finally {
+      await ctx.shutdown();
+    }
+  }
+
+  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;
+    const sessionId = managerSessionId || eventSessionId;
+
+    if (typeof sessionId === \"string\" && sessionId) {
+      latestSessionId = sessionId;
+    }
+
+    persistSessionSnapshot(sessionId);
+  });
+
+  // Capture session_id as early as possible from session_start so it is available
+  // as a fallback even when the agent_end handler fires during error/shutdown paths.
+  pi.on(\"session_start\", (event, ctx) => {
+    const managerSessionId =
+      typeof ctx?.sessionManager?.getSessionId === \"function\"
+        ? ctx.sessionManager.getSessionId()
+        : undefined;
+    if (typeof managerSessionId === \"string\" && managerSessionId) {
+      latestSessionId = managerSessionId;
+    }
+    if (latestSessionId) {
+      persistSessionSnapshot(latestSessionId);
+    }
+  });
+
+  // When Pi auto-retries a failed request, it calls agent.continue() internally which
+  // emits a new agent_start event before the retry runs. By cancelling any pending
+  // error-based shutdown timer here we ensure the retry has time to complete and emit
+  // its own agent_end (success or error) before we finalize. This is the primary
+  // mechanism for surviving multiple retries — the 30s error delay is only the last-
+  // resort fallback when all retries are exhausted and no new agent_start arrives.
+  pi.on(\"agent_start\", () => {
+    clearPendingShutdown();
+  });
+
+  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;
+
+    // Cancel any previously scheduled shutdown (e.g. from a prior error agent_end).
+    clearPendingShutdown();
+
+    // When stopReason is \"error\", Pi may internally auto-retry the request.
+    // Pi fires agent_start before each retry attempt (via agent.continue() →
+    // runAgentLoopContinue), so the agent_start handler above will cancel this
+    // timer before it fires during an active retry. The long delay is therefore
+    // only the fallback for when all retries are exhausted and no new agent_start
+    // arrives within errorAgentEndDelayMs.
+    const delay = stopReason === \"error\" ? errorAgentEndDelayMs : shutdownDelayMs;
+
+    pendingShutdownTimer = setTimeout(() => {
+      pendingShutdownTimer = undefined;
+      if (completed) {
+        return;
+      }
+      completed = true;
+      void finalizeAndShutdown(event, ctx);
+    }, delay);
+  });
+}
+"""
+        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.
@@ -2262,10 +3048,26 @@ Model shorthands:
         verbose = args.verbose
         pretty = args.pretty.lower() != "false"
         capture_path = os.environ.get("JUNO_SUBAGENT_CAPTURE_PATH")
+        if not os.environ.get("JUNO_TOOL_ID"):
+            # Ignore inherited capture paths outside juno-code shell-backend execution.
+            capture_path = None
+        if capture_path:
+            # Each invocation should start with a clean capture file. This avoids
+            # stale inherited env values from previous runs poisoning status.
+            try:
+                Path(capture_path).unlink(missing_ok=True)
+            except Exception:
+                pass
         hide_types = self._build_hide_types()
         self._buffered_tool_stdout_lines.clear()
         self._reset_run_cost_tracking()
         cancel_delayed_toolcalls = lambda: None
+        stderr_error_messages: List[str] = []
+        stderr_output_lines: 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 +3099,90 @@ 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:
+                                    stderr_output_lines.append(stderr_line)
+                                    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)
+                        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)
+
+                    _, suppress_stderr_promotion = self._apply_capture_result_event(capture_path)
+
+                    final_stderr_error_message = self._extract_error_message_from_stderr_output(
+                        "".join(stderr_output_lines)
+                    )
+                    if not final_stderr_error_message and stderr_error_messages:
+                        final_stderr_error_message = stderr_error_messages[-1]
+                    if (
+                        final_stderr_error_message
+                        and not suppress_stderr_promotion
+                        and self._should_promote_stderr_error(self.last_result_event)
+                    ):
+                        self.last_result_event = self._build_error_result_event(final_stderr_error_message)
+
+                    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 +3245,15 @@ 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:
+                            stderr_output_lines.append(stderr_line)
                             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)
                 except (ValueError, OSError):
                     pass
 
@@ -2484,9 +3373,22 @@ Model shorthands:
                 def _emit_parsed_event(parsed_event: dict, raw_json_line: Optional[str] = None) -> None:
                     event_type = parsed_event.get("type", "")
 
-                    # Capture session ID from the session event (sent at stream start)
-                    if event_type == "session":
-                        self.session_id = parsed_event.get("id")
+                    # Capture session ID as early as possible from any event shape.
+                    event_session_id = self._extract_session_id_from_event(parsed_event)
+                    if event_session_id:
+                        self.session_id = event_session_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)
@@ -2504,16 +3406,38 @@ Model shorthands:
                         # agent_end has a 'messages' array; extract final assistant text
                         messages = parsed_event.get("messages", [])
                         text = ""
+                        assistant_stop_reason = ""
+                        assistant_error_message = ""
                         if isinstance(messages, list):
-                            # Walk messages in reverse to find last assistant message with text
+                            # Use the latest assistant message as source of truth.
                             for m in reversed(messages):
                                 if isinstance(m, dict) and m.get("role") == "assistant":
+                                    stop_reason = m.get("stopReason")
+                                    if isinstance(stop_reason, str):
+                                        assistant_stop_reason = stop_reason.strip()
+                                    error_message = m.get("errorMessage")
+                                    if isinstance(error_message, str):
+                                        assistant_error_message = error_message.strip()
                                     text = self._extract_text_from_message(m)
-                                    if text:
-                                        break
-                        if text:
-                            self.last_result_event = self._build_success_result_event(text, parsed_event)
-                        else:
+                                    break
+
+                        if assistant_stop_reason in {"error", "aborted"}:
+                            terminal_error = (
+                                assistant_error_message
+                                or text
+                                or f"Request {assistant_stop_reason}"
+                            )
+                            self.last_result_event = self._build_error_result_event(
+                                terminal_error,
+                                parsed_event,
+                            )
+                        elif text:
+                            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 +3445,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 +3631,51 @@ 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
+            _, suppress_stderr_promotion = self._apply_capture_result_event(capture_path)
+
+            # If stderr surfaced a terminal error, persist the failure unless a
+            # non-assistant-text success envelope is already authoritative.
+            final_stderr_error_message = self._extract_error_message_from_stderr_output(
+                "".join(stderr_output_lines)
+            )
+            if not final_stderr_error_message and stderr_error_messages:
+                final_stderr_error_message = stderr_error_messages[-1]
+            if (
+                final_stderr_error_message
+                and not suppress_stderr_promotion
+                and self._should_promote_stderr_error(self.last_result_event)
+            ):
+                self.last_result_event = self._build_error_result_event(final_stderr_error_message)
+
+            # 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 +3685,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:
@@ -2746,7 +3699,23 @@ Model shorthands:
 
         # Prompt handling
         prompt_value = args.prompt or os.environ.get("JUNO_INSTRUCTION")
-        if not prompt_value and not args.prompt_file:
+        resume_session = args.resume if isinstance(args.resume, str) and args.resume.strip() else None
+        live_manual_session = bool(args.live and args.live_manual)
+
+        if (
+            args.live
+            and resume_session
+            and not prompt_value
+            and not args.prompt_file
+        ):
+            # Defensive fallback for direct wrapper usage: allow promptless live resume
+            # even if --live-manual was not passed explicitly.
+            live_manual_session = True
+
+        if live_manual_session:
+            args.live_manual = True
+
+        if not prompt_value and not args.prompt_file and not live_manual_session:
             print("Error: Either -p/--prompt or -pp/--prompt-file is required.", file=sys.stderr)
             print("\nRun 'pi.py --help' for usage information.", file=sys.stderr)
             return 1
@@ -2780,11 +3749,37 @@ Model shorthands:
 
         if args.prompt_file:
             self.prompt = self.read_prompt_file(args.prompt_file)
-        else:
+        elif prompt_value:
             self.prompt = prompt_value
+        else:
+            self.prompt = ""
+
+        if args.live and args.no_extensions and not live_manual_session:
+            print("Error: --live requires extensions enabled (remove --no-extensions).", file=sys.stderr)
+            return 1
+
+        live_extension_file: Optional[Path] = None
+        if args.live and not live_manual_session:
+            capture_path = os.environ.get("JUNO_SUBAGENT_CAPTURE_PATH")
+            if not os.environ.get("JUNO_TOOL_ID"):
+                capture_path = None
+            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
 
-        cmd, stdin_prompt = self.build_pi_command(args)
-        return self.run_pi(cmd, args, stdin_prompt=stdin_prompt)
+        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():