@costrict/csc 4.1.3 → 4.1.4

package/dist/chunk-ksav9jw1.js

@@ -0,0 +1,2118 @@
+// @bun
+import {
+  getProjectDir,
+  init_sessionStoragePortable
+} from "./chunk-jakx4th4.js";
+import {
+  init_log,
+  logError
+} from "./chunk-vtcqe66h.js";
+import {
+  init_slowOperations,
+  jsonParse,
+  jsonStringify
+} from "./chunk-dea6k409.js";
+import {
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// src/server/sessionHandle.ts
+init_slowOperations();
+init_log();
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+import { readdir, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+
+// src/server/childSpawn.ts
+import { basename } from "path";
+var INIT_TIMEOUT_MS = (() => {
+  const raw = Number(process.env.CSC_SERVE_INIT_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : 120000;
+})();
+function getScriptArgsForChild() {
+  const argv1 = process.argv[1];
+  if (!argv1)
+    return [];
+  const execBase = basename(process.execPath);
+  if (!/^(bun|node)/i.test(execBase))
+    return [];
+  if (argv1.startsWith("B:/~BUN/") || argv1.startsWith("/snapshot/"))
+    return [];
+  if (argv1 === process.execPath)
+    return [];
+  if (argv1.endsWith(".ts") || argv1.endsWith(".tsx") || argv1.includes("/") || argv1.includes("\\")) {
+    return [argv1];
+  }
+  return [];
+}
+function getChildSpawnArgs() {
+  const execPath = process.execPath;
+  const scriptArgs = getScriptArgsForChild();
+  return { execPath, scriptArgs };
+}
+async function saveChildSpawnPrefix() {
+  if (process.env._CSC_CHILD_SPAWN_PREFIX)
+    return;
+  const { execPath, scriptArgs } = getChildSpawnArgs();
+  let defineArgs = [];
+  let featureArgs = [];
+  const isRunningSourceFile = scriptArgs.length > 0 && (scriptArgs[0].endsWith(".tsx") || scriptArgs[0].endsWith(".ts"));
+  if (isRunningSourceFile) {
+    try {
+      const definesMod = await import("./chunk-4md0mpss.js");
+      const defines = definesMod.getMacroDefines();
+      defineArgs = Object.entries(defines).flatMap(([k, v]) => ["-d", `${k}:${v}`]);
+      const features = definesMod.DEFAULT_BUILD_FEATURES;
+      featureArgs = features.flatMap((f) => ["--feature", f]);
+    } catch {}
+    const envFeatures = Object.entries(process.env).filter(([k]) => k.startsWith("FEATURE_") && k.slice(8)).map(([k]) => ["--feature", k.slice(8)]).flat();
+    featureArgs = [...featureArgs, ...envFeatures];
+  }
+  const prefix = JSON.stringify({ execPath, scriptArgs, defineArgs, featureArgs });
+  process.env._CSC_CHILD_SPAWN_PREFIX = prefix;
+}
+function loadChildSpawnPrefix() {
+  const raw = process.env._CSC_CHILD_SPAWN_PREFIX;
+  if (!raw)
+    return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/server/sessionControlChannel.ts
+class ControlChannel {
+  pending = new Map;
+  register(requestId, timeoutMs = 1e4) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(new Error(`Control response timed out for ${requestId}`));
+      }, timeoutMs);
+      this.pending.set(requestId, { resolve, reject, timeout });
+    });
+  }
+  tryResolve(msg) {
+    if (msg.type !== "control_response")
+      return false;
+    const response = msg.response;
+    const requestId = response?.request_id;
+    if (!requestId || !this.pending.has(requestId))
+      return false;
+    const entry = this.pending.get(requestId);
+    this.pending.delete(requestId);
+    clearTimeout(entry.timeout);
+    if (response?.subtype === "error") {
+      entry.reject(new Error(response.error ?? "Unknown error"));
+    } else {
+      entry.resolve(response?.response ?? {});
+    }
+    return true;
+  }
+  rejectAll(error) {
+    for (const [, entry] of this.pending) {
+      clearTimeout(entry.timeout);
+      entry.reject(error);
+    }
+    this.pending.clear();
+  }
+}
+
+// src/server/sessionMessageRouter.ts
+init_slowOperations();
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/server/streamStateTracker.ts
+import { randomUUID } from "crypto";
+var states = new Map;
+var streamedSessions = new Set;
+var completedTools = new Map;
+function getOrCreate(sessionID) {
+  let state = states.get(sessionID);
+  if (!state) {
+    state = {
+      messageID: randomUUID(),
+      parentID: "",
+      modelID: "",
+      activeBlocks: new Map,
+      stepStartPartID: randomUUID(),
+      assistantPartEmitted: false,
+      usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 },
+      stopReason: ""
+    };
+    states.set(sessionID, state);
+  }
+  return state;
+}
+function resetStreamState(sessionID) {
+  states.delete(sessionID);
+}
+function hasActiveStream(sessionID) {
+  return states.has(sessionID);
+}
+function consumeStreamedTurn(sessionID) {
+  if (streamedSessions.has(sessionID)) {
+    streamedSessions.delete(sessionID);
+    return true;
+  }
+  return false;
+}
+var pendingAgentSessions = new Map;
+function registerAgentSession(sessionID, toolUseID, agentSessionID) {
+  let sessionMap = pendingAgentSessions.get(sessionID);
+  if (!sessionMap) {
+    sessionMap = new Map;
+    pendingAgentSessions.set(sessionID, sessionMap);
+  }
+  sessionMap.set(toolUseID, agentSessionID);
+}
+function getCompletedToolInfo(sessionID, toolUseID) {
+  return completedTools.get(sessionID)?.get(toolUseID);
+}
+function processStreamEvent(sessionID, event) {
+  const results = [];
+  const state = getOrCreate(sessionID);
+  const eventType = event.type;
+  switch (eventType) {
+    case "message_start": {
+      const msg = event.message;
+      state.messageID = randomUUID();
+      state.modelID = msg?.model ?? "";
+      const msgUsage = msg?.usage;
+      state.usage.inputTokens = msgUsage?.input_tokens ?? 0;
+      state.usage.cacheReadTokens = msgUsage?.cache_read_input_tokens ?? 0;
+      state.usage.cacheWriteTokens = msgUsage?.cache_creation_input_tokens ?? 0;
+      state.activeBlocks.clear();
+      if (!state.assistantPartEmitted) {
+        results.push({
+          type: "message.updated",
+          properties: {
+            sessionID,
+            info: {
+              id: state.messageID,
+              role: "assistant",
+              modelID: state.modelID,
+              time: { created: Date.now() }
+            }
+          }
+        });
+        state.assistantPartEmitted = true;
+      }
+      state.stepStartPartID = randomUUID();
+      results.push({
+        type: "message.part.updated",
+        properties: {
+          sessionID,
+          part: { type: "step-start", id: state.stepStartPartID, messageID: state.messageID, sessionID }
+        }
+      });
+      break;
+    }
+    case "content_block_start": {
+      const evt = event;
+      const block = evt.content_block;
+      const index = evt.index;
+      if (!block)
+        break;
+      const partID = randomUUID();
+      const blockState = {
+        type: block.type,
+        partID,
+        inputJson: "",
+        startTime: Date.now(),
+        text: ""
+      };
+      state.activeBlocks.set(index, blockState);
+      if (block.type === "text") {
+        results.push({
+          type: "message.part.updated",
+          properties: {
+            sessionID,
+            part: { type: "text", id: partID, text: "", messageID: state.messageID, sessionID }
+          }
+        });
+      } else if (block.type === "thinking" || block.type === "redacted_thinking") {
+        results.push({
+          type: "message.part.updated",
+          properties: {
+            sessionID,
+            part: {
+              type: "reasoning",
+              id: partID,
+              text: "",
+              redacted: block.type === "redacted_thinking",
+              messageID: state.messageID,
+              sessionID
+            }
+          }
+        });
+      } else if (block.type === "tool_use") {
+        blockState.toolUseID = block.id;
+        blockState.toolName = block.name;
+        results.push({
+          type: "message.part.updated",
+          properties: {
+            sessionID,
+            part: {
+              type: "tool",
+              id: partID,
+              callID: block.id,
+              tool: normalizeToolName(block.name),
+              state: { status: "pending", input: {} },
+              messageID: state.messageID,
+              sessionID
+            }
+          }
+        });
+      }
+      break;
+    }
+    case "content_block_delta": {
+      const evt = event;
+      const delta = evt.delta;
+      const index = evt.index;
+      const blockState = state.activeBlocks.get(index);
+      if (!blockState || !delta)
+        break;
+      if (delta.type === "text_delta") {
+        blockState.text += delta.text ?? "";
+        results.push({
+          type: "message.part.delta",
+          properties: {
+            sessionID,
+            messageID: state.messageID,
+            partID: blockState.partID,
+            field: "text",
+            delta: delta.text
+          }
+        });
+      } else if (delta.type === "thinking_delta") {
+        blockState.text += delta.thinking ?? "";
+        results.push({
+          type: "message.part.delta",
+          properties: {
+            sessionID,
+            messageID: state.messageID,
+            partID: blockState.partID,
+            field: "text",
+            delta: delta.thinking
+          }
+        });
+      } else if (delta.type === "input_json_delta") {
+        blockState.inputJson += delta.partial_json ?? "";
+        results.push({
+          type: "message.part.delta",
+          properties: {
+            sessionID,
+            messageID: state.messageID,
+            partID: blockState.partID,
+            field: "input",
+            delta: delta.partial_json
+          }
+        });
+      }
+      break;
+    }
+    case "content_block_stop": {
+      const index = event.index;
+      const blockState = state.activeBlocks.get(index);
+      if (!blockState)
+        break;
+      const now = Date.now();
+      if (blockState.type === "tool_use") {
+        let parsedInput = {};
+        try {
+          parsedInput = JSON.parse(blockState.inputJson || "{}");
+        } catch {
+          parsedInput = {};
+        }
+        parsedInput = normalizeToolInput(parsedInput);
+        const title = parsedInput.description ?? blockState.toolName ?? "";
+        const toolState = {
+          status: "running",
+          input: parsedInput,
+          title,
+          time: { start: blockState.startTime }
+        };
+        results.push({
+          type: "message.part.updated",
+          properties: {
+            sessionID,
+            part: {
+              type: "tool",
+              id: blockState.partID,
+              callID: blockState.toolUseID,
+              tool: normalizeToolName(blockState.toolName ?? ""),
+              state: toolState,
+              messageID: state.messageID,
+              sessionID
+            }
+          }
+        });
+        if (blockState.toolUseID) {
+          let sessionTools = completedTools.get(sessionID);
+          if (!sessionTools) {
+            sessionTools = new Map;
+            completedTools.set(sessionID, sessionTools);
+          }
+          sessionTools.set(blockState.toolUseID, {
+            toolName: blockState.toolName ?? "",
+            partID: blockState.partID,
+            messageID: state.messageID,
+            startTime: blockState.startTime,
+            input: parsedInput,
+            title
+          });
+        }
+      } else if (blockState.type === "text" || blockState.type === "thinking" || blockState.type === "redacted_thinking") {
+        const partType = blockState.type === "text" ? "text" : "reasoning";
+        results.push({
+          type: "message.part.updated",
+          properties: {
+            sessionID,
+            part: {
+              type: partType,
+              id: blockState.partID,
+              text: blockState.text.trimEnd(),
+              messageID: state.messageID,
+              sessionID,
+              time: { start: blockState.startTime, end: now },
+              ...blockState.type === "redacted_thinking" ? { redacted: true } : {}
+            }
+          }
+        });
+      }
+      state.activeBlocks.delete(index);
+      break;
+    }
+    case "message_delta": {
+      const evt = event;
+      if (evt.delta?.stop_reason) {
+        state.stopReason = evt.delta.stop_reason;
+      }
+      if (evt.usage?.output_tokens) {
+        state.usage.outputTokens = evt.usage.output_tokens;
+      }
+      break;
+    }
+    case "message_stop": {
+      results.push({
+        type: "message.part.updated",
+        properties: {
+          sessionID,
+          part: {
+            type: "step-finish",
+            id: randomUUID(),
+            reason: state.stopReason || "stop",
+            cost: 0,
+            tokens: {
+              input: state.usage.inputTokens,
+              output: state.usage.outputTokens,
+              reasoning: 0,
+              cache: {
+                read: state.usage.cacheReadTokens,
+                write: state.usage.cacheWriteTokens
+              }
+            },
+            messageID: state.messageID,
+            sessionID
+          }
+        }
+      });
+      results.push({
+        type: "message.updated",
+        properties: {
+          sessionID,
+          info: {
+            id: state.messageID,
+            role: "assistant",
+            modelID: state.modelID,
+            time: { completed: Date.now() }
+          }
+        }
+      });
+      resetStreamState(sessionID);
+      streamedSessions.add(sessionID);
+      break;
+    }
+  }
+  return results;
+}
+function normalizeToolInput(input) {
+  const renames = {
+    file_path: "filePath",
+    old_string: "oldString",
+    new_string: "newString",
+    replace_all: "replaceAll"
+  };
+  for (const [oldKey, newKey] of Object.entries(renames)) {
+    if (oldKey in input) {
+      input[newKey] = input[oldKey];
+      delete input[oldKey];
+    }
+  }
+  return input;
+}
+function normalizeToolName(name) {
+  const map = {
+    Read: "read",
+    Edit: "edit",
+    Write: "edit",
+    Glob: "glob",
+    Grep: "grep",
+    LS: "list",
+    Bash: "bash",
+    PowerShell: "bash",
+    Agent: "task",
+    Task: "task",
+    WebFetch: "webfetch",
+    WebSearch: "websearch",
+    TodoRead: "todoread",
+    TodoWrite: "todowrite"
+  };
+  return map[name] ?? name.toLowerCase();
+}
+
+// src/server/sessionMessageRouter.ts
+var API_ERROR_PREFIX_RE = /^API Error:\s*/;
+var COSTRICT_API_ERROR_PREFIX_RE = /^CoStrict API Error:\s*/;
+var subagentToolState = new Map;
+function isApiErrorContent(content) {
+  if (typeof content === "string") {
+    return API_ERROR_PREFIX_RE.test(content) || COSTRICT_API_ERROR_PREFIX_RE.test(content);
+  }
+  if (!Array.isArray(content))
+    return false;
+  for (const block of content) {
+    if (!block || typeof block !== "object")
+      continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") {
+      const text = b.text;
+      if (API_ERROR_PREFIX_RE.test(text) || COSTRICT_API_ERROR_PREFIX_RE.test(text))
+        return true;
+    }
+  }
+  return false;
+}
+function buildErrorFromContent(content) {
+  let raw = "";
+  if (typeof content === "string") {
+    raw = content.replace(API_ERROR_PREFIX_RE, "").replace(COSTRICT_API_ERROR_PREFIX_RE, "");
+  } else if (Array.isArray(content)) {
+    for (const block of content) {
+      if (!block || typeof block !== "object")
+        continue;
+      const b = block;
+      if (b.type === "text" && typeof b.text === "string") {
+        raw = b.text.replace(API_ERROR_PREFIX_RE, "").replace(COSTRICT_API_ERROR_PREFIX_RE, "");
+        break;
+      }
+    }
+  }
+  const statusMatch = raw.match(/^(\d{3})\s+/);
+  const statusCode = statusMatch ? parseInt(statusMatch[1], 10) : undefined;
+  const isRetryable = statusCode === 429 || statusCode === 503 || statusCode === 529;
+  let message = raw;
+  try {
+    const jsonStart = raw.indexOf("{");
+    if (jsonStart !== -1) {
+      const parsed = JSON.parse(raw.slice(jsonStart));
+      if (parsed?.error?.message) {
+        message = parsed.error.message;
+      } else if (typeof parsed?.message === "string") {
+        message = parsed.message;
+      }
+    }
+  } catch {}
+  return { name: "APIError", data: { message, statusCode, isRetryable } };
+}
+function extractToolResultContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  const parts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object")
+      continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") {
+      parts.push(b.text);
+    } else if (b.type === "image") {
+      const src = b.source;
+      if (typeof src?.data === "string") {
+        parts.push(`[image: ${src.type}]`);
+      }
+    }
+  }
+  return parts.join(`
+`);
+}
+function getActiveSubagentId(ctx) {
+  const subs = ctx.getActiveSubagents();
+  if (subs.size === 0)
+    return;
+  return subs.keys().next().value;
+}
+function getSubagentProgress(agentId) {
+  const state = subagentToolState.get(agentId);
+  if (!state)
+    return;
+  return { progressLines: state.progressLines, mainToolUseID: state.mainToolUseID };
+}
+function routeMessage(msg, ctx) {
+  if (ctx.getStatus() === "starting" && msg.type === "control_response") {
+    const response = msg.response;
+    if (response?.subtype === "success" && response?.request_id === ctx.getInitRequestId()) {
+      handleInitResponse(response, ctx);
+      return;
+    }
+  }
+  if (msg.type === "control_response") {
+    if (ctx.getControlChannel().tryResolve(msg))
+      return;
+  }
+  ctx.emitMessage(msg);
+  switch (msg.type) {
+    case "assistant": {
+      handleAssistantMessage(msg, ctx);
+      break;
+    }
+    case "user": {
+      handleUserMessage(msg, ctx);
+      break;
+    }
+    case "result": {
+      handleResultMessage(msg, ctx);
+      break;
+    }
+    case "control_request": {
+      handleControlRequest(msg, ctx);
+      break;
+    }
+    case "control_cancel_request": {
+      handleCancelRequest(msg, ctx);
+      break;
+    }
+    case "stream_event": {
+      handleStreamEvent(msg, ctx);
+      break;
+    }
+    case "system": {
+      handleSystemMessage(msg, ctx);
+      break;
+    }
+    case "attachment": {
+      handleAttachment(msg, ctx);
+      break;
+    }
+    case "progress": {
+      handleProgress(msg, ctx);
+      break;
+    }
+    case "tombstone": {
+      handleTombstone(msg, ctx);
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+function handleInitResponse(response, ctx) {
+  const initData = response.response ?? {};
+  ctx.setInitData(initData);
+  if (Array.isArray(initData.models) && initData.models.length > 0 && !ctx.getModel()) {
+    const first = initData.models[0];
+    ctx.setModel(first?.value ?? first?.name);
+  }
+  if (initData.account?.apiProvider) {
+    ctx.setProviderId(initData.account.apiProvider);
+  }
+  ctx.setStatus("running");
+  ctx.setLastActiveAt(Date.now());
+  ctx.resolveInit(initData);
+  ctx.emitOpencodeEvent("session.updated", {
+    sessionID: ctx.sessionId,
+    status: "running",
+    model: ctx.getModel(),
+    providerID: ctx.getProviderId()
+  });
+}
+function handleAssistantMessage(msg, ctx) {
+  ctx.setLastActiveAt(Date.now());
+  ctx.setStatus("running");
+  if (msg.uuid && typeof msg.uuid === "string") {
+    ctx.setLastMessageUuid(msg.uuid);
+  }
+  const rawContent = msg.message?.content ?? msg.content;
+  const isApiError = isApiErrorContent(rawContent);
+  const agentId = msg.agent_id || getActiveSubagentId(ctx);
+  const emitSessionID = agentId && ctx.getActiveSubagents().has(agentId) ? agentId : ctx.sessionId;
+  const wasStreamed = hasActiveStream(emitSessionID) || consumeStreamedTurn(emitSessionID);
+  if (msg.uuid) {
+    ctx.pushBufferMessage({
+      uuid: msg.uuid,
+      type: "assistant",
+      role: "assistant",
+      content: isApiError ? [] : msg.message ?? msg.content ?? "",
+      timestamp: msg.timestamp ? new Date(msg.timestamp).getTime() : Date.now(),
+      parent_uuid: msg.parentUuid ?? null,
+      ...isApiError ? { error: buildErrorFromContent(rawContent) } : {}
+    });
+  }
+  if (wasStreamed) {
+    if (Array.isArray(rawContent)) {
+      for (const block of rawContent) {
+        const b = block;
+        if (b.type !== "tool_result")
+          continue;
+        const toolUseID = b.tool_use_id;
+        if (!toolUseID)
+          continue;
+        const toolInfo = getCompletedToolInfo(emitSessionID, toolUseID);
+        const output = extractToolResultContent(b.content);
+        const isError = b.is_error === true;
+        ctx.emitOpencodeEvent("message.part.updated", {
+          sessionID: emitSessionID,
+          part: {
+            type: "tool",
+            id: toolInfo?.partID ?? randomUUID2(),
+            callID: toolUseID,
+            tool: toolInfo?.toolName ? normalizeToolName2(toolInfo.toolName) : "",
+            messageID: ctx.getLastMessageUuid() ?? "",
+            sessionID: emitSessionID,
+            state: {
+              status: isError ? "error" : "completed",
+              input: toolInfo?.input ?? {},
+              title: toolInfo?.title ?? toolInfo?.toolName ?? "",
+              ...isError ? { error: output } : { output },
+              time: { start: toolInfo?.startTime ?? Date.now(), end: Date.now() }
+            }
+          }
+        });
+      }
+    }
+    return;
+  }
+  let enriched = msg;
+  if (!msg.model && ctx.getModel()) {
+    enriched = { ...enriched, model: ctx.getModel() };
+  }
+  if (!msg.provider_id && ctx.getProviderId()) {
+    enriched = { ...enriched, provider_id: ctx.getProviderId() };
+  }
+  const assistantMsgID = msg.uuid ?? randomUUID2();
+  ctx.emitOpencodeEvent("message.updated", {
+    sessionID: emitSessionID,
+    info: {
+      id: assistantMsgID,
+      role: "assistant",
+      modelID: enriched.model,
+      providerID: enriched.provider_id,
+      cost: 0,
+      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+      time: {
+        created: msg.timestamp ? new Date(msg.timestamp).getTime() : Date.now()
+      },
+      parentID: msg.parentUuid ?? null,
+      ...isApiError ? { error: buildErrorFromContent(rawContent) } : {}
+    }
+  });
+  if (Array.isArray(rawContent)) {
+    for (const block of rawContent) {
+      const part = buildPartFromContentBlock(block, assistantMsgID, emitSessionID);
+      if (part) {
+        if (isApiError && part.type === "text")
+          continue;
+        ctx.emitOpencodeEvent("message.part.updated", {
+          sessionID: emitSessionID,
+          part
+        });
+      }
+    }
+  }
+}
+function handleUserMessage(msg, ctx) {
+  if (msg.isReplay)
+    return;
+  const agentId = msg.agent_id || getActiveSubagentId(ctx);
+  const emitSessionID = agentId && ctx.getActiveSubagents().has(agentId) ? agentId : ctx.sessionId;
+  let rawContent = msg.message ?? msg.content;
+  if (rawContent && typeof rawContent === "object" && !Array.isArray(rawContent) && "content" in rawContent) {
+    rawContent = rawContent.content;
+  }
+  if (Array.isArray(rawContent)) {
+    for (const block of rawContent) {
+      const b = block;
+      if (b.type !== "tool_result")
+        continue;
+      const toolUseID = b.tool_use_id;
+      if (!toolUseID)
+        continue;
+      const output = extractToolResultContent(b.content);
+      const isError = b.is_error === true;
+      const toolInfo = getCompletedToolInfo(emitSessionID, toolUseID);
+      ctx.emitOpencodeEvent("message.part.updated", {
+        sessionID: emitSessionID,
+        part: {
+          type: "tool",
+          id: toolInfo?.partID ?? randomUUID2(),
+          callID: toolUseID,
+          tool: toolInfo?.toolName ? normalizeToolName2(toolInfo.toolName) : "",
+          messageID: toolInfo?.messageID,
+          sessionID: emitSessionID,
+          state: {
+            status: isError ? "error" : "completed",
+            input: toolInfo?.input ?? {},
+            title: toolInfo?.title ?? toolInfo?.toolName ?? "",
+            ...isError ? { error: output } : { output },
+            time: { start: toolInfo?.startTime, end: Date.now() }
+          }
+        }
+      });
+    }
+  }
+  const content = typeof msg.content === "string" ? msg.content : "";
+  if (content.includes("<local-command-stdout>"))
+    return;
+  ctx.emitOpencodeEvent("message.updated", {
+    sessionID: emitSessionID,
+    info: {
+      id: msg.uuid ?? randomUUID2(),
+      role: "user",
+      time: { created: Date.now() },
+      parentID: null
+    }
+  });
+}
+function handleResultMessage(msg, ctx) {
+  ctx.setLastActiveAt(Date.now());
+  ctx.setStatus("running");
+  const cost = msg.cost_usd;
+  const usage = msg.usage;
+  if (cost)
+    ctx.addCost(cost);
+  if (usage?.input_tokens)
+    ctx.addInputTokens(usage.input_tokens);
+  if (usage?.output_tokens)
+    ctx.addOutputTokens(usage.output_tokens);
+  ctx.setBusyStatus({ type: "idle" });
+  ctx.emitBusyStatus();
+  ctx.emitOpencodeEvent("session.result", {
+    sessionID: ctx.sessionId,
+    subtype: msg.subtype ?? "success",
+    costUsd: msg.cost_usd,
+    usage: msg.usage,
+    stopReason: msg.stop_reason
+  });
+  const subtype = msg.subtype;
+  if (subtype && subtype !== "success") {
+    const errorData = msg.errors;
+    const errorMessage = errorData?.[0]?.message ?? msg.subtype ?? "Unknown error";
+    ctx.emitOpencodeEvent("session.error", {
+      sessionID: ctx.sessionId,
+      error: {
+        subtype,
+        level: "error",
+        message: typeof errorMessage === "string" ? errorMessage : JSON.stringify(errorMessage)
+      }
+    });
+  }
+  ctx.resolvePrompt({ done: true });
+}
+function handleStreamEvent(msg, ctx) {
+  ctx.setLastActiveAt(Date.now());
+  const event = msg.event;
+  if (!event)
+    return;
+  const agentId = msg.agent_id;
+  const subagentActive = agentId && ctx.getActiveSubagents().has(agentId);
+  const emitSessionID = subagentActive ? agentId : ctx.sessionId;
+  const canonicalEvents = processStreamEvent(emitSessionID, event);
+  for (const ce of canonicalEvents) {
+    ctx.emitOpencodeEvent(ce.type, ce.properties);
+  }
+}
+function handleSystemMessage(msg, ctx) {
+  const subtype = msg.subtype;
+  switch (subtype) {
+    case "task_notification":
+      emitTaskCompleted(msg, ctx);
+      break;
+    case "task_started":
+      emitTaskStarted(msg, ctx);
+      break;
+    case "task_progress":
+      emitTaskProgress(msg, ctx);
+      break;
+    case "api_error":
+    case "api_retry":
+      emitSessionError(msg, ctx);
+      break;
+    case "compact_boundary":
+    case "microcompact_boundary":
+      emitCompactionEvent(msg, ctx);
+      break;
+    case "stop_hook_summary":
+      emitHookSummary(msg, ctx);
+      break;
+    case "turn_duration":
+      emitSessionMetrics(msg, ctx);
+      break;
+    case "cache_warning":
+      emitSessionWarning(msg, ctx);
+      break;
+    case "informational":
+    case "post_turn_summary":
+      emitSessionInfo(msg, ctx);
+      break;
+    case "session_state_changed":
+    case "status":
+      emitSessionStatus(msg, ctx);
+      break;
+    default:
+      if (subtype) {
+        emitSessionInfo(msg, ctx);
+      }
+      break;
+  }
+}
+function handleAttachment(msg, ctx) {
+  ctx.emitOpencodeEvent("message.attachment", {
+    sessionID: ctx.sessionId,
+    attachmentType: msg.attachment?.type,
+    attachment: msg.attachment
+  });
+}
+function handleProgress(msg, ctx) {
+  ctx.emitOpencodeEvent("tool.progress", {
+    sessionID: ctx.sessionId,
+    toolUseID: msg.toolUseID,
+    parentToolUseID: msg.parentToolUseID,
+    data: msg.data
+  });
+}
+function handleTombstone(msg, ctx) {
+  const messageObj = msg.message;
+  const targetUuid = messageObj?.uuid;
+  if (targetUuid) {
+    ctx.addTombstonedUuid(targetUuid);
+    ctx.emitOpencodeEvent("message.removed", {
+      sessionID: ctx.sessionId,
+      messageID: targetUuid
+    });
+  }
+}
+function handleControlRequest(msg, ctx) {
+  const request = msg.request;
+  const requestId = msg.request_id;
+  if (request?.subtype === "can_use_tool") {
+    const toolName = request.tool_name ?? "Unknown";
+    const perm = {
+      requestId,
+      sessionId: ctx.sessionId,
+      toolName,
+      toolUseId: request.tool_use_id ?? "",
+      input: request.input ?? {},
+      title: `${request.tool_name}: ${JSON.stringify(request.input).slice(0, 80)}`,
+      description: `Execute ${request.tool_name}`,
+      suggestions: request.permission_suggestions ?? []
+    };
+    ctx.getPendingPermissions().set(requestId, perm);
+    ctx.emitEvent("control_request", { request_id: requestId, request });
+    if (toolName === "AskUserQuestion") {
+      const input = request.input ?? {};
+      const questions = input.questions ?? [];
+      ctx.emitOpencodeEvent("question.asked", {
+        sessionID: ctx.sessionId,
+        id: requestId,
+        questions: questions.map((q) => ({
+          question: q.question,
+          header: q.header ?? "",
+          options: (q.options ?? []).map((o) => ({
+            label: o.label,
+            description: o.description
+          })),
+          multiple: q.multiSelect ?? false,
+          custom: false
+        })),
+        tool: {
+          messageID: "",
+          callID: perm.toolUseId
+        }
+      });
+    } else {
+      ctx.emitOpencodeEvent("permission.asked", {
+        sessionID: ctx.sessionId,
+        id: requestId,
+        permission: toPermissionKey(toolName),
+        patterns: extractPatterns(perm.input),
+        metadata: { input: perm.input },
+        always: [],
+        tool: {
+          messageID: "",
+          callID: perm.toolUseId
+        }
+      });
+    }
+  } else if (request?.subtype === "elicitation") {
+    const question = {
+      requestId,
+      sessionId: ctx.sessionId,
+      mcpServerName: request.mcp_server_name ?? "",
+      message: request.message ?? "",
+      mode: request.mode ?? "form",
+      requestedSchema: request.requested_schema ?? {}
+    };
+    ctx.getPendingQuestions().set(requestId, question);
+    ctx.emitEvent("control_request", { request_id: requestId, request });
+    ctx.emitOpencodeEvent("question.asked", {
+      sessionID: ctx.sessionId,
+      id: requestId,
+      questions: [{
+        question: question.message,
+        header: question.mcpServerName || "MCP",
+        options: [],
+        multiple: false,
+        custom: true
+      }]
+    });
+  } else if (request?.subtype === "hook_callback") {
+    ctx.emitEvent("control_request", { request_id: requestId, request });
+    const callbackId = request.callback_id;
+    if (!callbackId || callbackId === "AUTO_APPROVE_CALLBACK_ID") {
+      ctx.writeStdin(jsonStringify({
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: requestId,
+          response: {
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              permissionDecision: "allow",
+              permissionDecisionReason: "Auto-approved by serve"
+            }
+          }
+        }
+      }));
+    } else {
+      ctx.writeStdin(jsonStringify({
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: requestId,
+          response: {
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              permissionDecision: "ask",
+              permissionDecisionReason: "Forwarding to can_use_tool"
+            }
+          }
+        }
+      }));
+    }
+  }
+}
+function handleCancelRequest(msg, ctx) {
+  const cancelRequestId = msg.request_id;
+  const wasPerm = ctx.getPendingPermissions().has(cancelRequestId);
+  const wasQuestion = ctx.getPendingQuestions().has(cancelRequestId);
+  ctx.getPendingPermissions().delete(cancelRequestId);
+  ctx.getPendingQuestions().delete(cancelRequestId);
+  if (wasQuestion) {
+    ctx.emitOpencodeEvent("question.rejected", {
+      sessionID: ctx.sessionId,
+      requestID: cancelRequestId
+    });
+  }
+  if (wasPerm) {
+    ctx.emitOpencodeEvent("permission.replied", {
+      sessionID: ctx.sessionId,
+      requestID: cancelRequestId
+    });
+  }
+}
+function buildPartFromContentBlock(block, messageID, sessionID) {
+  switch (block.type) {
+    case "text":
+      return { type: "text", id: randomUUID2(), text: block.text, messageID, sessionID };
+    case "thinking":
+      return { type: "reasoning", id: randomUUID2(), text: block.thinking, messageID, sessionID };
+    case "redacted_thinking":
+      return { type: "reasoning", id: randomUUID2(), text: "", redacted: true, messageID, sessionID };
+    case "tool_use": {
+      const toolInput = normalizeToolInput2(block.input);
+      return {
+        type: "tool",
+        id: randomUUID2(),
+        callID: block.id,
+        tool: normalizeToolName2(block.name),
+        state: {
+          status: "running",
+          input: toolInput,
+          title: toolInput?.description ?? block.name,
+          time: { start: Date.now() }
+        },
+        messageID,
+        sessionID
+      };
+    }
+    default:
+      return null;
+  }
+}
+function normalizeToolName2(name) {
+  return toPermissionKey(name);
+}
+function emitTaskStarted(msg, ctx) {
+  const agentId = msg.agent_id ?? msg.task_id;
+  const taskType = msg.task_type;
+  const description = msg.description;
+  const prompt = msg.prompt;
+  const toolUseId = msg.tool_use_id;
+  const assistantMessageID = randomUUID2();
+  ctx.registerSubagent({
+    agentId,
+    agentType: taskType,
+    description,
+    prompt,
+    toolUseId
+  });
+  const toolUseIdForMain = toolUseId;
+  subagentToolState.set(agentId, {
+    emittedToolCount: 0,
+    assistantMessageID,
+    toolPartIDs: new Map,
+    mainToolUseID: toolUseIdForMain ?? "",
+    progressLines: []
+  });
+  ctx.emitOpencodeEvent("task.started", {
+    sessionID: ctx.sessionId,
+    taskID: msg.task_id,
+    toolUseID: toolUseId,
+    description,
+    taskType,
+    workflowName: msg.workflow_name,
+    prompt
+  });
+  ctx.emitOpencodeEvent("session.created", {
+    sessionID: agentId,
+    info: {
+      id: agentId,
+      parentID: ctx.sessionId,
+      title: description || `Subagent ${agentId.slice(0, 8)}`,
+      agent: taskType ?? "general-purpose",
+      createdAt: Date.now(),
+      status: "running"
+    }
+  });
+  ctx.emitOpencodeEvent("message.updated", {
+    sessionID: agentId,
+    info: {
+      id: assistantMessageID,
+      role: "assistant",
+      modelID: "subagent",
+      time: { created: Date.now() },
+      parentID: null
+    }
+  });
+  ctx.emitOpencodeEvent("session.status", {
+    sessionID: agentId,
+    status: { type: "busy" }
+  });
+  if (toolUseId) {
+    registerAgentSession(ctx.sessionId, toolUseId, agentId);
+  }
+}
+function emitTaskProgress(msg, ctx) {
+  const agentId = msg.agent_id ?? msg.task_id;
+  const usage = msg.usage;
+  const toolUses = usage?.tool_uses ?? 0;
+  const lastToolName = msg.last_tool_name ?? "Tool";
+  const description = msg.description;
+  ctx.emitOpencodeEvent("task.progress", {
+    sessionID: ctx.sessionId,
+    taskID: msg.task_id,
+    description,
+    usage,
+    lastToolName,
+    summary: msg.summary,
+    workflowProgress: msg.workflow_progress
+  });
+  const toolState = subagentToolState.get(agentId);
+  if (!toolState)
+    return;
+  if (description) {
+    const lines = toolState.progressLines;
+    lines.push(description);
+    if (lines.length > 3)
+      lines.splice(0, lines.length - 3);
+    toolState.progressLines = lines;
+    if (toolState.mainToolUseID) {
+      const mainToolInfo = getCompletedToolInfo(ctx.sessionId, toolState.mainToolUseID);
+      ctx.emitOpencodeEvent("message.part.updated", {
+        sessionID: ctx.sessionId,
+        part: {
+          type: "tool",
+          id: randomUUID2(),
+          callID: toolState.mainToolUseID,
+          tool: mainToolInfo?.toolName ? normalizeToolName2(mainToolInfo.toolName) : "task",
+          state: {
+            status: "running",
+            input: mainToolInfo?.input ?? {},
+            title: mainToolInfo?.title ?? "",
+            time: { start: mainToolInfo?.startTime ?? Date.now() },
+            progress: toolState.progressLines
+          },
+          messageID: mainToolInfo?.messageID ?? "",
+          sessionID: ctx.sessionId
+        }
+      });
+    }
+  }
+  while (toolState.emittedToolCount < toolUses) {
+    toolState.emittedToolCount++;
+    const toolIndex = toolState.emittedToolCount;
+    const isLast = toolIndex === toolUses;
+    const toolName = toolIndex === toolUses ? lastToolName : "Tool";
+    let partID = toolState.toolPartIDs.get(toolIndex);
+    if (!partID) {
+      partID = randomUUID2();
+      toolState.toolPartIDs.set(toolIndex, partID);
+    }
+    ctx.emitOpencodeEvent("message.part.updated", {
+      sessionID: agentId,
+      part: {
+        type: "tool",
+        id: partID,
+        callID: `subagent-tool-${toolIndex}`,
+        tool: normalizeToolName2(toolName),
+        state: {
+          status: "completed",
+          output: isLast && description ? description.replace(/^Running\s*/i, "") : "",
+          title: `${toolName} #${toolIndex}`,
+          time: { start: Date.now() - (usage?.duration_ms ?? 0), end: Date.now() }
+        },
+        messageID: toolState.assistantMessageID,
+        sessionID: agentId
+      }
+    });
+  }
+}
+function emitTaskCompleted(msg, ctx) {
+  const agentId = msg.agent_id ?? msg.task_id;
+  const status = msg.status;
+  const summary = msg.summary;
+  const toolUseId = msg.tool_use_id;
+  const toolState = subagentToolState.get(agentId);
+  ctx.emitOpencodeEvent("task.completed", {
+    sessionID: ctx.sessionId,
+    taskID: msg.task_id,
+    toolUseID: toolUseId,
+    status,
+    summary,
+    outputFile: msg.output_file,
+    usage: msg.usage
+  });
+  if (toolUseId) {
+    const agentToolInfo = getCompletedToolInfo(ctx.sessionId, toolUseId);
+    ctx.emitOpencodeEvent("message.part.updated", {
+      sessionID: ctx.sessionId,
+      part: {
+        type: "tool",
+        id: agentToolInfo?.partID ?? randomUUID2(),
+        callID: toolUseId,
+        tool: agentToolInfo?.toolName ? normalizeToolName2(agentToolInfo.toolName) : undefined,
+        messageID: agentToolInfo?.messageID,
+        sessionID: ctx.sessionId,
+        state: {
+          status: status === "failed" ? "error" : "completed",
+          input: agentToolInfo?.input ?? {},
+          ...status === "failed" ? { error: summary || "Task failed" } : { output: summary || "" },
+          title: summary || "",
+          time: { start: agentToolInfo?.startTime, end: Date.now() }
+        }
+      }
+    });
+  }
+  if (toolState) {
+    ctx.emitOpencodeEvent("message.updated", {
+      sessionID: agentId,
+      info: {
+        id: toolState.assistantMessageID,
+        role: "assistant",
+        modelID: "subagent",
+        time: { completed: Date.now() }
+      }
+    });
+    subagentToolState.delete(agentId);
+  }
+  const subagent = ctx.getActiveSubagents().get(agentId);
+  if (subagent || agentId) {
+    ctx.emitOpencodeEvent("session.updated", {
+      sessionID: agentId,
+      info: {
+        id: agentId,
+        status,
+        summary,
+        completedAt: Date.now()
+      }
+    });
+    ctx.emitOpencodeEvent("session.status", {
+      sessionID: agentId,
+      status: { type: "idle" }
+    });
+    ctx.emitOpencodeEvent("session.idle", {
+      sessionID: agentId
+    });
+    ctx.unregisterSubagent(agentId);
+  }
+}
+function emitSessionError(msg, ctx) {
+  ctx.emitOpencodeEvent("session.error", {
+    sessionID: ctx.sessionId,
+    error: {
+      subtype: msg.subtype,
+      level: msg.level ?? "error",
+      message: msg.content ?? msg.error?.message,
+      retryInMs: msg.retry_in_ms ?? msg.retryInMs,
+      retryAttempt: msg.retry_attempt ?? msg.retryAttempt,
+      maxRetries: msg.max_retries ?? msg.maxRetries
+    }
+  });
+}
+function emitCompactionEvent(msg, ctx) {
+  ctx.emitOpencodeEvent("message.part.updated", {
+    sessionID: ctx.sessionId,
+    part: {
+      type: "compaction",
+      id: msg.uuid ?? randomUUID2(),
+      auto: msg.subtype === "microcompact_boundary" || msg.compact_metadata?.trigger === "auto"
+    }
+  });
+}
+function emitHookSummary(msg, ctx) {
+  ctx.emitOpencodeEvent("session.hook_summary", {
+    sessionID: ctx.sessionId,
+    hookLabel: msg.hook_label ?? msg.hookLabel,
+    hookCount: msg.hook_count ?? msg.hookCount,
+    hookErrors: msg.hook_errors ?? msg.hookErrors,
+    preventedContinuation: msg.prevented_continuation ?? msg.preventedContinuation,
+    totalDurationMs: msg.total_duration_ms ?? msg.totalDurationMs
+  });
+}
+function emitSessionMetrics(msg, ctx) {
+  ctx.emitOpencodeEvent("session.metrics", {
+    sessionID: ctx.sessionId,
+    turnDuration: msg.duration ?? msg.turn_duration
+  });
+}
+function emitSessionWarning(msg, ctx) {
+  ctx.emitOpencodeEvent("session.warning", {
+    sessionID: ctx.sessionId,
+    message: msg.content
+  });
+}
+function emitSessionInfo(msg, ctx) {
+  ctx.emitOpencodeEvent("session.info", {
+    sessionID: ctx.sessionId,
+    subtype: msg.subtype,
+    content: msg.content
+  });
+}
+function emitSessionStatus(msg, ctx) {
+  ctx.emitOpencodeEvent("session.status", {
+    sessionID: ctx.sessionId,
+    status: msg.status
+  });
+}
+function toPermissionKey(toolName) {
+  const map = {
+    Read: "read",
+    Edit: "edit",
+    Write: "edit",
+    Glob: "glob",
+    Grep: "grep",
+    LS: "list",
+    Bash: "bash",
+    PowerShell: "bash",
+    Agent: "task",
+    WebFetch: "webfetch",
+    WebSearch: "websearch",
+    TodoRead: "todoread",
+    TodoWrite: "todowrite"
+  };
+  return map[toolName] ?? toolName.toLowerCase();
+}
+function extractPatterns(input) {
+  const patterns = [];
+  for (const key of ["file_path", "path", "pattern", "glob"]) {
+    const v = typeof input[key] === "string" ? input[key] : "";
+    if (v)
+      patterns.push(v);
+  }
+  const cmd = typeof input.command === "string" ? input.command : "";
+  if (cmd)
+    patterns.push(cmd);
+  return patterns;
+}
+function normalizeToolInput2(input) {
+  const renames = {
+    file_path: "filePath",
+    old_string: "oldString",
+    new_string: "newString",
+    replace_all: "replaceAll"
+  };
+  for (const [oldKey, newKey] of Object.entries(renames)) {
+    if (oldKey in input) {
+      input[newKey] = input[oldKey];
+      delete input[oldKey];
+    }
+  }
+  return input;
+}
+
+// src/server/sessionHandle.ts
+init_sessionStoragePortable();
+class SessionHandle {
+  opts;
+  sessionId;
+  cwd;
+  _spawnCwd;
+  child = null;
+  _status = "starting";
+  _busyStatus = { type: "idle" };
+  _model;
+  _agent;
+  _providerId;
+  _permissionMode;
+  _title;
+  _costUsd = 0;
+  _inputTokens = 0;
+  _outputTokens = 0;
+  createdAt = Date.now();
+  lastActiveAt = Date.now();
+  eventBus;
+  pendingPermissions = new Map;
+  pendingQuestions = new Map;
+  promptResolve = null;
+  promptReject = null;
+  verbose;
+  lastStderr = [];
+  listeners = new Set;
+  _initData = null;
+  initRequestId = null;
+  initResolve = null;
+  initReject = null;
+  _prompting = false;
+  _lastMessageUuid = null;
+  _controlChannel = new ControlChannel;
+  _titleGenerationAttempted = false;
+  _firstPromptContent;
+  _messageBuffer = [];
+  _tombstonedUuids = new Set;
+  _activeSubagents = new Map;
+  _subagentIndex = new Map;
+  get subagentIndex() {
+    return this._subagentIndex;
+  }
+  get tombstonedUuids() {
+    return this._tombstonedUuids;
+  }
+  get activeSubagents() {
+    return this._activeSubagents;
+  }
+  get status() {
+    return this._status;
+  }
+  get busyStatus() {
+    return this._busyStatus;
+  }
+  get model() {
+    return this._model;
+  }
+  get agent() {
+    return this._agent;
+  }
+  get permissionMode() {
+    return this._permissionMode;
+  }
+  get title() {
+    return this._title;
+  }
+  get costUsd() {
+    return this._costUsd;
+  }
+  get inputTokens() {
+    return this._inputTokens;
+  }
+  get messageCount() {
+    return 0;
+  }
+  get usage() {
+    return {
+      input_tokens: this._inputTokens,
+      output_tokens: this._outputTokens
+    };
+  }
+  get initData() {
+    return this._initData;
+  }
+  get prompting() {
+    return this._prompting;
+  }
+  get messageBuffer() {
+    return this._messageBuffer;
+  }
+  pushMessage(msg) {
+    if (this._messageBuffer.length > 0) {
+      const last = this._messageBuffer[this._messageBuffer.length - 1];
+      if (last.uuid === msg.uuid)
+        return;
+    }
+    this._messageBuffer.push(msg);
+  }
+  get lastMessageUuid() {
+    return this._lastMessageUuid;
+  }
+  getEffectiveBusyStatus() {
+    if (this._prompting) {
+      return { type: "busy" };
+    }
+    if (this._status === "stopped") {
+      return { type: "idle" };
+    }
+    return this._busyStatus;
+  }
+  get ready() {
+    return this._status === "running";
+  }
+  get silent() {
+    return this.opts.silent ?? false;
+  }
+  get spawnCwd() {
+    return this._spawnCwd ?? this.cwd;
+  }
+  async waitReady(timeoutMs = INIT_TIMEOUT_MS) {
+    if (this._status === "running")
+      return;
+    if (this._status === "stopped") {
+      throw new Error(`Session ${this.sessionId} is stopped`);
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Session ${this.sessionId} init timed out`));
+      }, timeoutMs);
+      const origResolve = this.initResolve;
+      const origReject = this.initReject;
+      this.initResolve = (data) => {
+        clearTimeout(timer);
+        origResolve?.(data);
+        resolve();
+      };
+      this.initReject = (err) => {
+        clearTimeout(timer);
+        origReject?.(err);
+        reject(err);
+      };
+    });
+  }
+  constructor(opts) {
+    this.opts = opts;
+    this.sessionId = opts.sessionId;
+    this.cwd = opts.cwd;
+    this.eventBus = opts.eventBus;
+    this._model = opts.model;
+    this._agent = opts.agent;
+    this._permissionMode = opts.permissionMode ?? "default";
+    this.verbose = opts.verbose ?? false;
+  }
+  onMessage(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async buildSubagentIndex() {
+    const projectDir = getProjectDir(this.cwd);
+    const sessionDir = join(projectDir, this.sessionId, "subagents");
+    if (!existsSync(sessionDir))
+      return;
+    try {
+      const entries = await readdir(sessionDir);
+      for (const entry of entries) {
+        if (!entry.startsWith("agent-") || !entry.endsWith(".jsonl"))
+          continue;
+        const agentId = entry.slice("agent-".length, -".jsonl".length);
+        const transcriptPath = join(sessionDir, entry);
+        const metaPath = transcriptPath.replace(/\.jsonl$/, ".meta.json");
+        let meta = {};
+        try {
+          const raw = await readFile(metaPath, "utf-8");
+          meta = JSON.parse(raw);
+        } catch {}
+        this._subagentIndex.set(agentId, { transcriptPath, meta });
+      }
+    } catch {}
+  }
+  spawn() {
+    const printArgs = [
+      "--print",
+      "--input-format",
+      "stream-json",
+      "--output-format",
+      "stream-json",
+      ...this.opts.resumeSessionId ? [] : ["--session-id", this.sessionId],
+      ...this.opts.model ? ["--model", this.opts.model] : [],
+      ...this._agent ? ["--agent", this._agent] : [],
+      "--permission-mode",
+      this._permissionMode,
+      "--permission-prompt-tool",
+      "stdio",
+      ...this.opts.resumeSessionId ? ["--resume", this.opts.resumeSessionId] : [],
+      ...this.opts.resumeSessionAt ? ["--resume-session-at", this.opts.resumeSessionAt] : [],
+      "--verbose"
+    ];
+    const env = {
+      ...process.env,
+      CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+      CSC_SERVE_MODE: "1"
+    };
+    if (this.opts.systemPrompt) {
+      env.CLAUDE_CODE_SYSTEM_PROMPT = this.opts.systemPrompt;
+    }
+    const saved = loadChildSpawnPrefix();
+    const defineArgs = saved?.defineArgs ?? [];
+    const featureArgs = saved?.featureArgs ?? [];
+    const spawnArgs = [
+      ...defineArgs,
+      ...featureArgs,
+      ...this.opts.scriptArgs,
+      ...printArgs.filter((x) => x != null)
+    ];
+    this._spawnCwd = this.opts.cwd;
+    this.child = spawn(this.opts.execPath, spawnArgs, {
+      cwd: this.opts.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env,
+      windowsHide: true
+    });
+    this.setupStdout();
+    this.setupStderr();
+    this.child.on("close", (code, signal) => {
+      if (this._status !== "stopped") {
+        this._status = "stopped";
+        this._busyStatus = { type: "idle" };
+        this.emitBusyStatus();
+        this.emitOpencodeEvent("session.deleted", {
+          sessionID: this.sessionId,
+          status: "stopped",
+          exit_code: code,
+          signal: signal ?? null
+        });
+      }
+      if (this.initReject) {
+        const reject = this.initReject;
+        this.initResolve = null;
+        this.initReject = null;
+        process.stderr.write(`[serve:${this.sessionId}] exit_code=${code} cwd=${this.cwd} stderr:
+${this.lastStderr.slice(-5).join(`
+`)}
+`);
+        reject(new Error(`Process exited with code ${code}`));
+      }
+      if (this.promptReject) {
+        this.promptReject(new Error(`Process exited with code ${code}`));
+      }
+    });
+    this.child.on("error", (err) => {
+      logError(err);
+      this._status = "stopped";
+      this._busyStatus = { type: "idle" };
+      this.emitBusyStatus();
+      if (this.initReject) {
+        const reject = this.initReject;
+        this.initResolve = null;
+        this.initReject = null;
+        reject(err);
+      }
+      if (this.promptReject) {
+        this.promptReject(err);
+      }
+    });
+    this.initRequestId = crypto.randomUUID();
+    this.sendInitialize();
+    const timeout = setTimeout(() => {
+      if (this.initReject) {
+        const reject = this.initReject;
+        this.initResolve = null;
+        this.initReject = null;
+        this._status = "stopped";
+        this.emitOpencodeEvent("session.deleted", {
+          sessionID: this.sessionId,
+          status: "stopped",
+          reason: "init_timeout"
+        });
+        reject(new Error(`Session ${this.sessionId} init timed out`));
+      }
+    }, INIT_TIMEOUT_MS);
+    this.initResolve = (data) => {
+      clearTimeout(timeout);
+      this.initReject = null;
+    };
+    this.initReject = (_err) => {
+      clearTimeout(timeout);
+      this.initResolve = null;
+    };
+  }
+  async start() {
+    if (!this.child) {
+      this.spawn();
+    }
+    if (this._status === "running")
+      return;
+    return new Promise((resolve, reject) => {
+      const origResolve = this.initResolve;
+      const origReject = this.initReject;
+      this.initResolve = (data) => {
+        origResolve?.(data);
+        resolve();
+      };
+      this.initReject = (err) => {
+        origReject?.(err);
+        reject(err);
+      };
+    });
+  }
+  sendInitialize() {
+    const request = {
+      subtype: "initialize"
+    };
+    if (this.opts.hooks) {
+      request.hooks = this.opts.hooks;
+    }
+    const msg = jsonStringify({
+      type: "control_request",
+      request_id: this.initRequestId,
+      request
+    });
+    this.writeStdin(msg);
+  }
+  setupStdout() {
+    if (!this.child?.stdout)
+      return;
+    const rl = createInterface({ input: this.child.stdout });
+    rl.on("line", (line) => {
+      if (!line.trim())
+        return;
+      let msg;
+      try {
+        msg = jsonParse(line);
+      } catch {
+        return;
+      }
+      routeMessage(msg, this.createRouterCtx());
+    });
+  }
+  setupStderr() {
+    if (!this.child?.stderr)
+      return;
+    const rl = createInterface({ input: this.child.stderr });
+    rl.on("line", (line) => {
+      if (this.verbose) {
+        process.stderr.write(`[serve:${this.sessionId}] ${line}
+`);
+      }
+      if (this.lastStderr.length >= 20) {
+        this.lastStderr.shift();
+      }
+      this.lastStderr.push(line);
+    });
+  }
+  emitEvent(event, data) {
+    if (this.opts.silent)
+      return;
+    this.eventBus.publishSessionEvent(this.sessionId, event, data);
+  }
+  emitOpencodeEvent(event, properties) {
+    if (this.opts.silent)
+      return;
+    this.eventBus.publish(event, {
+      _native_opencode: true,
+      session_id: properties.sessionID,
+      ...properties
+    });
+  }
+  emitBusyStatus() {
+    if (this.opts.silent)
+      return;
+    this.eventBus.publish("session.status", {
+      sessionID: this.sessionId,
+      status: this._busyStatus
+    });
+  }
+  emitMessage(msg) {
+    for (const listener of this.listeners) {
+      try {
+        listener(msg);
+      } catch {}
+    }
+  }
+  writeStdin(data) {
+    if (this.child?.stdin && !this.child.stdin.destroyed) {
+      const flushed = this.child.stdin.write(data + `
+`);
+      if (!flushed) {
+        this.child.stdin.once("drain", () => {});
+      }
+    }
+  }
+  createRouterCtx() {
+    return {
+      sessionId: this.sessionId,
+      silent: this.opts.silent ?? false,
+      getStatus: () => this._status,
+      getBusyStatus: () => this._busyStatus,
+      getModel: () => this._model,
+      getProviderId: () => this._providerId,
+      getInitRequestId: () => this.initRequestId,
+      getLastMessageUuid: () => this._lastMessageUuid,
+      setStatus: (s) => {
+        this._status = s;
+      },
+      setBusyStatus: (s) => {
+        this._busyStatus = s;
+      },
+      setModel: (m) => {
+        this._model = m;
+      },
+      setProviderId: (id) => {
+        this._providerId = id;
+      },
+      setInitData: (d) => {
+        this._initData = d;
+      },
+      setLastMessageUuid: (u) => {
+        this._lastMessageUuid = u;
+      },
+      setLastActiveAt: (t) => {
+        this.lastActiveAt = t;
+      },
+      addCost: (c) => {
+        this._costUsd += c;
+      },
+      addInputTokens: (t) => {
+        this._inputTokens += t;
+      },
+      addOutputTokens: (t) => {
+        this._outputTokens += t;
+      },
+      getControlChannel: () => this._controlChannel,
+      getPendingPermissions: () => this.pendingPermissions,
+      getPendingQuestions: () => this.pendingQuestions,
+      resolveInit: (data) => {
+        const resolve = this.initResolve;
+        this.initResolve = null;
+        this.initReject = null;
+        resolve?.(data);
+        this.opts.onInit?.(data);
+      },
+      resolvePrompt: (value) => {
+        this._busyStatus = { type: "idle" };
+        this.emitBusyStatus();
+        if (this.promptResolve) {
+          this.promptResolve(value);
+          this.promptResolve = null;
+          this.promptReject = null;
+        }
+        if (this._firstPromptContent && !this._titleGenerationAttempted) {
+          this._titleGenerationAttempted = true;
+          const content = this._firstPromptContent;
+          this.sendControlRequest({
+            subtype: "generate_session_title",
+            description: content,
+            persist: true
+          }, 30000).then((res) => {
+            const title = res.title || content.slice(0, 100);
+            this.setTitle(title);
+          }).catch(() => {
+            this.setTitle(content.slice(0, 100));
+          });
+        }
+      },
+      emitEvent: (event, data) => this.emitEvent(event, data),
+      emitOpencodeEvent: (event, props) => this.emitOpencodeEvent(event, props),
+      emitBusyStatus: () => this.emitBusyStatus(),
+      emitMessage: (msg) => this.emitMessage(msg),
+      writeStdin: (data) => this.writeStdin(data),
+      pushBufferMessage: (msg) => this.pushMessage(msg),
+      addTombstonedUuid: (uuid) => this._tombstonedUuids.add(uuid),
+      getActiveSubagents: () => this._activeSubagents,
+      registerSubagent: (info) => this._activeSubagents.set(info.agentId, info),
+      unregisterSubagent: (agentId) => this._activeSubagents.delete(agentId)
+    };
+  }
+  setTitle(title) {
+    this._title = title;
+    this.emitOpencodeEvent("session.updated", {
+      sessionID: this.sessionId,
+      status: this._status,
+      model: this._model,
+      title: this._title,
+      providerID: this._providerId
+    });
+  }
+  async sendControlRequest(request, timeoutMs = 1e4) {
+    const requestId = crypto.randomUUID();
+    this.writeStdin(jsonStringify({
+      type: "control_request",
+      request_id: requestId,
+      request
+    }));
+    return this._controlChannel.register(requestId, timeoutMs);
+  }
+  async setModel(model) {
+    this._model = model;
+    await this.sendControlRequest({ subtype: "set_model", model });
+  }
+  async setAgent(agent) {
+    this._agent = agent;
+    await this.sendControlRequest({ subtype: "set_agent", agent });
+  }
+  async setPermissionMode(mode) {
+    this._permissionMode = mode;
+    await this.sendControlRequest({ subtype: "set_permission_mode", mode });
+  }
+  async getMcpStatus() {
+    const response = await this.sendControlRequest({ subtype: "mcp_status" });
+    return response.mcpServers ?? [];
+  }
+  async prompt(content, opts) {
+    if (this._status === "stopped") {
+      throw new Error(`Session ${this.sessionId} is stopped`);
+    }
+    if (this._prompting) {
+      throw new Error(`Session ${this.sessionId} is already processing a prompt`);
+    }
+    this._prompting = true;
+    const alreadyBusy = this._busyStatus?.type === "busy";
+    if (!alreadyBusy) {
+      this._busyStatus = { type: "busy" };
+      this.emitBusyStatus();
+    }
+    this.lastActiveAt = Date.now();
+    const uuid = opts?.messageID ?? crypto.randomUUID();
+    const userMsg = jsonStringify({
+      type: "user",
+      content,
+      uuid,
+      session_id: this.sessionId,
+      message: { role: "user", content },
+      parent_tool_use_id: null
+    });
+    this.emitOpencodeEvent("message.updated", {
+      sessionID: this.sessionId,
+      info: {
+        id: uuid,
+        role: "user",
+        modelID: this._model ?? "",
+        providerID: this._providerId ?? "",
+        time: { created: Date.now() },
+        parentID: null
+      }
+    });
+    this.pushMessage({
+      uuid,
+      type: "user",
+      role: "user",
+      content,
+      timestamp: Date.now(),
+      parent_uuid: null
+    });
+    this.writeStdin(userMsg);
+    if (!this._title && !this._titleGenerationAttempted) {
+      this._firstPromptContent = content;
+    }
+    return new Promise((resolve, reject) => {
+      this.promptResolve = (value) => {
+        this._prompting = false;
+        resolve(value);
+      };
+      this.promptReject = (reason) => {
+        this._prompting = false;
+        reject(reason);
+      };
+    });
+  }
+  async abort() {
+    if (!this.child || this.child.killed)
+      return;
+    const interrupt = jsonStringify({
+      type: "control_request",
+      request_id: crypto.randomUUID(),
+      request: { subtype: "interrupt" }
+    });
+    this.writeStdin(interrupt);
+    this._busyStatus = { type: "idle" };
+    this.emitBusyStatus();
+    this.emitOpencodeEvent("session.result", {
+      sessionID: this.sessionId,
+      subtype: "error_during_execution",
+      is_error: true,
+      is_interrupted: true
+    });
+    if (!this.promptResolve)
+      return;
+    await new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.kill();
+        resolve();
+      }, 2000);
+      const originalResolve = this.promptResolve;
+      this.promptResolve = (value) => {
+        clearTimeout(timeout);
+        originalResolve?.(value);
+        resolve();
+      };
+    });
+  }
+  replyPermission(requestId, behavior, opts) {
+    const response = {
+      type: "control_response",
+      response: {
+        subtype: "success",
+        request_id: requestId,
+        response: behavior === "allow" ? {
+          behavior: "allow",
+          updatedInput: opts?.updatedInput ?? {},
+          ...opts?.updatedPermissions ? { updatedPermissions: opts.updatedPermissions } : {},
+          ...opts?.decisionClassification ? { decisionClassification: opts.decisionClassification } : {}
+        } : {
+          behavior: "deny",
+          message: opts?.message ?? "Denied",
+          ...opts?.interrupt ? { interrupt: true } : {}
+        }
+      }
+    };
+    this.writeStdin(jsonStringify(response));
+    const perm = this.getPendingPermission(requestId);
+    const toolName = perm?.toolName;
+    this.pendingPermissions.delete(requestId);
+    this.emitEvent("permission_replied", {
+      request_id: requestId,
+      behavior
+    });
+    if (toolName === "AskUserQuestion") {
+      const eventType = behavior === "allow" ? "question.replied" : "question.rejected";
+      this.emitOpencodeEvent(eventType, {
+        sessionID: this.sessionId,
+        requestID: requestId
+      });
+    } else {
+      this.emitOpencodeEvent("permission.replied", {
+        sessionID: this.sessionId,
+        requestID: requestId
+      });
+    }
+  }
+  replyQuestion(requestId, action, content) {
+    const response = {
+      type: "control_response",
+      response: {
+        subtype: "success",
+        request_id: requestId,
+        response: action === "accept" ? { action: "accept", content } : { action: "decline" }
+      }
+    };
+    this.writeStdin(jsonStringify(response));
+    this.pendingQuestions.delete(requestId);
+    this.emitEvent("question_replied", {
+      request_id: requestId,
+      action
+    });
+    const eventType = action === "accept" ? "question.replied" : "question.rejected";
+    this.emitOpencodeEvent(eventType, {
+      sessionID: this.sessionId,
+      requestID: requestId
+    });
+  }
+  kill() {
+    if (this.child && !this.child.killed) {
+      if (process.platform === "win32") {
+        this.child.kill();
+      } else {
+        this.child.kill("SIGTERM");
+      }
+    }
+    this._status = "stopped";
+    this._controlChannel.rejectAll(new Error("Session killed"));
+  }
+  forceKill() {
+    if (this.child && !this.child.killed) {
+      if (process.platform === "win32") {
+        this.child.kill();
+      } else {
+        this.child.kill("SIGKILL");
+      }
+    }
+    this._status = "stopped";
+    this._controlChannel.rejectAll(new Error("Session force killed"));
+  }
+  [Symbol.dispose]() {
+    this.forceKill();
+  }
+  getPendingPermissions() {
+    return [...this.pendingPermissions.values()];
+  }
+  getPendingPermission(requestId) {
+    return this.pendingPermissions.get(requestId);
+  }
+  getPendingQuestions() {
+    return [...this.pendingQuestions.values()];
+  }
+  getPendingQuestion(requestId) {
+    return this.pendingQuestions.get(requestId);
+  }
+  handleMessage(msg) {
+    routeMessage(msg, this.createRouterCtx());
+  }
+  getLastStderr() {
+    return [...this.lastStderr];
+  }
+  getInfo() {
+    return {
+      id: this.sessionId,
+      session_id: this.sessionId,
+      slug: this.sessionId,
+      projectID: "",
+      directory: this.cwd,
+      cwd: this.cwd,
+      title: this._title,
+      version: "",
+      time: {
+        created: this.createdAt,
+        updated: this.lastActiveAt
+      },
+      status: this._status,
+      model: this._model,
+      permission_mode: this._permissionMode,
+      created_at: this.createdAt,
+      last_active_at: this.lastActiveAt,
+      cost_usd: this._costUsd,
+      input_tokens: this._inputTokens,
+      output_tokens: this._outputTokens,
+      last_message_uuid: this._lastMessageUuid
+    };
+  }
+}
+
+export { getScriptArgsForChild, getChildSpawnArgs, saveChildSpawnPrefix, getSubagentProgress, SessionHandle };
+
+//# debugId=39BAD054F367F45364756E2164756E21
+//# sourceMappingURL=chunk-ksav9jw1.js.map