juno-code 1.0.51 → 1.0.53

package/dist/templates/services/pi.py

@@ -407,6 +407,13 @@ Model shorthands:
             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,
@@ -500,21 +507,32 @@ Model shorthands:
 
         # 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).
-            cmd.append(full_prompt)
+            # 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:
-                    cmd = cmd[:-1] + extra + [cmd[-1]]
+                    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
@@ -2245,6 +2263,46 @@ 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."""
@@ -2287,12 +2345,89 @@ Model shorthands:
 
         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
 
@@ -2328,7 +2463,7 @@ Model shorthands:
         if not isinstance(raw_text, str):
             return None
 
-        text = raw_text.strip()
+        text = PiService._normalize_error_text(raw_text).strip()
         if not text:
             return None
 
@@ -2354,6 +2489,17 @@ Model shorthands:
                 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
@@ -2384,6 +2530,8 @@ Model shorthands:
             "too many requests",
             "codex error",
             "server_error",
+            "please retry this request later",
+            "occurred while processing your request",
         )
 
         if lowered.startswith("error:"):
@@ -2416,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:
@@ -2486,6 +2638,58 @@ Model shorthands:
         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.
 
@@ -2498,6 +2702,12 @@ Model shorthands:
 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--) {
@@ -2665,46 +2875,61 @@ function persistSessionSnapshot(sessionId: unknown): void {
 
 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;
+  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;
     }
+  }
 
-    if (completed) return;
-    completed = true;
-
+  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 sessionId =
+      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: \"success\",
-        is_error: false,
-        result: extractTextFromMessages(messages),
+        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;
       }
@@ -2713,8 +2938,80 @@ export default function (pi: ExtensionAPI) {
     } catch {
       // Keep shutdown behavior even when capture writing fails.
     } finally {
-      ctx.shutdown();
+      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);
   });
 }
 """
@@ -2751,11 +3048,22 @@ export default function (pi: ExtensionAPI) {
         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():
@@ -2833,12 +3141,11 @@ export default function (pi: ExtensionAPI) {
                         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)
-                                        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
 
@@ -2848,8 +3155,19 @@ export default function (pi: ExtensionAPI) {
                     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])
+                    _, 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)
 
@@ -2931,12 +3249,11 @@ export default function (pi: ExtensionAPI) {
                 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)
-                                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
 
@@ -3056,9 +3373,10 @@ export default function (pi: ExtensionAPI) {
                 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")
@@ -3088,14 +3406,32 @@ export default function (pi: ExtensionAPI) {
                         # 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:
+                                    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)
@@ -3304,10 +3640,21 @@ export default function (pi: ExtensionAPI) {
             # Wait for stderr thread to finish before deriving fallback errors.
             stderr_thread.join(timeout=3)
 
-            # 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])
+            _, 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)
@@ -3352,7 +3699,23 @@ export default function (pi: ExtensionAPI) {
 
         # 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
@@ -3386,16 +3749,20 @@ export default function (pi: ExtensionAPI) {
 
         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:
+        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:
+        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)