pi-freeflow 1.44.1 → 1.45.0

package/src/relay-state.ts

@@ -46,6 +46,7 @@ function isPrivateRelayHostname(hostname: string): boolean {
   return false;
  }
  if (host.includes(":")) {
+  if (host.startsWith("64:ff9b:") || host.startsWith("2002:")) return true;
   if (host.startsWith("fc") || host.startsWith("fd")) return true; // ULA fc00::/7
   if (/^fe[89ab]/.test(host)) return true; // link-local fe80::/10
   return false;
@@ -611,7 +612,8 @@ const RELAY_STATE_LOCK_FILE = `${RELAY_STATE_FILE}.lock`;
 /** A lock older than this is presumed abandoned (crashed holder) and taken over. */
 const LOCK_STALE_MS = 30_000;
 
-function tryAcquireRelayLock(): boolean {
+export function tryAcquireRelayLock(depth = 0): boolean {
+ if (depth >= 3) return false;
  try {
   fs.writeFileSync(RELAY_STATE_LOCK_FILE, String(process.pid), { flag: "wx" });
   return true;
@@ -630,9 +632,12 @@ function tryAcquireRelayLock(): boolean {
    stale = Date.now() - fs.statSync(RELAY_STATE_LOCK_FILE).mtimeMs > LOCK_STALE_MS;
   } catch {
    // The lock vanished between the failed create and the stat — retry once.
-   return tryAcquireRelayLock();
+   return tryAcquireRelayLock(depth + 1);
+  }
+  if (!stale) {
+   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+   return tryAcquireRelayLock(depth + 1);
   }
-  if (!stale) return false;
   try {
    fs.rmSync(RELAY_STATE_LOCK_FILE, { force: true });
   } catch {
@@ -640,7 +645,7 @@ function tryAcquireRelayLock(): boolean {
    // the proxy request path.
    return false;
   }
-  return tryAcquireRelayLock();
+  return tryAcquireRelayLock(depth + 1);
  }
 }
 

package/src/relay.ts

@@ -401,50 +401,97 @@ export async function relayFetch(
      fetchA.catch(() => {});
      fetchB.catch(() => {});
      interface HedgedWin { url: string; response: Response; }
+     let hedgeBAbortedByWinner = false;
+     let bProducedOutcome = false;
+     const isCallerAborted = () => Boolean(opts.signal?.aborted);
+     const isNonWinning = (status: number): boolean =>
+      isRetriableStatus(status) || status === 403 || status === 401 || status === 402;
      try {
-      const winner = await new Promise<HedgedWin>((resolve, reject) => {
-       let failures = 0;
-       let firstError: unknown = null;
-       const onError = (err: unknown) => {
-        failures += 1;
-        if (firstError === null) firstError = err;
-        if (failures >= 2) reject(firstError);
-       };
-       fetchA.then(
-        (response) => resolve({ url: primaryUrl, response }),
-        onError,
-       );
-       fetchB.then(
-        (response) => resolve({ url: nextUrl, response }),
-        onError,
-       );
-      });
+      const { promise: winnerPromise, resolve, reject } = Promise.withResolvers<HedgedWin>();
+      let firstBad: HedgedWin | null = null;
+      let firstError: unknown = null;
+      let settledCount = 0;
+      const onResponse = (legUrl: string, response: Response) => {
+       settledCount += 1;
+       if (legUrl === nextUrl) {
+        bProducedOutcome = true;
+       }
+       if (!isNonWinning(response.status)) {
+        if (firstBad) {
+         firstBad.response.body?.cancel().catch(() => {});
+         markRelayFailure(firstBad.url, firstBad.response.status);
+        }
+        resolve({ url: legUrl, response });
+        return;
+       }
+       if (!firstBad) {
+        if (settledCount >= 2) {
+         resolve({ url: legUrl, response });
+        } else {
+         firstBad = { url: legUrl, response };
+        }
+        return;
+       }
+       if (legUrl === nextUrl) {
+        markRelayFailure(nextUrl, response.status);
+        response.body?.cancel().catch(() => {});
+       } else {
+        markRelayFailure(primaryUrl, response.status);
+        response.body?.cancel().catch(() => {});
+       }
+       resolve(firstBad);
+      };
+      const onError = (legUrl: string, err: unknown) => {
+       settledCount += 1;
+       if (legUrl === nextUrl && !hedgeBAbortedByWinner) {
+        bProducedOutcome = true;
+       }
+       if (firstBad) {
+        if (legUrl === nextUrl && !hedgeBAbortedByWinner && !isCallerAborted()) {
+         markRelayFailure(nextUrl, 0, (err as Error)?.message || String(err));
+        }
+        resolve(firstBad);
+        return;
+       }
+       if (firstError === null) {
+        firstError = err;
+       }
+       if (settledCount >= 2) {
+        reject(firstError);
+       }
+      };
+      fetchA.then(
+       (r) => onResponse(primaryUrl, r),
+       (e) => onError(primaryUrl, e),
+      );
+      fetchB.then(
+       (r) => onResponse(nextUrl, r),
+       (e) => onError(nextUrl, e),
+      );
+      const winner = await winnerPromise;
       if (winner.url === nextUrl) {
        hedgeCtlA.abort();
        targetUrl = nextUrl;
        attemptStart = hedgeStart;
       } else {
+       hedgeBAbortedByWinner = true;
        hedgeCtlB.abort();
       }
       res = winner.response;
-      // Both candidates are consumed by this race: skip the next
-      // index so the loser is never retried in this request.
-      hedgeSkipNext = true;
+      if (bProducedOutcome) {
+       hedgeSkipNext = true;
+      }
      } catch (hedgeErr) {
-      // Both hedged attempts failed without usable headers. Caller
-      // abort must propagate unmarked (the outer catch rethrows);
-      // otherwise record the next relay here and let the outer
-      // catch record the primary.
       if ((hedgeErr as Error)?.name === "AbortError" && opts.signal?.aborted) {
        throw hedgeErr;
       }
-      markRelayFailure(nextUrl, 0, (hedgeErr as Error)?.message || String(hedgeErr));
-      // Both legs of this race were abandoned; the outer catch
-      // reports the primary one, this reports the hedge leg.
-      reportAbandoned(
-       (hedgeErr as Error)?.name === "AbortError" ? "header-timeout" : "network-error",
-      );
-      hedgeSkipNext = true;
+      if (bProducedOutcome) {
+       markRelayFailure(nextUrl, 0, (hedgeErr as Error)?.message || String(hedgeErr));
+       reportAbandoned(
+        (hedgeErr as Error)?.name === "AbortError" ? "header-timeout" : "network-error",
+       );
+       hedgeSkipNext = true;
+      }
       throw hedgeErr;
      }
     }

package/src/sse-aggregator.ts

@@ -349,6 +349,7 @@ export function sseToResponsesJson(
   const ev = events[i];
   try {
    const parsed = JSON.parse(ev.data);
+   if (parsed?.type === "response.created" || parsed?.type === "response.in_progress") continue;
    if (parsed?.response && typeof parsed.response === "object") {
     cloakResponsesObject(parsed.response, callerHadTools, caseRestore, findGlob, injected, argSchemas);
     return parsed.response as Record<string, unknown>;

package/src/stream-cloak.ts

@@ -222,6 +222,7 @@ export function shouldBypassStreamCloak(cloak?: StreamCloakOptions): boolean {
  if (cloak.injected !== undefined && cloak.injected.length > 0) return false;
  if (cloak.caseRestore && Object.keys(cloak.caseRestore).length > 0) return false;
  if (cloak.findGlob?.renamedFindToGlob === true) return false;
+ if (cloak.findGlob?.renamed && Object.keys(cloak.findGlob.renamed).length > 0) return false;
  // Tool-less callers must still see tool calls stripped when the
  // injected record exists (legacy direct calls keep everything).
  if (!cloak.callerHadTools && cloak.injected !== undefined) return false;
@@ -655,11 +656,13 @@ export function rewriteChatBlock(
      // Hold this call's arguments: the packet is only judgeable once whole,
      // so it is re-emitted repaired on the terminal finish_reason chunk.
      // Reset-then-absorb mirrors the old per-index buffer exactly.
-     if (!call.buffered) state.audit?.repair("arguments-buffered", toolName);
-     call.buffered = true;
-     call.args = "";
+     if (!call.buffered) {
+      state.audit?.repair("arguments-buffered", toolName);
+      call.buffered = true;
+      call.args = "";
+     }
      if (fnRec && typeof fnRec.arguments === "string" && fnRec.arguments !== "") {
-      call.args = fnRec.arguments;
+      call.args += fnRec.arguments;
       delete fnRec.arguments;
       changed = true;
      }

package/src/stream-pipe.ts

@@ -619,6 +619,7 @@ export function pipeUpstreamStream(
   sseDecoder = new StringDecoder("utf8");
   terminalScanCarry = Buffer.alloc(0);
   watch(next);
+  scheduleStallCut(next);
   try {
    if (!cut.destroyed) cut.destroy();
   } catch { }
@@ -939,6 +940,10 @@ export function pipeUpstreamStream(
     ensureTerminalEvent(false, errorMsg || "stream interrupted", false);
    } else {
     if (await tryRefire()) return;
+    if (cloakState && cloak) {
+     const flushed = flushBufferedToolArgs(cloakState, cloak);
+     if (flushed !== null) forwardText(flushed);
+    }
     sseBuffer = "";
     terminalScanCarry = Buffer.alloc(0);
     ensureTerminalEvent(!isSubstantial(totalChunks, totalBytes), errorMsg, true);
@@ -990,12 +995,17 @@ export function pipeUpstreamStream(
   if (sseBuffer.trim() !== "") {
    const tail = sseBuffer;
    sseBuffer = "";
-   if (checkTerminalEvent(tail)) {
+   const isCutTerminal =
+    (tail.includes("response.completed") ||
+     tail.includes("response.incomplete") ||
+     tail.includes("response.failed")) &&
+    !endsOnFinishedSseLine(tail);
+   if (!isCutTerminal && checkTerminalEvent(tail)) {
     if (cloakState && cloak) {
      const rewritten = rewriteSseBlock(tail, cloakState, cloak);
      if (rewritten !== null) forwardText(`${rewritten}\n\n`);
     } else {
-     forwardText(tail);
+     forwardText(tail.endsWith("\n") ? `${tail}\n` : `${tail}\n\n`);
     }
    } else if (endsOnFinishedSseLine(tail)) {
     // A complete final event that merely lost its trailing blank line: forward

package/src/system-ca-fetch.ts

@@ -13,6 +13,7 @@
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import { execFileSync } from "node:child_process";
+import tls from "node:tls";
 import { randomBytes } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
@@ -163,18 +164,26 @@ function windowsBundle(): string[] {
 
 let systemCaCache: string[] | null = null;
 
+/** Test-only: reset the system CA bundle cache. */
+export function _resetSystemCaCacheForTest(): void {
+ systemCaCache = null;
+}
+
 /** OS trust bundle: platform store plus NODE_EXTRA_CA_CERTS when set. */
-function systemCaBundle(): string[] {
+export function systemCaBundle(): string[] {
  if (systemCaCache) return systemCaCache;
  const extra = nodeExtraCa();
  const platform = process.platform === "win32" ? windowsBundle() : linuxBundle();
  const seen = new Set<string>();
- systemCaCache = [...extra, ...platform].filter((b) => {
+ const combined = [...extra, ...platform].filter((b) => {
   if (seen.has(b)) return false;
   seen.add(b);
   return true;
  });
-  return systemCaCache;
+ if (combined.length > 0) {
+  systemCaCache = combined;
+ }
+ return combined;
 }
 
 function toNodeHeaders(headers: HeadersInit | undefined): Record<string, string> {
@@ -229,9 +238,11 @@ export function requestViaNodeHttp(input: string, init?: RequestInit): Promise<R
  const req = sender(url, {
   method: init?.method ?? "GET",
   headers,
-  ca: bundle.length > 0 ? bundle : undefined,
+  ca: bundle.length > 0 ? [...tls.rootCertificates, ...bundle] : undefined,
   signal: nodeSignal,
  }, (res) => {
+  res.on("error", reject);
+  res.on("aborted", () => reject(new Error("upstream response aborted")));
   const chunks: Buffer[] = [];
   res.on("data", (c: Buffer) => chunks.push(c));
   res.on("end", () => {

package/src/token.ts

@@ -88,9 +88,14 @@ export function tokenAuthHeaders(dataDir?: string): Record<string, string> {
  * accepting unauthenticated traffic.
  */
 export function ensureToken(): string {
- const existing = readToken();
- if (existing) return existing;
  const file = resolveTokenPath();
+ const existing = readToken();
+ if (existing) {
+  try {
+   if (process.platform !== "win32") chmodSync(file, TOKEN_MODE);
+  } catch { }
+  return existing;
+ }
  const token = randomBytes(TOKEN_BYTES).toString("hex");
  try {
   mkdirSync(path.dirname(file), { recursive: true });

package/src/tool-args.ts

@@ -180,6 +180,7 @@ function matchesSchema(value: unknown, schema: Record<string, unknown>, depth: n
  }
  if (type === "string") return typeof value === "string";
  if (type === "number") return typeof value === "number" && Number.isFinite(value);
+ if (type === "integer") return typeof value === "number" && Number.isInteger(value);
  if (type === "boolean") return typeof value === "boolean";
  if (Array.isArray(resolved.enum)) return resolved.enum.some((member) => member === value);
  return true;
@@ -342,7 +343,13 @@ function adoptDeclaredKeys(
   for (const key of unknownKeys) {
    const raw = value[key];
    const want = Array.isArray(raw) ? "array" : raw !== null && typeof raw === "object" ? "object" : typeof raw;
-   const candidates = missing.filter((name) => !taken.has(name) && schemaType(declared[name]) === want);
+   const candidates = missing.filter((name) => {
+    if (taken.has(name)) return false;
+    const st = schemaType(declared[name]);
+    if (st === want) return true;
+    if (st === "integer" && want === "number" && typeof raw === "number" && Number.isInteger(raw)) return true;
+    return false;
+   });
    if (candidates.length !== 1) return null;
    taken.add(candidates[0]);
    targets.set(key, candidates[0]);
@@ -540,14 +547,14 @@ function parseArguments(argsJson: string): { value: Record<string, unknown>; sal
  // (`{"opts":{"a":1` must not salvage to `{"a":1}`).
  for (const start of topLevelObjectStarts(argsJson)) {
   const candidate = argsJson.slice(start);
-  const i = start;
   // Two shapes to try, in order: the candidate as written, then the candidate
   // with its missing closers appended. The closer is only offered at the FIRST
   // brace and only when something precedes it — that fragment is the evidence
   // the model was mid-call and lost the tail. A bare `{"op":"init"` stays
   // refused, and so does an inner `{"phase":…` inside an already-truncated
   // object, which is why this is not offered at every brace.
-  const candidates = i === 0 ? [candidate] : [candidate, appendClosers(candidate)];
+  const hasPreceding = argsJson.slice(0, start).trim().length > 0;
+  const candidates = hasPreceding ? [candidate, appendClosers(candidate)] : [candidate];
   for (const attempt of candidates) {
    if (attempt === undefined) continue;
    try {

package/src/toolcall-audit.ts

@@ -101,6 +101,8 @@ interface CallAcc {
  /** Accumulated arguments, bounded; `bytes` is the unbounded payload size. */
  args: string;
  bytes: number;
+ argsTruncated?: boolean;
+ argsValid?: boolean;
 }
 
 interface StreamState {
@@ -189,6 +191,9 @@ function appendArgs(state: StreamState, call: CallAcc, chunk: string): void {
   MAX_ARGS_CHARS - call.args.length,
   MAX_TURN_ARGS_CHARS - state.argsChars,
  );
+ if (room <= 0 || chunk.length > room) {
+  call.argsTruncated = true;
+ }
  if (room <= 0) return;
  const take = chunk.length > room ? chunk.slice(0, room) : chunk;
  call.args += take;
@@ -203,6 +208,10 @@ function setArgs(state: StreamState, call: CallAcc, args: string): void {
   0,
   Math.min(MAX_ARGS_CHARS, MAX_TURN_ARGS_CHARS - state.argsChars),
  );
+ if (args.length > room) {
+  call.argsTruncated = true;
+  call.argsValid = isArgsObject(args);
+ }
  const take = args.length > room ? args.slice(0, room) : args;
  call.args = take;
  state.argsChars += take.length;
@@ -261,14 +270,18 @@ function observeChat(evt: Record<string, unknown>, state: StreamState): void {
 
 function observeResponses(evt: Record<string, unknown>, state: StreamState): void {
  const type = typeof evt["type"] === "string" ? (evt["type"] as string) : "";
+ const outputIndex = typeof evt["output_index"] === "number" ? (evt["output_index"] as number) : undefined;
  if (type === "response.output_item.added" || type === "response.output_item.done") {
   const item = asRecord(evt["item"]);
   if (!item || item["type"] !== "function_call") return;
   const id = item["id"] !== undefined ? clip(item["id"], MAX_TEXT) : clip(item["call_id"], MAX_TEXT);
-  let call = findById(state.calls, id);
+  const index = outputIndex ?? state.calls.length;
+  let call = findById(state.calls, id) ?? (outputIndex !== undefined ? findByIndex(state.calls, outputIndex, id) : null);
   if (!call) {
-   call = pushCall(state, state.calls.length, id);
+   call = pushCall(state, index, id);
    if (!call) return;
+  } else if (call.id === "" && id !== "") {
+   call.id = id;
   }
   const name = clip(item["name"], MAX_TEXT);
   if (name !== "") call.name = name;
@@ -281,9 +294,9 @@ function observeResponses(evt: Record<string, unknown>, state: StreamState): voi
  }
  if (type === "response.function_call_arguments.delta") {
   const id = clip(evt["item_id"], MAX_TEXT);
-  let call = findById(state.calls, id);
+  let call = findById(state.calls, id) ?? (outputIndex !== undefined ? findByIndex(state.calls, outputIndex, id) : null);
   if (!call) {
-   call = pushCall(state, state.calls.length, id);
+   call = pushCall(state, outputIndex ?? state.calls.length, id);
    if (!call) return;
   }
   if (typeof evt["delta"] === "string") appendArgs(state, call, evt["delta"] as string);
@@ -291,9 +304,9 @@ function observeResponses(evt: Record<string, unknown>, state: StreamState): voi
  }
  if (type === "response.function_call_arguments.done") {
   const id = clip(evt["item_id"], MAX_TEXT);
-  let call = findById(state.calls, id);
+  let call = findById(state.calls, id) ?? (outputIndex !== undefined ? findByIndex(state.calls, outputIndex, id) : null);
   if (!call) {
-   call = pushCall(state, state.calls.length, id);
+   call = pushCall(state, outputIndex ?? state.calls.length, id);
    if (!call) return;
   }
   if (typeof evt["arguments"] === "string") setArgs(state, call, evt["arguments"] as string);
@@ -421,7 +434,7 @@ export function createToolcallRecorder(opts: ToolcallRecorderOptions): ToolcallR
   const calls = state.calls.slice(0, MAX_CALLS).map((call) => ({
    name: clip(call.name, MAX_NAME),
    argsBytes: call.bytes,
-   argsValid: isArgsObject(call.args),
+   argsValid: call.argsValid ?? (call.argsTruncated ? true : isArgsObject(call.args)),
    known: declaredExact.has(call.name),
   }));
   // A body that never carried an event stream says nothing about the model:

package/src/update-checker.ts

@@ -67,20 +67,33 @@ export function setCachedUpdate(latest: string): void {
  }
 }
 
+let inFlightUpdateCheck: Promise<void> | null = null;
+
 export function checkForUpdateInBackground(ui?: ExtensionUIContext | null): void {
  try {
   if (isLinkedInstall()) return;
 
   const cached = getCachedUpdate();
+  const local = getLocalVersion();
   if (
    cached &&
    typeof cached.checkedAt === "number" &&
    Date.now() - cached.checkedAt < UPDATE_CHECK_TTL_MS
   ) {
+   if (local && compareVersions(cached.latest, local) > 0) {
+    try {
+     if (!getActiveRelayState().hideWidget) {
+      const targetUi = ui ?? getStatusUi();
+      targetUi?.setStatus?.("freeflow", `update: ${local} → ${cached.latest}`);
+     }
+    } catch { }
+   }
    return;
   }
 
-  void fetchLatestVersion()
+  if (inFlightUpdateCheck !== null) return;
+
+  inFlightUpdateCheck = fetchLatestVersion()
    .then((latest) => {
     if (!latest) return;
     try {
@@ -119,6 +132,9 @@ export function checkForUpdateInBackground(ui?: ExtensionUIContext | null): void
    })
    .catch(() => {
     // swallow — offline / transient network error
+   })
+   .finally(() => {
+    inFlightUpdateCheck = null;
    });
  } catch {
   // swallow — never throw from background check

package/src/update-core.ts

@@ -252,8 +252,11 @@ export function runUpdateStep(
    // unref is best-effort
   }
   const emit = (d: Buffer): void => {
-   const s = String(d).trim();
-   if (s) opts.onOutput?.(s);
+   const text = String(d);
+   for (const raw of text.split(/\r?\n/)) {
+    const s = raw.trim();
+    if (s) opts.onOutput?.(s);
+   }
   };
   child.stdout?.on("data", emit);
   child.stderr?.on("data", emit);

package/src/updater.ts

@@ -12,7 +12,7 @@
  * spawnSync install (minutes on npm/bun) would freeze the host TUI.
  */
 
-import { spawn, spawnSync } from "node:child_process";
+import { spawn, spawnSync, type ChildProcess } from "node:child_process";
 
 import { getClientPort } from "./client.ts";
 import {
@@ -122,9 +122,14 @@ export function probeCommandsAvailable(cmds: string[]): Promise<boolean[]> {
       resolve(false);
       return;
      }
-     const timer = setTimeout(() => resolve(false), PROBE_TIMEOUT_MS);
+     let child: ChildProcess | undefined;
+     const timer = setTimeout(() => {
+      try { child?.kill(); } catch { }
+      resolve(false);
+     }, PROBE_TIMEOUT_MS);
+     timer.unref?.();
      try {
-      const child = spawn(cmd, ["--version"], {
+      child = spawn(cmd, ["--version"], {
        stdio: "ignore",
        windowsHide: true,
        shell: process.platform === "win32",

package/src/upstream-health.ts

@@ -400,8 +400,28 @@ export function isUnprovenSession(parsedBody: unknown, pathname: string): boolea
  const key = sessionKeyOf(parsedBody);
  if (key && isEstablished(key)) return false;
  if (String(pathname ?? "").includes("responses")) return true;
- const messages = (parsedBody as { messages?: unknown }).messages;
- if (Array.isArray(messages) && messages.length > 1) return false;
+ const messages = typeof parsedBody === "object" && parsedBody !== null && "messages" in parsedBody
+  ? (parsedBody as { messages?: unknown }).messages
+  : undefined;
+ if (Array.isArray(messages)) {
+  const hasPriorTurn = messages.some(
+   (m) =>
+    m !== null &&
+    typeof m === "object" &&
+    "role" in m &&
+    (m.role === "assistant" || m.role === "tool"),
+  );
+  if (hasPriorTurn) return false;
+  const nonSystemCount = messages.filter(
+   (m) =>
+    m !== null &&
+    typeof m === "object" &&
+    "role" in m &&
+    m.role !== "system" &&
+    m.role !== "developer",
+  ).length;
+  if (nonSystemCount > 1) return false;
+ }
  return true;
 }
 

package/src/zen-sidecar.ts

@@ -82,6 +82,7 @@ process.stdout.write(`${JSON.stringify({ status: res.status, headers: out })}\n`
 // A closed stdout means the bridge is gone; stop quietly instead of crashing
 // on EPIPE while the body is still streaming.
 process.stdout.on("error", () => process.exit(0));
+process.stdout.on("close", () => process.exit(0));
 try {
  if (res.body) {
   for await (const c of res.body) {

package/src/zen-transport.ts

@@ -13,6 +13,7 @@
 import { spawn, spawnSync, type ChildProcess } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { Readable } from "node:stream";
 import { ZEN_TRANSPORT_ENV } from "./config.ts";
@@ -132,21 +133,32 @@ export function probeBunVersion(opts: {
  */
 export function findBunOnPath(envPath?: string): string | null {
  const raw = envPath ?? process.env.PATH ?? process.env.Path ?? "";
- if (!raw || typeof raw !== "string") return null;
- const extensions = process.platform === "win32"
-  ? (process.env.PATHEXT ? process.env.PATHEXT.split(";").filter(Boolean) : [".exe", ".cmd", ".bat"])
-  : [""];
- for (const dir of raw.split(path.delimiter).filter(Boolean)) {
-  for (const ext of extensions) {
-   const candidate = ext ? path.join(dir, `bun${ext}`) : path.join(dir, "bun");
-   try {
-    const stat = fs.statSync(candidate);
-    if (!stat.isFile()) continue;
-    if (process.platform !== "win32") fs.accessSync(candidate, fs.constants.X_OK);
-    return candidate;
-   } catch { }
+ if (raw && typeof raw === "string") {
+  const extensions = process.platform === "win32"
+   ? (process.env.PATHEXT ? process.env.PATHEXT.split(";").filter(Boolean) : [".exe", ".cmd", ".bat"])
+   : [""];
+  for (const dir of raw.split(path.delimiter).filter(Boolean)) {
+   for (const ext of extensions) {
+    const candidate = ext ? path.join(dir, `bun${ext}`) : path.join(dir, "bun");
+    try {
+     const stat = fs.statSync(candidate);
+     if (!stat.isFile()) continue;
+     if (process.platform !== "win32") fs.accessSync(candidate, fs.constants.X_OK);
+     return candidate;
+    } catch { }
+   }
   }
  }
+ if (envPath === undefined) {
+  const fallback = path.join(os.homedir(), ".bun", "bin", process.platform === "win32" ? "bun.exe" : "bun");
+  try {
+   const stat = fs.statSync(fallback);
+   if (stat.isFile()) {
+    if (process.platform !== "win32") fs.accessSync(fallback, fs.constants.X_OK);
+    return fallback;
+   }
+  } catch { }
+ }
  return null;
 }
 
@@ -252,11 +264,21 @@ export function fetchZenDirectViaSidecar(
  let stdoutEnded = false;
  const spawnFn = opts.spawnImpl ?? spawn;
  try {
-  child = spawnFn(opts.runtimePath, [...(opts.runtimeArgs ?? []), opts.scriptPath], {
-   stdio: ["pipe", "pipe", "pipe"],
-   windowsHide: true,
-   detached: false,
-  });
+  if (process.platform === "win32" && /\.(?:cmd|bat)$/i.test(opts.runtimePath) && opts.spawnImpl === undefined) {
+   const quotedCmd = `"${opts.runtimePath}" ${[...(opts.runtimeArgs ?? []), opts.scriptPath].map((a) => `"${a}"`).join(" ")}`;
+   child = spawnFn(quotedCmd, [], {
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+    detached: false,
+    shell: true,
+   });
+  } else {
+   child = spawnFn(opts.runtimePath, [...(opts.runtimeArgs ?? []), opts.scriptPath], {
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+    detached: false,
+   });
+  }
  } catch (e) {
   reject(e instanceof Error ? e : new Error(String(e)));
   return promise;
@@ -363,6 +385,14 @@ export function fetchZenDirectViaSidecar(
     // Backpressure: only resume the child pipe when the consumer wants more.
     if (!stdoutEnded) stdout.resume();
    },
+   destroy(err, cb) {
+    finished = true;
+    opts.signal?.removeEventListener("abort", onAbort);
+    try {
+     killZenSidecarTree(proc);
+    } catch { }
+    cb(err);
+   },
   });
   const pushBody = (c: Buffer): void => {
    if (nullBody || stream === null) return;