@linzumi/cli 0.0.74-beta → 0.0.76-beta

package/dist/index.js

@@ -934,6 +934,7 @@ function codexThreadRuntimeOverrides(options) {
     ...session.model === void 0 ? {} : { model: session.model },
     ...session.reasoningEffort === void 0 ? {} : { reasoningEffort: session.reasoningEffort },
     ...options.fast === true ? { serviceTier: "fast" } : {},
+    ...session.codexEnvironmentId === void 0 ? {} : { environmentId: session.codexEnvironmentId },
     approvalPolicy: codexApprovalPolicyForRequest(
       session.approvalPolicy,
       session.sandbox
@@ -948,6 +949,7 @@ function codexTurnRuntimeOverrides(options) {
     ...session.model === void 0 ? {} : { model: session.model },
     ...session.reasoningEffort === void 0 ? {} : { effort: session.reasoningEffort },
     ...options.fast === true ? { serviceTier: "fast" } : {},
+    ...session.codexEnvironmentId === void 0 ? {} : { environmentId: session.codexEnvironmentId },
     approvalPolicy: codexApprovalPolicyForRequest(
       session.approvalPolicy,
       session.sandbox
@@ -3822,6 +3824,14 @@ async function attachChannelSession(args) {
           case "turn/cancelled":
           case "turn/failed":
             if (turnId !== void 0) {
+              clearInterruptedThreadOnlyCompletionForExplicitTerminal(
+                state,
+                threadId,
+                turnId
+              );
+              if (turnTerminalNotificationIsStale(args, state, turnId)) {
+                break;
+              }
               void failActiveCodexTurn(
                 args,
                 state,
@@ -3837,6 +3847,16 @@ async function attachChannelSession(args) {
             }
             break;
           case "turn/completed": {
+            if (turnId !== void 0) {
+              clearInterruptedThreadOnlyCompletionForExplicitTerminal(
+                state,
+                threadId,
+                turnId
+              );
+            }
+            if (turnId !== void 0 && turnTerminalNotificationIsStale(args, state, turnId)) {
+              break;
+            }
             const completedTurnId = turnId ?? inferThreadOnlyCompletedTurnId(args, state, threadId);
             if (completedTurnId !== void 0) {
               enqueueWebSearchProgressCompletion(args, state, completedTurnId);
@@ -4023,7 +4043,9 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     queue: createPendingKandanMessageQueue(),
     forwardedTurnIds: /* @__PURE__ */ new Set(),
     forwardingTurnIds: /* @__PURE__ */ new Set(),
+    completionForwardingTurnIds: /* @__PURE__ */ new Set(),
     recoveredCompletingTurnIds: /* @__PURE__ */ new Set(),
+    pendingInterruptedThreadOnlyCompletions: [],
     retryableTurnIds: /* @__PURE__ */ new Set(),
     completedAssistantItemKeys: /* @__PURE__ */ new Set(),
     completedAssistantItemTurns: createBoundedCache(maxForwardedTurnIds),
@@ -4143,6 +4165,10 @@ async function bindChannelSession(args, state, payloadContext) {
     if (state.rootSeq !== void 0) {
       state.minSeq = Math.max(state.minSeq, state.rootSeq);
     }
+  } else if (session.startCodexThread === true) {
+    state.codexThreadId = await startCodexThread(args.codex, args.options);
+    await hydrateKandanThreadTitleFromThreadContext(args, state);
+    await bindCurrentCodexThread(args, state);
   } else if (state.codexThreadId !== void 0) {
     await hydrateKandanThreadTitleFromThreadContext(args, state);
     await bindCurrentCodexThread(args, state);
@@ -4193,6 +4219,55 @@ async function recoverCompletingCodexTurn(args, state, reason) {
     reason
   });
 }
+async function recoverInterruptedCodexTurn(args, state, threadId, turnId, queuedSeq) {
+  interruptCodexTurnBestEffort(args, threadId, turnId);
+  state.turn = { status: "idle" };
+  clearActiveProcessingState(state, queuedSeq);
+  rememberForwardedTurnId(state, turnId);
+  state.pendingInterruptedThreadOnlyCompletions.push({
+    threadId,
+    interruptedTurnId: turnId,
+    interruptedQueuedSeq: queuedSeq
+  });
+  trimBoundedArray(
+    state.pendingInterruptedThreadOnlyCompletions,
+    maxForwardedTurnIds
+  );
+  forgetRetryableTurnId(state, turnId);
+  forgetLocalTuiTurnId(state, turnId);
+  forgetTurnReplyTarget(state, turnId);
+  rejectPendingApprovalRequestsForTurn(
+    state,
+    turnId,
+    new Error("Codex turn interrupted")
+  );
+  if (state.kandanThreadId !== void 0) {
+    await publishMessageState(
+      args,
+      state.kandanThreadId,
+      queuedSeq,
+      {
+        status: "processed"
+      },
+      void 0,
+      void 0,
+      state.codexThreadId
+    );
+  }
+  await stopCodexTyping(args, state);
+}
+function interruptCodexTurnBestEffort(args, threadId, turnId) {
+  void args.codex.request("turn/interrupt", {
+    threadId,
+    turnId
+  }).catch((error) => {
+    args.log("codex.turn_interrupt_failed", {
+      thread_id: threadId,
+      turn_id: turnId,
+      message: error instanceof Error ? error.message : String(error)
+    });
+  });
+}
 async function handleChannelSessionControl(args, state, payloadContext, control) {
   if (control.type === "update_session_settings") {
     return updateSessionSettings(args, state, payloadContext, control);
@@ -4236,23 +4311,12 @@ async function handleChannelSessionControl(args, state, payloadContext, control)
   }
   switch (state.turn.status) {
     case "active":
-      const interruptedActiveSeq = state.turn.queuedSeq;
-      await args.codex.request("turn/interrupt", {
-        threadId: state.codexThreadId,
-        turnId: state.turn.turnId
-      });
-      state.turn = { status: "idle" };
-      clearActiveProcessingState(state, interruptedActiveSeq);
-      await publishMessageState(
+      await recoverInterruptedCodexTurn(
         args,
-        state.kandanThreadId,
-        interruptedActiveSeq,
-        {
-          status: "processed"
-        },
-        void 0,
-        void 0,
-        state.codexThreadId
+        state,
+        state.codexThreadId,
+        state.turn.turnId,
+        state.turn.queuedSeq
       );
       break;
     case "starting":
@@ -5525,25 +5589,13 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
     rememberTurnReplyTarget(state, turnId, next.seq);
     args.log("codex.turn_started", { turn_id: turnId });
     if (interruptAfterStart) {
-      await args.codex.request("turn/interrupt", {
-        threadId: codexThreadId,
-        turnId
-      });
-      state.turn = { status: "idle" };
-      clearActiveProcessingState(state, next.seq);
-      if (state.kandanThreadId !== void 0) {
-        await publishMessageState(
-          args,
-          state.kandanThreadId,
-          next.seq,
-          {
-            status: "processed"
-          },
-          void 0,
-          void 0,
-          state.codexThreadId
-        );
-      }
+      await recoverInterruptedCodexTurn(
+        args,
+        state,
+        codexThreadId,
+        turnId,
+        next.seq
+      );
       await drainKandanMessageQueue(args, state, payloadContext);
     }
   } catch (error) {
@@ -5783,43 +5835,44 @@ async function forwardCompletedCodexTurn(args, state, turnId, payloadContext) {
   if (isLocalTuiTurn(state, turnId)) {
     ensureKandanThreadForLocalTuiTurn(state);
   }
-  if (state.kandanThreadId === void 0 || state.codexThreadId === void 0 || state.forwardedTurnIds.has(turnId) || state.forwardingTurnIds.has(turnId) || !turnCanForward(state, turnId)) {
+  if (state.kandanThreadId === void 0 || state.codexThreadId === void 0 || state.forwardedTurnIds.has(turnId) || state.forwardingTurnIds.has(turnId) || state.completionForwardingTurnIds.has(turnId) || !turnCanForward(state, turnId)) {
     return;
   }
   const completingQueuedSeq = completingQueuedSeqForTurn(state.turn, turnId);
   const completingActiveTurn = completingQueuedSeq !== void 0;
   const completingLocalTuiTurn = isLocalTuiTurn(state, turnId);
-  if (completingQueuedSeq !== void 0) {
-    state.turn = {
-      status: "completing",
-      turnId,
-      queuedSeq: completingQueuedSeq
-    };
-  }
-  await waitForPendingTuiInputMirror(state, turnId);
-  if (completingTurnWasRecovered(state, turnId)) {
-    return;
-  }
-  await waitForPendingCompletedAssistantItemForwards(state, turnId);
-  if (completingTurnWasRecovered(state, turnId)) {
-    return;
-  }
-  if (completingQueuedSeq !== void 0) {
-    await waitForPendingCompletedAssistantItemSourceForwards(
-      state,
-      completingQueuedSeq
-    );
-  }
-  if (completingTurnWasRecovered(state, turnId)) {
-    return;
-  }
-  await waitForStreamingForwardChains(args, state, payloadContext);
-  if (completingTurnWasRecovered(state, turnId)) {
-    return;
-  }
-  rememberForwardingTurnId(state, turnId);
-  forgetRetryableTurnId(state, turnId);
+  rememberCompletionForwardingTurnId(state, turnId);
   try {
+    if (completingQueuedSeq !== void 0) {
+      state.turn = {
+        status: "completing",
+        turnId,
+        queuedSeq: completingQueuedSeq
+      };
+    }
+    await waitForPendingTuiInputMirror(state, turnId);
+    if (completingTurnWasRecovered(state, turnId)) {
+      return;
+    }
+    await waitForPendingCompletedAssistantItemForwards(state, turnId);
+    if (completingTurnWasRecovered(state, turnId)) {
+      return;
+    }
+    if (completingQueuedSeq !== void 0) {
+      await waitForPendingCompletedAssistantItemSourceForwards(
+        state,
+        completingQueuedSeq
+      );
+    }
+    if (completingTurnWasRecovered(state, turnId)) {
+      return;
+    }
+    await waitForStreamingForwardChains(args, state, payloadContext);
+    if (completingTurnWasRecovered(state, turnId)) {
+      return;
+    }
+    rememberForwardingTurnId(state, turnId);
+    forgetRetryableTurnId(state, turnId);
     const read = await args.codex.request("thread/read", {
       threadId: state.codexThreadId,
       includeTurns: true
@@ -5967,6 +6020,7 @@ async function forwardCompletedCodexTurn(args, state, turnId, payloadContext) {
     rememberRetryableTurnId(state, turnId);
     throw error;
   } finally {
+    forgetCompletionForwardingTurnId(state, turnId);
     forgetForwardingTurnId(state, turnId);
     if (completingActiveTurn && state.turn.status === "completing" && state.turn.turnId === turnId) {
       state.turn = { status: "idle" };
@@ -6157,7 +6211,10 @@ function completedMessagesWithSessionLog(readMessages, sessionLogMessages) {
           }
           nextReadIndex += 1;
         }
-        mergedMessages.push(readMessages[entry.readIndex]);
+        const readMessage = readMessages[entry.readIndex];
+        if (readMessage !== void 0) {
+          mergedMessages.push(readMessage);
+        }
         nextReadIndex = Math.max(nextReadIndex, entry.readIndex + 1);
         break;
       case "session":
@@ -8004,6 +8061,16 @@ function inferThreadOnlyCompletedTurnId(args, state, threadId) {
   switch (state.turn.status) {
     case "active":
     case "completing":
+      clearInterruptedThreadOnlyCompletionsBeforeQueuedSeq(
+        state,
+        threadId,
+        state.turn.queuedSeq
+      );
+      rejectPendingApprovalRequestsForTurn(
+        state,
+        state.turn.turnId,
+        new Error("Codex turn completed with thread-only notification")
+      );
       args.log("codex.turn_completion_inferred", {
         thread_id: threadId,
         turn_id: state.turn.turnId,
@@ -8012,6 +8079,24 @@ function inferThreadOnlyCompletedTurnId(args, state, threadId) {
       });
       return state.turn.turnId;
     case "idle":
+    case "starting":
+      break;
+  }
+  const pending = consumeAmbiguousInterruptedThreadOnlyCompletion(
+    state,
+    threadId
+  );
+  if (pending !== void 0) {
+    args.log("codex.thread_only_completion_after_interrupt_ignored", {
+      thread_id: threadId,
+      interrupted_turn_id: pending.interruptedTurnId,
+      interrupted_queued_seq: pending.interruptedQueuedSeq,
+      turn_status: state.turn.status
+    });
+    return void 0;
+  }
+  switch (state.turn.status) {
+    case "idle":
     case "starting":
       args.log("codex.turn_completion_without_turn_id", {
         thread_id: threadId,
@@ -8021,6 +8106,46 @@ function inferThreadOnlyCompletedTurnId(args, state, threadId) {
       return void 0;
   }
 }
+function consumeAmbiguousInterruptedThreadOnlyCompletion(state, threadId) {
+  const index = state.pendingInterruptedThreadOnlyCompletions.findIndex(
+    (pending2) => pending2.threadId === threadId
+  );
+  if (index < 0) {
+    return void 0;
+  }
+  const [pending] = state.pendingInterruptedThreadOnlyCompletions.splice(
+    index,
+    1
+  );
+  return pending;
+}
+function clearInterruptedThreadOnlyCompletionForExplicitTerminal(state, threadId, turnId) {
+  state.pendingInterruptedThreadOnlyCompletions = state.pendingInterruptedThreadOnlyCompletions.filter((pending) => {
+    if (threadId !== void 0 && pending.threadId !== threadId) {
+      return true;
+    }
+    if (pending.interruptedTurnId === turnId) {
+      return false;
+    }
+    return true;
+  });
+}
+function clearInterruptedThreadOnlyCompletionsBeforeQueuedSeq(state, threadId, queuedSeq) {
+  state.pendingInterruptedThreadOnlyCompletions = state.pendingInterruptedThreadOnlyCompletions.filter(
+    (pending) => pending.threadId !== threadId || pending.interruptedQueuedSeq >= queuedSeq
+  );
+}
+function turnTerminalNotificationIsStale(args, state, turnId) {
+  if (!state.forwardedTurnIds.has(turnId)) {
+    return false;
+  }
+  args.log("codex.stale_turn_terminal_ignored", {
+    turn_id: turnId,
+    active_turn_id: activeTurnId(state.turn) ?? null,
+    turn_status: state.turn.status
+  });
+  return true;
+}
 function codexNotificationActiveTurnFallback(method, state, params, threadId) {
   if (threadId === void 0 || state.codexThreadId !== threadId) {
     return void 0;
@@ -8212,6 +8337,9 @@ function rememberTurnReplyTarget(state, turnId, replyToSeq) {
     replyToSeq
   });
 }
+function forgetTurnReplyTarget(state, turnId) {
+  forgetBoundedCacheValue(state.turnReplyTargets, turnId);
+}
 function sourceMessageSeqForTurn(state, turnId) {
   return getBoundedCacheValue(state.turnReplyTargets, turnId)?.replyToSeq;
 }
@@ -8282,6 +8410,16 @@ function rememberForwardingTurnId(state, turnId) {
 function forgetForwardingTurnId(state, turnId) {
   state.forwardingTurnIds.delete(turnId);
 }
+function rememberCompletionForwardingTurnId(state, turnId) {
+  rememberBoundedStringSet(
+    state.completionForwardingTurnIds,
+    turnId,
+    maxForwardedTurnIds
+  );
+}
+function forgetCompletionForwardingTurnId(state, turnId) {
+  state.completionForwardingTurnIds.delete(turnId);
+}
 function rememberRecoveredCompletingTurnId(state, turnId) {
   rememberBoundedStringSet(
     state.recoveredCompletingTurnIds,
@@ -8321,6 +8459,11 @@ function trimBoundedMap(values, maxSize) {
     values.delete(oldest);
   }
 }
+function trimBoundedArray(values, maxSize) {
+  while (values.length > maxSize) {
+    values.shift();
+  }
+}
 async function stopCodexTyping(args, state) {
   stopCodexTypingHeartbeat(state);
   if (state.kandanThreadId === void 0) {
@@ -9743,6 +9886,7 @@ import {
   spawn
 } from "node:child_process";
 import { createServer } from "node:net";
+import { WebSocket as NodeWebSocket } from "ws";
 async function chooseLoopbackPort() {
   return new Promise((resolve11, reject) => {
     const server = createServer();
@@ -9783,7 +9927,7 @@ async function startCodexAppServerAttempt(codexBin, cwd, options, attempt) {
   });
   const child = spawn(codexBin, args, {
     cwd,
-    env: codexAppServerEnv(options.env),
+    env: codexAppServerEnv(options.env, options.inheritEnv ?? true),
     stdio,
     detached: true
   });
@@ -9870,8 +10014,8 @@ function drainCodexAppServerOutput(child, streamName, onText = void 0) {
     });
   });
 }
-function codexAppServerEnv(overrides) {
-  const env = { ...process.env };
+function codexAppServerEnv(overrides, inheritEnv) {
+  const env = inheritEnv ? { ...process.env } : {};
   for (const key of blockedCodexAppServerEnvKeys) {
     delete env[key];
   }
@@ -9943,8 +10087,11 @@ function codexConfigArgs(options) {
     )
   ];
 }
-async function connectCodexAppServer(websocketUrl, socketFactory = (url) => new WebSocket(url)) {
-  const websocket = socketFactory(websocketUrl);
+async function connectCodexAppServer(websocketUrl, socketFactory = (url) => new NodeWebSocket(url)) {
+  const websocket = await openCodexAppServerWebSocket(
+    websocketUrl,
+    socketFactory
+  );
   const pending = /* @__PURE__ */ new Map();
   const notificationCallbacks = /* @__PURE__ */ new Set();
   const requestCallbacks = /* @__PURE__ */ new Set();
@@ -9994,7 +10141,6 @@ async function connectCodexAppServer(websocketUrl, socketFactory = (url) => new
       }
     }
   });
-  await waitForOpen(websocket);
   await initialize(websocket, pending);
   const request = (method, params) => {
     const id = state.nextId;
@@ -10018,6 +10164,27 @@ async function connectCodexAppServer(websocketUrl, socketFactory = (url) => new
     close: () => websocket.close()
   };
 }
+async function openCodexAppServerWebSocket(websocketUrl, socketFactory, timeoutMs = 2e3) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  while (Date.now() <= deadline) {
+    const websocket = socketFactory(websocketUrl);
+    try {
+      await waitForOpen(websocket);
+      return websocket;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      closeWebSocketAfterFailedOpen(websocket);
+    }
+  }
+  throw lastError ?? new Error("websocket open failed");
+}
+function closeWebSocketAfterFailedOpen(websocket) {
+  try {
+    websocket.close();
+  } catch (_error) {
+  }
+}
 async function respondToServerRequest(websocket, request, callbacks) {
   try {
     if (callbacks.size === 0) {
@@ -10253,21 +10420,62 @@ function codexNotificationConsoleLogPayload(method, params) {
   };
 }
 function codexNotificationConsoleStats(method, params) {
+  const creditExhaustion = creditExhaustionStats(method, params);
   switch (method) {
     case "thread/tokenUsage/updated":
       return {
-        token_usage_summary: tokenUsageSummary(params) ?? "seen (no details)"
+        token_usage_summary: tokenUsageSummary(params) ?? "seen (no details)",
+        ...creditExhaustion
       };
     case "account/rateLimits/updated":
       return {
-        rate_limit_summary: rateLimitSummary(params) ?? "seen (no details)"
+        rate_limit_summary: rateLimitSummary(params) ?? "seen (no details)",
+        ...creditExhaustion
       };
     case "warning":
     case "error":
-      return codexNotificationDiagnosticDetails(method, params);
+      return {
+        ...codexNotificationDiagnosticDetails(method, params),
+        ...creditExhaustion
+      };
     default:
-      return {};
+      return creditExhaustion;
+  }
+}
+function creditExhaustionStats(method, params) {
+  if (!creditExhaustionDetected(method, params)) {
+    return {};
+  }
+  return {
+    credit_exhaustion_detected: true,
+    credit_exhaustion_summary: "OpenAI credits exhausted. Add credits or upgrade the account to continue Codex jobs."
+  };
+}
+function creditExhaustionDetected(method, params) {
+  const haystack = [method, ...diagnosticStrings(params, 0)].join("\n").toLowerCase();
+  return creditExhaustionMatchers.some((matcher) => haystack.includes(matcher));
+}
+function diagnosticStrings(value, depth) {
+  if (depth > 4) {
+    return [];
+  }
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return [String(value)];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => diagnosticStrings(entry, depth + 1));
+  }
+  const object = objectValue4(value);
+  if (object === void 0) {
+    return [];
   }
+  return Object.entries(object).flatMap(([key, entry]) => [
+    key,
+    ...diagnosticStrings(entry, depth + 1)
+  ]);
 }
 function tokenUsageSummary(params) {
   const usage = objectValue4(params.tokenUsage) ?? objectValue4(params.token_usage) ?? objectValue4(params.usage) ?? params;
@@ -10359,11 +10567,19 @@ function integerValue2(value) {
   const parsed = Number.parseInt(value, 10);
   return Number.isSafeInteger(parsed) && parsed.toString() === value.trim() ? parsed : void 0;
 }
+var creditExhaustionMatchers;
 var init_codexNotificationConsoleStats = __esm({
   "src/codexNotificationConsoleStats.ts"() {
     "use strict";
     init_codexNotificationDiagnostics();
     init_protocol();
+    creditExhaustionMatchers = [
+      "insufficient_quota",
+      "quota_exceeded",
+      "billing_hard_limit",
+      "billing hard limit",
+      "credit_exhausted"
+    ];
   }
 });
 
@@ -11266,6 +11482,263 @@ var init_localConfig = __esm({
   }
 });
 
+// src/remoteCodexExecutionContext.ts
+async function handleRemoteCodexExecControl(control, options) {
+  const requestId = normalizedString(control.requestId) ?? null;
+  const cwd = resolveAllowedCwd(control.cwd, options.allowedCwds);
+  if (!cwd.ok) {
+    return {
+      instanceId: options.instanceId,
+      controlType: control.type,
+      requestId,
+      ok: false,
+      error: cwd.reason
+    };
+  }
+  const command = normalizedString(control.command);
+  if (command === void 0) {
+    return {
+      instanceId: options.instanceId,
+      controlType: control.type,
+      requestId,
+      ok: false,
+      error: "command_required"
+    };
+  }
+  const args = normalizedStringList(control.args);
+  if (args === void 0) {
+    return {
+      instanceId: options.instanceId,
+      controlType: control.type,
+      requestId,
+      ok: false,
+      error: "invalid_args"
+    };
+  }
+  const extraEnv = normalizedEnvOverrideMap(control.env);
+  if (extraEnv === void 0) {
+    return {
+      instanceId: options.instanceId,
+      controlType: control.type,
+      requestId,
+      ok: false,
+      error: "invalid_env"
+    };
+  }
+  const timeoutMs = normalizedTimeoutMs(control.timeoutMs);
+  if (timeoutMs === void 0) {
+    return {
+      instanceId: options.instanceId,
+      controlType: control.type,
+      requestId,
+      ok: false,
+      error: "invalid_timeout"
+    };
+  }
+  if (options.sandboxRunner === void 0) {
+    return {
+      instanceId: options.instanceId,
+      controlType: control.type,
+      requestId,
+      ok: false,
+      cwd: cwd.cwd,
+      matchedRoot: cwd.matchedRoot,
+      command,
+      args,
+      error: "remote_codex_exec_sandbox_unavailable"
+    };
+  }
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const result = await runSandboxRunnerWithTimeout(
+      options.sandboxRunner,
+      {
+        command,
+        args,
+        cwd: cwd.cwd,
+        env: remoteExecEnv(options.inheritedEnv ?? process.env, extraEnv),
+        stdin: typeof control.stdin === "string" ? control.stdin : void 0,
+        timeoutMs
+      },
+      options.abortSignal
+    );
+    return {
+      instanceId: options.instanceId,
+      controlType: control.type,
+      requestId,
+      ok: true,
+      cwd: cwd.cwd,
+      matchedRoot: cwd.matchedRoot,
+      command,
+      args,
+      startedAt,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      exitCode: result.exitCode,
+      signal: result.signal,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      stdoutTruncated: result.stdoutTruncated,
+      stderrTruncated: result.stderrTruncated,
+      timedOut: result.timedOut
+    };
+  } catch (error) {
+    return {
+      instanceId: options.instanceId,
+      controlType: control.type,
+      requestId,
+      ok: false,
+      cwd: cwd.cwd,
+      matchedRoot: cwd.matchedRoot,
+      command,
+      args,
+      error: error instanceof Error ? `remote_codex_exec_failed:${error.message}` : "remote_codex_exec_failed"
+    };
+  }
+}
+function runSandboxRunnerWithTimeout(sandboxRunner, request, parentAbortSignal) {
+  const abortController = new AbortController();
+  const timeoutResult = {
+    exitCode: null,
+    signal: null,
+    stdout: "",
+    stderr: "remote_codex_exec_timed_out",
+    stdoutTruncated: false,
+    stderrTruncated: false,
+    timedOut: true
+  };
+  const requestWithSignal = {
+    ...request,
+    abortSignal: abortController.signal
+  };
+  let timeout;
+  let timedOut = false;
+  const onParentAbort = () => {
+    abortController.abort(parentAbortSignal?.reason);
+  };
+  if (parentAbortSignal?.aborted === true) {
+    onParentAbort();
+  } else {
+    parentAbortSignal?.addEventListener("abort", onParentAbort, {
+      once: true
+    });
+  }
+  const runnerPromise = sandboxRunner(requestWithSignal).catch((error) => {
+    if (timedOut) {
+      return timeoutResult;
+    }
+    throw error;
+  });
+  const timeoutPromise = new Promise((resolve11) => {
+    timeout = setTimeout(() => {
+      timedOut = true;
+      resolve11(timeoutResult);
+      abortController.abort();
+    }, request.timeoutMs);
+  });
+  return Promise.race([runnerPromise, timeoutPromise]).finally(() => {
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+    }
+    parentAbortSignal?.removeEventListener("abort", onParentAbort);
+  });
+}
+function remoteExecEnv(inheritedEnv, extraEnv) {
+  return {
+    ...inheritedEnv.PATH === void 0 ? {} : { PATH: inheritedEnv.PATH },
+    ...extraEnv,
+    LINZUMI_REMOTE_CODEX_EXEC: "1"
+  };
+}
+function normalizedString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function normalizedStringList(value) {
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const values = value.flatMap(
+    (entry) => typeof entry === "string" ? [entry] : []
+  );
+  return values.length === value.length ? values : void 0;
+}
+function normalizedEnvOverrideMap(value) {
+  if (value === void 0) {
+    return {};
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  const entries = Object.entries(value).flatMap(([key, entry]) => {
+    if (ignoredEnvOverrideKeys.has(key) && typeof entry === "string") {
+      return [];
+    }
+    if (typeof entry !== "string" || !validEnvKey(key) || reservedEnvKeys.has(key) || deniedEnvKeys.has(key) || deniedEnvPrefixes.some((prefix) => key.startsWith(prefix))) {
+      return [];
+    }
+    return [[key, entry]];
+  });
+  const expectedEntries = Object.entries(value).filter(
+    ([key, entry]) => !(ignoredEnvOverrideKeys.has(key) && typeof entry === "string")
+  );
+  return entries.length === expectedEntries.length ? Object.fromEntries(entries) : void 0;
+}
+function validEnvKey(key) {
+  return /^[A-Z_][A-Z0-9_]*$/.test(key);
+}
+function normalizedTimeoutMs(value) {
+  if (value === void 0) {
+    return defaultTimeoutMs;
+  }
+  if (!Number.isInteger(value) || value <= 0 || value > maxTimeoutMs) {
+    return void 0;
+  }
+  return value;
+}
+var defaultTimeoutMs, maxTimeoutMs, reservedEnvKeys, ignoredEnvOverrideKeys, deniedEnvKeys, deniedEnvPrefixes;
+var init_remoteCodexExecutionContext = __esm({
+  "src/remoteCodexExecutionContext.ts"() {
+    "use strict";
+    init_localCapabilities();
+    defaultTimeoutMs = 12e4;
+    maxTimeoutMs = 3e5;
+    reservedEnvKeys = /* @__PURE__ */ new Set([
+      "HOME",
+      "LINZUMI_REMOTE_CODEX_EXEC",
+      "NODE_OPTIONS",
+      "SHELL",
+      "TMPDIR"
+    ]);
+    ignoredEnvOverrideKeys = /* @__PURE__ */ new Set(["PATH"]);
+    deniedEnvKeys = /* @__PURE__ */ new Set([
+      "BASH_ENV",
+      "ENV",
+      "NODE_PATH",
+      "PERL5LIB",
+      "PYTHONHOME",
+      "PYTHONPATH",
+      "RUBYLIB",
+      "RUBYOPT",
+      "ZDOTDIR"
+    ]);
+    deniedEnvPrefixes = [
+      "AWS_",
+      "DYLD_",
+      "GIT_",
+      "LD_",
+      "NPM_CONFIG_",
+      "OPENAI_",
+      "SSH_"
+    ];
+  }
+});
+
 // src/helloLinzumiProject.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname3, join as join7, resolve as resolve5 } from "node:path";
@@ -13778,14 +14251,17 @@ function codeServerDependencyStatus(args) {
   }) : probeTool(args.codeServerBin, args.cwd);
 }
 function assertStartDependencies(status) {
-  if (!status.node.available) {
+  assertRunnerConnectionDependencies(status);
+  if (!status.codex.available) {
     throw new Error(
-      "Node.js is not available. Install Node.js 20+, then rerun the bootstrap command."
+      `Codex is not available at ${status.codex.command}. Install Codex or pass --codex-bin <path>.`
     );
   }
-  if (!status.codex.available) {
+}
+function assertRunnerConnectionDependencies(status) {
+  if (!status.node.available) {
     throw new Error(
-      `Codex is not available at ${status.codex.command}. Install Codex or pass --codex-bin <path>.`
+      "Node.js is not available. Install Node.js 20+, then rerun the bootstrap command."
     );
   }
   if (status.editorRuntime?.status === "unavailable" || status.codeServer?.available === false && status.codeServer.reason !== "not_configured") {
@@ -14157,7 +14633,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.74-beta";
+    linzumiCliVersion = "0.0.76-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -14175,11 +14651,7 @@ import {
 import { dirname as dirname7, join as join11 } from "node:path";
 function runnerLockPath(machineId, configPath = localConfigPath(), linzumiUrl) {
   const lockName = linzumiUrl === void 0 ? encodeURIComponent(machineId) : localConfigScopeFileStem(linzumiUrl);
-  return join11(
-    dirname7(configPath),
-    "runners",
-    `${lockName}.lock`
-  );
+  return join11(dirname7(configPath), "runners", `${lockName}.lock`);
 }
 function acquireRunnerLock(options) {
   const path2 = runnerLockPath(
@@ -14196,6 +14668,7 @@ function acquireRunnerLock(options) {
     cwd: options.cwd,
     workspace: options.workspace,
     ...options.linzumiUrl === void 0 ? {} : { linzumiUrl: kandanHttpBaseUrl(options.linzumiUrl) },
+    ...options.launchSource === void 0 ? {} : { launchSource: options.launchSource },
     startedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
     cliVersion: options.cliVersion ?? linzumiCliVersion
   };
@@ -14482,12 +14955,16 @@ function updateRunnerConsoleDashboard(state, event, payload, nowMs) {
     case "codex.notification": {
       const tokenUsage = stringValue4(payload.token_usage_summary);
       const rateLimit = stringValue4(payload.rate_limit_summary);
+      const creditExhaustion = stringValue4(payload.credit_exhaustion_summary);
       if (tokenUsage !== void 0) {
         state.tokenUsage = tokenUsage;
       }
       if (rateLimit !== void 0) {
         state.rateLimit = mergeRateLimitSummary(state.rateLimit, rateLimit);
       }
+      if (creditExhaustion !== void 0) {
+        state.creditExhaustion = creditExhaustion;
+      }
       const method = stringValue4(payload.method);
       const metadata = objectValue5(payload.metadata);
       const metadataHasJobSignal = stringValue4(metadata?.threadId) !== void 0 || stringValue4(metadata?.turnId) !== void 0 || stringValue4(metadata?.itemId) !== void 0;
@@ -14499,8 +14976,9 @@ function updateRunnerConsoleDashboard(state, event, payload, nowMs) {
       if (job !== void 0) {
         job.codexThreadId = codexThreadId ?? job.codexThreadId;
         job.tokenUsage = tokenUsage ?? job.tokenUsage;
+        job.creditExhaustion = creditExhaustion ?? job.creditExhaustion;
         job.latestCodexEventId = codexEventId(payload);
-        job.eventType = method ?? event;
+        job.eventType = payload.credit_exhaustion_detected === true ? "credit_exhausted" : method ?? event;
         job.turnId = stringValue4(metadata?.turnId) ?? job.turnId;
         job.updatedAtMs = nowMs;
       }
@@ -14529,7 +15007,7 @@ function updateRunnerConsoleDashboard(state, event, payload, nowMs) {
   rememberRawLine(state, event, payload, previousJobKey);
 }
 function renderRunnerConsoleDashboard(state, nowMs) {
-  if (state.jobs.size === 0 && state.tokenUsage === void 0 && state.rateLimit === void 0) {
+  if (state.jobs.size === 0 && state.tokenUsage === void 0 && state.rateLimit === void 0 && state.creditExhaustion === void 0) {
     return void 0;
   }
   const jobs = dashboardJobs(state);
@@ -14566,6 +15044,7 @@ function renderDashboardTable(state, jobs, nowMs) {
     "Linzumi Commander",
     "",
     `Jobs: ${jobs.length}  Last update: ${timeAgo(state.lastUpdateAtMs, nowMs)}`,
+    ...creditExhaustionBanner(state.creditExhaustion),
     `Overall Token Usage: ${state.tokenUsage ?? "?"}`,
     `Account rate limits: ${state.rateLimit ?? "?"}`,
     "Controls: up/down select | enter raw job | r raw stream | esc table",
@@ -14574,6 +15053,12 @@ function renderDashboardTable(state, jobs, nowMs) {
     ""
   ].join("\n");
 }
+function creditExhaustionBanner(summary) {
+  if (summary === void 0) {
+    return [];
+  }
+  return [`*** ACTION REQUIRED: ${summary} ***`];
+}
 function dashboardTableModel(state, jobs, nowMs) {
   const selectedJobKey = selectedDashboardJobKey(state, jobs);
   const rows = jobs.length === 0 ? [dashboardTableHeader(), emptyJobRow()] : [
@@ -14639,7 +15124,9 @@ function formatRunnerConsoleEvent(event, payload) {
     case "codex.turn_started":
       return `Codex turn started: id=${text(payload.turn_id)}`;
     case "codex.notification": {
+      const creditExhaustion = stringValue4(payload.credit_exhaustion_summary);
       const summary = [
+        creditExhaustion === void 0 ? void 0 : `URGENT ${creditExhaustion}`,
         stringValue4(payload.token_usage_summary),
         stringValue4(payload.rate_limit_summary),
         stringValue4(payload.diagnostic_summary)
@@ -15142,6 +15629,7 @@ function tuiHeaderContent(state, jobCount, nowMs) {
   return [
     "Linzumi Commander",
     `Jobs: ${jobCount}  Last update: ${timeAgo(state.lastUpdateAtMs, nowMs)}`,
+    ...creditExhaustionBanner(state.creditExhaustion),
     `Overall Token Usage: ${state.tokenUsage ?? "?"}`,
     `Account rate limits: ${state.rateLimit ?? "?"}`,
     "Controls: click row/enter raw job | r raw stream | esc/back table | mouse wheel scroll"
@@ -15200,6 +15688,7 @@ function dashboardJobForPayload(state, payload, nowMs) {
     lastAssistantAtMs: void 0,
     latestCodexEventId: void 0,
     eventType: void 0,
+    creditExhaustion: void 0,
     queueDepth: void 0,
     turnId: void 0,
     updatedAtMs: nowMs
@@ -15262,6 +15751,7 @@ function dashboardJobForKey(state, key, nowMs) {
     lastAssistantAtMs: void 0,
     latestCodexEventId: void 0,
     eventType: void 0,
+    creditExhaustion: void 0,
     queueDepth: void 0,
     turnId: void 0,
     updatedAtMs: nowMs
@@ -15410,6 +15900,7 @@ var init_runnerConsoleReporter = __esm({
       selectedJobKey: void 0,
       tokenUsage: void 0,
       rateLimit: void 0,
+      creditExhaustion: void 0,
       lastUpdateAtMs: void 0
     };
     maxRawLines = 500;
@@ -16135,8 +16626,281 @@ var init_signupTaskSuggestions = __esm({
   }
 });
 
+// src/remoteCodexSandboxRunner.ts
+import { spawn as spawn7 } from "node:child_process";
+import { existsSync as existsSync9, realpathSync as realpathSync5 } from "node:fs";
+import { dirname as dirname9, isAbsolute as isAbsolute3 } from "node:path";
+function createConfiguredRemoteCodexSandboxRunner(args) {
+  const kind = normalizedSandboxKind(args.env.LINZUMI_REMOTE_CODEX_SANDBOX);
+  if (kind === void 0) {
+    return void 0;
+  }
+  const sandboxBin = requiredSandboxBin(kind, args.env);
+  switch (kind) {
+    case "bubblewrap":
+      if (args.platform !== "linux") {
+        throw new Error("bubblewrap remote Codex sandbox requires linux");
+      }
+      break;
+    case "macos-seatbelt":
+      if (args.platform !== "darwin") {
+        throw new Error("macos-seatbelt remote Codex sandbox requires darwin");
+      }
+      break;
+  }
+  if (!existsSync9(sandboxBin)) {
+    throw new Error(`remote Codex sandbox binary not found: ${sandboxBin}`);
+  }
+  return createRemoteCodexSandboxRunner({
+    kind,
+    sandboxBin
+  });
+}
+function createRemoteCodexSandboxRunner(config, deps = {}) {
+  const resolvedDeps = {
+    platform: deps.platform ?? process.platform,
+    exists: deps.exists ?? existsSync9,
+    spawnProcess: deps.spawnProcess ?? spawn7
+  };
+  return (request) => runSandboxInvocation(
+    buildRemoteCodexSandboxInvocation(config, request, resolvedDeps),
+    request,
+    resolvedDeps.spawnProcess
+  );
+}
+function buildRemoteCodexSandboxInvocation(config, request, deps) {
+  switch (config.kind) {
+    case "bubblewrap":
+      return {
+        command: config.sandboxBin,
+        args: bubblewrapArgs(config.sandboxBin, request, deps.exists),
+        env: {},
+        cwd: request.cwd
+      };
+    case "macos-seatbelt":
+      return {
+        command: config.sandboxBin,
+        args: [
+          "-p",
+          macosSeatbeltProfile(request, deps.exists),
+          "--",
+          request.command,
+          ...request.args
+        ],
+        env: request.env,
+        cwd: request.cwd
+      };
+  }
+}
+function runSandboxInvocation(invocation, request, spawnProcess) {
+  return new Promise((resolve11, reject) => {
+    const child = spawnProcess(invocation.command, invocation.args, {
+      cwd: invocation.cwd,
+      env: invocation.env,
+      shell: false,
+      stdio: "pipe"
+    });
+    const stdout = createBoundedOutputBuffer();
+    const stderr = createBoundedOutputBuffer();
+    let settled = false;
+    const killChild = () => {
+      child.kill("SIGKILL");
+    };
+    child.stdout.on("data", (chunk) => stdout.append(chunk));
+    child.stderr.on("data", (chunk) => stderr.append(chunk));
+    child.on("error", (error) => {
+      if (!settled) {
+        settled = true;
+        reject(error);
+      }
+    });
+    child.on("close", (exitCode, signal) => {
+      if (!settled) {
+        settled = true;
+        resolve11({
+          exitCode,
+          signal,
+          stdout: stdout.value(),
+          stderr: stderr.value(),
+          stdoutTruncated: stdout.truncated(),
+          stderrTruncated: stderr.truncated(),
+          timedOut: false
+        });
+      }
+    });
+    if (request.abortSignal.aborted) {
+      killChild();
+    } else {
+      request.abortSignal.addEventListener("abort", killChild, { once: true });
+    }
+    child.stdin.end(request.stdin ?? "");
+  });
+}
+function bubblewrapArgs(sandboxBin, request, exists) {
+  const envArgs = Object.entries(request.env).flatMap(([key, value]) => [
+    "--setenv",
+    key,
+    value
+  ]);
+  const readOnlyBindArgs = uniqueStrings2([
+    ...linuxReadOnlyRoots,
+    ...isAbsolute3(request.command) ? [dirname9(request.command)] : [],
+    dirname9(sandboxBin)
+  ]).flatMap((path2) => exists(path2) ? ["--ro-bind", path2, path2] : []);
+  const cwdParentDirs = parentDirs(request.cwd).flatMap((path2) => [
+    "--dir",
+    path2
+  ]);
+  return [
+    "--unshare-all",
+    "--die-with-parent",
+    "--new-session",
+    "--clearenv",
+    ...envArgs,
+    "--tmpfs",
+    "/tmp",
+    "--proc",
+    "/proc",
+    "--dev",
+    "/dev",
+    ...cwdParentDirs,
+    ...readOnlyBindArgs,
+    "--bind",
+    request.cwd,
+    request.cwd,
+    "--chdir",
+    request.cwd,
+    "--",
+    request.command,
+    ...request.args
+  ];
+}
+function macosSeatbeltProfile(request, exists) {
+  const readableRoots = uniqueStrings2([
+    ...macosReadOnlyRoots,
+    ...isAbsolute3(request.command) ? [dirname9(request.command)] : []
+  ]).filter(exists);
+  const readableRules = readableRoots.map((path2) => `(allow file-read* (subpath ${sandboxString(path2)}))`).join("\n");
+  const writableTempRules = macosWritableTempRoots.filter(exists).flatMap((path2) => [
+    `(allow file-read* (subpath ${sandboxString(path2)}))`,
+    `(allow file-write* (subpath ${sandboxString(path2)}))`
+  ]).join("\n");
+  const cwdRules = existingPathAliases(request.cwd).flatMap((path2) => [
+    `(allow file-read* (subpath ${sandboxString(path2)}))`,
+    `(allow file-write* (subpath ${sandboxString(path2)}))`
+  ]).join("\n");
+  return [
+    "(version 1)",
+    "(deny default)",
+    "(allow process*)",
+    "(allow signal (target self))",
+    "(allow sysctl-read)",
+    "(allow file-read-metadata)",
+    '(allow file-read-data (literal "/"))',
+    '(allow file-read* (literal "/dev/null"))',
+    '(allow file-read* (literal "/dev/random"))',
+    '(allow file-read* (literal "/dev/urandom"))',
+    readableRules,
+    writableTempRules,
+    cwdRules
+  ].join("\n");
+}
+function createBoundedOutputBuffer() {
+  let bytes = 0;
+  let output = "";
+  let isTruncated = false;
+  return {
+    append: (chunk) => {
+      const text2 = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk;
+      const remaining = maxCapturedOutputBytes - bytes;
+      if (remaining <= 0) {
+        isTruncated = true;
+        return;
+      }
+      const buffer = Buffer.from(text2, "utf8");
+      if (buffer.byteLength <= remaining) {
+        bytes += buffer.byteLength;
+        output += text2;
+        return;
+      }
+      bytes = maxCapturedOutputBytes;
+      output += buffer.subarray(0, remaining).toString("utf8");
+      isTruncated = true;
+    },
+    value: () => output,
+    truncated: () => isTruncated
+  };
+}
+function normalizedSandboxKind(value) {
+  switch (value) {
+    case void 0:
+    case "":
+      return void 0;
+    case "bubblewrap":
+    case "macos-seatbelt":
+      return value;
+    default:
+      throw new Error(`unsupported remote Codex sandbox: ${value}`);
+  }
+}
+function requiredSandboxBin(kind, env) {
+  const value = env.LINZUMI_REMOTE_CODEX_SANDBOX_BIN;
+  if (value === void 0 || value.trim() === "") {
+    throw new Error(`LINZUMI_REMOTE_CODEX_SANDBOX_BIN is required for ${kind}`);
+  }
+  if (!isAbsolute3(value)) {
+    throw new Error("LINZUMI_REMOTE_CODEX_SANDBOX_BIN must be absolute");
+  }
+  return value;
+}
+function parentDirs(path2) {
+  const parts = path2.split("/").filter((part) => part !== "");
+  const parents = parts.slice(0, -1);
+  return parents.map(
+    (_part, index) => `/${parents.slice(0, index + 1).join("/")}`
+  );
+}
+function uniqueStrings2(values) {
+  return Array.from(new Set(values));
+}
+function existingPathAliases(path2) {
+  return uniqueStrings2([path2, realpathSync5(path2)]);
+}
+function sandboxString(value) {
+  return JSON.stringify(value);
+}
+var maxCapturedOutputBytes, linuxReadOnlyRoots, macosReadOnlyRoots, macosWritableTempRoots;
+var init_remoteCodexSandboxRunner = __esm({
+  "src/remoteCodexSandboxRunner.ts"() {
+    "use strict";
+    maxCapturedOutputBytes = 512 * 1024;
+    linuxReadOnlyRoots = [
+      "/bin",
+      "/etc/pki",
+      "/etc/ssl",
+      "/lib",
+      "/lib64",
+      "/nix/store",
+      "/usr",
+      "/usr/local"
+    ];
+    macosReadOnlyRoots = [
+      "/System",
+      "/Library",
+      "/etc",
+      "/private/etc",
+      "/usr",
+      "/bin",
+      "/sbin",
+      "/opt/homebrew",
+      "/nix/store"
+    ];
+    macosWritableTempRoots = ["/tmp", "/private/tmp"];
+  }
+});
+
 // src/runner.ts
-import { spawn as spawn7, spawnSync as spawnSync4 } from "node:child_process";
+import { spawn as spawn8, spawnSync as spawnSync4 } from "node:child_process";
 import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
 import {
   chmodSync as chmodSync2,
@@ -16144,13 +16908,13 @@ import {
   mkdirSync as mkdirSync9,
   mkdtempSync as mkdtempSync4,
   readdirSync as readdirSync2,
-  realpathSync as realpathSync5,
+  realpathSync as realpathSync6,
   rmSync as rmSync4,
   statSync
 } from "node:fs";
 import { createServer as createServer3 } from "node:http";
 import { hostname as hostname2, tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname9, isAbsolute as isAbsolute3, join as join14, resolve as resolve7 } from "node:path";
+import { dirname as dirname10, isAbsolute as isAbsolute4, join as join14, resolve as resolve7 } from "node:path";
 async function runLocalCodexRunner(options) {
   const log = makeRunnerLogger(options);
   const cleanup = {
@@ -16173,6 +16937,7 @@ async function runLocalCodexRunner(options) {
         cwd: options.cwd,
         workspace: runnerWorkspaceSlug(options) ?? null,
         linzumiUrl: options.kandanUrl,
+        launchSource: options.launchSource,
         configPath: options.runnerLockConfigPath
       });
       cleanup.actions.push(() => runnerLock.release());
@@ -16214,6 +16979,7 @@ async function runThreadCodexWorker(options) {
 }
 async function openLocalCodexRunner(options, log, cleanup, close) {
   const agentProviders = availableRunnerAgentProviders(options);
+  const localCodexAppServerAvailable = hasLocalCodexAppServerCapability(options);
   const allowedForwardPorts = options.allowedForwardPorts ?? [];
   const liveForwardPorts = new Set(allowedForwardPorts);
   const managedForwardPorts = /* @__PURE__ */ new Set();
@@ -16274,6 +17040,11 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   });
   const startupAllowedCwds = normalizeAllowedCwds(options.allowedCwds);
   const allowedCwds = { value: [...startupAllowedCwds] };
+  const remoteCodexSandboxRunner = options.remoteCodexSandboxRunner ?? createConfiguredRemoteCodexSandboxRunner({
+    env: process.env,
+    platform: process.platform
+  });
+  const activeRemoteCodexExecRequests = /* @__PURE__ */ new Map();
   const missingAllowedCwds = {
     value: normalizeAllowedCwds(options.missingAllowedCwds ?? [])
   };
@@ -16290,6 +17061,10 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     queuedCandidates: /* @__PURE__ */ new Map()
   };
   cleanup.actions.push(() => {
+    for (const controller of activeRemoteCodexExecRequests.values()) {
+      controller.abort(new Error("local runner stopped"));
+    }
+    activeRemoteCodexExecRequests.clear();
     if (localEditorState.value.status === "running") {
       localEditorState.value.process.kill("SIGINT");
       localEditorState.value.collaboration?.process.kill("SIGINT");
@@ -16314,8 +17089,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     };
   });
   const capabilitiesPayload = () => ({
-    codexAppServer: true,
-    codexRemoteTui: true,
+    codexAppServer: localCodexAppServerAvailable,
+    codexRemoteTui: localCodexAppServerAvailable,
     agentProviders,
     defaultAgentProvider: "codex",
     startInstance: allowedCwds.value.length > 0,
@@ -16331,6 +17106,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     portForwarding: liveForwardPorts.size > 0,
     tcpForwarding: true,
     linzumiMcp: true,
+    remoteCodexExecution: remoteCodexSandboxRunner !== void 0 && allowedCwds.value.length > 0,
+    remoteCodexExecutionStatus: remoteCodexSandboxRunner === void 0 ? "sandbox_unavailable" : allowedCwds.value.length > 0 ? "ready" : "cwd_unavailable",
     allowedPorts: Array.from(liveForwardPorts).sort(
       (left, right) => left - right
     ),
@@ -16380,18 +17157,15 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const replacedRunners = replacementRunnerSummaries(
     objectValue(joinResponse)?.replaced_runners
   );
-  const started = options.codexUrl === void 0 ? await startOwnedCodexAppServer(options) : void 0;
+  const started = options.codexUrl === void 0 && localCodexAppServerAvailable ? await startOwnedCodexAppServer(options) : void 0;
   if (started !== void 0) {
     cleanup.actions.push(() => {
       started.stop();
     });
   }
   const codexUrl = options.codexUrl ?? started?.url;
-  if (codexUrl === void 0) {
-    throw new Error("missing codex app-server websocket URL");
-  }
   if (started !== void 0) {
-    const appServerPort = explicitUrlPort(codexUrl);
+    const appServerPort = explicitUrlPort(started.url);
     if (appServerPort !== void 0) {
       markCommanderManagedForwardPort(appServerPort, {
         processName: "Codex app-server",
@@ -17081,15 +17855,20 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     };
     void state.exited.then(handleExitAfterInitialStatus);
   };
-  const codex = await connectCodexAppServer(codexUrl);
-  cleanup.actions.push(() => codex.close());
+  const codex = codexUrl === void 0 ? void 0 : await connectCodexAppServer(codexUrl);
+  if (codex !== void 0) {
+    cleanup.actions.push(() => codex.close());
+  }
+  if (options.channelSession !== void 0 && codex === void 0) {
+    throw new Error("channel session requires a Codex app-server connection");
+  }
   const seq = { value: 0 };
   const discoveredCodexThreads = { value: [] };
   const runtimeDefaults = runnerRuntimeDefaults(options);
   const instancePayload = {
     instanceId,
     clientId,
-    codexUrl,
+    ...codexUrl === void 0 ? {} : { codexUrl },
     tuiLaunched: options.launchTui,
     cwd: options.cwd,
     hostname: runnerHost,
@@ -17108,7 +17887,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     workspace: runnerWorkspaceSlug(options) ?? null,
     version: linzumiCliVersion,
     instanceId,
-    codexUrl,
+    codexUrl: codexUrl ?? null,
     replacedRunners
   });
   const channelSession = options.channelSession === void 0 ? void 0 : await attachChannelSession({
@@ -17422,6 +18201,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
             options,
             agentProviders,
             allowedCwds,
+            remoteCodexSandboxRunner,
+            activeRemoteCodexExecRequests,
             activeClaudeCodeSessions,
             pendingClaudeCodeApprovals,
             ensureClaudeCodeForwardPortSession,
@@ -17444,7 +18225,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const heartbeatPayload = () => ({
     instanceId,
     clientId,
-    codexUrl,
+    ...codexUrl === void 0 ? {} : { codexUrl },
     cwd: options.cwd,
     hostname: runnerHost,
     workspace: runnerWorkspaceSlug(options) ?? null,
@@ -17476,10 +18257,13 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   );
   cleanup.actions.push(() => forwardTcp.close());
   const channelCodexThreadId = channelSession?.currentCodexThreadId();
-  if (options.launchTui && channelCodexThreadId !== void 0) {
+  if (options.launchTui && codex === void 0) {
+    throw new Error("Codex TUI requires a Codex app-server connection");
+  }
+  if (options.launchTui && codex !== void 0 && channelCodexThreadId !== void 0) {
     await prepareCodexThreadForTuiResume(codex, channelCodexThreadId);
   }
-  const tui = options.launchTui ? launchCodexTui(
+  const tui = options.launchTui && codexUrl !== void 0 ? launchCodexTui(
     options.codexBin,
     codexUrl,
     options.cwd,
@@ -17492,7 +18276,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       tui.kill("SIGINT");
     });
   }
-  codex.onNotification((notification) => {
+  codex?.onNotification((notification) => {
     seq.value += 1;
     const params = notification.params ?? {};
     const logPayload = codexNotificationConsoleLogPayload(
@@ -17747,6 +18531,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         options,
         agentProviders,
         allowedCwds,
+        remoteCodexSandboxRunner,
+        activeRemoteCodexExecRequests,
         activeClaudeCodeSessions,
         pendingClaudeCodeApprovals,
         ensureClaudeCodeForwardPortSession,
@@ -17831,6 +18617,8 @@ function controlThreadId(control) {
     case "forward_tcp_open":
     case "forward_tcp_send":
     case "forward_tcp_close":
+    case "remote_codex_exec":
+    case "remote_codex_exec_cancel":
     case "update_thread_interaction_access": {
       const threadId = stringValue(control.threadId)?.trim();
       return threadId === void 0 || threadId === "" ? void 0 : threadId;
@@ -17940,9 +18728,15 @@ function replacementRunnerSummaries(value) {
   });
 }
 function makeRunnerLogger(options) {
+  const consoleReporter = options.launchTui && options.consoleReporter === void 0 ? void 0 : (event, payload) => {
+    if (!options.launchTui) {
+      reportRunnerConsoleEvent(event, payload);
+    }
+    options.consoleReporter?.(event, payload);
+  };
   return createRunnerLogger(
     options.logFile ?? defaultRunnerLogFile(),
-    options.launchTui ? void 0 : reportRunnerConsoleEvent
+    consoleReporter
   );
 }
 function installCleanupHandlers(close) {
@@ -17971,7 +18765,7 @@ function launchCodexTui(codexBin, codexUrl, cwd, codexThreadId, session, fast) {
     cwd,
     purpose: "codex.tui"
   });
-  const child = spawn7(codexBin, args, {
+  const child = spawn8(codexBin, args, {
     cwd,
     env: process.env,
     stdio: "inherit"
@@ -18098,7 +18892,29 @@ async function resumeCodexThreadForReconnect(codex, codexThreadId, resumeOverrid
     );
   }
 }
-async function applyControl(codex, kandan, topic, instanceId, options, agentProviders, allowedCwds, activeClaudeCodeSessions, pendingClaudeCodeApprovals, ensureClaudeCodeForwardPortSession, disposeClaudeCodeForwardPortSession, control, log, onStartedThread, onThreadProcessStart) {
+async function applyControl(codex, kandan, topic, instanceId, options, agentProviders, allowedCwds, remoteCodexSandboxRunner, activeRemoteCodexExecRequests, activeClaudeCodeSessions, pendingClaudeCodeApprovals, ensureClaudeCodeForwardPortSession, disposeClaudeCodeForwardPortSession, control, log, onStartedThread, onThreadProcessStart) {
+  if (codex === void 0) {
+    switch (control.type) {
+      case "remote_codex_exec":
+      case "remote_codex_exec_cancel":
+        return await applyRemoteCodexExecControl(
+          control,
+          instanceId,
+          allowedCwds.value,
+          remoteCodexSandboxRunner,
+          activeRemoteCodexExecRequests,
+          log
+        );
+      default:
+        return {
+          instanceId,
+          controlType: control.type,
+          requestId: "requestId" in control ? stringValue(control.requestId) ?? null : null,
+          ok: false,
+          error: "agent_provider_unavailable:codex"
+        };
+    }
+  }
   switch (control.type) {
     case "start_instance": {
       const cwd = resolveAllowedCwd(control.cwd, allowedCwds.value);
@@ -18597,6 +19413,26 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
     case "suggest_tasks": {
       return suggestRunnerTasks(control, options, allowedCwds.value);
     }
+    case "remote_codex_exec": {
+      return await applyRemoteCodexExecControl(
+        control,
+        instanceId,
+        allowedCwds.value,
+        remoteCodexSandboxRunner,
+        activeRemoteCodexExecRequests,
+        log
+      );
+    }
+    case "remote_codex_exec_cancel": {
+      return await applyRemoteCodexExecControl(
+        control,
+        instanceId,
+        allowedCwds.value,
+        remoteCodexSandboxRunner,
+        activeRemoteCodexExecRequests,
+        log
+      );
+    }
     case "start_turn": {
       const response = await codex.request("turn/start", {
         threadId: control.threadId,
@@ -18769,6 +19605,55 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
       return { instanceId, controlType: control.type, skipped: true };
   }
 }
+async function applyRemoteCodexExecControl(control, instanceId, allowedCwds, remoteCodexSandboxRunner, activeRemoteCodexExecRequests, log) {
+  switch (control.type) {
+    case "remote_codex_exec": {
+      const requestId = stringValue(control.requestId)?.trim();
+      const abortController = new AbortController();
+      if (requestId !== void 0 && requestId !== "") {
+        activeRemoteCodexExecRequests.set(requestId, abortController);
+      }
+      const result = await handleRemoteCodexExecControl(control, {
+        instanceId,
+        allowedCwds,
+        sandboxRunner: remoteCodexSandboxRunner,
+        abortSignal: abortController.signal
+      });
+      if (requestId !== void 0 && requestId !== "") {
+        activeRemoteCodexExecRequests.delete(requestId);
+      }
+      log("remote_codex_exec.handled", {
+        requestId: stringValue(control.requestId) ?? null,
+        ok: result.ok === true,
+        error: typeof result.error === "string" ? result.error : null
+      });
+      return result;
+    }
+    case "remote_codex_exec_cancel": {
+      const requestId = stringValue(control.requestId)?.trim();
+      if (requestId === void 0 || requestId === "") {
+        return {
+          instanceId,
+          controlType: control.type,
+          ok: false,
+          error: "request_id_required"
+        };
+      }
+      const activeRequest = activeRemoteCodexExecRequests.get(requestId);
+      if (activeRequest !== void 0) {
+        activeRequest.abort(new Error("remote_codex_exec_cancelled"));
+        activeRemoteCodexExecRequests.delete(requestId);
+      }
+      return {
+        instanceId,
+        controlType: control.type,
+        requestId,
+        ok: true,
+        cancelled: activeRequest !== void 0
+      };
+    }
+  }
+}
 function startInstanceFailureReason(stage, error) {
   const detail = truncateFailureDetail(
     error instanceof Error ? error.message : String(error)
@@ -18901,6 +19786,18 @@ function availableRunnerAgentProviders(options) {
       return ["codex"];
   }
 }
+function hasLocalCodexAppServerCapability(options) {
+  if (options.codexUrl !== void 0) {
+    return true;
+  }
+  switch (options.dependencyStatus?.codex.available) {
+    case false:
+      return false;
+    case true:
+    case void 0:
+      return true;
+  }
+}
 function startInstanceAgentProvider(control) {
   const value = stringValue(control.agentProvider)?.trim();
   switch (value) {
@@ -20362,7 +21259,7 @@ async function spawnLocalThreadRunnerProcess(options) {
     cwd: options.cwd,
     purpose: "linzumi.thread_runner"
   });
-  const child = spawn7(process.execPath, nodeArgs, {
+  const child = spawn8(process.execPath, nodeArgs, {
     cwd: options.cwd,
     env,
     stdio: ["inherit", "inherit", "inherit", "ipc"]
@@ -20477,7 +21374,7 @@ function threadRunnerScriptPath(scriptPath, cwd) {
       "cannot fork thread runner without current CLI script path"
     );
   }
-  return isAbsolute3(scriptPath) ? scriptPath : resolve7(cwd, scriptPath);
+  return isAbsolute4(scriptPath) ? scriptPath : resolve7(cwd, scriptPath);
 }
 function threadRunnerLoaderExecArgv(execArgv, index = 0) {
   const current = execArgv[index];
@@ -20812,7 +21709,7 @@ function configuredAllowedCwds(values, options = {}) {
       if (options.createMissing === true) {
         mkdirSync9(absolutePath, { recursive: true });
       }
-      const realPath = realpathSync5(absolutePath);
+      const realPath = realpathSync6(absolutePath);
       allowedCwds.push(
         ...realPath === absolutePath ? [realPath] : [realPath, absolutePath]
       );
@@ -20859,7 +21756,7 @@ function browseRunnerDirectory(control, options) {
   const requestId = stringValue(control.requestId) ?? null;
   const requestedPath = stringValue(control.path) ?? currentHomeDirectory();
   try {
-    const currentPath = realpathSync5(resolve7(expandUserPath(requestedPath)));
+    const currentPath = realpathSync6(resolve7(expandUserPath(requestedPath)));
     const stats = statSync(currentPath);
     if (!stats.isDirectory()) {
       return {
@@ -20870,7 +21767,7 @@ function browseRunnerDirectory(control, options) {
         error: "not_directory"
       };
     }
-    const parent = dirname9(currentPath);
+    const parent = dirname10(currentPath);
     const entries = readdirSync2(currentPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => visibleRunnerDirectoryEntryName(entry.name)).map((entry) => {
       const path2 = join14(currentPath, entry.name);
       return {
@@ -20982,7 +21879,7 @@ function createRunnerProject(control, options, allowedCwds) {
         error: cleanupError === void 0 ? `git_init_failed:${gitFailure}` : `git_init_cleanup_failed:${cleanupError}`
       };
     }
-    const projectRealPath = realpathSync5(projectPath);
+    const projectRealPath = realpathSync6(projectPath);
     const persistedAllowedCwds = addAllowedCwdForLinzumiUrl(
       projectRealPath,
       options.kandanUrl
@@ -21090,6 +21987,7 @@ var init_runner = __esm({
     init_linzumiContext();
     init_localCapabilities();
     init_localConfig();
+    init_remoteCodexExecutionContext();
     init_helloLinzumiProject();
     init_localForwarding();
     init_localEditor();
@@ -21109,6 +22007,7 @@ var init_runner = __esm({
     init_threadCodexWorkerIpc();
     init_signupTaskSuggestions();
     init_userFacingErrors();
+    init_remoteCodexSandboxRunner();
     THREAD_RUNNER_READY_TIMEOUT_MS = 3e4;
     claudeSessionStoreSequenceHighWater = /* @__PURE__ */ new Map();
     ClaudeCodeOutputPostError = class extends Error {
@@ -21122,9 +22021,9 @@ var init_runner = __esm({
 });
 
 // src/kandanTls.ts
-import { existsSync as existsSync9, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
 import { Agent } from "undici";
-import { WebSocket as WsWebSocket } from "ws";
+import WsWebSocket from "ws";
 function kandanTlsTrustFromEnv() {
   return kandanTlsTrustFromCaFile(process.env.KANDAN_TLS_CA_FILE);
 }
@@ -21133,7 +22032,7 @@ function kandanTlsTrustFromCaFile(caFile) {
     return void 0;
   }
   const trimmed = caFile.trim();
-  if (!existsSync9(trimmed)) {
+  if (!existsSync10(trimmed)) {
     throw new Error(`KANDAN_TLS_CA_FILE does not exist: ${trimmed}`);
   }
   const ca = readFileSync11(trimmed, "utf8");
@@ -39919,7 +40818,7 @@ var init_RemoveFileError = __esm({
 });
 
 // ../../node_modules/@inquirer/external-editor/dist/esm/index.js
-import { spawn as spawn9, spawnSync as spawnSync5 } from "child_process";
+import { spawn as spawn10, spawnSync as spawnSync5 } from "child_process";
 import { readFileSync as readFileSync14, unlinkSync as unlinkSync3, writeFileSync as writeFileSync10 } from "fs";
 import path from "node:path";
 import os from "node:os";
@@ -40075,7 +40974,7 @@ var init_esm5 = __esm({
       }
       launchEditorAsync(callback) {
         try {
-          const editorProcess = spawn9(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
+          const editorProcess = spawn10(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
           editorProcess.on("exit", (code) => {
             this.lastExitStatus = code;
             setImmediate(callback);
@@ -41409,9 +42308,9 @@ __export(signupFlow_exports, {
   signupTaskSuggestionWaitMessageForTest: () => signupTaskSuggestionWaitMessageForTest,
   toggleProjectPickerSelectionForTest: () => toggleProjectPickerSelectionForTest
 });
-import { spawn as spawn10, spawnSync as spawnSync6 } from "node:child_process";
+import { spawn as spawn11, spawnSync as spawnSync6 } from "node:child_process";
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   constants as fsConstants,
   mkdirSync as mkdirSync12,
   mkdtempSync as mkdtempSync5,
@@ -41423,7 +42322,7 @@ import {
 } from "node:fs";
 import { access } from "node:fs/promises";
 import { homedir as homedir12, tmpdir as tmpdir4 } from "node:os";
-import { delimiter as delimiter3, dirname as dirname12, join as join17, resolve as resolve9 } from "node:path";
+import { delimiter as delimiter3, dirname as dirname13, join as join17, resolve as resolve9 } from "node:path";
 import { stdin as defaultStdin, stdout as defaultStdout } from "node:process";
 import { emitKeypressEvents } from "node:readline";
 function signupHelpText() {
@@ -41522,7 +42421,7 @@ function defaultSignupDraftStore(serviceUrl) {
   const path2 = defaultSignupDraftPath(serviceUrl);
   return {
     read: () => {
-      if (!existsSync12(path2)) {
+      if (!existsSync13(path2)) {
         return void 0;
       }
       let parsed;
@@ -41537,7 +42436,7 @@ function defaultSignupDraftStore(serviceUrl) {
       return comparableServiceUrl(parsed.serviceUrl) === comparableServiceUrl(serviceUrl) ? parsed : void 0;
     },
     write: (draft) => {
-      mkdirSync12(dirname12(path2), { recursive: true });
+      mkdirSync12(dirname13(path2), { recursive: true });
       writeFileSync11(path2, `${JSON.stringify(draft, null, 2)}
 `, {
         encoding: "utf8",
@@ -41551,7 +42450,7 @@ function defaultSignupDraftStore(serviceUrl) {
 }
 function defaultSignupDraftPath(serviceUrl) {
   return join17(
-    dirname12(localConfigPath()),
+    dirname13(localConfigPath()),
     `signup-draft.${localConfigScopeFileStem(serviceUrl)}.json`
   );
 }
@@ -41585,7 +42484,7 @@ function defaultSignupTaskCacheStore(serviceUrl) {
           }
         }
       };
-      mkdirSync12(dirname12(path2), { recursive: true });
+      mkdirSync12(dirname13(path2), { recursive: true });
       writeFileSync11(path2, `${JSON.stringify(next, null, 2)}
 `, {
         encoding: "utf8",
@@ -41596,12 +42495,12 @@ function defaultSignupTaskCacheStore(serviceUrl) {
 }
 function defaultSignupTaskCachePath(serviceUrl) {
   return join17(
-    dirname12(localConfigPath()),
+    dirname13(localConfigPath()),
     `signup-task-cache.${localConfigScopeFileStem(serviceUrl)}.json`
   );
 }
 function readSignupTaskCache(path2) {
-  if (!existsSync12(path2)) {
+  if (!existsSync13(path2)) {
     return { version: 1, entries: {} };
   }
   let parsed;
@@ -42916,7 +43815,7 @@ async function openUrlInBrowser(url) {
   }
   const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
   await new Promise((resolve11, reject) => {
-    const child = spawn10(command, args, { stdio: "ignore", detached: true });
+    const child = spawn11(command, args, { stdio: "ignore", detached: true });
     child.once("spawn", () => {
       child.unref();
       resolve11();
@@ -44114,7 +45013,7 @@ function parseTaskSuggestionResponse2(response) {
 }
 function runProcess3(args) {
   return new Promise((resolveProcess, rejectProcess) => {
-    const child = spawn10(args.command, [...args.args], {
+    const child = spawn11(args.command, [...args.args], {
       cwd: args.cwd,
       stdio: ["pipe", "ignore", "pipe"]
     });
@@ -44156,7 +45055,7 @@ function runProcess3(args) {
 }
 function runProcessCapture(args) {
   return new Promise((resolveProcess) => {
-    const child = spawn10(args.command, [...args.args], {
+    const child = spawn11(args.command, [...args.args], {
       cwd: args.cwd,
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -44374,7 +45273,7 @@ function spawnSyncGitOutput(args, cwd) {
 }
 function probeToolWithArgs(command, args, cwd) {
   return new Promise((resolve11) => {
-    const child = spawn10(command, [...args], {
+    const child = spawn11(command, [...args], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -44412,7 +45311,7 @@ async function discoverCodeRoots(homeDir) {
   const candidates = ["src", "code", "projects"].map(
     (name) => join17(homeDir, name)
   );
-  return candidates.filter((path2) => existsSync12(path2)).flatMap((path2) => discoveredProjectNames(path2));
+  return candidates.filter((path2) => existsSync13(path2)).flatMap((path2) => discoveredProjectNames(path2));
 }
 function discoveredProjectNames(root) {
   try {
@@ -44516,25 +45415,25 @@ function looksLikeProject(path2) {
     "pnpm-lock.yaml",
     "yarn.lock",
     "package-lock.json"
-  ].some((name) => existsSync12(join17(path2, name)));
+  ].some((name) => existsSync13(join17(path2, name)));
 }
 function detectProjectLanguage(path2) {
-  if (existsSync12(join17(path2, "pyproject.toml")) || existsSync12(join17(path2, "requirements.txt"))) {
+  if (existsSync13(join17(path2, "pyproject.toml")) || existsSync13(join17(path2, "requirements.txt"))) {
     return "Python";
   }
-  if (existsSync12(join17(path2, "Cargo.toml"))) {
+  if (existsSync13(join17(path2, "Cargo.toml"))) {
     return "Rust";
   }
-  if (existsSync12(join17(path2, "go.mod"))) {
+  if (existsSync13(join17(path2, "go.mod"))) {
     return "Go";
   }
-  if (existsSync12(join17(path2, "mix.exs"))) {
+  if (existsSync13(join17(path2, "mix.exs"))) {
     return "Elixir";
   }
-  if (existsSync12(join17(path2, "tsconfig.json")) || packageJsonMentionsTypeScript(path2)) {
+  if (existsSync13(join17(path2, "tsconfig.json")) || packageJsonMentionsTypeScript(path2)) {
     return "TypeScript";
   }
-  if (existsSync12(join17(path2, "package.json"))) {
+  if (existsSync13(join17(path2, "package.json"))) {
     return "JavaScript";
   }
   return "Project";
@@ -44550,7 +45449,7 @@ function packageJsonMentionsTypeScript(path2) {
   }
 }
 function hasGitMetadata(path2) {
-  return existsSync12(join17(path2, ".git"));
+  return existsSync13(join17(path2, ".git"));
 }
 function childDirectories(root) {
   try {
@@ -44672,7 +45571,7 @@ secure mission control for all your agents on your computers
 init_runner();
 init_claudeCodeSession();
 init_authCache();
-import { existsSync as existsSync13, readFileSync as readFileSync16, realpathSync as realpathSync6 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync16, realpathSync as realpathSync7 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
 import { resolve as resolve10 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
@@ -44734,8 +45633,8 @@ init_kandanTls();
 init_protocol();
 init_json();
 init_defaultUrls();
-import { existsSync as existsSync10, mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname10, join as join15 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname11, join as join15 } from "node:path";
 import { homedir as homedir10 } from "node:os";
 async function runAgentCliCommand(args, deps = {
   fetchImpl: fetch,
@@ -45453,10 +46352,10 @@ function authorizationHeaders(token) {
   return { authorization: `Bearer ${token}` };
 }
 function readOptionalTextFile(path2) {
-  return existsSync10(path2) ? readFileSync12(path2, "utf8") : void 0;
+  return existsSync11(path2) ? readFileSync12(path2, "utf8") : void 0;
 }
 function writeTextFile(path2, content) {
-  mkdirSync10(dirname10(path2), { recursive: true });
+  mkdirSync10(dirname11(path2), { recursive: true });
   writeFileSync8(path2, content);
 }
 function readStoredAgentTokenFile(path2, readTextFile = readOptionalTextFile) {
@@ -45544,7 +46443,7 @@ init_helloLinzumiProject();
 // src/commanderDaemon.ts
 init_runnerLogger();
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   closeSync as closeSync2,
   mkdirSync as mkdirSync11,
   openSync as openSync3,
@@ -45553,8 +46452,8 @@ import {
   writeFileSync as writeFileSync9
 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
-import { dirname as dirname11, join as join16, resolve as resolve8 } from "node:path";
-import { execFileSync, spawn as spawn8 } from "node:child_process";
+import { dirname as dirname12, join as join16, resolve as resolve8 } from "node:path";
+import { execFileSync, spawn as spawn9 } from "node:child_process";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var connectedMarkers = ["Connected to Linzumi", "Runner connected:"];
 function commanderStatusDir() {
@@ -45586,7 +46485,7 @@ function startCommanderDaemon(options) {
     logFile
   ];
   mkdirSync11(statusDir, { recursive: true });
-  mkdirSync11(dirname11(logFile), { recursive: true });
+  mkdirSync11(dirname12(logFile), { recursive: true });
   const out = openSync3(logFile, "a");
   const err = openSync3(logFile, "a");
   writeCliAuditEvent(
@@ -45599,7 +46498,7 @@ function startCommanderDaemon(options) {
     },
     { sessionId: options.runnerId }
   );
-  const child = (options.spawnImpl ?? spawn8)(nodeBin, command, {
+  const child = (options.spawnImpl ?? spawn9)(nodeBin, command, {
     detached: true,
     stdio: ["ignore", out, err],
     env: process.env
@@ -45638,7 +46537,7 @@ function startCommanderDaemon(options) {
 }
 function commanderDaemonStatus(runnerId, statusDir = commanderStatusDir(), processIdentityReader = readProcessIdentity) {
   const statusFile = commanderStatusFile(runnerId, statusDir);
-  if (!existsSync11(statusFile)) {
+  if (!existsSync12(statusFile)) {
     return { status: "missing", runnerId, statusFile };
   }
   const record = parseRecord(readFileSync13(statusFile, "utf8"));
@@ -45646,7 +46545,7 @@ function commanderDaemonStatus(runnerId, statusDir = commanderStatusDir(), proce
 }
 async function waitForCommanderDaemon(options) {
   const now = options.now ?? (() => Date.now());
-  const readTextFile = options.readTextFile ?? ((path2) => existsSync11(path2) ? readFileSync13(path2, "utf8") : void 0);
+  const readTextFile = options.readTextFile ?? ((path2) => existsSync12(path2) ? readFileSync13(path2, "utf8") : void 0);
   const statusImpl = options.statusImpl ?? commanderDaemonStatus;
   const deadline = now() + options.timeoutMs;
   while (now() <= deadline) {
@@ -57610,6 +58509,8 @@ function createLinzumiMcpApiClient(options) {
     sendChannelMessage: (params) => request("POST", `${apiPrefix}/channel-message`, params),
     prepareMessageUploads: (params) => request("POST", `${apiPrefix}/message-uploads/prepare`, params),
     attachMessageFiles: (params) => request("POST", `${apiPrefix}/message-files/attach`, params),
+    prepareCustomEmoji: (params) => request("POST", `${apiPrefix}/custom-emoji/prepare`, params),
+    renameCustomEmoji: (params) => request("POST", `${apiPrefix}/custom-emoji/rename`, params),
     sendThreadReply: (params) => request("POST", `${apiPrefix}/thread-reply`, params),
     sendDm: (params) => request("POST", `${apiPrefix}/dm`, params),
     dmOwner: (params) => request("POST", `${apiPrefix}/dm-owner`, params),
@@ -57620,6 +58521,17 @@ function createLinzumiMcpApiClient(options) {
 // src/mcpServer.ts
 init_mcpConfig();
 init_oauth();
+init_protocol();
+var maxCustomEmojiNameLength = 64;
+function normalizeCustomEmojiNameForSchema(value) {
+  return value.trim().replace(/^:+/, "").replace(/:+$/, "").toLowerCase();
+}
+var customEmojiNameSchema = external_exports2.string().min(1).refine(
+  (value) => normalizeCustomEmojiNameForSchema(value).length <= maxCustomEmojiNameLength,
+  {
+    message: `Custom emoji shortcode name must be at most ${maxCustomEmojiNameLength} characters after trimming surrounding colons.`
+  }
+);
 var mcpFlagDefinitions = /* @__PURE__ */ new Map([
   ["api-url", { kind: "value" }],
   ["token", { kind: "value" }],
@@ -57680,6 +58592,10 @@ Tools:
   linzumi_dm_owner      Send a plain-text DM to the configured owner username.
   linzumi_get_vault_values
                         Request approved named vault values for a thread.
+  linzumi_upload_custom_emoji
+                        Upload a local image as a workspace custom emoji.
+  linzumi_rename_custom_emoji
+                        Rename an existing workspace custom emoji.
 
 Auth:
   Uses --token, LINZUMI_MCP_ACCESS_TOKEN, or cached local runner OAuth from linzumi auth.
@@ -57801,6 +58717,43 @@ async function runMcpServer(args) {
     {},
     async (params) => mcpJsonResult(await client.listVaultSecrets(params))
   );
+  server.tool(
+    "linzumi_upload_custom_emoji",
+    "Upload a local image as a workspace custom emoji. For generated emoji art, create a transparent PNG with a simple centered subject, crisp edges, strong contrast, minimal tiny details, and enough outline/highlight separation to read at 16-24px on both dark and light backgrounds. Use lowercase shortcode names without colons unless preserving a user-provided :name:.",
+    {
+      name: customEmojiNameSchema.describe(
+        "Custom emoji shortcode name, with or without surrounding colons."
+      ),
+      file: external_exports2.string().min(1).describe(
+        "Local PNG/WebP/GIF/JPEG file path to upload. Prefer transparent PNG for generated emoji."
+      ),
+      workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope.")
+    },
+    async (params) => mcpJsonResult(
+      await uploadCustomEmojiWithClient({
+        client,
+        cwd,
+        kandanUrl,
+        name: params.name,
+        file: params.file,
+        workspace: params.workspace
+      })
+    )
+  );
+  server.tool(
+    "linzumi_rename_custom_emoji",
+    "Rename an existing workspace custom emoji. The new name may include surrounding colons; Linzumi stores the normalized shortcode without colons.",
+    {
+      emoji_id: external_exports2.union([external_exports2.string(), external_exports2.number().int().positive()]).describe(
+        "Workspace custom emoji id returned by linzumi_upload_custom_emoji or workspace emoji listings."
+      ),
+      name: customEmojiNameSchema.describe(
+        "New shortcode name, with or without surrounding colons."
+      ),
+      workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope.")
+    },
+    async (params) => mcpJsonResult(await client.renameCustomEmoji(params))
+  );
   server.tool(
     "linzumi_dm_owner",
     "Send a plain-text DM to the configured Commander owner. Requires dm.write and a visible owner username.",
@@ -57936,6 +58889,69 @@ async function uploadFilesWithClient(args) {
     uploaded_file_ids: uploadedFileIds
   });
 }
+async function uploadCustomEmojiWithClient(args) {
+  const file = await commanderUploadFileForPath(args.cwd, args.file);
+  const prepare = await args.client.prepareCustomEmoji({
+    ...args.workspace === void 0 ? {} : { workspace: args.workspace },
+    name: args.name,
+    file_name: file.fileName,
+    content_type: file.contentType,
+    size_bytes: file.sizeBytes
+  });
+  const upload = objectValue(prepare.upload);
+  const uploadUrl = stringValue(upload?.upload_url);
+  const uploadMethod = stringValue(upload?.upload_method) ?? "PUT";
+  if (uploadUrl === void 0) {
+    throw new Error("Linzumi custom emoji prepare response missing upload_url");
+  }
+  const bytes = await readFile2(file.path);
+  const uploadBody = bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  );
+  const response = await fetch(
+    resolveLinzumiUploadUrl(args.kandanUrl, uploadUrl),
+    {
+      method: uploadMethod,
+      headers: { "content-type": file.contentType },
+      body: uploadBody
+    }
+  );
+  if (!response.ok) {
+    const fallbackError = `${response.status} ${response.statusText}`;
+    const responseText = await response.text();
+    const trimmedResponseText = responseText.trim();
+    const error = trimmedResponseText === "" ? fallbackError : (() => {
+      try {
+        const parsedError = JSON.parse(trimmedResponseText);
+        return isJsonObject(parsedError) && typeof parsedError.error === "string" ? parsedError.error : trimmedResponseText;
+      } catch {
+        return trimmedResponseText;
+      }
+    })();
+    throw new Error(`Linzumi custom emoji upload failed: ${error}`);
+  }
+  const parsed = await response.json();
+  if (!isJsonObject(parsed)) {
+    throw new Error("Linzumi custom emoji upload returned non-object JSON");
+  }
+  const emoji = objectValue(parsed.custom_emoji);
+  if (emoji === void 0) {
+    throw new Error(
+      "Linzumi custom emoji upload response missing custom_emoji"
+    );
+  }
+  return {
+    ok: true,
+    workspace: prepare.workspace,
+    emoji,
+    asset_id: stringValue(parsed.asset_id),
+    id: integerValue(emoji?.id),
+    name: stringValue(emoji?.name),
+    shortcode: stringValue(emoji?.shortcode),
+    image_url: stringValue(emoji?.image_url)
+  };
+}
 function targetWithDefaultThread(target, defaultThreadId) {
   const existingThreadId = stringValue(target.thread_id);
   if (existingThreadId !== void 0 || defaultThreadId === void 0) {
@@ -58124,6 +59140,338 @@ function required(values, key) {
   return value;
 }
 
+// src/remoteCodexHarnessWorker.ts
+init_channelSession();
+init_codexAppServer();
+init_phoenix();
+init_runnerLogger();
+init_userFacingErrors();
+init_version();
+var configEnvKey = "LINZUMI_REMOTE_CODEX_HARNESS_CONFIG_B64";
+var remoteHarnessEnvironmentId = "linzumi-remote-codex-harness";
+async function runRemoteCodexHarnessWorkerFromEnv(env = process.env) {
+  await runRemoteCodexHarnessWorker(remoteCodexHarnessWorkerConfigFromEnv(env));
+}
+async function runRemoteCodexHarnessWorker(config, deps = {}) {
+  const resolvedDeps = {
+    startCodexAppServer,
+    connectCodexAppServer,
+    connectPhoenixClient,
+    attachChannelSession,
+    waitUntilShutdown: defaultWaitUntilShutdown,
+    writeStdout: (chunk) => process.stdout.write(chunk),
+    log: writeCliAuditEvent,
+    ...deps
+  };
+  const started = await resolvedDeps.startCodexAppServer(
+    config.codexBin,
+    config.workerCwd,
+    {
+      model: config.model,
+      reasoningEffort: config.reasoningEffort,
+      fast: config.fast,
+      inheritEnv: false,
+      env: remoteHarnessCodexEnv(process.env, config.execServerUrl)
+    }
+  );
+  let kandan;
+  let codex;
+  let session;
+  const cleanup = async () => {
+    await session?.close();
+    codex?.close();
+    kandan?.close();
+    started.stop();
+  };
+  const cleanupOnce = onceAsync(cleanup);
+  try {
+    codex = await resolvedDeps.connectCodexAppServer(started.url);
+    await registerExecServerEnvironment(codex, config.execServerUrl);
+    kandan = await resolvedDeps.connectPhoenixClient(
+      config.kandanUrl,
+      config.token
+    );
+    const runnerTopic = `local_runner:${config.runnerId}`;
+    const runnerJoinPayload = () => remoteHarnessRunnerJoinPayload(config);
+    const pendingControls = [];
+    const controlDispatcher = { value: void 0 };
+    kandan.onControl((control) => {
+      const dispatcher = controlDispatcher.value;
+      if (dispatcher === void 0) {
+        pendingControls.push(control);
+        return;
+      }
+      dispatcher(control);
+    });
+    await kandan.join(runnerTopic, runnerJoinPayload(), {
+      rejoinPayload: runnerJoinPayload
+    });
+    session = await resolvedDeps.attachChannelSession({
+      kandan,
+      codex,
+      topic: runnerTopic,
+      instanceId: config.instanceId,
+      options: {
+        kandanUrl: config.kandanUrl,
+        token: config.token,
+        runnerId: config.runnerId,
+        cwd: config.cwd,
+        codexBin: config.codexBin,
+        fast: config.fast,
+        launchTui: false,
+        enablePortForwardWatch: false,
+        channelSession: {
+          workspaceSlug: config.workspaceSlug,
+          channelSlug: config.channelSlug,
+          kandanThreadId: config.kandanThreadId,
+          rootSeq: config.rootSeq,
+          startCodexThread: true,
+          linzumiContext: config.linzumiContext,
+          listenUser: config.listenUser,
+          model: config.model,
+          reasoningEffort: config.reasoningEffort,
+          sandbox: config.sandbox,
+          approvalPolicy: config.approvalPolicy,
+          codexEnvironmentId: remoteHarnessEnvironmentId,
+          allowPortForwardingByDefault: config.allowPortForwardingByDefault
+        }
+      },
+      log: resolvedDeps.log
+    });
+    kandan.onReconnect(() => session?.handleKandanReconnect());
+    const dispatchControl = (control) => {
+      const liveSession = session;
+      const liveKandan = kandan;
+      if (liveSession === void 0 || liveKandan === void 0) {
+        pendingControls.push(control);
+        return;
+      }
+      void liveSession.handleControl(control).then(
+        (response) => response === void 0 ? void 0 : liveKandan.push(runnerTopic, "codex_response", response)
+      ).catch(
+        (error) => liveKandan.push(runnerTopic, "codex_error", {
+          instanceId: config.instanceId,
+          message: runnerActionErrorMessage(error)
+        })
+      ).catch((error) => {
+        resolvedDeps.log("remote_codex_harness.control_push_failed", {
+          message: error instanceof Error ? error.message : String(error)
+        });
+      });
+    };
+    controlDispatcher.value = dispatchControl;
+    pendingControls.splice(0).forEach(dispatchControl);
+    codex.onNotification((notification) => {
+      const params = notification.params ?? {};
+      session?.handleCodexNotification(notification.method, params);
+    });
+    await session.startThreadMessageTurn({
+      seq: config.sourceSeq,
+      body: config.workDescription
+    });
+    resolvedDeps.writeStdout(
+      `LINZUMI_REMOTE_CODEX_HARNESS_READY ${config.readyToken}
+`
+    );
+    const stopReason = await Promise.race([
+      resolvedDeps.waitUntilShutdown(cleanupOnce).then(() => ({ type: "shutdown" })),
+      waitForCodexAppServerExit(started.process).then((exit) => ({
+        type: "codex_exit",
+        exit
+      }))
+    ]);
+    if (stopReason.type === "codex_exit") {
+      resolvedDeps.log("remote_codex_harness.codex_app_server_exited", {
+        code: stopReason.exit.code,
+        signal: stopReason.exit.signal
+      });
+      await cleanupOnce();
+    }
+  } catch (error) {
+    await cleanupOnce();
+    throw error;
+  }
+}
+function remoteCodexHarnessWorkerConfigFromEnv(env) {
+  const encoded = env[configEnvKey];
+  if (encoded === void 0 || encoded.trim() === "") {
+    throw new Error(`${configEnvKey} is required`);
+  }
+  return remoteCodexHarnessWorkerConfigFromJson(
+    JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"))
+  );
+}
+function remoteCodexHarnessWorkerConfigFromJson(value) {
+  const input = requireObject(value);
+  const config = {
+    kandanUrl: requiredString2(input, "kandanUrl"),
+    token: requiredString2(input, "token"),
+    runnerId: requiredString2(input, "runnerId"),
+    instanceId: requiredString2(input, "instanceId"),
+    workspaceSlug: requiredString2(input, "workspaceSlug"),
+    channelSlug: requiredString2(input, "channelSlug"),
+    kandanThreadId: requiredString2(input, "kandanThreadId"),
+    rootSeq: requiredPositiveInteger(input, "rootSeq"),
+    sourceSeq: requiredPositiveInteger(input, "sourceSeq"),
+    cwd: requiredString2(input, "cwd"),
+    workerCwd: requiredString2(input, "workerCwd"),
+    workDescription: requiredString2(input, "workDescription"),
+    readyToken: requiredString2(input, "readyToken"),
+    codexBin: requiredString2(input, "codexBin"),
+    execServerUrl: requiredString2(input, "execServerUrl"),
+    listenUser: requiredString2(input, "listenUser"),
+    ...optionalStringField(input, "model"),
+    ...optionalStringField(input, "reasoningEffort"),
+    ...optionalStringField(input, "approvalPolicy"),
+    ...optionalStringField(input, "sandbox"),
+    ...optionalBooleanField(input, "fast"),
+    ...optionalBooleanField(input, "allowPortForwardingByDefault"),
+    ...optionalObjectField(input, "linzumiContext")
+  };
+  return config;
+}
+async function registerExecServerEnvironment(codex, execServerUrl) {
+  const response = await codex.request("environment/add", {
+    environmentId: remoteHarnessEnvironmentId,
+    execServerUrl
+  });
+  assertJsonRpcOk(response, "environment/add");
+}
+function assertJsonRpcOk(response, method) {
+  if ("error" in response) {
+    throw new Error(`${method} failed: ${response.error.message}`);
+  }
+}
+function remoteHarnessCodexEnv(sourceEnv, execServerUrl) {
+  const env = {
+    CODEX_EXEC_SERVER_URL: execServerUrl,
+    LINZUMI_REMOTE_CODEX_HARNESS: "1"
+  };
+  for (const key of remoteHarnessCodexEnvAllowlist) {
+    const value = sourceEnv[key];
+    if (value !== void 0 && value.trim() !== "") {
+      env[key] = value;
+    }
+  }
+  return env;
+}
+var remoteHarnessCodexEnvAllowlist = [
+  "PATH",
+  "HOME",
+  "TMPDIR",
+  "SHELL",
+  "USER",
+  "LOGNAME",
+  "CODEX_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "SSL_CERT_FILE",
+  "NIX_SSL_CERT_FILE",
+  "NODE_EXTRA_CA_CERTS"
+];
+function remoteHarnessRunnerJoinPayload(config) {
+  return {
+    clientName: "kandan-remote-codex-harness-worker",
+    clientId: config.instanceId,
+    connectionMode: "session_worker",
+    runnerPid: process.pid,
+    version: linzumiCliVersion,
+    cwd: config.cwd,
+    workspace: config.workspaceSlug,
+    channel: config.channelSlug,
+    capabilities: {
+      codexAppServer: true,
+      defaultAgentProvider: "codex",
+      agentProviders: ["codex"],
+      remoteCodexExecution: false,
+      allowedCwdSuggestions: [],
+      allowedCwdProjects: [],
+      portForwarding: false,
+      tcpForwarding: false,
+      linzumiMcp: true
+    }
+  };
+}
+function defaultWaitUntilShutdown(cleanup) {
+  return new Promise((resolve11, reject) => {
+    const finish = () => {
+      cleanup().then(resolve11, reject);
+    };
+    process.once("SIGINT", finish);
+    process.once("SIGTERM", finish);
+  });
+}
+function onceAsync(fn) {
+  let promise;
+  return () => {
+    promise = promise ?? fn();
+    return promise;
+  };
+}
+function waitForCodexAppServerExit(child) {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return Promise.resolve({
+      code: child.exitCode,
+      signal: child.signalCode
+    });
+  }
+  return new Promise((resolve11) => {
+    child.once("exit", (code, signal) => {
+      resolve11({ code, signal });
+    });
+  });
+}
+function requireObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("remote Codex harness worker config must be an object");
+  }
+  return value;
+}
+function requiredString2(input, key) {
+  const value = input[key];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`remote Codex harness worker config missing ${key}`);
+  }
+  return value;
+}
+function requiredPositiveInteger(input, key) {
+  const value = input[key];
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`remote Codex harness worker config missing ${key}`);
+  }
+  return value;
+}
+function optionalStringField(input, key) {
+  const value = input[key];
+  if (value === void 0) {
+    return {};
+  }
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`remote Codex harness worker config invalid ${key}`);
+  }
+  return { [key]: value };
+}
+function optionalBooleanField(input, key) {
+  const value = input[key];
+  if (value === void 0) {
+    return {};
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`remote Codex harness worker config invalid ${key}`);
+  }
+  return { [key]: value };
+}
+function optionalObjectField(input, key) {
+  const value = input[key];
+  if (value === void 0) {
+    return {};
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`remote Codex harness worker config invalid ${key}`);
+  }
+  return { [key]: value };
+}
+
 // src/index.ts
 init_userFacingErrors();
 var flagDefinitions = /* @__PURE__ */ new Map([
@@ -58250,6 +59598,9 @@ async function main(args) {
     case "commanderDaemon":
       await runCommanderDaemonCommand(parsed.args);
       return;
+    case "remoteCodexHarnessWorker":
+      await runRemoteCodexHarnessWorkerFromEnv();
+      return;
     case "agentRunner": {
       const options = await parseAgentRunnerArgs(parsed.args);
       await runLocalCodexRunner(withLocalMachineId(options));
@@ -58301,6 +59652,8 @@ function parseCommand(args) {
       return ["daemon", "status", "wait", "stop"].includes(rest[0] ?? "") ? { command: "commanderDaemon", args: rest } : { command: "agentRunner", args: rest };
     case "commander-daemon":
       return { command: "commanderDaemon", args: ["daemon", ...rest] };
+    case "remote-codex-harness-worker":
+      return { command: "remoteCodexHarnessWorker", args: rest };
     case "commander-status":
       return { command: "commanderDaemon", args: ["status", ...rest] };
     case "commander-wait":
@@ -58397,7 +59750,7 @@ function runPathsCommand(args) {
       if (pathValue === void 0 || pathValue.trim() === "") {
         throw new Error("missing path for linzumi paths add");
       }
-      const trustedPath = realpathSync6(resolve10(expandUserPath(pathValue)));
+      const trustedPath = realpathSync7(resolve10(expandUserPath(pathValue)));
       if (linzumiUrl === void 0) {
         addAllowedCwd(pathValue);
       } else {
@@ -58606,7 +59959,7 @@ async function parseStartRunnerArgs(args, deps = {
     codexBin: requestedCodexBin,
     codeServerBin: customCodeServerBin
   });
-  assertStartDependencies(initialDependencyStatus);
+  assertRunnerConnectionDependencies(initialDependencyStatus);
   const codexBin = initialDependencyStatus.codex.command;
   const explicitToken = stringValue7(values, "token");
   const authFilePath = stringValue7(values, "auth-file");
@@ -58652,7 +60005,7 @@ async function parseStartRunnerArgs(args, deps = {
     codeServerBin: editorRuntime.codeServerBin,
     editorRuntime: editorRuntime.status
   });
-  assertStartDependencies(dependencyStatus);
+  assertRunnerConnectionDependencies(dependencyStatus);
   const claudeCodeAvailable = await resolveClaudeCodeAvailability(deps, cwd);
   return {
     kandanUrl,
@@ -58664,6 +60017,7 @@ async function parseStartRunnerArgs(args, deps = {
     cwd,
     codexBin,
     codexUrl: stringValue7(values, "codex-url"),
+    launchSource: electronAutoConnectLaunchSource(),
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
     logFile: stringValue7(values, "log-file"),
@@ -58741,7 +60095,7 @@ async function parseAgentRunnerArgs(args, deps = {
     codexBin: requestedCodexBin,
     codeServerBin: customCodeServerBin
   });
-  assertStartDependencies(initialDependencyStatus);
+  assertRunnerConnectionDependencies(initialDependencyStatus);
   const codexBin = initialDependencyStatus.codex.command;
   const editorRuntime = await deps.resolveEditorRuntime({
     kandanUrl,
@@ -58755,7 +60109,7 @@ async function parseAgentRunnerArgs(args, deps = {
     codeServerBin: editorRuntime.codeServerBin,
     editorRuntime: editorRuntime.status
   });
-  assertStartDependencies(dependencyStatus);
+  assertRunnerConnectionDependencies(dependencyStatus);
   const claudeCodeAvailable = await resolveClaudeCodeAvailability(deps, cwd);
   return {
     kandanUrl,
@@ -58767,6 +60121,7 @@ async function parseAgentRunnerArgs(args, deps = {
     cwd,
     codexBin,
     codexUrl: stringValue7(values, "codex-url"),
+    launchSource: electronAutoConnectLaunchSource(),
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
     logFile: stringValue7(values, "log-file"),
@@ -58785,7 +60140,7 @@ async function parseAgentRunnerArgs(args, deps = {
   };
 }
 function readAgentTokenTextFile(path2) {
-  return existsSync13(path2) ? readFileSync16(path2, "utf8") : void 0;
+  return existsSync14(path2) ? readFileSync16(path2, "utf8") : void 0;
 }
 function rejectAgentRunnerTargetingFlags(values) {
   const unsupportedFlags = [
@@ -58901,7 +60256,7 @@ async function parseRunnerArgs(args, deps = {
     codexBin: requestedCodexBin,
     codeServerBin: customCodeServerBin
   });
-  assertStartDependencies(initialDependencyStatus);
+  assertRunnerConnectionDependencies(initialDependencyStatus);
   const codexBin = initialDependencyStatus.codex.command;
   const explicitToken = stringValue7(values, "token");
   const token = await deps.resolveToken({
@@ -58928,7 +60283,7 @@ async function parseRunnerArgs(args, deps = {
     codeServerBin: editorRuntime.codeServerBin,
     editorRuntime: editorRuntime.status
   });
-  assertStartDependencies(dependencyStatus);
+  assertRunnerConnectionDependencies(dependencyStatus);
   const claudeCodeAvailable = await resolveClaudeCodeAvailability(deps, cwd);
   return {
     kandanUrl,
@@ -58939,6 +60294,7 @@ async function parseRunnerArgs(args, deps = {
     cwd,
     codexBin,
     codexUrl: stringValue7(values, "codex-url"),
+    launchSource: electronAutoConnectLaunchSource(),
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
     logFile: stringValue7(values, "log-file"),
@@ -58968,6 +60324,9 @@ function runnerRuntimeDefaultsFromValues(values) {
     allowPortForwardingByDefault: true
   };
 }
+function electronAutoConnectLaunchSource() {
+  return process.env.LINZUMI_ELECTRON_AUTO_CONNECT_RUNNER === "1" ? "electron_auto_connect" : void 0;
+}
 function kandanUrlValue(values) {
   const apiUrl = stringValue7(values, "api-url");
   const linzumiUrl = stringValue7(values, "linzumi-url");