@parall/daemon 1.28.1 → 1.29.0

package/bundle/parall-codex-agent.js

@@ -112,6 +112,9 @@ function buildEventBody(event) {
   }
   return lines.join("\n") + buildSendMessageHint(event);
 }
+function buildEventBodyForForkResult(event) {
+  return buildEventBody(event).replace(/\n<system-reminder>[\s\S]*<\/system-reminder>$/, "");
+}
 function buildSendMessageHint(event) {
   if (event.noReply)
     return "";
@@ -143,14 +146,16 @@ function buildForkResultPrefix(results) {
   if (!results.length)
     return "";
   const blocks = results.map((result) => {
-    const lines = [`[Fork result]`];
-    lines.push(`[Handled: ${result.sourceEvent.type} \u2014 ${result.sourceEvent.summary}]`);
+    const lines = [];
+    for (const body of result.eventBodies) {
+      lines.push(body);
+    }
+    lines.push(`[This event was handled by a parallel fork session. Do NOT re-handle, re-reply, or duplicate work for it.]`);
+    lines.push(`[Fork summary: ${result.agentSummary ? sanitizeMeta(result.agentSummary) : "No fork summary available \u2014 the fork completed without producing a text summary. Check the target chat/task for any actions the fork already took before acting."}]`);
     if (result.actions.length)
-      lines.push(`[Actions: ${result.actions.join("; ")}]`);
-    if (result.agentSummary)
-      lines.push(`[Summary: ${sanitizeMeta(result.agentSummary)}]`);
+      lines.push(`[Fork actions: ${result.actions.join("; ")}]`);
     if (result.historyPath)
-      lines.push(`[History: ${result.historyPath}]`);
+      lines.push(`[Fork history: ${result.historyPath}]`);
     return lines.join("\n");
   });
   return blocks.join("\n\n") + "\n\n---\n\n";
@@ -418,11 +423,19 @@ Messages may arrive with a \`[Thread: prll://msg_xxx]\` line in the event block,
 - Keep thread replies focused on the original topic
 `;
 
+// ts/agent-core/dist/logger.js
+function createLogger(prefix) {
+  return {
+    info: (msg) => console.log(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
+    warn: (msg) => console.warn(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
+    error: (msg) => console.error(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`)
+  };
+}
+
 // ts/agent-core/dist/gateway-base.js
 import * as os from "node:os";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { randomUUID } from "node:crypto";
 
 // ts/sdk/dist/types.js
 var MENTION_ALL_USER_ID = "all";
@@ -473,7 +486,6 @@ var ENDPOINTS = {
   CHAT_MESSAGES: (orgId, chatId) => `${API_BASE}/orgs/${orgId}/chats/${chatId}/messages`,
   // Messages (global, by message ID)
   MESSAGE: (id) => `${API_BASE}/messages/${id}`,
-  MESSAGE_PATCHES: (id) => `${API_BASE}/messages/${id}/patches`,
   MESSAGE_REPLIES: (id) => `${API_BASE}/messages/${id}/replies`,
   // Upload (org-scoped)
   UPLOAD_PRESIGN: (orgId) => `${API_BASE}/orgs/${orgId}/upload/presign`,
@@ -500,6 +512,7 @@ var ENDPOINTS = {
   AGENT_SESSION: (orgId, agentId, sessionId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions/${sessionId}`,
   AGENT_SESSION_STEPS: (orgId, agentId, sessionId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions/${sessionId}/steps`,
   AGENT_SESSION_STEP: (orgId, agentId, sessionId, stepId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions/${sessionId}/steps/${stepId}`,
+  AGENT_STEP_BY_ID: (orgId, stepId) => `${API_BASE}/orgs/${orgId}/agent-steps/${stepId}`,
   AGENT_TASKS: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/tasks`,
   AGENT_RUNTIME_AUTH: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/runtime-auth`,
   AGENT_RUNTIME_AUTH_SESSIONS: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/runtime-auth-sessions`,
@@ -524,9 +537,12 @@ var ENDPOINTS = {
   // Attach/Detach bind an agent to/from a daemon Machine.
   MACHINE_ATTACH_AGENT: (orgId, machineId, agentId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/agents/${agentId}`,
   MACHINE_DETACH_AGENT: (orgId, machineId, agentId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/agents/${agentId}`,
+  MACHINE_LLM_SOURCE: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/llm-source`,
   MACHINE_RUNTIME_AUTH: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth`,
   MACHINE_KEYS: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys`,
   MACHINE_KEY: (orgId, machineId, keyId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys/${keyId}`,
+  MACHINE_RUNTIME_AUTH_SESSIONS: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth-sessions`,
+  MACHINE_RUNTIME_AUTH_SESSION_COMPLETE: (orgId, machineId, sessionId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth-sessions/${sessionId}/complete`,
   // Machine self-control-plane (mck_-scoped). The bearer token implicitly
   // identifies the Machine, so there is no `:mid` URL parameter — these are
   // "self" routes called by the daemon for its own host.
@@ -1167,9 +1183,6 @@ var ParallClient = class _ParallClient {
   async deleteMessage(id) {
     return this.request("DELETE", ENDPOINTS.MESSAGE(id));
   }
-  async patchMessage(id, req) {
-    return this.request("POST", ENDPOINTS.MESSAGE_PATCHES(id), req);
-  }
   async getMessageReplies(id, params) {
     return this.request("GET", ENDPOINTS.MESSAGE_REPLIES(id), void 0, params);
   }
@@ -1262,8 +1275,7 @@ var ParallClient = class _ParallClient {
    * @param params.status - Comma-separated status filter (e.g., `'open'`).
    */
   async getAgentSessions(orgId, agentId, params) {
-    const res = await this.request("GET", ENDPOINTS.AGENT_SESSIONS(orgId, agentId), void 0, params);
-    return res.data;
+    return this.request("GET", ENDPOINTS.AGENT_SESSIONS(orgId, agentId), void 0, params);
   }
   async getAgentSession(orgId, agentId, sessionId) {
     return this.request("GET", ENDPOINTS.AGENT_SESSION(orgId, agentId, sessionId));
@@ -1275,12 +1287,14 @@ var ParallClient = class _ParallClient {
     return this.request("POST", ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), req);
   }
   async getAgentSessionSteps(orgId, agentId, sessionId, params) {
-    const res = await this.request("GET", ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), void 0, params);
-    return res.data;
+    return this.request("GET", ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), void 0, params);
   }
   async getAgentSessionStep(orgId, agentId, sessionId, stepId) {
     return this.request("GET", ENDPOINTS.AGENT_SESSION_STEP(orgId, agentId, sessionId, stepId));
   }
+  async getAgentStepById(orgId, stepId) {
+    return this.request("GET", ENDPOINTS.AGENT_STEP_BY_ID(orgId, stepId));
+  }
   // ---- Agent runtime auth (hosted Claude OAuth) ----
   async getAgentRuntimeAuth(orgId, agentId) {
     return this.request("GET", ENDPOINTS.AGENT_RUNTIME_AUTH(orgId, agentId));
@@ -1377,10 +1391,22 @@ var ParallClient = class _ParallClient {
   async detachAgent(orgId, machineId, agentId) {
     return this.request("DELETE", ENDPOINTS.MACHINE_DETACH_AGENT(orgId, machineId, agentId));
   }
+  async patchMachineLLMSource(orgId, machineId, llmSource) {
+    return this.request("PATCH", ENDPOINTS.MACHINE_LLM_SOURCE(orgId, machineId), { llm_source: llmSource });
+  }
   /** Get machine-level runtime auth state. */
   async getMachineRuntimeAuth(orgId, machineId) {
     return this.request("GET", ENDPOINTS.MACHINE_RUNTIME_AUTH(orgId, machineId));
   }
+  async startMachineRuntimeAuthSession(orgId, machineId, req = {}) {
+    return this.request("POST", ENDPOINTS.MACHINE_RUNTIME_AUTH_SESSIONS(orgId, machineId), req);
+  }
+  async completeMachineRuntimeAuthSession(orgId, machineId, sessionId, req) {
+    return this.request("POST", ENDPOINTS.MACHINE_RUNTIME_AUTH_SESSION_COMPLETE(orgId, machineId, sessionId), req);
+  }
+  async disconnectMachineRuntimeAuth(orgId, machineId) {
+    return this.request("DELETE", ENDPOINTS.MACHINE_RUNTIME_AUTH(orgId, machineId));
+  }
   // ---- Machine self-control-plane (mck_-scoped) ----
   //
   // The four methods below are intended to be called from a daemon-mode
@@ -2312,9 +2338,9 @@ var ParallAgentGateway = class {
     this.SHUTDOWN_DEADLINE_MS = opts.shutdownDeadlineMs ?? 6e4;
   }
   async run(abortSignal) {
-    const { ws, log } = this.opts;
+    const { ws, log: log2 } = this.opts;
     ws.onStateChange((state) => {
-      log?.info(`parall[${this.opts.accountId}]: connection state \u2192 ${state}`);
+      log2?.info(`parall[${this.opts.accountId}]: connection state \u2192 ${state}`);
     });
     ws.on("hello", async (data) => {
       await this.handleHello(data);
@@ -2727,7 +2753,8 @@ var ParallAgentGateway = class {
           continue;
         }
         if (!binding) {
-          throw new Error(`runtime emitted ${runtimeEvent.type} before runtime_session`);
+          const detail = runtimeEvent.type === "error" ? `: ${runtimeEvent.message}` : "";
+          throw new Error(`runtime emitted ${runtimeEvent.type} before runtime_session${detail}`);
         }
         if (!triggerMessageSet) {
           triggerMessageSet = true;
@@ -2842,6 +2869,7 @@ var ParallAgentGateway = class {
             targetId: fork.targetId,
             summary: fork.processedEvents.length === 1 ? `${first.type} from ${first.senderName} in ${first.targetName ?? fork.targetId}` : `${fork.processedEvents.length} events in ${first.targetName ?? fork.targetId}`
           },
+          eventBodies: fork.processedEvents.map((e) => buildEventBodyForForkResult(e)),
           actions: [],
           agentSummary,
           historyPath
@@ -2881,32 +2909,11 @@ var ParallAgentGateway = class {
       return;
     this.draining = true;
     try {
-      while (this.dispatchState.mainBuffer.length > 0 || this.dispatchState.pendingForkResults.length > 0) {
+      while (this.dispatchState.mainBuffer.length > 0) {
         if (this.shuttingDown) {
           this.opts.log?.info(`parall[${this.opts.accountId}]: drainMainBuffer halted (shutting down) \u2014 ${this.dispatchState.mainBuffer.length} buffered, ${this.dispatchState.pendingForkResults.length} pending fork results left for catch-up`);
           break;
         }
-        if (this.dispatchState.mainBuffer.length === 0 && this.dispatchState.pendingForkResults.length > 0) {
-          const pending = this.dispatchState.pendingForkResults.splice(0);
-          const forkPrefix2 = buildForkResultPrefix(pending);
-          const syntheticEvent = {
-            type: "message",
-            targetId: "_orchestrator",
-            targetType: "system",
-            senderId: "system",
-            senderName: "system",
-            messageId: `synthetic-${this.opts.accountId}-${randomUUID()}`,
-            body: "[Orchestrator: fork session(s) completed \u2014 review results above]"
-          };
-          this.dispatchState.mainCurrentTargetId = void 0;
-          this.dispatchState.mainPreDispatchBranchPoint = this.opts.dispatchAdapter.getBranchPoint?.(this.opts.runtimeKey);
-          const dispatched2 = await this.runDispatch(syntheticEvent, this.opts.runtimeKey, forkPrefix2 + buildEventBody(syntheticEvent));
-          if (!dispatched2) {
-            this.dispatchState.pendingForkResults.unshift(...pending);
-            break;
-          }
-          continue;
-        }
         const targetId = this.dispatchState.mainBuffer[0].targetId;
         const events = [];
         while (this.dispatchState.mainBuffer[0]?.targetId === targetId) {
@@ -3438,12 +3445,12 @@ var ParallAgentGateway = class {
     }
   }
   async handleHello(data) {
-    const { client, config, log } = this.opts;
+    const { client, config, log: log2 } = this.opts;
     this.sessionId = data.session_id ?? "";
     const intervalSec = data.heartbeat_interval > 0 ? data.heartbeat_interval : 30;
     try {
       const count = await fetchAllChats(client, config.org_id, this.chatInfoMap);
-      log?.info(`parall[${this.opts.accountId}]: WebSocket connected, ${count} chats cached`);
+      log2?.info(`parall[${this.opts.accountId}]: WebSocket connected, ${count} chats cached`);
       await this.opts.onSessionReady?.({
         activeSessionId: this.activeSessionId,
         ws: this.opts.ws,
@@ -3457,7 +3464,7 @@ var ParallAgentGateway = class {
         const expectedMs = intervalSec * 1e3;
         const drift = now - this.lastHeartbeatAt - expectedMs;
         if (drift > 15e3) {
-          log?.warn(`parall[${this.opts.accountId}]: heartbeat drift ${drift}ms \u2014 event loop may be blocked`);
+          log2?.warn(`parall[${this.opts.accountId}]: heartbeat drift ${drift}ms \u2014 event loop may be blocked`);
         }
         this.lastHeartbeatAt = now;
         if (this.opts.ws.state !== "connected")
@@ -3473,10 +3480,10 @@ var ParallAgentGateway = class {
       const isFirstHello = !this.hadSuccessfulHello;
       this.hadSuccessfulHello = true;
       this.catchUpFromDispatch(isFirstHello).catch((err) => {
-        log?.warn(`parall[${this.opts.accountId}]: dispatch catch-up failed: ${String(err)}`);
+        log2?.warn(`parall[${this.opts.accountId}]: dispatch catch-up failed: ${String(err)}`);
       });
     } catch (err) {
-      log?.error(`parall[${this.opts.accountId}]: failed to fetch chats: ${String(err)}`);
+      log2?.error(`parall[${this.opts.accountId}]: failed to fetch chats: ${String(err)}`);
     }
   }
   // Resolves when in-flight dispatches hit 0 or the deadline elapses.
@@ -3581,7 +3588,7 @@ function extractDefaults(config, runtimeType) {
   return { model, thinkingEffort };
 }
 function createPlatformConfigManager(opts) {
-  const { client, stateDir, runtimeType, log } = opts;
+  const { client, stateDir, runtimeType, log: log2 } = opts;
   let cachedVersion;
   let currentDefaults = { model: null, thinkingEffort: null };
   let currentRawConfig = null;
@@ -3598,20 +3605,20 @@ function createPlatformConfigManager(opts) {
         fresh = await client.getPlatformConfig(cachedVersion);
       } catch (err) {
         if (cached) {
-          log?.warn(`platform config fetch failed, using cached version ${cachedVersion}: ${String(err)}`);
+          log2?.warn(`platform config fetch failed, using cached version ${cachedVersion}: ${String(err)}`);
           return currentDefaults;
         }
-        log?.warn(`platform config fetch failed and no cache available: ${String(err)}`);
+        log2?.warn(`platform config fetch failed and no cache available: ${String(err)}`);
         return currentDefaults;
       }
       if (fresh === null) {
         return currentDefaults;
       }
       if (fresh.schema_version !== void 0 && fresh.schema_version > SUPPORTED_SCHEMA_VERSION) {
-        log?.warn(`platform config schema_version ${fresh.schema_version} > supported (${SUPPORTED_SCHEMA_VERSION}), keeping current`);
+        log2?.warn(`platform config schema_version ${fresh.schema_version} > supported (${SUPPORTED_SCHEMA_VERSION}), keeping current`);
         return currentDefaults;
       }
-      log?.info(`platform config updated to version ${fresh.version}`);
+      log2?.info(`platform config updated to version ${fresh.version}`);
       saveCache(stateDir, fresh);
       cachedVersion = fresh.version;
       currentRawConfig = fresh.config;
@@ -4199,9 +4206,8 @@ function stepIdFilePathForSession(stateDir, sessionKey) {
 }
 
 // ts/codex-agent/dist/dispatch.js
-import { spawn } from "node:child_process";
-import { execSync as execSync2 } from "node:child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { execSync as execSync2, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import * as fs5 from "node:fs";
 
 // ts/agent-core/dist/internal/attachment-input.js
@@ -4503,7 +4509,7 @@ function sameFileIdentity(a, b) {
 function sameFile(a, b) {
   return sameFileIdentity(a, b) && a.size === b.size && a.mtimeMs === b.mtimeMs;
 }
-async function cleanupOldAttachmentFiles(rootDir, ttlMs, log, preserveDirs) {
+async function cleanupOldAttachmentFiles(rootDir, ttlMs, log2, preserveDirs) {
   let entries;
   try {
     entries = await fs4.readdir(rootDir, { withFileTypes: true });
@@ -4525,11 +4531,11 @@ async function cleanupOldAttachmentFiles(rootDir, ttlMs, log, preserveDirs) {
         await fs4.rm(fullPath, { recursive: true, force: true });
       }
     } catch (err) {
-      log?.warn?.(`agent-core: failed to clean attachment temp dir ${fullPath}: ${String(err)}`);
+      log2?.warn?.(`agent-core: failed to clean attachment temp dir ${fullPath}: ${String(err)}`);
     }
   }));
 }
-async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
+async function pruneAttachmentCache(rootDir, maxBytes, log2, preserveDirs) {
   if (maxBytes <= 0)
     return;
   let entries;
@@ -4552,7 +4558,7 @@ async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
       dirs.push({ path: fullPath, mtimeMs: stat.mtimeMs, size });
       total += size;
     } catch (err) {
-      log?.warn?.(`agent-core: failed to inspect attachment cache dir ${fullPath}: ${String(err)}`);
+      log2?.warn?.(`agent-core: failed to inspect attachment cache dir ${fullPath}: ${String(err)}`);
     }
   }
   if (total <= maxBytes)
@@ -4567,7 +4573,7 @@ async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
       await fs4.rm(dir.path, { recursive: true, force: true });
       total -= dir.size;
     } catch (err) {
-      log?.warn?.(`agent-core: failed to prune attachment cache dir ${dir.path}: ${String(err)}`);
+      log2?.warn?.(`agent-core: failed to prune attachment cache dir ${dir.path}: ${String(err)}`);
     }
   }
 }
@@ -4996,14 +5002,16 @@ var DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
 var JsonRpcStdioClient = class {
   proc;
   requestTimeoutMs;
+  killProcess;
   nextId = 1;
   pending = /* @__PURE__ */ new Map();
   buffer = "";
   onNotification = null;
   disposed = false;
-  constructor(proc, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  constructor(proc, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, killProcess) {
     this.proc = proc;
     this.requestTimeoutMs = requestTimeoutMs;
+    this.killProcess = killProcess;
     proc.stdout.setEncoding("utf8");
     proc.stdout.on("data", (chunk) => this.ingest(chunk));
     proc.once("close", () => this.dispose(new Error("app-server subprocess closed")));
@@ -5063,7 +5071,11 @@ var JsonRpcStdioClient = class {
   killUnhealthy(err) {
     this.dispose(err);
     if (this.proc.exitCode === null && this.proc.signalCode === null) {
-      this.proc.kill("SIGTERM");
+      if (this.killProcess) {
+        this.killProcess(this.proc);
+      } else {
+        this.proc.kill("SIGTERM");
+      }
     }
   }
   ingest(chunk) {
@@ -5110,6 +5122,20 @@ function isNotification(m) {
 }
 
 // ts/codex-agent/dist/dispatch.js
+var IS_WIN32 = process.platform === "win32";
+function quoteWin32Arg(arg) {
+  if (!/[\s"&|^<>()]/.test(arg))
+    return arg;
+  return `"${arg.replace(/"/g, '""')}"`;
+}
+function killWin32Tree(pid) {
+  try {
+    execSync2(`taskkill /T /F /PID ${pid}`, { windowsHide: true, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
 var CodexAppServerAdapter = class {
   opts;
   client = null;
@@ -5127,10 +5153,10 @@ var CodexAppServerAdapter = class {
    * replacement would be a perpetually hung dispatch generator, which is
    * hard to debug.
    */
-  setActiveTurn(threadId, sink, log) {
+  setActiveTurn(threadId, sink, log2) {
     const existing = this.activeTurns.get(threadId);
     if (existing) {
-      (log ?? this.opts.log)?.warn?.(`codex-agent: thread ${threadId} already had an active turn; failing the previous dispatch`);
+      (log2 ?? this.opts.log)?.warn?.(`codex-agent: thread ${threadId} already had an active turn; failing the previous dispatch`);
       existing.push({ kind: "error", message: `thread ${threadId} replaced by concurrent turn` });
       existing.close();
     }
@@ -5152,7 +5178,7 @@ var CodexAppServerAdapter = class {
       yield { type: "error", message: "Codex app-server not available (subprocess died during dispatch start)" };
       return;
     }
-    const log = this.opts.log ?? context.log;
+    const log2 = this.opts.log ?? context.log;
     const isMainSession = this.opts.sessionManager.isMain(sessionKey);
     let threadId = this.opts.sessionManager.getThreadId(sessionKey);
     if (!threadId) {
@@ -5170,7 +5196,7 @@ var CodexAppServerAdapter = class {
         this.opts.sessionManager.recordThreadId(sessionKey, threadId);
         this.resumedThreadIds.add(threadId);
       } catch (err) {
-        log?.warn?.(`codex-agent: thread/resume failed (${errToString(err)}); attempting one-shot fresh-thread start`);
+        log2?.warn?.(`codex-agent: thread/resume failed (${errToString(err)}); attempting one-shot fresh-thread start`);
         let freshThreadId;
         try {
           freshThreadId = await this.openThread(client, { resumeId: void 0 });
@@ -5188,8 +5214,8 @@ var CodexAppServerAdapter = class {
       }
     }
     const sink = new TurnSink();
-    this.setActiveTurn(threadId, sink, log);
-    const groupKey = randomUUID2();
+    this.setActiveTurn(threadId, sink, log2);
+    const groupKey = randomUUID();
     let sawTurnEnd = false;
     let releasePreparedAttachments = () => {
     };
@@ -5199,13 +5225,13 @@ var CodexAppServerAdapter = class {
       try {
         const prepared = await appendPreparedLocalAttachmentRefs(bodyForAgent, event, context, {
           workspaceDir: this.opts.workspaceDir,
-          log
+          log: log2
         });
         preparedBody = prepared.body;
         preparedImages = prepared.attachments.images;
         releasePreparedAttachments = pinLocalAttachmentPaths(preparedImages);
       } catch (err) {
-        log?.warn?.(`codex-agent[${context.accountId}]: failed to prepare local attachments: ${errToString(err)}`);
+        log2?.warn?.(`codex-agent[${context.accountId}]: failed to prepare local attachments: ${errToString(err)}`);
       }
       const turnInput = buildTurnInput(preparedBody, preparedImages);
       const startTurn = (targetThreadId) => client.sendRequest("turn/start", {
@@ -5226,7 +5252,7 @@ var CodexAppServerAdapter = class {
           yield { type: "error", message: `Codex turn/start failed: ${message}` };
           return;
         }
-        log?.warn?.(`codex-agent: turn/start on thread ${threadId} failed (${message}); attempting one-shot fresh-thread retry`);
+        log2?.warn?.(`codex-agent: turn/start on thread ${threadId} failed (${message}); attempting one-shot fresh-thread retry`);
         this.activeTurns.delete(threadId);
         let freshThreadId;
         try {
@@ -5240,7 +5266,7 @@ var CodexAppServerAdapter = class {
           yield { type: "error", message: `Codex turn/start failed; could not create replacement thread: ${errToString(createErr)}` };
           return;
         }
-        this.setActiveTurn(freshThreadId, sink, log);
+        this.setActiveTurn(freshThreadId, sink, log2);
         try {
           turnStartResult = await startTurn(freshThreadId);
         } catch (retryErr) {
@@ -5341,10 +5367,12 @@ var CodexAppServerAdapter = class {
     if (client)
       client.dispose(new Error("adapter stopped"));
     if (proc && proc.exitCode === null && proc.signalCode === null) {
-      proc.kill("SIGTERM");
+      if (!IS_WIN32 || !proc.pid || !killWin32Tree(proc.pid)) {
+        proc.kill("SIGTERM");
+      }
     }
   }
-  async ensureStarted(log) {
+  async ensureStarted(log2) {
     if (this.client?.isDisposed()) {
       for (const activeSink of this.activeTurns.values()) {
         activeSink.push({ kind: "error", message: "Codex app-server disposed; resetting adapter" });
@@ -5360,14 +5388,14 @@ var CodexAppServerAdapter = class {
       return;
     if (this.startPromise)
       return this.startPromise;
-    this.startPromise = this.doStart(log);
+    this.startPromise = this.doStart(log2);
     try {
       await this.startPromise;
     } finally {
       this.startPromise = null;
     }
   }
-  async doStart(log) {
+  async doStart(log2) {
     this.stopping = false;
     ensureGitRepo(this.opts.workspaceDir);
     const env = {
@@ -5380,20 +5408,25 @@ var CodexAppServerAdapter = class {
       env.PRLL_CONTEXT_FILE = this.opts.contextFilePath;
     }
     const args = ["app-server", "--listen", "stdio://"];
-    (log ?? this.opts.log)?.info?.(`codex-agent: spawning ${this.opts.codexBin} ${args.join(" ")}`);
-    const proc = spawn(this.opts.codexBin, args, {
+    (log2 ?? this.opts.log)?.info?.(`codex-agent: spawning ${this.opts.codexBin} ${args.join(" ")}`);
+    const proc = spawn(IS_WIN32 ? quoteWin32Arg(this.opts.codexBin) : this.opts.codexBin, IS_WIN32 ? args.map(quoteWin32Arg) : args, {
       cwd: this.opts.workspaceDir,
       env,
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: IS_WIN32
     });
     proc.stderr.setEncoding("utf8");
     proc.stderr.on("data", (chunk) => {
-      (log ?? this.opts.log)?.warn?.(`codex-agent[stderr]: ${chunk.trim()}`);
+      (log2 ?? this.opts.log)?.warn?.(`codex-agent[stderr]: ${chunk.trim()}`);
+    });
+    const client = new JsonRpcStdioClient(proc, void 0, (p) => {
+      if (!IS_WIN32 || !p.pid || !killWin32Tree(p.pid)) {
+        p.kill("SIGTERM");
+      }
     });
-    const client = new JsonRpcStdioClient(proc);
     client.setNotificationHandler((method, params) => this.routeNotification(method, params));
-    proc.once("close", (code, signal) => this.handleSubprocessClose(proc, code, signal, log));
-    proc.once("error", (err) => this.handleSubprocessClose(proc, null, null, log, err));
+    proc.once("close", (code, signal) => this.handleSubprocessClose(proc, code, signal, log2));
+    proc.once("error", (err) => this.handleSubprocessClose(proc, null, null, log2, err));
     try {
       await client.sendRequest("initialize", {
         clientInfo: { name: "parall-codex-agent", version: "1" },
@@ -5402,19 +5435,22 @@ var CodexAppServerAdapter = class {
       client.sendNotification("initialized", {});
     } catch (err) {
       client.dispose(err instanceof Error ? err : new Error(String(err)));
-      if (proc.exitCode === null && proc.signalCode === null)
-        proc.kill("SIGTERM");
+      if (proc.exitCode === null && proc.signalCode === null) {
+        if (!IS_WIN32 || !proc.pid || !killWin32Tree(proc.pid)) {
+          proc.kill("SIGTERM");
+        }
+      }
       throw err;
     }
     this.proc = proc;
     this.client = client;
     this.initialized = true;
   }
-  handleSubprocessClose(proc, code, signal, log, err) {
+  handleSubprocessClose(proc, code, signal, log2, err) {
     if (this.proc !== null && this.proc !== proc)
       return;
     const reason = err ? `spawn error: ${err.message}` : `exited (code=${code ?? "null"}${signal ? `, signal=${signal}` : ""})`;
-    const logger = log ?? this.opts.log;
+    const logger = log2 ?? this.opts.log;
     if (this.stopping) {
       logger?.info?.(`codex-agent: app-server subprocess ${reason} during graceful stop`);
     } else {
@@ -6332,7 +6368,7 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
 }
 
 // ts/codex-agent/dist/workspace.js
-function ensureWorkspaceTrusted(codexHome, workspaceDir, log) {
+function ensureWorkspaceTrusted(codexHome, workspaceDir, log2) {
   const configPath = path7.join(codexHome, "config.toml");
   const normalizedPath = path7.resolve(workspaceDir);
   try {
@@ -6348,7 +6384,7 @@ function ensureWorkspaceTrusted(codexHome, workspaceDir, log) {
       try {
         parsed = parse(content);
       } catch {
-        log?.warn(`Codex config.toml is not valid TOML; skipping trust write for ${normalizedPath}`);
+        log2?.warn(`Codex config.toml is not valid TOML; skipping trust write for ${normalizedPath}`);
         return;
       }
     }
@@ -6380,9 +6416,9 @@ ${trustLine}
       }
       fs7.writeFileSync(configPath, content, "utf8");
     } else if (projects?.[normalizedPath] !== void 0) {
-      log?.warn(`Codex config.toml has non-canonical header for ${normalizedPath}; skipping trust write`);
+      log2?.warn(`Codex config.toml has non-canonical header for ${normalizedPath}; skipping trust write`);
     } else if (projects && !content.includes("[projects.")) {
-      log?.warn(`Codex config.toml uses inline table for projects; skipping trust write for ${normalizedPath}`);
+      log2?.warn(`Codex config.toml uses inline table for projects; skipping trust write for ${normalizedPath}`);
     } else {
       fs7.mkdirSync(codexHome, { recursive: true });
       fs7.appendFileSync(configPath, `
@@ -6391,7 +6427,7 @@ ${trustLine}
 `, "utf8");
     }
   } catch (err) {
-    log?.warn(`failed to write Codex project trust for ${normalizedPath}: ${String(err)}`);
+    log2?.warn(`failed to write Codex project trust for ${normalizedPath}: ${String(err)}`);
   }
 }
 function isParallProxyMode(env = process.env) {
@@ -6401,7 +6437,7 @@ function isParallProxyMode(env = process.env) {
     return false;
   return baseUrl === apiUrl || baseUrl.startsWith(`${apiUrl}/`);
 }
-function ensureParallProvider(codexHome, apiUrl, log) {
+function ensureParallProvider(codexHome, apiUrl, log2) {
   const configPath = path7.join(codexHome, "config.toml");
   const baseUrl = apiUrl.replace(/\/$/, "") + "/api/llm/v1";
   try {
@@ -6445,7 +6481,7 @@ function findSectionEnd(content, fromIndex) {
   const nextHeader = content.indexOf("\n[", fromIndex);
   return nextHeader === -1 ? content.length : nextHeader;
 }
-function ensureCodexWorkspace(workspaceDir, log, agentIdentity) {
+function ensureCodexWorkspace(workspaceDir, log2, agentIdentity) {
   const systemPrompt = [
     buildIdentity(agentIdentity),
     BRIDGE_WORKSPACE_INSTRUCTIONS,
@@ -6468,13 +6504,7 @@ ${systemPrompt.replace(/\\/g, "\\\\").replace(/"""/g, '\\"""')}
 }
 
 // ts/codex-agent/dist/index.js
-function createLogger(prefix) {
-  return {
-    info: (msg) => console.log(`[${prefix}] ${msg}`),
-    warn: (msg) => console.warn(`[${prefix}] ${msg}`),
-    error: (msg) => console.error(`[${prefix}] ${msg}`)
-  };
-}
+var log = createLogger("codex-agent");
 async function getAgentMeWithLegacyFallback(client, orgId) {
   try {
     return await client.getAgentMe(orgId);
@@ -6488,7 +6518,6 @@ async function getAgentMeWithLegacyFallback(client, orgId) {
 }
 async function main() {
   const config = resolveCodexAgentConfig(process.env);
-  const log = createLogger("codex-agent");
   const client = new ParallClient({
     baseUrl: config.apiUrl,
     token: config.apiKey,
@@ -6596,7 +6625,7 @@ async function main() {
   }
 }
 main().catch((err) => {
-  console.error(`[codex-agent] fatal: ${String(err)}`);
+  log.error(`fatal: ${String(err)}`);
   process.exitCode = 1;
 });
 /*! Bundled license information: