@cydm/pie 1.0.13 → 1.0.15

package/dist/cli.js

@@ -14,7 +14,7 @@ import {
   getSettingsPath,
   getThemesDir,
   migrateConfigFromAgentDir
-} from "./chunks/chunk-EFG2MQFD.js";
+} from "./chunks/chunk-55RUSXEA.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -52,7 +52,8 @@ import {
   selectToolsForRuntimePolicy,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-LF5Q7BVU.js";
+} from "./chunks/chunk-R5LYKDKA.js";
+import "./chunks/chunk-VE2HDCNB.js";
 import {
   Deref,
   Errors,
@@ -86,7 +87,7 @@ import {
   setLogger,
   sortToolModelCandidatesByCapability,
   type_exports
-} from "./chunks/chunk-D7NAXU7F.js";
+} from "./chunks/chunk-5DA2D3K2.js";
 import {
   resolveCliProjectRoot
 } from "./chunks/chunk-NTYHFBUA.js";
@@ -43943,7 +43944,7 @@ import * as path26 from "path";
 
 // src/cli-args.ts
 var FLAGS_WITH_VALUES = /* @__PURE__ */ new Set(["--session-id", "--extension-path"]);
-var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--raw-output", "--json-output"]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--raw-output", "--json-output", "--json-events"]);
 var HELP_FLAGS = /* @__PURE__ */ new Set(["help", "--help", "-h"]);
 var COMMANDS = /* @__PURE__ */ new Set(["chat", "help"]);
 function parseCliInvocation(args) {
@@ -64043,6 +64044,34 @@ function buildCliSystemPrompt(options) {
   ].filter(Boolean).join("\n\n");
 }
 
+// src/runtime/retry-policy.ts
+var TRANSIENT_MODEL_ERROR_PATTERN = /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|sse stream aborted|sse stream closed before end|sse stream ended before response completed/i;
+var USER_ABORT_PATTERN = /request was aborted/i;
+var CLI_RETRY_MAX_RETRIES = 3;
+var CLI_RETRY_BASE_DELAY_MS = 2e3;
+function isCliContextOverflowError(errorMessage3) {
+  return /context length exceeded|context_length_exceeded|maximum context length|maximum context size|too many tokens|input.*too long|prompt.*too long|context window|token limit exceeded|exceeds.{0,20}context/i.test(
+    errorMessage3
+  );
+}
+function isCliRetryableError(errorMessage3) {
+  if (isCliContextOverflowError(errorMessage3)) {
+    return false;
+  }
+  if (USER_ABORT_PATTERN.test(errorMessage3)) {
+    return false;
+  }
+  return TRANSIENT_MODEL_ERROR_PATTERN.test(errorMessage3);
+}
+function getCliRetryBaseDelayMs() {
+  const override = process.env.PIE_TEST_CLI_RETRY_BASE_DELAY_MS;
+  if (!override) {
+    return CLI_RETRY_BASE_DELAY_MS;
+  }
+  const parsed = Number(override);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : CLI_RETRY_BASE_DELAY_MS;
+}
+
 // src/runtime/interactive-context-ui.ts
 function calculateContextUsage(host) {
   const messages = host.agent?.state.messages ?? [];
@@ -64266,9 +64295,7 @@ function setupAutocomplete(host) {
   host.editor.setAutocompleteProvider(provider);
 }
 function isContextOverflowError(errorMessage3) {
-  return /context length exceeded|context_length_exceeded|maximum context length|maximum context size|too many tokens|input.*too long|prompt.*too long|context window|token limit exceeded|exceeds.{0,20}context/i.test(
-    errorMessage3
-  );
+  return isCliContextOverflowError(errorMessage3);
 }
 function shouldAutoCompact(host, contextTokens, contextWindow) {
   if (!host.options.settingsManager.getAutoCompactEnabled()) return false;
@@ -64277,9 +64304,7 @@ function shouldAutoCompact(host, contextTokens, contextWindow) {
   return contextTokens > contextWindow - reserveTokens;
 }
 function isRetryableError(errorMessage3) {
-  return /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay/i.test(
-    errorMessage3
-  );
+  return isCliRetryableError(errorMessage3);
 }
 function isInvalidFileReferenceError(errorMessage3) {
   return /not the owner of this file|owner of this file|invalid_authentication_error/i.test(
@@ -64778,9 +64803,9 @@ function createInteractiveAgentSessionController(host) {
     },
     getAutoContinueMessage: () => host.getTodoAutoContinueMessage(),
     retry: {
-      isRetryableError: (errorMessage3) => !host._isContextOverflowError(errorMessage3) && host._isRetryableError(errorMessage3),
-      maxRetries: 3,
-      baseDelayMs: 2e3
+      isRetryableError: (errorMessage3) => !host._isContextOverflowError(errorMessage3) && isCliRetryableError(errorMessage3),
+      maxRetries: CLI_RETRY_MAX_RETRIES,
+      baseDelayMs: getCliRetryBaseDelayMs()
     },
     compaction: {
       compact: async ({ messages }) => createAutoCompactionResult(host, messages)
@@ -66739,7 +66764,7 @@ var InteractiveMode = class {
     if (savedLevel) {
       this.thinkingLevel = savedLevel;
     }
-    const { Agent } = await import("./chunks/src-LZC56DRG.js");
+    const { Agent } = await import("./chunks/src-6WPNVGT2.js");
     const activeSession = this.sessionManager.getActiveSession();
     this.agent = new Agent({
       initialState: {
@@ -67303,6 +67328,12 @@ function createNoOpExtensionUIContext() {
     custom: async () => void 0
   };
 }
+function readAssistantError(message) {
+  if (message.role !== "assistant") {
+    return "";
+  }
+  return message.errorMessage || "assistant response failed";
+}
 async function loadPrintModeExtensions(params) {
   const uiContext = createNoOpExtensionUIContext();
   const executionState = new ExecutionStateManager();
@@ -67400,7 +67431,7 @@ async function runPrintMode(params) {
 `);
     console.log("Assistant: ");
   }
-  const { Agent: AgentClass } = await import("./chunks/src-LZC56DRG.js");
+  const { Agent: AgentClass } = await import("./chunks/src-6WPNVGT2.js");
   let agent;
   const printModeExtensions = await loadPrintModeExtensions({
     cwd: runtime.cwd,
@@ -67437,8 +67468,10 @@ async function runPrintMode(params) {
       tools: printModeTools,
       thinkingLevel: "off"
     },
-    apiKey: runtime.apiKey
+    apiKey: runtime.apiKey,
+    streamFn: params.streamFn
   });
+  const sessionTrace = new SessionTraceWriter(runtime.paths.sessionsDir, runtime.sessionManager);
   const agentSessionController = new AgentSessionController({
     agent,
     sessionManager: runtime.sessionManager,
@@ -67458,9 +67491,25 @@ async function runPrintMode(params) {
         systemPrompt: result.systemPrompt ?? context.baseSystemPrompt ?? baseSystemPrompt,
         messages: result.messages?.length ? [...context.messages, ...result.messages] : context.messages
       };
+    },
+    retry: {
+      isRetryableError: isCliRetryableError,
+      maxRetries: CLI_RETRY_MAX_RETRIES,
+      baseDelayMs: getCliRetryBaseDelayMs()
+    },
+    onEvent: (event) => {
+      sessionTrace.noteRuntimeEvent(event.type, event);
+      if (event.type === "retry_scheduled") {
+        console.error(`Transient request error: ${event.errorMessage}. Retrying in ${event.delayMs / 1e3}s (${event.attempt}/${event.maxRetries}).`);
+      } else if (event.type === "retry_start") {
+        console.error(`Retrying request (${event.attempt}/${event.maxRetries})...`);
+      } else if (event.type === "retry_succeeded") {
+        console.error(`Retry succeeded after ${event.attempts} attempt${event.attempts === 1 ? "" : "s"}.`);
+      } else if (event.type === "retry_exhausted") {
+        console.error(`Request failed after ${event.maxRetries} retries: ${event.errorMessage}`);
+      }
     }
   });
-  const sessionTrace = new SessionTraceWriter(runtime.paths.sessionsDir, runtime.sessionManager);
   sessionTrace.notePendingUserText(params.initialPrompt);
   attachAgentEventsToSessionTrace({ agent, trace: sessionTrace });
   agent.setTools(wrapToolsWithExtensions(agent.state.tools, printModeExtensions.runner));
@@ -67470,19 +67519,37 @@ async function runPrintMode(params) {
     await agentSessionController.prompt(params.initialPrompt, { source: "print" });
     sessionTrace.noteDispatchSettled({ mode: "print" });
     sessionTrace.noteWaitForIdleStart({ mode: "print" });
-    await agentSessionController.waitForIdle();
+    await agentSessionController.waitForSettled();
     sessionTrace.noteWaitForIdleSettled({ mode: "print" });
     const messages = agent.state.messages;
     const lastMessage = messages[messages.length - 1];
     let assistantText = "";
+    let assistantError = "";
     if (lastMessage?.role === "assistant") {
       for (const content of lastMessage.content) {
         if (typeof content === "object" && "type" in content && content.type === "text" && "text" in content) {
           assistantText += content.text;
         }
       }
+      if (lastMessage.stopReason === "error" || lastMessage.stopReason === "aborted") {
+        assistantError = readAssistantError(lastMessage);
+      }
     }
-    if (params.jsonOutput) {
+    if (assistantError) {
+      process.exitCode = 1;
+      if (params.jsonOutput) {
+        console.log(
+          JSON.stringify({
+            ok: false,
+            error: assistantError,
+            sessionId: runtime.sessionManager.getActiveSession()?.id,
+            provider: runtime.provider,
+            modelId: runtime.modelId
+          })
+        );
+      }
+      console.error("Error:", assistantError);
+    } else if (params.jsonOutput) {
       console.log(
         JSON.stringify({
           ok: true,
@@ -67520,6 +67587,628 @@ async function runPrintMode(params) {
   sessionTrace.flush();
 }
 
+// src/app/json-events-mode.ts
+import readline from "node:readline";
+var MAX_EVENT_OBJECT_KEYS = 50;
+var MAX_EVENT_ARRAY_ITEMS = 50;
+var MAX_EVENT_VALUE_DEPTH = 4;
+var MAX_EVENT_STRING_LENGTH = 4e3;
+function createNoOpExtensionUIContext2() {
+  return {
+    notify: () => {
+    },
+    select: async () => void 0,
+    confirm: async () => false,
+    input: async () => void 0,
+    editor: async () => void 0,
+    custom: async () => void 0
+  };
+}
+function writeEvent(event) {
+  process.stdout.write(`${JSON.stringify(event)}
+`);
+}
+function toJsonValue(value, depth = 0) {
+  if (value === null) return null;
+  if (typeof value === "string") {
+    return value.length > MAX_EVENT_STRING_LENGTH ? `${value.slice(0, MAX_EVENT_STRING_LENGTH)}...` : value;
+  }
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (typeof value === "boolean") return value;
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value !== "object") return void 0;
+  if (depth >= MAX_EVENT_VALUE_DEPTH) return "[truncated]";
+  if (Array.isArray(value)) {
+    return value.slice(0, MAX_EVENT_ARRAY_ITEMS).map((item) => toJsonValue(item, depth + 1) ?? null);
+  }
+  const result = {};
+  for (const [key, item] of Object.entries(value).slice(0, MAX_EVENT_OBJECT_KEYS)) {
+    result[key] = toJsonValue(item, depth + 1);
+  }
+  return result;
+}
+function isRecord3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function parseInput(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord3(parsed) || typeof parsed.type !== "string") return null;
+  if (parsed.type === "shutdown") {
+    return { type: "shutdown", reason: typeof parsed.reason === "string" ? parsed.reason : void 0 };
+  }
+  if (parsed.type === "turn.interrupt") {
+    return {
+      type: "turn.interrupt",
+      sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : void 0,
+      turnId: typeof parsed.turnId === "string" ? parsed.turnId : void 0,
+      reason: typeof parsed.reason === "string" ? parsed.reason : void 0
+    };
+  }
+  if (parsed.type === "turn.request" && typeof parsed.turnId === "string" && typeof parsed.prompt === "string") {
+    return {
+      type: "turn.request",
+      sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : void 0,
+      turnId: parsed.turnId,
+      prompt: parsed.prompt,
+      cwd: typeof parsed.cwd === "string" ? parsed.cwd : void 0,
+      metadata: isRecord3(parsed.metadata) ? parsed.metadata : void 0
+    };
+  }
+  return null;
+}
+function assistantTextFromAgent(agent) {
+  const messages = agent?.state.messages ?? [];
+  const lastMessage = messages[messages.length - 1];
+  if (lastMessage?.role !== "assistant") return "";
+  let text = "";
+  for (const content of lastMessage.content) {
+    if (content.type === "text") {
+      text += content.text;
+    }
+  }
+  return text;
+}
+function assistantErrorFromAgent(agent) {
+  const messages = agent?.state.messages ?? [];
+  const lastMessage = messages[messages.length - 1];
+  if (lastMessage?.role !== "assistant") return "";
+  if (lastMessage.stopReason !== "error" && lastMessage.stopReason !== "aborted") return "";
+  return lastMessage.errorMessage || "assistant response failed";
+}
+function readProgressText(value) {
+  return typeof value === "string" ? value : "";
+}
+function extractJsonEventsToolProgressText(partialResult) {
+  const plainText = readProgressText(partialResult).trim();
+  if (plainText) return plainText;
+  if (!isRecord3(partialResult)) return "";
+  const content = partialResult.content;
+  if (Array.isArray(content)) {
+    return content.map((block) => isRecord3(block) && block.type === "text" ? readProgressText(block.text) : "").filter(Boolean).join("\n").trim();
+  }
+  const directText = readProgressText(partialResult.text) || readProgressText(partialResult.message);
+  if (directText) return directText.trim();
+  const details = partialResult.details;
+  if (isRecord3(details)) {
+    return (readProgressText(details.text) || readProgressText(details.message)).trim();
+  }
+  return "";
+}
+async function loadJsonModeExtensions(params) {
+  const uiContext = createNoOpExtensionUIContext2();
+  const executionState = new ExecutionStateManager();
+  const activeSession = params.runtime.sessionManager.getActiveSession();
+  executionState.restoreFromMetadata(activeSession?.metadata?.executionState);
+  const actions = {
+    setActiveTools: (toolNames) => {
+      const agent = params.getAgent();
+      if (!agent) return;
+      agent.state.tools = agent.state.tools.filter((tool) => toolNames.includes(tool.name));
+    },
+    getActiveTools: () => params.getAgent()?.state.tools.map((tool) => tool.name) ?? [],
+    sendUserMessage: () => {
+    },
+    setPlanMode: () => {
+    },
+    setExecutionReminder: (text) => {
+      const session = params.runtime.sessionManager.getActiveSession();
+      if (!session) return;
+      if (text) {
+        session.metadata.executionReminder = text;
+      } else {
+        delete session.metadata.executionReminder;
+      }
+    },
+    getExecutionState: () => executionState.read(),
+    setExecutionState: (state) => {
+      const nextState = executionState.replace(state);
+      const session = params.runtime.sessionManager.getActiveSession();
+      if (session) {
+        session.metadata.executionState = executionState.createMetadata();
+      }
+      return nextState;
+    },
+    cwd: params.runtime.cwd,
+    apiKey: params.runtime.apiKey,
+    model: params.runtime.model,
+    skills: params.runtime.skills,
+    getAllTools: () => params.getAgent()?.state.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    })) ?? [],
+    getRuntimeTools: () => params.getAgent()?.state.tools ?? [],
+    resolveModelClass: (modelClass) => params.runtime.modelRegistry.resolveModelClass(modelClass),
+    getMessages: () => params.getAgent()?.state.messages ?? [],
+    getSessionMetadata: () => ({ ...params.runtime.sessionManager.getActiveSession()?.metadata ?? {} }),
+    setSessionMetadata: (key, value) => {
+      const session = params.runtime.sessionManager.getActiveSession();
+      if (!session) return;
+      session.metadata[key] = value;
+    },
+    yoloMode: false
+  };
+  const { extensions } = await loadExtensions(
+    params.runtime.extensionPaths,
+    params.runtime.cwd,
+    uiContext,
+    () => params.getAgent()?.abort(),
+    () => true,
+    false,
+    actions
+  );
+  const runner = new ExtensionRunner(
+    extensions,
+    actions,
+    {
+      isIdle: () => true,
+      abort: () => params.getAgent()?.abort()
+    },
+    false
+  );
+  runner.setUIContext(uiContext);
+  return {
+    runner,
+    extensionTools: convertExtensionTools(extensions),
+    extensionCount: extensions.length
+  };
+}
+async function runJsonEventsMode(params) {
+  const sessionId = params.explicitSessionId || params.runtime?.sessionManager.getActiveSession()?.id || `pie-json-${Date.now()}`;
+  let activeTurn = null;
+  let agent;
+  let controller;
+  let disposeAgentSubscription;
+  let disposeSemanticSubscription;
+  let trace;
+  let lastRetryEvent;
+  const noProgressTimeoutMs = Number(process.env.PIE_JSON_EVENTS_NO_PROGRESS_MS || 6e5);
+  const mockResponseDelayMs = Number(process.env.PIE_TEST_MOCK_RESPONSE_DELAY_MS || 0);
+  writeEvent({ type: "agent.ready", sessionId });
+  function sessionMismatchError(requestedSessionId) {
+    return `session mismatch: JSON events process is bound to ${sessionId}, received ${requestedSessionId}`;
+  }
+  function isSessionMismatch(message) {
+    return typeof message.sessionId === "string" && message.sessionId !== sessionId;
+  }
+  function delay(ms) {
+    return new Promise((resolve4) => setTimeout(resolve4, Math.max(0, ms)));
+  }
+  function touch() {
+    if (activeTurn) {
+      activeTurn.lastActivityAt = Date.now();
+    }
+  }
+  function display(chunk, options) {
+    if (!activeTurn || !chunk) return;
+    if (options?.appendToSummary !== false) {
+      activeTurn.summary += chunk;
+    }
+    touch();
+    writeEvent({
+      type: "display.output",
+      sessionId: activeTurn.sessionId,
+      turnId: activeTurn.turnId,
+      stream: "terminal",
+      chunk
+    });
+  }
+  function finalize(kind, detail) {
+    const turn = activeTurn;
+    if (!turn || turn.finalized) return;
+    turn.finalized = true;
+    switch (kind) {
+      case "completed":
+        writeEvent({ type: "turn.completed", sessionId: turn.sessionId, turnId: turn.turnId, summary: (detail ?? turn.summary).trim() });
+        break;
+      case "failed":
+        writeEvent({ type: "turn.failed", sessionId: turn.sessionId, turnId: turn.turnId, error: detail || "turn failed" });
+        break;
+      case "cancelled":
+        writeEvent({ type: "turn.cancelled", sessionId: turn.sessionId, turnId: turn.turnId, reason: detail || "interrupted" });
+        break;
+      case "stalled":
+        writeEvent({ type: "turn.stalled", sessionId: turn.sessionId, turnId: turn.turnId, reason: detail || "no_progress_timeout" });
+        break;
+    }
+  }
+  function handleSemanticEvent(event) {
+    if (!activeTurn || activeTurn.finalized) return;
+    switch (event.type) {
+      case "assistant_response_delta":
+        display(event.delta);
+        break;
+      case "tool_started":
+        touch();
+        writeEvent({
+          type: "tool.started",
+          sessionId: activeTurn.sessionId,
+          turnId: activeTurn.turnId,
+          toolCallId: event.toolCallId,
+          name: event.toolName,
+          data: toJsonValue({ args: event.args })
+        });
+        break;
+      case "tool_progressed":
+        touch();
+        {
+          const progressText = extractJsonEventsToolProgressText(event.partialResult);
+          if (progressText) {
+            display(progressText.endsWith("\n") ? progressText : `${progressText}
+`, { appendToSummary: false });
+          }
+        }
+        break;
+      case "tool_finished":
+        touch();
+        writeEvent({
+          type: "tool.completed",
+          sessionId: activeTurn.sessionId,
+          turnId: activeTurn.turnId,
+          toolCallId: event.toolCallId,
+          name: event.toolName,
+          status: event.isError ? "error" : "ok",
+          data: toJsonValue({
+            resultText: extractJsonEventsToolProgressText(event.result),
+            isError: event.isError
+          })
+        });
+        break;
+    }
+  }
+  function handleControllerEvent(event) {
+    trace?.noteRuntimeEvent(event.type, event);
+    if (!activeTurn || activeTurn.finalized) return;
+    if (event.type === "retry_scheduled") {
+      lastRetryEvent = {
+        attempt: event.attempt,
+        maxRetries: event.maxRetries,
+        delayMs: event.delayMs,
+        error: event.errorMessage
+      };
+      touch();
+      writeEvent({
+        type: "turn.retry.scheduled",
+        sessionId: activeTurn.sessionId,
+        turnId: activeTurn.turnId,
+        attempt: event.attempt,
+        maxRetries: event.maxRetries,
+        delayMs: event.delayMs,
+        error: event.errorMessage
+      });
+    } else if (event.type === "retry_start") {
+      activeTurn.summary = "";
+      lastRetryEvent = {
+        attempt: event.attempt,
+        maxRetries: event.maxRetries,
+        delayMs: lastRetryEvent?.delayMs,
+        error: lastRetryEvent?.error
+      };
+      touch();
+      writeEvent({
+        type: "turn.retry.started",
+        sessionId: activeTurn.sessionId,
+        turnId: activeTurn.turnId,
+        attempt: event.attempt,
+        maxRetries: event.maxRetries,
+        delayMs: lastRetryEvent.delayMs,
+        error: lastRetryEvent.error
+      });
+    } else if (event.type === "retry_succeeded") {
+      touch();
+      writeEvent({
+        type: "turn.retry.succeeded",
+        sessionId: activeTurn.sessionId,
+        turnId: activeTurn.turnId,
+        attempt: event.attempts,
+        maxRetries: lastRetryEvent?.maxRetries ?? CLI_RETRY_MAX_RETRIES,
+        delayMs: lastRetryEvent?.delayMs,
+        error: lastRetryEvent?.error
+      });
+      lastRetryEvent = void 0;
+    } else if (event.type === "retry_exhausted") {
+      touch();
+      writeEvent({
+        type: "turn.retry.exhausted",
+        sessionId: activeTurn.sessionId,
+        turnId: activeTurn.turnId,
+        attempt: lastRetryEvent?.attempt ?? event.maxRetries,
+        maxRetries: event.maxRetries,
+        delayMs: lastRetryEvent?.delayMs,
+        error: event.errorMessage
+      });
+      lastRetryEvent = void 0;
+    }
+  }
+  async function ensureRuntime() {
+    if (params.mockResponse !== void 0 || controller) return;
+    const runtime = params.runtime;
+    if (!runtime) {
+      throw new Error("JSON events mode requires a CLI runtime");
+    }
+    if (runtime.initialModel.unconfigured) {
+      return;
+    }
+    const { Agent: AgentClass } = await import("./chunks/src-6WPNVGT2.js");
+    const jsonModeExtensions = await loadJsonModeExtensions({ runtime, getAgent: () => agent });
+    const tools = [...runtime.tools, ...jsonModeExtensions.extensionTools];
+    recordCliCompositionStep(runtime.compositionTrace, {
+      id: "extensions_tool_wrapping",
+      inputSummary: `baseTools=${runtime.tools.length} extensionPaths=${runtime.extensionPaths.length}`,
+      outputSummary: `extensions=${jsonModeExtensions.extensionCount}`,
+      toolCount: tools.length,
+      extensionWrapping: {
+        extensionCount: jsonModeExtensions.extensionCount,
+        extensionToolCount: jsonModeExtensions.extensionTools.length,
+        wrappedToolCount: tools.length
+      }
+    });
+    const baseSystemPrompt = buildCliSystemPrompt({
+      cwd: runtime.cwd,
+      skillsSection: runtime.skillsSection,
+      knowledgeSection: runtime.knowledgeSection,
+      tools: tools.map((tool) => ({ name: tool.name, description: tool.description }))
+    });
+    agent = new AgentClass({
+      initialState: {
+        systemPrompt: baseSystemPrompt,
+        model: runtime.model,
+        tools,
+        thinkingLevel: "off"
+      },
+      apiKey: runtime.apiKey,
+      streamFn: params.streamFn
+    });
+    controller = new AgentSessionController({
+      agent,
+      sessionManager: runtime.sessionManager,
+      cwd: runtime.cwd,
+      baseSystemPrompt,
+      prepareTurn: async (context) => {
+        const result = await jsonModeExtensions.runner.emitBeforeAgentStart({
+          type: "before_agent_start",
+          messages: context.messages,
+          baseSystemPrompt: context.baseSystemPrompt ?? baseSystemPrompt,
+          source: context.source
+        });
+        return {
+          systemPrompt: result?.systemPrompt ?? context.baseSystemPrompt ?? baseSystemPrompt,
+          messages: result?.messages?.length ? [...context.messages, ...result.messages] : context.messages
+        };
+      },
+      retry: {
+        isRetryableError: isCliRetryableError,
+        maxRetries: CLI_RETRY_MAX_RETRIES,
+        baseDelayMs: getCliRetryBaseDelayMs()
+      },
+      onEvent: handleControllerEvent
+    });
+    trace = new SessionTraceWriter(runtime.paths.sessionsDir, runtime.sessionManager);
+    attachAgentEventsToSessionTrace({ agent, trace });
+    agent.setTools(wrapToolsWithExtensions(agent.state.tools, jsonModeExtensions.runner));
+    controller.updateRuntimeContext({ tools: agent.state.tools });
+    disposeSemanticSubscription = agent.subscribeSemantic(handleSemanticEvent);
+  }
+  async function runTurn(message) {
+    if (isSessionMismatch(message)) {
+      writeEvent({
+        type: "turn.failed",
+        sessionId,
+        turnId: message.turnId,
+        error: sessionMismatchError(message.sessionId)
+      });
+      return;
+    }
+    if (activeTurn && !activeTurn.finalized) {
+      writeEvent({
+        type: "turn.failed",
+        sessionId,
+        turnId: message.turnId,
+        error: "another turn is already running"
+      });
+      return;
+    }
+    activeTurn = {
+      sessionId,
+      turnId: message.turnId,
+      prompt: message.prompt,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now(),
+      interrupted: false,
+      stalled: false,
+      finalized: false,
+      summary: ""
+    };
+    const turn = activeTurn;
+    writeEvent({ type: "turn.started", sessionId: activeTurn.sessionId, turnId: activeTurn.turnId });
+    if (params.mockResponse !== void 0) {
+      if (mockResponseDelayMs > 0) {
+        await delay(mockResponseDelayMs);
+      }
+      if (activeTurn !== turn || turn.finalized) {
+        return;
+      }
+      display(params.mockResponse);
+      finalize("completed");
+      if (activeTurn === turn) activeTurn = null;
+      return;
+    }
+    if (params.startupError) {
+      finalize("failed", params.startupError);
+      if (activeTurn === turn) activeTurn = null;
+      return;
+    }
+    try {
+      await ensureRuntime();
+    } catch (error) {
+      finalize("failed", error instanceof Error ? error.message : String(error));
+      if (activeTurn === turn) activeTurn = null;
+      return;
+    }
+    const runtime = params.runtime;
+    if (runtime?.initialModel.unconfigured) {
+      finalize("failed", runtime.initialModel.warning || "No models are configured.");
+      if (activeTurn === turn) activeTurn = null;
+      return;
+    }
+    if (!controller || !agent) {
+      finalize("failed", "JSON events runtime was not initialized");
+      if (activeTurn === turn) activeTurn = null;
+      return;
+    }
+    const progressTimer = setInterval(() => {
+      const turn2 = activeTurn;
+      if (!turn2 || turn2.finalized) return;
+      if (Date.now() - turn2.lastActivityAt >= noProgressTimeoutMs) {
+        turn2.stalled = true;
+        controller?.abort();
+        finalize("stalled", "no_progress_timeout");
+      }
+    }, Math.max(1e3, Math.min(noProgressTimeoutMs, 1e4)));
+    progressTimer.unref?.();
+    try {
+      trace?.notePendingUserText(message.prompt);
+      trace?.noteDispatchStart({ mode: "json-events" });
+      await controller.prompt(message.prompt, { source: "json-events" });
+      trace?.noteDispatchSettled({ mode: "json-events" });
+      trace?.noteWaitForIdleStart({ mode: "json-events" });
+      await controller.waitForSettled();
+      trace?.noteWaitForIdleSettled({ mode: "json-events" });
+      if (!activeTurn?.finalized) {
+        const finalError = assistantErrorFromAgent(agent);
+        if (activeTurn?.interrupted) {
+          finalize("cancelled", "user_interrupt");
+          return;
+        }
+        if (finalError) {
+          finalize("failed", finalError);
+          return;
+        }
+        const text = assistantTextFromAgent(agent);
+        if (!activeTurn?.summary && text) {
+          display(text);
+        }
+        finalize("completed", text || activeTurn?.summary.trim());
+      }
+    } catch (error) {
+      const messageText = error instanceof Error ? error.message : String(error);
+      trace?.noteStalled(messageText, { mode: "json-events" });
+      if (!activeTurn?.finalized) {
+        finalize(activeTurn?.interrupted ? "cancelled" : "failed", activeTurn?.interrupted ? "user_interrupt" : messageText);
+      }
+    } finally {
+      clearInterval(progressTimer);
+      trace?.flush();
+      await runtime?.sessionManager.save();
+      if (activeTurn === turn) activeTurn = null;
+    }
+  }
+  async function interrupt(message) {
+    if (isSessionMismatch(message)) {
+      writeEvent({
+        type: "turn.cancelled",
+        sessionId,
+        turnId: message.turnId || "no-active-turn",
+        reason: sessionMismatchError(message.sessionId)
+      });
+      return;
+    }
+    if (!activeTurn || activeTurn.finalized) {
+      writeEvent({
+        type: "turn.cancelled",
+        sessionId,
+        turnId: message.turnId || "no-active-turn",
+        reason: message.reason || "no_active_turn"
+      });
+      return;
+    }
+    if (message.turnId && message.turnId !== activeTurn.turnId) {
+      writeEvent({
+        type: "turn.cancelled",
+        sessionId,
+        turnId: message.turnId,
+        reason: `turn mismatch: active turn is ${activeTurn.turnId}`
+      });
+      return;
+    }
+    activeTurn.interrupted = true;
+    controller?.abort();
+    if (params.mockResponse !== void 0) {
+      finalize("cancelled", message.reason || "user_interrupt");
+      activeTurn = null;
+    }
+  }
+  const input = readline.createInterface({ input: process.stdin });
+  let activeTurnPromise = null;
+  for await (const line of input) {
+    if (!line.trim()) continue;
+    const message = parseInput(line);
+    if (!message) {
+      writeEvent({ type: "turn.failed", sessionId, turnId: `invalid-${Date.now()}`, error: "invalid JSON events input" });
+      continue;
+    }
+    if (message.type === "shutdown") {
+      if (activeTurn && !activeTurn.finalized) {
+        activeTurn.interrupted = true;
+        controller?.abort();
+        finalize("cancelled", message.reason || "shutdown");
+      }
+      break;
+    }
+    if (message.type === "turn.interrupt") {
+      await interrupt(message);
+      continue;
+    }
+    const shouldTrackTurn = !activeTurn || activeTurn.finalized;
+    const turnPromise = runTurn(message).catch((error) => {
+      writeEvent({
+        type: "turn.failed",
+        sessionId,
+        turnId: message.turnId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }).finally(() => {
+      if (activeTurnPromise === turnPromise) {
+        activeTurnPromise = null;
+      }
+    });
+    if (shouldTrackTurn) {
+      activeTurnPromise = turnPromise;
+    }
+  }
+  await activeTurnPromise;
+  disposeAgentSubscription?.();
+  disposeSemanticSubscription?.();
+  controller?.dispose();
+  await params.runtime?.sessionManager.save();
+  trace?.flush();
+}
+
 // src/cli.ts
 enableEarlyLogBuffer();
 var logError = (msg, err) => {
@@ -67567,6 +68256,7 @@ Config Files:
 Print Mode Options:
   --raw-output     Print assistant text only in non-interactive mode
   --json-output    Print structured JSON in non-interactive mode
+  --json-events    Run JSONL protocol mode over stdin/stdout
   --session-id     Reuse or create a specific session in non-interactive mode
   --extension-path Add an extra extension search directory (repeatable)
 `);
@@ -67649,12 +68339,66 @@ function parseRepeatedFlag(args, flag) {
   }
   return values;
 }
+async function runWithJsonEventsConsoleIsolation(fn) {
+  const originalLog = console.log;
+  const originalInfo = console.info;
+  const originalDebug = console.debug;
+  const redirectToStderr = (...args) => console.error(...args);
+  console.log = redirectToStderr;
+  console.info = redirectToStderr;
+  console.debug = redirectToStderr;
+  try {
+    await fn();
+  } finally {
+    console.log = originalLog;
+    console.info = originalInfo;
+    console.debug = originalDebug;
+  }
+}
+async function createCliTestStreamFnFromEnv() {
+  if (!process.env.PIE_TEST_MOCK_STREAM_SEQUENCE) {
+    return void 0;
+  }
+  const { createTestStreamFnFromSequenceEnv } = await import("./chunks/test-stream-ZSKNLUEJ.js");
+  return createTestStreamFnFromSequenceEnv();
+}
 async function startChat(initialPrompt, testCommand) {
   const rawOutput = process.argv.includes("--raw-output");
   const jsonOutput = process.argv.includes("--json-output");
+  const jsonEvents = process.argv.includes("--json-events");
   const sessionIdFlagIndex = process.argv.indexOf("--session-id");
   const explicitSessionId = sessionIdFlagIndex >= 0 ? process.argv[sessionIdFlagIndex + 1] : void 0;
   const extensionPaths = parseRepeatedFlag(process.argv, "--extension-path");
+  if (jsonEvents) {
+    await runWithJsonEventsConsoleIsolation(async () => {
+      if (process.env.PIE_TEST_MOCK_RESPONSE !== void 0) {
+        await runJsonEventsMode({
+          explicitSessionId,
+          mockResponse: process.env.PIE_TEST_MOCK_RESPONSE
+        });
+        return;
+      }
+      let runtime2;
+      try {
+        runtime2 = await composeCliRuntime({ explicitSessionId, extensionPaths });
+      } catch (error) {
+        if (error instanceof CliMissingApiKeyError) {
+          await runJsonEventsMode({
+            explicitSessionId,
+            startupError: error.message
+          });
+          return;
+        }
+        throw error;
+      }
+      await runJsonEventsMode({
+        runtime: runtime2,
+        explicitSessionId,
+        streamFn: await createCliTestStreamFnFromEnv()
+      });
+    });
+    return;
+  }
   if (initialPrompt && process.env.PIE_TEST_MOCK_RESPONSE !== void 0) {
     const text = process.env.PIE_TEST_MOCK_RESPONSE;
     if (jsonOutput) {
@@ -67680,7 +68424,13 @@ async function startChat(initialPrompt, testCommand) {
     throw error;
   }
   if (initialPrompt) {
-    await runPrintMode({ initialPrompt, rawOutput, jsonOutput, runtime });
+    await runPrintMode({
+      initialPrompt,
+      rawOutput,
+      jsonOutput,
+      runtime,
+      streamFn: await createCliTestStreamFnFromEnv()
+    });
     process.exit(process.exitCode ?? 0);
     return;
   }