@ganglion/xacpx 0.17.1 → 0.18.1

package/dist/bridge/bridge-main.js

@@ -2633,6 +2633,561 @@ var init_prompt_media = __esm(() => {
   };
 });
 
+// src/transport/claude-background-followup.ts
+import { access, open as open2, readFile, readdir, stat } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename, dirname as dirname2, join as join2 } from "node:path";
+function isClaudeAsyncAgentLaunch(event) {
+  return isAsyncAgentLaunchOutput(event.rawOutput);
+}
+function isAsyncAgentLaunchOutput(rawOutput) {
+  const candidate = typeof rawOutput === "string" ? tryParseJsonObject(rawOutput) ?? rawOutput : rawOutput;
+  if (candidate && typeof candidate === "object" && !Array.isArray(candidate)) {
+    const status = candidate.status;
+    if (status !== undefined)
+      return status === "async_launched";
+  }
+  return ASYNC_AGENT_LAUNCH.test(textOfUnknown(rawOutput));
+}
+function tryParseJsonObject(text) {
+  if (!text.trimStart().startsWith("{"))
+    return;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function claudeAsyncAgentId(event) {
+  const fromObject = findStringField(event.rawOutput, new Set(["agentId", "agent_id"]));
+  if (fromObject)
+    return fromObject;
+  return /\bagent(?:Id|_id)["']?\s*[:=]\s*["']?([A-Za-z0-9_-]+)/i.exec(textOfUnknown(event.rawOutput))?.[1];
+}
+async function findClaudeTranscriptPath(input) {
+  const configDirName = input.driver === "qoder" ? ".qoder" : ".claude";
+  const projectsDir = join2(input.homeDir ?? homedir2(), configDirName, "projects");
+  const direct = join2(projectsDir, encodeClaudeProjectDirectory(input.cwd), `${input.sessionId}.jsonl`);
+  if (await exists(direct))
+    return direct;
+  try {
+    const entries = await readdir(projectsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const candidate = join2(projectsDir, entry.name, `${input.sessionId}.jsonl`);
+      if (await exists(candidate))
+        return candidate;
+    }
+  } catch {
+    return;
+  }
+  return;
+}
+async function followClaudeBackgroundTurn(options) {
+  const transcriptPath = options.transcriptPath ?? await findClaudeTranscriptPath(options);
+  if (!transcriptPath) {
+    return { status: "unavailable", completedToolCallIds: [], failedToolCallIds: [] };
+  }
+  let initial;
+  try {
+    initial = await readFile(transcriptPath);
+  } catch {
+    return { status: "unavailable", transcriptPath, completedToolCallIds: [], failedToolCallIds: [] };
+  }
+  const initialCompleteEnd = initial.lastIndexOf(10);
+  const initialComplete = initial.subarray(0, initialCompleteEnd >= 0 ? initialCompleteEnd : 0).toString("utf8");
+  const mainCursor = {
+    offset: initial.length,
+    partial: initialCompleteEnd >= 0 ? initial.subarray(initialCompleteEnd + 1).toString("utf8") : initial.toString("utf8")
+  };
+  const initialRecords = initialComplete.split(`
+`).map(parseRecord);
+  const launched = new Set([...options.launchedToolCallIds].filter(Boolean));
+  const completed = new Set;
+  const failed = new Set;
+  const toolEvents = new Map;
+  for (const event of options.initialToolEvents ?? [])
+    toolEvents.set(event.toolCallId, event);
+  const parentToolCallIdByAgentId = new Map;
+  for (const [toolCallId, agentId] of options.subagentIdsByToolCallId ?? []) {
+    if (toolCallId && agentId)
+      parentToolCallIdByAgentId.set(agentId, toolCallId);
+  }
+  const boundary = findPromptBoundary(initialRecords, launched);
+  let launchSeen = boundary >= 0 || initialRecords.some((record) => hasTrackedLaunch(record, launched));
+  let boundarySeen = boundary >= 0;
+  let sequence = 0;
+  let lastNotificationSequence = -1;
+  let done = false;
+  const emitTool = async (event) => {
+    toolEvents.set(event.toolCallId, event);
+    await options.onToolEvent?.(event);
+  };
+  const processRecord = async (record) => {
+    if (!record)
+      return;
+    sequence += 1;
+    const blocks = contentBlocks(record.message?.content);
+    if (record.type === "user") {
+      const userText = blocks.map(blockText).filter(Boolean).join(`
+`);
+      for (const notification of taskNotifications(userText)) {
+        if (launched.has(notification.toolCallId)) {
+          completed.add(notification.toolCallId);
+          if (notification.failed)
+            failed.add(notification.toolCallId);
+          lastNotificationSequence = sequence;
+          const previous = toolEvents.get(notification.toolCallId);
+          if (previous) {
+            await emitTool({
+              ...previous,
+              status: notification.failed ? "error" : "success",
+              ...notification.failed ? { rawOutput: { message: "background Agent failed" } } : {}
+            });
+          }
+        }
+      }
+      for (const block of blocks) {
+        if (readString(block, "type") !== "tool_result")
+          continue;
+        const toolCallId = readString(block, "tool_use_id");
+        if (!toolCallId)
+          continue;
+        const output = blockText(block);
+        if (ASYNC_AGENT_LAUNCH.test(output))
+          launched.add(toolCallId);
+        const previous = toolEvents.get(toolCallId);
+        await emitTool({
+          toolCallId,
+          toolName: previous?.toolName ?? "Tool",
+          kind: previous?.kind ?? "other",
+          ...previous?.parentToolCallId ? { parentToolCallId: previous.parentToolCallId } : {},
+          ...previous?.isSubagent ? { isSubagent: true } : {},
+          ...previous?.summary ? { summary: previous.summary } : {},
+          ...previous?.rawInput !== undefined ? { rawInput: previous.rawInput } : {},
+          ...output ? { rawOutput: output } : {},
+          status: readBoolean(block, "is_error") ? "error" : "success"
+        });
+      }
+      return;
+    }
+    if (record.type !== "assistant" || record.isSidechain === true)
+      return;
+    for (const block of blocks) {
+      const type = readString(block, "type");
+      if (type === "text") {
+        const text = readString(block, "text");
+        if (text)
+          await options.onText?.(text);
+      } else if (type === "thinking") {
+        const thought = readString(block, "thinking");
+        if (thought)
+          await options.onThought?.(thought);
+      } else if (type === "tool_use") {
+        const toolCallId = readString(block, "id");
+        if (!toolCallId)
+          continue;
+        const name = readString(block, "name") ?? "Tool";
+        const rawInput = block.input;
+        const event = {
+          toolCallId,
+          toolName: name,
+          kind: classifyToolKind(name),
+          ...toolSummary(rawInput) ? { summary: toolSummary(rawInput) } : {},
+          ...rawInput !== undefined ? { rawInput } : {},
+          status: "running"
+        };
+        await emitTool(event);
+      }
+    }
+    if (record.message?.stop_reason === "end_turn" && launched.size > 0 && [...launched].every((id) => completed.has(id)) && lastNotificationSequence >= 0 && sequence > lastNotificationSequence) {
+      done = true;
+    }
+  };
+  const processAfterBoundary = async (record) => {
+    if (!record)
+      return;
+    if (!boundarySeen) {
+      if (hasTrackedLaunch(record, launched))
+        launchSeen = true;
+      if (launchSeen && isMainEndTurn(record))
+        boundarySeen = true;
+      return;
+    }
+    await processRecord(record);
+  };
+  const processSubagentRecord = async (record, parentToolCallId) => {
+    if (!record)
+      return;
+    const blocks = contentBlocks(record.message?.content);
+    if (record.type === "assistant") {
+      for (const block of blocks) {
+        if (readString(block, "type") !== "tool_use")
+          continue;
+        const toolCallId = readString(block, "id");
+        if (!toolCallId)
+          continue;
+        const name = readString(block, "name") ?? "Tool";
+        const rawInput = block.input;
+        const previous = toolEvents.get(toolCallId);
+        await emitTool({
+          ...previous,
+          toolCallId,
+          parentToolCallId: previous?.parentToolCallId ?? parentToolCallId,
+          ...previous?.isSubagent || isAgentToolName(name) ? { isSubagent: true } : {},
+          toolName: previous?.toolName ?? name,
+          kind: previous?.kind ?? classifyToolKind(name),
+          ...previous?.summary ? { summary: previous.summary } : toolSummary(rawInput) ? { summary: toolSummary(rawInput) } : {},
+          ...previous?.rawInput !== undefined ? { rawInput: previous.rawInput } : rawInput !== undefined ? { rawInput } : {},
+          status: previous?.status === "success" || previous?.status === "error" ? previous.status : "running"
+        });
+      }
+      return;
+    }
+    if (record.type !== "user")
+      return;
+    for (const block of blocks) {
+      if (readString(block, "type") !== "tool_result")
+        continue;
+      const toolCallId = readString(block, "tool_use_id");
+      if (!toolCallId)
+        continue;
+      const previous = toolEvents.get(toolCallId);
+      const output = blockText(block);
+      const event = {
+        ...previous,
+        toolCallId,
+        parentToolCallId: previous?.parentToolCallId ?? parentToolCallId,
+        ...previous?.isSubagent ? { isSubagent: true } : {},
+        toolName: previous?.toolName ?? "Tool",
+        kind: previous?.kind ?? "other",
+        ...previous?.summary ? { summary: previous.summary } : {},
+        ...previous?.rawInput !== undefined ? { rawInput: previous.rawInput } : {},
+        ...previous?.rawOutput !== undefined ? { rawOutput: previous.rawOutput } : output ? { rawOutput: output } : {},
+        status: readBoolean(block, "is_error") || previous?.status === "error" ? "error" : "success"
+      };
+      if (event.isSubagent && isClaudeAsyncAgentLaunch(event)) {
+        const agentId = claudeAsyncAgentId(event);
+        if (agentId)
+          parentToolCallIdByAgentId.set(agentId, event.toolCallId);
+      }
+      await emitTool(event);
+    }
+  };
+  const subagentCursors = new Map;
+  const processSubagentTranscripts = async () => {
+    const transcripts = await findSubagentTranscripts(transcriptPath);
+    let advanced = false;
+    let discoveredNestedAgent = true;
+    while (discoveredNestedAgent) {
+      const mappedAgentCount = parentToolCallIdByAgentId.size;
+      for (const subagent of transcripts) {
+        const parentToolCallId = parentToolCallIdByAgentId.get(subagent.agentId);
+        if (!parentToolCallId)
+          continue;
+        const cursor = subagentCursors.get(subagent.path) ?? { offset: 0, partial: "" };
+        const previousOffset = cursor.offset;
+        const lines = await readJsonlDelta(subagent.path, cursor);
+        if (cursor.offset !== previousOffset)
+          advanced = true;
+        subagentCursors.set(subagent.path, cursor);
+        for (const line of lines)
+          await processSubagentRecord(parseRecord(line), parentToolCallId);
+      }
+      discoveredNestedAgent = parentToolCallIdByAgentId.size > mappedAgentCount;
+    }
+    return advanced;
+  };
+  await processSubagentTranscripts();
+  if (boundary >= 0) {
+    for (const record of initialRecords.slice(boundary + 1)) {
+      await processRecord(record);
+      if (done)
+        break;
+    }
+  }
+  const startedAt = Date.now();
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  while (!done) {
+    throwIfAborted(options.signal);
+    if (Date.now() - startedAt >= timeoutMs) {
+      return {
+        status: "timeout",
+        transcriptPath,
+        completedToolCallIds: [...completed],
+        failedToolCallIds: [...failed]
+      };
+    }
+    await waitForPoll(pollIntervalMs, options.signal);
+    await processSubagentTranscripts();
+    const lines = await readJsonlDelta(transcriptPath, mainCursor);
+    for (const line of lines) {
+      await processAfterBoundary(parseRecord(line));
+      if (done)
+        break;
+    }
+  }
+  if (parentToolCallIdByAgentId.size > 0) {
+    let stablePolls = 0;
+    for (let poll = 0;poll < FINAL_SUBAGENT_DRAIN_MAX_POLLS && stablePolls < FINAL_SUBAGENT_DRAIN_STABLE_POLLS; poll += 1) {
+      await waitForPoll(pollIntervalMs, options.signal);
+      stablePolls = await processSubagentTranscripts() ? 0 : stablePolls + 1;
+    }
+  }
+  return {
+    status: "completed",
+    transcriptPath,
+    completedToolCallIds: [...completed],
+    failedToolCallIds: [...failed]
+  };
+}
+async function readJsonlDelta(path2, cursor) {
+  let size;
+  try {
+    size = (await stat(path2)).size;
+  } catch {
+    return [];
+  }
+  if (size < cursor.offset) {
+    cursor.offset = 0;
+    cursor.partial = "";
+  }
+  if (size <= cursor.offset)
+    return [];
+  let chunk;
+  try {
+    const handle = await open2(path2, "r");
+    try {
+      chunk = Buffer.alloc(size - cursor.offset);
+      const result = await handle.read(chunk, 0, chunk.length, cursor.offset);
+      chunk = chunk.subarray(0, result.bytesRead);
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return [];
+  }
+  cursor.offset += chunk.length;
+  cursor.partial += chunk.toString("utf8");
+  const lines = cursor.partial.split(`
+`);
+  cursor.partial = lines.pop() ?? "";
+  return lines;
+}
+function findPromptBoundary(records, launched) {
+  let launchIndex = -1;
+  for (let index = 0;index < records.length; index += 1) {
+    const record = records[index];
+    if (record?.type !== "assistant" || record.isSidechain === true)
+      continue;
+    for (const block of contentBlocks(record.message?.content)) {
+      if (readString(block, "type") === "tool_use" && launched.has(readString(block, "id") ?? "")) {
+        launchIndex = index;
+      }
+    }
+  }
+  if (launchIndex < 0)
+    return -1;
+  for (let index = launchIndex + 1;index < records.length; index += 1) {
+    const record = records[index];
+    if (record?.type === "assistant" && record.isSidechain !== true && record.message?.stop_reason === "end_turn") {
+      return index;
+    }
+  }
+  return -1;
+}
+function hasTrackedLaunch(record, launched) {
+  if (record?.type !== "assistant" || record.isSidechain === true)
+    return false;
+  return contentBlocks(record.message?.content).some((block) => readString(block, "type") === "tool_use" && launched.has(readString(block, "id") ?? ""));
+}
+function isMainEndTurn(record) {
+  return record.type === "assistant" && record.isSidechain !== true && record.message?.stop_reason === "end_turn";
+}
+function parseRecord(line) {
+  if (!line.trim())
+    return;
+  try {
+    return JSON.parse(line);
+  } catch {
+    return;
+  }
+}
+function contentBlocks(content) {
+  if (typeof content === "string")
+    return [{ type: "text", text: content }];
+  return Array.isArray(content) ? content.filter((block) => !!block && typeof block === "object") : [];
+}
+function blockText(block) {
+  if (typeof block.text === "string")
+    return block.text;
+  if (typeof block.content === "string")
+    return block.content;
+  if (Array.isArray(block.content))
+    return block.content.map((item) => textOfUnknown(item)).filter(Boolean).join(`
+`);
+  return textOfUnknown(block.content);
+}
+function textOfUnknown(value) {
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value))
+    return value.map(textOfUnknown).filter(Boolean).join(`
+`);
+  if (!value || typeof value !== "object")
+    return "";
+  const object = value;
+  if (typeof object.text === "string")
+    return object.text;
+  if (object.content !== undefined)
+    return textOfUnknown(object.content);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function findStringField(value, keys) {
+  if (!value || typeof value !== "object")
+    return;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const found = findStringField(item, keys);
+      if (found)
+        return found;
+    }
+    return;
+  }
+  const object = value;
+  for (const key of keys) {
+    const candidate = object[key];
+    if (typeof candidate === "string" && candidate.trim())
+      return candidate.trim();
+  }
+  for (const candidate of Object.values(object)) {
+    const found = findStringField(candidate, keys);
+    if (found)
+      return found;
+  }
+  return;
+}
+function taskNotifications(text) {
+  const notifications = [];
+  const blocks = [...text.matchAll(/<task-notification>([\s\S]*?)<\/task-notification>/gi)].map((match) => match[1] ?? "");
+  for (const block of blocks.length > 0 ? blocks : [text]) {
+    const toolCallId = /<tool-use-id>([^<]+)<\/tool-use-id>/i.exec(block)?.[1]?.trim();
+    if (!toolCallId)
+      continue;
+    const status = /<status>([^<]+)<\/status>/i.exec(block)?.[1]?.trim().toLowerCase();
+    notifications.push({
+      toolCallId,
+      failed: status === "failed" || status === "error" || status === "cancelled" || status === "canceled"
+    });
+  }
+  return notifications;
+}
+function classifyToolKind(name) {
+  const normalized = name.toLowerCase();
+  if (/(read|view|open)/.test(normalized))
+    return "read";
+  if (/(grep|search|find|glob)/.test(normalized))
+    return "search";
+  if (/(edit|write|patch|replace|create)/.test(normalized))
+    return "edit";
+  if (/(bash|shell|exec|run|terminal|command)/.test(normalized))
+    return "execute";
+  if (/(think|reason|plan|agent|task)/.test(normalized))
+    return "think";
+  return "other";
+}
+function isAgentToolName(name) {
+  const normalized = name.trim().toLowerCase();
+  return normalized === "agent" || normalized === "task";
+}
+async function findSubagentTranscripts(transcriptPath) {
+  const sessionDir = join2(dirname2(transcriptPath), basename(transcriptPath, ".jsonl"), "subagents");
+  const found = [];
+  const visit = async (directory) => {
+    let entries;
+    try {
+      entries = await readdir(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const path2 = join2(directory, entry.name);
+      if (entry.isDirectory()) {
+        await visit(path2);
+      } else if (entry.isFile() && entry.name.startsWith("agent-") && entry.name.endsWith(".jsonl")) {
+        found.push({ agentId: entry.name.slice("agent-".length, -".jsonl".length), path: path2 });
+      }
+    }
+  };
+  await visit(sessionDir);
+  return found;
+}
+function toolSummary(input) {
+  if (!input || typeof input !== "object")
+    return;
+  const object = input;
+  for (const key of ["description", "summary", "path", "file_path", "query", "pattern", "command"]) {
+    if (typeof object[key] === "string" && object[key].trim())
+      return object[key].trim();
+  }
+  return;
+}
+function readString(object, key) {
+  if (!object || typeof object !== "object")
+    return;
+  const value = object[key];
+  return typeof value === "string" ? value : undefined;
+}
+function readBoolean(object, key) {
+  return !!object && typeof object === "object" && object[key] === true;
+}
+function encodeClaudeProjectDirectory(cwd) {
+  return cwd.replace(/[:\\/]/g, "-");
+}
+async function exists(path2) {
+  try {
+    await access(path2, fsConstants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw new DOMException("background follow-up aborted", "AbortError");
+}
+async function waitForPoll(ms, signal) {
+  if (!signal) {
+    await new Promise((resolve2) => setTimeout(resolve2, ms));
+    return;
+  }
+  throwIfAborted(signal);
+  await new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new DOMException("background follow-up aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var DEFAULT_POLL_INTERVAL_MS = 250, DEFAULT_TIMEOUT_MS, FINAL_SUBAGENT_DRAIN_MAX_POLLS = 4, FINAL_SUBAGENT_DRAIN_STABLE_POLLS = 2, ASYNC_AGENT_LAUNCH;
+var init_claude_background_followup = __esm(() => {
+  DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+  ASYNC_AGENT_LAUNCH = /Async agent launched successfully|["']?status["']?\s*:\s*["']async_launched["']/i;
+});
+
 // src/transport/tool-event-mode.ts
 function resolveToolEventMode(input) {
   if (input?.toolEventMode !== undefined) {
@@ -2822,7 +3377,7 @@ function formatToolCallEvent(update, sessionUpdate) {
     return null;
   const emoji = TOOL_KIND_EMOJI[kind] ?? DEFAULT_TOOL_EMOJI;
   const inputSummary = summarizeToolInput(update.rawInput, title) || summarizeToolInput(update.rawOutput, title);
-  const status = readString(update, "status");
+  const status = readString2(update, "status");
   if (!inputSummary && status === "pending")
     return null;
   if (!inputSummary && isGenericToolTitle(kind, title))
@@ -2894,12 +3449,12 @@ function buildToolUseEvent(update, driver) {
   const toolName = title || "Tool";
   const summaryRaw = summarizeToolInput(update.rawInput, title) || summarizeToolInput(update.rawOutput, title);
   const summary = summaryRaw && summaryRaw !== title ? summaryRaw : undefined;
-  const statusRaw = readString(update, "status");
+  const statusRaw = readString2(update, "status");
   const isClaudeDriver = driver === undefined || driver === "claude";
   const claudeMeta = isClaudeDriver ? update._meta?.claudeCode : undefined;
   const claudeToolResponse = claudeMeta?.toolResponse;
   const hasClaudeToolResponse = !isEmptyToolField(claudeToolResponse);
-  const isAsyncAgentLaunch = update._meta?.claudeCode?.toolName === "Agent" && isRecord2(claudeToolResponse) && claudeToolResponse.status === "async_launched";
+  const isAsyncAgentLaunch = update._meta?.claudeCode?.toolName === "Agent" && isRecord2(claudeToolResponse) && claudeToolResponse.status === "async_launched" || driver === "qoder" && update._meta?.qoder?.toolName === "Agent" && isAsyncAgentLaunchOutput(update.rawOutput);
   const status = isAsyncAgentLaunch ? "running" : statusRaw === "completed" || statusRaw === "success" ? "success" : statusRaw === "failed" || statusRaw === "error" ? "error" : hasClaudeToolResponse ? "success" : "running";
   const rawInput = update.rawInput;
   const content = update.content;
@@ -3029,7 +3584,7 @@ function normalizeUsageCost(value) {
   if (!isRecord2(value))
     return;
   const amount = asFiniteNumber(value.amount);
-  const currency = readString(value, "currency");
+  const currency = readString2(value, "currency");
   if (amount === undefined && !currency)
     return;
   return { ...amount !== undefined ? { amount } : {}, ...currency ? { currency } : {} };
@@ -3041,10 +3596,10 @@ function normalizeAgentCommands(value) {
   for (const entry of value) {
     if (!isRecord2(entry))
       continue;
-    const name = readString(entry, "name");
+    const name = readString2(entry, "name");
     if (!name)
       continue;
-    const description = readString(entry, "description");
+    const description = readString2(entry, "description");
     out.push({ name, ...description ? { description } : {}, hasInput: entry.input != null });
   }
   return out;
@@ -3052,7 +3607,7 @@ function normalizeAgentCommands(value) {
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readString(rawInput, key) {
+function readString2(rawInput, key) {
   if (!isRecord2(rawInput))
     return;
   const value = rawInput[key];
@@ -3076,6 +3631,7 @@ function isGenericToolTitle(kind, title) {
 }
 var USAGE_BREAKDOWN_FIELDS;
 var init_streaming_prompt = __esm(() => {
+  init_claude_background_followup();
   init_tool_kind_emoji();
   USAGE_BREAKDOWN_FIELDS = [
     ["inputTokens", ["inputTokens", "input_tokens"]],
@@ -3097,22 +3653,22 @@ function isModelNotAdvertisedError(text) {
 // src/recovery/discover-parent-package-paths.ts
 import { spawn as spawn2 } from "node:child_process";
 import { createRequire as createRequire2 } from "node:module";
-import { access } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { access as access2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname3, join as join3 } from "node:path";
 function deriveParentPackageName(platformPackage) {
   return platformPackage.replace(/-(?:linux|darwin|win32|windows|freebsd|openbsd|sunos|aix)(?:-(?:x64|arm64|ia32|arm|ppc64|s390x))?(?:-(?:baseline|musl|gnu|gnueabihf|musleabihf|msvc))?$/, "");
 }
 async function discoverParentPackagePaths(platformPackage, seedPath, deps = {}) {
   const env = deps.env ?? process.env;
-  const home = deps.home ?? homedir2();
+  const home = deps.home ?? homedir3();
   const cwd = deps.cwd ?? process.cwd();
   const fsExists = deps.fsExists ?? defaultFsExists;
   const resolveFromCwd = deps.resolveFromCwd ?? defaultResolveFromCwd;
   const queryRoot = deps.queryPackageManagerRoot ?? defaultQueryPackageManagerRoot;
   const parentName = deriveParentPackageName(platformPackage);
   const rawCandidates = [];
-  const bunGlobalRoot = env.BUN_INSTALL ? join2(env.BUN_INSTALL, "install", "global", "node_modules") : join2(home, ".bun", "install", "global", "node_modules");
+  const bunGlobalRoot = env.BUN_INSTALL ? join3(env.BUN_INSTALL, "install", "global", "node_modules") : join3(home, ".bun", "install", "global", "node_modules");
   const [npmRoot, pnpmRoot, yarnRoot] = await Promise.all([
     queryRoot("npm"),
     queryRoot("pnpm"),
@@ -3135,20 +3691,20 @@ async function discoverParentPackagePaths(platformPackage, seedPath, deps = {})
     if (resolved)
       rawCandidates.push({ path: resolved, manager: classify(resolved) });
   }
-  rawCandidates.push({ path: join2(bunGlobalRoot, parentName), manager: "bun" });
+  rawCandidates.push({ path: join3(bunGlobalRoot, parentName), manager: "bun" });
   if (npmRoot)
-    rawCandidates.push({ path: join2(npmRoot, parentName), manager: "npm" });
+    rawCandidates.push({ path: join3(npmRoot, parentName), manager: "npm" });
   if (pnpmRoot)
-    rawCandidates.push({ path: join2(pnpmRoot, parentName), manager: "pnpm" });
+    rawCandidates.push({ path: join3(pnpmRoot, parentName), manager: "pnpm" });
   if (yarnRoot)
-    rawCandidates.push({ path: join2(yarnRoot, parentName), manager: "yarn" });
+    rawCandidates.push({ path: join3(yarnRoot, parentName), manager: "yarn" });
   const seen = new Set;
   const verified = [];
   for (const candidate of rawCandidates) {
     if (seen.has(candidate.path))
       continue;
     seen.add(candidate.path);
-    if (await fsExists(join2(candidate.path, "package.json"))) {
+    if (await fsExists(join3(candidate.path, "package.json"))) {
       verified.push(candidate);
     }
   }
@@ -3161,7 +3717,7 @@ function isUnder(child, parent) {
 }
 async function defaultFsExists(path2) {
   try {
-    await access(path2);
+    await access2(path2);
     return true;
   } catch {
     return false;
@@ -3172,7 +3728,7 @@ function defaultResolveFromCwd(name, cwd) {
     const pkgJson = require2.resolve(`${name}/package.json`, {
       paths: [cwd, ...require2.resolve.paths(name) ?? []]
     });
-    return dirname2(pkgJson);
+    return dirname3(pkgJson);
   } catch {
     return null;
   }
@@ -3219,7 +3775,7 @@ async function defaultQueryPackageManagerRoot(tool) {
       const trimmed = stdout.trim().split(/\r?\n/).pop()?.trim() ?? "";
       if (!trimmed)
         return done(null);
-      done(spec.postfix ? join2(trimmed, spec.postfix) : trimmed);
+      done(spec.postfix ? join3(trimmed, spec.postfix) : trimmed);
     });
   });
 }
@@ -5537,9 +6093,9 @@ var PRIMARY_PREFIX = "XACPX_", LEGACY_PREFIX = "WEACPX_";
 // src/transport/acpx-queue-owner-launcher.ts
 import { createHash as createHash2 } from "node:crypto";
 import { spawn as spawn3 } from "node:child_process";
-import { readFile, unlink } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { readFile as readFile2, unlink } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
 function buildXacpxMcpServerSpec(input) {
   const { command, args } = splitCommandLine(input.xacpxCommand);
   return {
@@ -5698,11 +6254,23 @@ function createDefaultQueueOwnerTerminator(_acpxCommand) {
     await terminateAcpxQueueOwner(sessionId);
   };
 }
+async function readQueueOwnerPid(sessionId) {
+  let owner;
+  try {
+    owner = JSON.parse(await readFile2(queueLockFilePath(sessionId), "utf8"));
+  } catch {
+    return;
+  }
+  if (typeof owner.pid === "number" && Number.isInteger(owner.pid) && owner.pid > 0) {
+    return owner.pid;
+  }
+  return;
+}
 async function terminateAcpxQueueOwner(sessionId) {
   const lockPath = queueLockFilePath(sessionId);
   let owner;
   try {
-    owner = JSON.parse(await readFile(lockPath, "utf8"));
+    owner = JSON.parse(await readFile2(lockPath, "utf8"));
   } catch {
     return;
   }
@@ -5712,7 +6280,7 @@ async function terminateAcpxQueueOwner(sessionId) {
   await unlink(lockPath).catch(() => {});
 }
 function queueLockFilePath(sessionId) {
-  return join3(homedir3(), ".acpx", "queues", `${shortHash(sessionId, 24)}.lock`);
+  return join4(homedir4(), ".acpx", "queues", `${shortHash(sessionId, 24)}.lock`);
 }
 function shortHash(value, length) {
   return createHash2("sha256").update(value).digest("hex").slice(0, length);
@@ -5740,9 +6308,91 @@ var init_acpx_queue_owner_launcher = __esm(() => {
   init_i18n();
 });
 
+// src/runtime/core-home.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+function coreHomeDir(home) {
+  const primary = join5(home, CORE_HOME_DIR_NAME);
+  if (existsSync2(primary))
+    return primary;
+  const legacy = join5(home, CORE_HOME_LEGACY_DIR_NAME);
+  if (existsSync2(legacy))
+    return legacy;
+  return primary;
+}
+function coreHomeDisplayPath(...segments) {
+  return ["~", CORE_HOME_DIR_NAME, ...segments].join("/");
+}
+var CORE_HOME_DIR_NAME = ".xacpx", CORE_HOME_LEGACY_DIR_NAME = ".weacpx";
+var init_core_home = () => {};
+
+// src/orchestration/orchestration-ipc.ts
+import { createHash as createHash3 } from "node:crypto";
+import { join as join6 } from "node:path";
+function resolveOrchestrationEndpoint(runtimeDir, platform = process.platform) {
+  if (platform === "win32") {
+    const suffix = createHash3("sha256").update(runtimeDir).digest("hex").slice(0, 12);
+    return {
+      kind: "named-pipe",
+      path: `\\\\.\\pipe\\xacpx-orchestration-${suffix}`
+    };
+  }
+  return {
+    kind: "unix",
+    path: join6(runtimeDir, "orchestration.sock")
+  };
+}
+function createOrchestrationEndpoint(path2, platform = process.platform) {
+  return {
+    kind: platform === "win32" || path2.startsWith("\\\\.\\pipe\\") ? "named-pipe" : "unix",
+    path: path2
+  };
+}
+function encodeOrchestrationRpcRequest(request) {
+  return `${JSON.stringify(request)}
+`;
+}
+function encodeOrchestrationRpcResponse(response) {
+  return `${JSON.stringify(response)}
+`;
+}
+var init_orchestration_ipc = () => {};
+
+// src/daemon/daemon-files.ts
+import { dirname as dirname4, join as join7 } from "node:path";
+function resolveDaemonPaths(options) {
+  const runtimeDir = options.runtimeDir ?? (options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : join7(coreHomeDir(options.home), "runtime"));
+  return {
+    runtimeDir,
+    pidFile: join7(runtimeDir, "daemon.pid"),
+    statusFile: join7(runtimeDir, "status.json"),
+    stdoutLog: join7(runtimeDir, "stdout.log"),
+    stderrLog: join7(runtimeDir, "stderr.log"),
+    appLog: join7(runtimeDir, "app.log")
+  };
+}
+function resolveRuntimeDirFromConfigPath(configPath) {
+  return join7(dirname4(configPath), "runtime");
+}
+function resolveDaemonOrchestrationSocketPath(runtimeDir, platform = process.platform) {
+  return resolveOrchestrationEndpoint(runtimeDir, platform).path;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+var init_daemon_files = __esm(() => {
+  init_core_home();
+  init_orchestration_ipc();
+});
+
 // src/util/path.ts
 import path2 from "node:path";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 function normalizePath(input) {
   const expanded = expandHome(input);
   if (isWindowsLikePath(expanded)) {
@@ -5770,7 +6420,7 @@ function isWindowsLikePath(input) {
   return WINDOWS_DRIVE_PATH_RE.test(input) || WINDOWS_UNC_PATH_RE.test(input);
 }
 function expandHome(input) {
-  return input.startsWith("~") ? homedir4() + input.slice(1) : input;
+  return input.startsWith("~") ? homedir5() + input.slice(1) : input;
 }
 var WINDOWS_DRIVE_PATH_RE, WINDOWS_UNC_PATH_RE, ROOT_PATH_RE;
 var init_path = __esm(() => {
@@ -5781,11 +6431,11 @@ var init_path = __esm(() => {
 
 // src/transport/codex-subagent-filter.ts
 import { closeSync, openSync, readdirSync, readSync, statSync } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join4 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { join as join8 } from "node:path";
 function resolveCodexHome(env = process.env) {
   const fromEnv = env.CODEX_HOME?.trim();
-  return fromEnv ? fromEnv : join4(homedir5(), ".codex");
+  return fromEnv ? fromEnv : join8(homedir6(), ".codex");
 }
 function isPlainObject(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -5850,7 +6500,7 @@ function filterSubagentSessions(result, isSubagent) {
   };
 }
 function nodeRolloutReader(home) {
-  const root = join4(home, "sessions");
+  const root = join8(home, "sessions");
   return {
     listRolloutPaths() {
       const out = [];
@@ -5862,7 +6512,7 @@ function nodeRolloutReader(home) {
           return;
         }
         for (const entry of entries) {
-          const full = join4(dir, entry.name);
+          const full = join8(dir, entry.name);
           if (entry.isDirectory())
             walk(full);
           else if (entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl"))
@@ -5976,24 +6626,24 @@ var init_agent_session_list = __esm(() => {
 });
 
 // src/transport/acpx-session-files.ts
-import { readdir, unlink as unlink2 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { join as join5 } from "node:path";
+import { readdir as readdir2, unlink as unlink2 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { join as join9 } from "node:path";
 async function deleteAcpxSessionFiles(options) {
-  const dir = options.sessionsDir ?? join5(homedir6(), ".acpx", "sessions");
+  const dir = options.sessionsDir ?? join9(homedir7(), ".acpx", "sessions");
   const safeId = encodeURIComponent(options.acpxRecordId);
-  await unlink2(join5(dir, `${safeId}.json`)).catch(() => {
+  await unlink2(join9(dir, `${safeId}.json`)).catch(() => {
     return;
   });
   let entries;
   try {
-    entries = await readdir(dir);
+    entries = await readdir2(dir);
   } catch {
     return;
   }
   const streamFiles = entries.filter((name) => name.startsWith(`${safeId}.stream.`));
   for (const name of streamFiles) {
-    await unlink2(join5(dir, name)).catch(() => {
+    await unlink2(join9(dir, name)).catch(() => {
       return;
     });
   }
@@ -6258,9 +6908,9 @@ init_terminate_process_tree();
 init_prompt_output();
 init_prompt_media();
 init_streaming_prompt();
-import { copyFile, readdir as readdir2 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
-import { dirname as dirname3, join as join6, win32 } from "node:path";
+import { copyFile, readdir as readdir3 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname5, join as join10, win32 } from "node:path";
 import { spawn as spawn4 } from "node:child_process";
 
 // src/bridge/parse-missing-optional-dep.ts
@@ -6279,6 +6929,7 @@ function parseMissingOptionalDep(text) {
 // src/bridge/bridge-runtime.ts
 init_discover_parent_package_paths();
 init_acpx_queue_owner_launcher();
+init_daemon_files();
 init_agent_session_list();
 init_codex_subagent_filter();
 init_acpx_session_files();
@@ -6343,6 +6994,7 @@ class BridgeRuntime {
     });
   }
   async resumeAgentSession(input) {
+    this.invalidateRecordIdCache(input);
     const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
       "sessions",
       "new",
@@ -6412,6 +7064,7 @@ class BridgeRuntime {
     throw new Error(message);
   }
   async ensureSession(input, onProgress) {
+    this.invalidateRecordIdCache(input);
     try {
       return await this.attemptEnsureSession(input, onProgress);
     } catch (error) {
@@ -6526,7 +7179,7 @@ class BridgeRuntime {
         const resolved = __require.resolve(`${candidate}/package.json`, {
           paths: [process.cwd(), ...__require.resolve.paths(candidate) ?? []]
         });
-        return dirname3(resolved);
+        return dirname5(resolved);
       } catch {
         continue;
       }
@@ -6713,6 +7366,7 @@ class BridgeRuntime {
     };
   }
   async removeSession(input) {
+    this.invalidateRecordIdCache(input);
     const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
       "sessions",
       "close",
@@ -6751,6 +7405,27 @@ class BridgeRuntime {
     await terminateAcpxQueueOwner(acpxRecordId);
     return {};
   }
+  recordIdCache = new Map;
+  recordIdCacheKey(input) {
+    return JSON.stringify([input.agent, input.agentCommand ?? null, input.cwd, input.name]);
+  }
+  invalidateRecordIdCache(input) {
+    this.recordIdCache.delete(this.recordIdCacheKey(input));
+  }
+  async isSessionWarm(input) {
+    const cacheKey = this.recordIdCacheKey(input);
+    let acpxRecordId = this.recordIdCache.get(cacheKey);
+    if (!acpxRecordId) {
+      try {
+        ({ acpxRecordId } = await this.readSessionRecord(input));
+      } catch {
+        return { warm: false };
+      }
+      this.recordIdCache.set(cacheKey, acpxRecordId);
+    }
+    const pid = await readQueueOwnerPid(acpxRecordId);
+    return { warm: pid !== undefined && isProcessAlive(pid) };
+  }
   async shutdown() {
     return {};
   }
@@ -6937,14 +7612,14 @@ async function tryRepairAcpxSessionIndex(deps = {}) {
   if (platform !== "win32") {
     return false;
   }
-  const home = deps.home ?? process.env.HOME ?? process.env.USERPROFILE ?? homedir7();
+  const home = deps.home ?? process.env.HOME ?? process.env.USERPROFILE ?? homedir8();
   if (!home) {
     return false;
   }
-  const pathJoin = platform === "win32" ? win32.join : join6;
+  const pathJoin = platform === "win32" ? win32.join : join10;
   const sessionsDir = pathJoin(home, ".acpx", "sessions");
   const indexPath = pathJoin(sessionsDir, "index.json");
-  const readdirFn = deps.readdirFn ?? readdir2;
+  const readdirFn = deps.readdirFn ?? readdir3;
   const copyFileFn = deps.copyFileFn ?? copyFile;
   let files;
   try {
@@ -6991,6 +7666,7 @@ var BRIDGE_METHODS = new Set([
   "removeSession",
   "deleteSession",
   "freeWarmProcess",
+  "isSessionWarm",
   "getAgentSessionId"
 ]);
 var SESSION_SCOPED_METHODS = new Set([
@@ -7008,6 +7684,7 @@ var SESSION_SCOPED_METHODS = new Set([
   "removeSession",
   "deleteSession",
   "freeWarmProcess",
+  "isSessionWarm",
   "getAgentSessionId"
 ]);
 
@@ -7068,7 +7745,7 @@ class BridgeServer {
     if (!sessionKey) {
       return await this.dispatch(requestId, method, params, writeLine);
     }
-    const lane = method === "cancel" ? "control" : "normal";
+    const lane = method === "cancel" || method === "isSessionWarm" ? "control" : "normal";
     return await this.scheduler.run(sessionKey, lane, () => this.dispatch(requestId, method, params, writeLine));
   }
   async dispatch(requestId, method, params, writeLine) {
@@ -7279,6 +7956,14 @@ class BridgeServer {
           cwd: requireString(params, "cwd"),
           name: requireString(params, "name")
         });
+      case "isSessionWarm":
+        return await this.runtime.isSessionWarm({
+          agent: requireString(params, "agent"),
+          ...agentExecutionSettings(params),
+          agentCommand: asOptionalString(params.agentCommand),
+          cwd: requireString(params, "cwd"),
+          name: requireString(params, "name")
+        });
       case "getAgentSessionId":
         return await this.runtime.getAgentSessionId({
           agent: requireString(params, "agent"),