@linzumi/cli 0.0.43-beta → 0.0.45-beta

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { existsSync as existsSync11, readFileSync as readFileSync10, realpathSync as realpathSync6 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync11, realpathSync as realpathSync6 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
 import { resolve as resolve9 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
@@ -2671,6 +2671,7 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     pendingApprovalRequests: new Map,
     approvalPromptChain: Promise.resolve(),
     pendingPortForwardRequests: new Map,
+    portForwardPreviousProcessingStates: new Map,
     queuedPortForwardCandidates: new Map,
     approvedForwardPorts: new Set,
     approvedForwardTargets: new Map,
@@ -2995,6 +2996,9 @@ async function resolvePendingPortForwardRequest(args, state, payloadContext, con
   state.pendingPortForwardRequests.delete(control.requestId);
   if (control.decision === "deny") {
     state.dismissedForwardTargets.set(request.port, approvedTargetFromRequest(request));
+    await publishForwardPortResolvedEvent(args, request, {
+      decision: "deny"
+    });
     await publishMessageStateForPortForwardResult(args, state, request, "failed");
     args.log("port_forward.request_denied", {
       request_id: control.requestId,
@@ -3014,7 +3018,10 @@ async function resolvePendingPortForwardRequest(args, state, payloadContext, con
     processName: processIdentity?.appName ?? null,
     processIconKey: processIdentity?.iconKey ?? null
   });
-  await publishForwardPortResolvedEvent(args, request, capabilities);
+  await publishForwardPortResolvedEvent(args, request, {
+    decision: "approve",
+    capabilities
+  });
   await publishMessageStateForPortForwardResult(args, state, request, "processed");
   await publishPortForwardReadyMessage(args, state, payloadContext, request);
   args.log("port_forward.request_approved", {
@@ -3099,12 +3106,14 @@ async function publishPortForwardPrompt(args, state, payloadContext, candidate)
     candidate
   });
   state.pendingPortForwardRequests.set(requestId, request);
+  if (state.activeProcessingState !== undefined) {
+    state.portForwardPreviousProcessingStates.set(requestId, state.activeProcessingState);
+  }
   const processIdentity = guessCanonicalProcessFromCommand(candidate.command);
   const processIconPath = processIdentity?.iconKey === undefined ? undefined : `/web/process-icons/${processIdentity.iconKey}.png`;
   const processName = processIdentity?.appName ?? label;
-  await publishForwardPortRequestedEvent(args, request);
-  await publishMessageState(args, state.kandanThreadId, sourceSeq, {
-    status: "processing",
+  state.activeProcessingState = {
+    seq: sourceSeq,
     reason: "awaiting approval",
     approval: {
       requestId,
@@ -3133,7 +3142,13 @@ async function publishPortForwardPrompt(args, state, payloadContext, candidate)
       allowedActorSlug: args.options.channelSession.listenUser,
       allowedActorUserId: args.options.channelSession.listenUser.toLowerCase() === (payloadContext.runnerIdentity.actorUsername ?? "").toLowerCase() ? payloadContext.runnerIdentity.actorUserId : undefined
     }
+  };
+  await publishMessageState(args, state.kandanThreadId, sourceSeq, {
+    status: "processing",
+    reason: "awaiting approval",
+    approval: state.activeProcessingState.approval
   });
+  await publishForwardPortRequestedEvent(args, state, request, processIdentity);
   args.log("port_forward.request_pending", {
     request_id: requestId,
     port: candidate.port,
@@ -3174,6 +3189,10 @@ async function expireLostPendingPortForwardRequest(args, state, payloadContext,
     return;
   }
   state.pendingPortForwardRequests.delete(request.requestId);
+  await publishForwardPortResolvedEvent(args, request, {
+    decision: "expired",
+    reason: "listener_exited"
+  });
   await publishMessageStateForPortForwardResult(args, state, request, "failed", "port_forward_listener_exited");
   args.log("port_forward.pending_request_expired", {
     request_id: request.requestId,
@@ -3220,17 +3239,23 @@ async function publishPortForwardReadyMessage(args, state, payloadContext, reque
     }
   }, args.log);
 }
-async function publishForwardPortRequestedEvent(args, request) {
+async function publishForwardPortRequestedEvent(args, state, request, processIdentity) {
   await pushOptional(args.kandan, args.topic, "forward_port_requested", {
     instanceId: args.instanceId,
     requestId: request.requestId,
+    sourceSeq: request.sourceSeq,
     port: request.port,
     pid: request.pid,
     command: request.command,
+    codexThreadId: state.codexThreadId ?? null,
+    kandanThreadId: state.kandanThreadId ?? null,
+    channelSlug: args.options.channelSession.channelSlug ?? null,
+    ...processIdentity?.appName === undefined ? {} : { processName: processIdentity.appName },
+    ...processIdentity?.iconKey === undefined ? {} : { processIconKey: processIdentity.iconKey },
     ...request.cwd === undefined ? {} : { cwd: request.cwd }
   }, args.log);
 }
-async function publishForwardPortResolvedEvent(args, request, capabilities) {
+async function publishForwardPortResolvedEvent(args, request, result) {
   await pushOptional(args.kandan, args.topic, "forward_port_resolved", {
     instanceId: args.instanceId,
     requestId: request.requestId,
@@ -3238,18 +3263,52 @@ async function publishForwardPortResolvedEvent(args, request, capabilities) {
     pid: request.pid,
     command: request.command,
     ...request.cwd === undefined ? {} : { cwd: request.cwd },
-    decision: "approve",
-    ...capabilities === undefined ? {} : { capabilities }
+    sourceSeq: request.sourceSeq,
+    decision: result.decision,
+    ...result.reason === undefined ? {} : { reason: result.reason },
+    ...result.capabilities === undefined ? {} : { capabilities: result.capabilities }
   }, args.log);
 }
 async function publishMessageStateForPortForwardResult(args, state, request, status, failedReason = "port_forward_denied") {
   if (state.kandanThreadId === undefined) {
     return;
   }
+  const previousProcessingState = state.portForwardPreviousProcessingStates.get(request.requestId);
+  state.portForwardPreviousProcessingStates.delete(request.requestId);
   const activeProcessingState = state.activeProcessingState;
   if (activeProcessingState !== undefined && activeProcessingState.seq === request.sourceSeq) {
-    await publishMessageState(args, state.kandanThreadId, request.sourceSeq, processingMessageStateFromActive(activeProcessingState), undefined, undefined, state.codexThreadId);
-    return;
+    const resolvingActiveApproval = activeProcessingState.reason === "awaiting approval" && activeProcessingState.approval.requestId === request.requestId;
+    if (resolvingActiveApproval) {
+      state.activeProcessingState = undefined;
+      if (previousProcessingState !== undefined && previousProcessingState.seq === request.sourceSeq) {
+        state.activeProcessingState = previousProcessingState;
+        await publishMessageState(args, state.kandanThreadId, request.sourceSeq, processingMessageStateFromActive(previousProcessingState), undefined, undefined, state.codexThreadId);
+        return;
+      }
+      switch (state.turn.status) {
+        case "active":
+        case "completing":
+          if (state.turn.queuedSeq === request.sourceSeq) {
+            state.activeProcessingState = {
+              seq: request.sourceSeq,
+              reason: "running terminal command"
+            };
+            await publishMessageState(args, state.kandanThreadId, request.sourceSeq, {
+              status: "processing",
+              reason: "running terminal command"
+            });
+            return;
+          }
+          break;
+        case "idle":
+        case "starting":
+          break;
+      }
+    }
+    if (!resolvingActiveApproval) {
+      await publishMessageState(args, state.kandanThreadId, request.sourceSeq, processingMessageStateFromActive(activeProcessingState), undefined, undefined, state.codexThreadId);
+      return;
+    }
   }
   switch (status) {
     case "processed":
@@ -3419,7 +3478,7 @@ function kandanMessageClaimKey(args, threadId, seq) {
 function claimKandanMessage(args, state, event) {
   const threadId = event.threadId;
   if (threadId === undefined) {
-    return false;
+    return true;
   }
   const key = kandanMessageClaimKey(args, threadId, event.seq);
   if (claimedKandanMessageKeys.has(key)) {
@@ -3428,8 +3487,9 @@ function claimKandanMessage(args, state, event) {
   claimedKandanMessageKeys.add(key);
   state.claimedKandanMessageKeys.add(key);
   if (state.claimedKandanMessageKeys.size > maxClaimedKandanMessageKeys) {
-    const [expiredKey] = state.claimedKandanMessageKeys;
-    if (expiredKey !== undefined) {
+    const overflow = state.claimedKandanMessageKeys.size - maxClaimedKandanMessageKeys;
+    const expiredKeys = Array.from(state.claimedKandanMessageKeys).slice(0, overflow);
+    for (const expiredKey of expiredKeys) {
       state.claimedKandanMessageKeys.delete(expiredKey);
       claimedKandanMessageKeys.delete(expiredKey);
     }
@@ -3604,7 +3664,16 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
           new_codex_thread_id: newCodexThreadId
         });
         await postCodexThreadReboundMessage(args, state, payloadContext, oldCodexThreadId, newCodexThreadId);
-        state.pendingReconnectContextInjection = await fetchReconnectContextInjection(args, state);
+        try {
+          state.pendingReconnectContextInjection = await fetchReconnectContextInjection(args, state);
+        } catch (contextError) {
+          state.pendingReconnectContextInjection = undefined;
+          args.log("codex.thread_reconnect_context_failed", {
+            kandan_thread_id: state.kandanThreadId,
+            codex_thread_id: newCodexThreadId,
+            message: contextError instanceof Error ? contextError.message : String(contextError)
+          });
+        }
         requeuePendingKandanMessageFront(state.queue, next);
         state.turn = { status: "idle" };
         await drainKandanMessageQueue(args, state, payloadContext);
@@ -4963,6 +5032,9 @@ async function refreshActiveProcessingState(args, state, turnId, reason) {
   if (state.activeProcessingState?.seq === seq && state.activeProcessingState.reason === reason) {
     return;
   }
+  if (state.activeProcessingState?.seq === seq && state.activeProcessingState.reason === "awaiting approval") {
+    return;
+  }
   state.activeProcessingState = { seq, reason };
   await publishMessageState(args, state.kandanThreadId, seq, {
     status: "processing",
@@ -4974,6 +5046,14 @@ async function refreshActiveProcessingHeartbeat(args, state) {
   if (activeProcessingState === undefined || state.kandanThreadId === undefined) {
     return;
   }
+  if (activeProcessingState.reason === "awaiting approval") {
+    switch (activeProcessingState.approval.kind) {
+      case "local_runner_port_forward":
+        return;
+      default:
+        break;
+    }
+  }
   await publishMessageState(args, state.kandanThreadId, activeProcessingState.seq, processingMessageStateFromActive(activeProcessingState), undefined, undefined, state.codexThreadId);
 }
 function clearActiveProcessingState(state, seq) {
@@ -5936,6 +6016,7 @@ function pathLooksAbsolute(pathValue) {
 
 // src/localForwarding.ts
 import { gzipSync } from "node:zlib";
+import NodeWebSocket from "ws";
 var maxForwardBodyBytes = 64 * 1024 * 1024;
 var gzipForwardThresholdBytes = 32 * 1024;
 async function handleForwardHttpRequest(control, allowedPorts) {
@@ -5979,15 +6060,15 @@ function isForwardHttpRequestControl(control) {
 function isForwardWebSocketControl(control) {
   return control.type === "forward_websocket_open" || control.type === "forward_websocket_send" || control.type === "forward_websocket_close";
 }
-function createForwardWebSocketManager(kandan, topic, allowedPorts) {
+function createForwardWebSocketManager(kandan, topic, allowedPorts, socketFactory = defaultForwardWebSocketFactory) {
   const sockets = new Map;
   const pushEvent = (payload) => kandan.push(topic, "forward:websocket_event", payload).catch(() => {
     return;
   });
   const closeSocket = (socketId) => {
-    const socket = sockets.get(socketId);
+    const stream = sockets.get(socketId);
     sockets.delete(socketId);
-    socket?.close();
+    stream?.socket.close();
   };
   return {
     handle: (control) => {
@@ -6001,12 +6082,12 @@ function createForwardWebSocketManager(kandan, topic, allowedPorts) {
             });
             return;
           }
-          openLocalWebSocket(control, sockets, pushEvent, "ws");
+          openLocalWebSocket(control, sockets, pushEvent, socketFactory, "ws");
           return;
         }
         case "forward_websocket_send": {
-          const socket = sockets.get(control.socketId);
-          if (socket === undefined || socket.readyState !== WebSocket.OPEN) {
+          const stream = sockets.get(control.socketId);
+          if (stream === undefined || stream.socket.readyState !== WebSocket.OPEN) {
             pushEvent({
               socketId: control.socketId,
               type: "error",
@@ -6017,12 +6098,12 @@ function createForwardWebSocketManager(kandan, topic, allowedPorts) {
           const body = Buffer.from(control.bodyBase64, "base64");
           switch (control.opcode) {
             case "text":
-              socket.send(body.toString());
+              stream.socket.send(body.toString());
               return;
             case "binary":
             case "ping":
             case "pong":
-              socket.send(body);
+              stream.socket.send(body);
               return;
           }
         }
@@ -6038,18 +6119,27 @@ function createForwardWebSocketManager(kandan, topic, allowedPorts) {
     }
   };
 }
-function openLocalWebSocket(control, sockets, pushEvent, scheme) {
+function openLocalWebSocket(control, sockets, pushEvent, socketFactory, scheme) {
   let opened = false;
-  const url = localForwardUrl(scheme === "ws" ? "http" : "https", control.port, control.path, control.queryString).replace(/^http/, scheme);
+  const url = localForwardWebSocketUrl(scheme, control.port, control.path, control.queryString);
   const protocols = webSocketProtocols(control.headers);
-  const websocket = protocols === undefined ? new WebSocket(url) : new WebSocket(url, protocols);
+  const headers = webSocketHeaders(control.headers);
+  const websocket = socketFactory(url, protocols, headers);
   websocket.binaryType = "arraybuffer";
-  sockets.set(control.socketId, websocket);
+  const previousStream = sockets.get(control.socketId);
+  previousStream?.socket.close();
+  sockets.set(control.socketId, { socket: websocket });
   websocket.addEventListener("open", () => {
+    if (!currentWebSocket(sockets, control.socketId, websocket)) {
+      return;
+    }
     opened = true;
     pushEvent({ socketId: control.socketId, type: "open" });
   });
   websocket.addEventListener("message", (event) => {
+    if (!currentWebSocket(sockets, control.socketId, websocket)) {
+      return;
+    }
     const body = typeof event.data === "string" ? Buffer.from(event.data) : Buffer.from(event.data);
     pushEvent({
       socketId: control.socketId,
@@ -6059,6 +6149,9 @@ function openLocalWebSocket(control, sockets, pushEvent, scheme) {
     });
   });
   websocket.addEventListener("close", (event) => {
+    if (!currentWebSocket(sockets, control.socketId, websocket)) {
+      return;
+    }
     sockets.delete(control.socketId);
     pushEvent({
       socketId: control.socketId,
@@ -6068,18 +6161,32 @@ function openLocalWebSocket(control, sockets, pushEvent, scheme) {
     });
   });
   websocket.addEventListener("error", () => {
+    if (!currentWebSocket(sockets, control.socketId, websocket)) {
+      return;
+    }
     sockets.delete(control.socketId);
     if (!opened && scheme === "ws") {
-      openLocalWebSocket(control, sockets, pushEvent, "wss");
+      openLocalWebSocket(control, sockets, pushEvent, socketFactory, "wss");
       return;
     }
     pushEvent({
       socketId: control.socketId,
       type: "error",
-      error: "websocket_error"
+      error: "websocket_error",
+      attemptedScheme: scheme
     });
   });
 }
+function defaultForwardWebSocketFactory(url, protocols, headers) {
+  if (headers === undefined) {
+    return protocols === undefined ? new WebSocket(url) : new WebSocket(url, protocols);
+  }
+  const options = { headers };
+  return protocols === undefined ? new NodeWebSocket(url, options) : new NodeWebSocket(url, protocols, options);
+}
+function currentWebSocket(sockets, socketId, socket) {
+  return sockets.get(socketId)?.socket === socket;
+}
 function webSocketProtocols(headers) {
   if (!Array.isArray(headers)) {
     return;
@@ -6092,6 +6199,21 @@ function webSocketProtocols(headers) {
   });
   return protocols.length === 0 ? undefined : protocols;
 }
+function webSocketHeaders(headers) {
+  if (!Array.isArray(headers)) {
+    return;
+  }
+  const forwarded = headers.reduce((acc, header) => {
+    if (isOctWebSocketHeader(header)) {
+      acc[header.name] = header.value;
+    }
+    return acc;
+  }, {});
+  return Object.keys(forwarded).length === 0 ? undefined : forwarded;
+}
+function isOctWebSocketHeader(value) {
+  return isHeader(value) && value.name.toLowerCase().startsWith("x-oct-");
+}
 function localForwardUrl(scheme, port, path, queryString) {
   const normalizedPath = path.startsWith("/") ? path : `/${path}`;
   const url = new URL(`${scheme}://127.0.0.1:${port}${normalizedPath}`);
@@ -6100,6 +6222,12 @@ function localForwardUrl(scheme, port, path, queryString) {
   }
   return url.toString();
 }
+function localForwardWebSocketUrl(scheme, port, path, queryString) {
+  const httpScheme = scheme === "ws" ? "http" : "https";
+  const url = new URL(localForwardUrl(httpScheme, port, path, queryString));
+  url.protocol = `${scheme}:`;
+  return url.toString();
+}
 async function fetchWithHttpsFallback(port, path, queryString, request) {
   try {
     return await fetch(localForwardUrl("http", port, path, queryString), request);
@@ -6212,8 +6340,10 @@ var blockedForwardHeaderNames = new Set([
   "connection",
   "content-encoding",
   "content-length",
+  "cookie",
   "host",
   "keep-alive",
+  "authorization",
   "proxy-authenticate",
   "proxy-authorization",
   "te",
@@ -6225,10 +6355,12 @@ var blockedForwardHeaderNames = new Set([
 // src/localEditor.ts
 import { spawn as spawn2 } from "node:child_process";
 import {
+  copyFileSync,
   cpSync,
   existsSync as existsSync2,
   mkdirSync as mkdirSync3,
   mkdtempSync,
+  readFileSync as readFileSync2,
   realpathSync as realpathSync3,
   writeFileSync as writeFileSync2
 } from "node:fs";
@@ -6430,6 +6562,7 @@ function prepareCodeServerProfile(collaboration, editorRuntime) {
     mkdirSync3(collaborationServerDir, { recursive: true });
     mkdirSync3(tempDir, { recursive: true });
     if (editorRuntime !== undefined) {
+      ensureCodeServerBrowserExtensionAssets(editorRuntime);
       installDirectory(editorRuntime.assets.documentStateExtensionDir, join4(extensionsDir, "kandan.document-state-telemetry"));
     }
     writeFileSync2(join4(userSettingsDir, "settings.json"), JSON.stringify(codeServerSettings(collaboration), null, 2));
@@ -6438,6 +6571,68 @@ function prepareCodeServerProfile(collaboration, editorRuntime) {
     return { ok: false, reason: "code_server_spawn_failed" };
   }
 }
+function ensureCodeServerBrowserExtensionAssets(runtime) {
+  const vscodeRoot = codeServerVscodeRoot(runtime);
+  const repairs = [
+    {
+      source: join4(vscodeRoot, "extensions", "git-base", "dist", "extension.js"),
+      target: join4(vscodeRoot, "extensions", "git-base", "dist", "browser", "extension.js"),
+      required: true
+    },
+    {
+      source: join4(vscodeRoot, "extensions", "git-base", "dist", "extension.js.map"),
+      target: join4(vscodeRoot, "extensions", "git-base", "dist", "browser", "extension.js.map"),
+      required: false
+    },
+    {
+      source: join4(vscodeRoot, "extensions", "merge-conflict", "dist", "mergeConflictMain.js"),
+      target: join4(vscodeRoot, "extensions", "merge-conflict", "dist", "browser", "mergeConflictMain.js"),
+      required: true
+    },
+    {
+      source: join4(vscodeRoot, "extensions", "merge-conflict", "dist", "mergeConflictMain.js.map"),
+      target: join4(vscodeRoot, "extensions", "merge-conflict", "dist", "browser", "mergeConflictMain.js.map"),
+      required: false
+    }
+  ];
+  repairs.forEach(({ source, target, required }) => {
+    switch (true) {
+      case existsSync2(target):
+        return;
+      case (!required && !existsSync2(source)):
+        return;
+      default:
+        mkdirSync3(dirname2(target), { recursive: true });
+        copyFileSync(source, target);
+        return;
+    }
+  });
+}
+function codeServerVscodeRoot(runtime) {
+  const roots = uniquePaths([
+    join4(runtime.root, "lib", "vscode"),
+    join4(dirname2(dirname2(runtime.codeServerBin)), "lib", "vscode"),
+    ...wrappedCodeServerBin(runtime.codeServerBin).map((codeServerBin) => join4(dirname2(dirname2(codeServerBin)), "lib", "vscode"))
+  ]);
+  const rootWithRequiredAssets = roots.find((root) => codeServerBrowserAssetSources(root).every((source) => existsSync2(source)));
+  return rootWithRequiredAssets ?? roots[0];
+}
+function wrappedCodeServerBin(codeServerBin) {
+  try {
+    const script = readFileSync2(codeServerBin, "utf8");
+    const match = script.match(/exec\s+(?:"([^"]+)"|'([^']+)'|([^\s]+))\s+"\$@"/u);
+    const target = match?.[1] ?? match?.[2] ?? match?.[3];
+    return target === undefined || target.trim() === "" ? [] : [target];
+  } catch (_error) {
+    return [];
+  }
+}
+function codeServerBrowserAssetSources(vscodeRoot) {
+  return [
+    join4(vscodeRoot, "extensions", "git-base", "dist", "extension.js"),
+    join4(vscodeRoot, "extensions", "merge-conflict", "dist", "mergeConflictMain.js")
+  ];
+}
 function prepareCodeServerLaunch(options) {
   const platform = options.platform ?? process.platform;
   if (platform === "linux") {
@@ -6570,12 +6765,16 @@ function prepareLocalEditorCollaboration(collaboration, runnerId, serverPort, br
   }
   const targetPath = `/local-codex-runners/${encodeURIComponent(runnerId)}/forwards/${serverPort}/preview-target`;
   const serverUrl = new URL(targetPath, `${browserBaseUrl}/`).toString();
-  const bootstrapServerUrl = collaboration.bootstrapToken === undefined || collaboration.bootstrapToken === "" ? serverUrl : new URL(`${targetPath}/_kandan-collaboration/${encodeURIComponent(collaboration.bootstrapToken)}`, `${browserBaseUrl}/`).toString();
+  const collaborationStatePath = `/api/v2/editor/sessions/${collaboration.editorSessionId}/collaboration-state`;
+  const collaborationBootstrapPath = collaboration.bootstrapToken === undefined || collaboration.bootstrapToken === "" ? undefined : `${targetPath}/_kandan-collaboration/${encodeURIComponent(collaboration.bootstrapToken)}`;
+  const collaborationStateUrl = collaborationBootstrapPath === undefined ? collaborationStatePath : `${collaborationBootstrapPath}${collaborationStatePath}`;
+  const bootstrapServerUrl = collaborationBootstrapPath === undefined ? serverUrl : new URL(collaborationBootstrapPath, `${browserBaseUrl}/`).toString();
   return {
     ...collaboration,
     serverPort,
     serverUrl,
-    bootstrapServerUrl
+    bootstrapServerUrl,
+    collaborationStateUrl
   };
 }
 function codeServerSettings(collaboration) {
@@ -6588,6 +6787,7 @@ function codeServerSettings(collaboration) {
     "oct.joinAcceptMode": "auto",
     ...collaboration === undefined ? {} : {
       "oct.kandanEditorSessionId": collaboration.editorSessionId,
+      "oct.kandanCollaborationStateUrl": collaboration.collaborationStateUrl,
       "oct.serverUrl": collaboration.bootstrapServerUrl
     },
     "security.workspace.trust.enabled": false,
@@ -6666,6 +6866,7 @@ async function startCollaborationSidecar(collaboration, profile, editorRuntime,
         serverPort: collaboration.serverPort,
         serverUrl: collaboration.serverUrl,
         bootstrapServerUrl: collaboration.bootstrapServerUrl,
+        collaborationStateUrl: collaboration.collaborationStateUrl,
         process: child,
         exited
       }
@@ -6906,7 +7107,7 @@ import {
   existsSync as existsSync3,
   mkdirSync as mkdirSync4,
   mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   renameSync,
   rmSync,
   writeFileSync as writeFileSync3
@@ -7394,7 +7595,7 @@ function installedRuntime(cacheRoot, manifest) {
     return { ok: false };
   }
   try {
-    const installed = JSON.parse(readFileSync2(manifestPath, "utf8"));
+    const installed = JSON.parse(readFileSync3(manifestPath, "utf8"));
     if (isJsonObject(installed) && installed.version === manifest.version && installed.platform === manifest.platform && (installed.archiveSha256 === undefined || installed.archiveSha256 === manifest.archiveSha256)) {
       return {
         ok: true,
@@ -7625,7 +7826,7 @@ function manifestAssetChecksums(assets) {
   return checksums;
 }
 function fileSha256Sync(path) {
-  return createHash2("sha256").update(readFileSync2(path)).digest("hex");
+  return createHash2("sha256").update(readFileSync3(path)).digest("hex");
 }
 function defaultEditorRuntimeCacheRoot() {
   return join5(homedir4(), ".linzumi", "editor-runtimes");
@@ -7804,6 +8005,7 @@ function firstNonBlank(...values) {
 }
 
 // src/phoenix.ts
+var defaultPushTimeoutMs = 30000;
 function phoenixWebsocketUrl(baseUrl, token) {
   const parsed = new URL(baseUrl);
   switch (parsed.protocol) {
@@ -7819,7 +8021,7 @@ function phoenixWebsocketUrl(baseUrl, token) {
   parsed.searchParams.set("vsn", "2.0.0");
   return parsed.toString();
 }
-async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new WebSocket(url)) {
+async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new WebSocket(url), options = {}) {
   const pending = new Map;
   const joins = new Map;
   const controlCallbacks = new Set;
@@ -7837,9 +8039,13 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new
     rejectReady: undefined,
     reconnectTimer: undefined
   };
+  const pushTimeoutMs = options.pushTimeoutMs ?? defaultPushTimeoutMs;
   const rejectPending = (message) => {
     const error = new Error(message);
-    pending.forEach((pendingPush) => pendingPush.reject(error));
+    pending.forEach((pendingPush) => {
+      clearTimeout(pendingPush.timer);
+      pendingPush.reject(error);
+    });
     pending.clear();
   };
   const resetReady = () => {
@@ -7855,6 +8061,7 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new
       const pendingPush = pending.get(ref);
       if (pendingPush !== undefined) {
         pending.delete(ref);
+        clearTimeout(pendingPush.timer);
         if (name === "phx_error") {
           pendingPush.reject(new Error("phoenix push failed"));
         } else if (isNonOkPushReply(payload) && pendingPush.event !== "phx_join") {
@@ -7880,7 +8087,12 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new
     state.nextRef += 1;
     const frame = [null, ref, topic, event, payload];
     return new Promise((resolve5, reject) => {
-      pending.set(ref, { event, resolve: resolve5, reject });
+      const timer = setTimeout(() => {
+        if (pending.delete(ref)) {
+          reject(new Error(`phoenix push timed out after ${pushTimeoutMs}ms: ${event}`));
+        }
+      }, pushTimeoutMs);
+      pending.set(ref, { event, timer, resolve: resolve5, reject });
       websocket.send(JSON.stringify(frame));
     });
   };
@@ -7955,10 +8167,10 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new
     return pushOnOpenSocket(topic, event, payload);
   };
   return {
-    join: async (topic, payload, options) => {
+    join: async (topic, payload, options2) => {
       const reply = await push(topic, "phx_join", payload);
       if (isJoinReply(reply)) {
-        joins.set(topic, { payload: options?.rejoinPayload ?? (() => payload) });
+        joins.set(topic, { payload: options2?.rejoinPayload ?? (() => payload) });
         return reply.response;
       }
       throw new Error(`phoenix join failed: ${joinErrorMessage(reply)}`);
@@ -8030,7 +8242,7 @@ import {
   existsSync as existsSync5,
   mkdirSync as mkdirSync6,
   openSync as openSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   unlinkSync as unlinkSync2,
   writeSync
 } from "node:fs";
@@ -8042,27 +8254,38 @@ import {
   existsSync as existsSync4,
   linkSync,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   realpathSync as realpathSync4,
   unlinkSync,
   writeFileSync as writeFileSync4
 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { basename as basename4, dirname as dirname4, join as join6, resolve as resolve5 } from "node:path";
+
+// src/defaultUrls.ts
+var defaultLinzumiHttpUrl = "https://serve.linzumi.com";
+var defaultLinzumiWebSocketUrl = "wss://serve.linzumi.com";
+
+// src/localConfig.ts
+var prodConfigScope = "prod";
 function localConfigPath(env = process.env) {
   const override = env.LINZUMI_CONFIG_FILE;
   return override !== undefined && override.trim() !== "" ? resolve5(expandUserPath(override)) : resolve5(homedir5(), ".linzumi", "config.json");
 }
+function localConfigScopeKey(linzumiUrl) {
+  const normalizedUrl = kandanHttpBaseUrl(linzumiUrl);
+  const normalizedProdUrl = kandanHttpBaseUrl(defaultLinzumiWebSocketUrl);
+  return normalizedUrl === normalizedProdUrl ? prodConfigScope : normalizedUrl;
+}
+function localConfigScopeFileStem(linzumiUrl) {
+  const scopeKey = localConfigScopeKey(linzumiUrl);
+  return scopeKey === prodConfigScope ? prodConfigScope : Buffer.from(scopeKey).toString("base64url");
+}
 function readLocalConfig(path = localConfigPath()) {
-  if (!existsSync4(path)) {
-    return { version: 1, allowedCwds: [] };
-  }
-  const parsed = JSON.parse(readFileSync3(path, "utf8"));
-  if (!isConfigPayload(parsed)) {
-    throw new Error(`invalid Linzumi config: ${path}`);
-  }
-  const allowedCwds = uniqueStrings(parsed.allowedCwds);
-  return parsed.machineId === undefined ? { version: 1, allowedCwds } : { version: 1, machineId: parsed.machineId, allowedCwds };
+  return readLocalConfigSection(path);
+}
+function readLocalConfigForLinzumiUrl(linzumiUrl, path = localConfigPath()) {
+  return readLocalConfigSection(path, linzumiUrl);
 }
 function ensureLocalMachineId(path = localConfigPath(), createMachineId = randomUUID2) {
   const config = readLocalConfig(path);
@@ -8078,13 +8301,36 @@ function ensureLocalMachineId(path = localConfigPath(), createMachineId = random
   writeLocalConfig({ ...latestConfig, machineId }, path);
   return machineId;
 }
-function localMachineIdSeedPath(configPath = localConfigPath()) {
+function ensureLocalMachineIdForLinzumiUrl(linzumiUrl, path = localConfigPath(), createMachineId = randomUUID2) {
+  if (localConfigScopeKey(linzumiUrl) === prodConfigScope) {
+    return ensureLocalMachineId(path, createMachineId);
+  }
+  const config = readLocalConfigForLinzumiUrl(linzumiUrl, path);
+  if (config.machineId !== undefined) {
+    return config.machineId;
+  }
+  const machineId = ensureLocalMachineIdSeed(path, createMachineId, linzumiUrl);
+  const latestConfig = readLocalConfigForLinzumiUrl(linzumiUrl, path);
+  const latestMachineId = latestConfig.machineId;
+  if (latestMachineId !== undefined) {
+    return latestMachineId;
+  }
+  writeLocalConfigSection({ ...latestConfig, machineId }, path, linzumiUrl);
+  return machineId;
+}
+function localMachineIdSeedPath(configPath = localConfigPath(), linzumiUrl) {
+  if (linzumiUrl !== undefined && localConfigScopeKey(linzumiUrl) !== prodConfigScope) {
+    return join6(dirname4(configPath), `${basename4(configPath)}.${localConfigScopeFileStem(linzumiUrl)}.machine-id`);
+  }
   return join6(dirname4(configPath), `${basename4(configPath)}.machine-id`);
 }
-function readConfiguredAllowedCwdDetails(path = localConfigPath()) {
+function readConfiguredAllowedCwdDetailsForLinzumiUrl(linzumiUrl, path = localConfigPath()) {
+  return readConfiguredAllowedCwdDetailsFromConfig(readLocalConfigForLinzumiUrl(linzumiUrl, path));
+}
+function readConfiguredAllowedCwdDetailsFromConfig(config) {
   const allowedCwds = [];
   const missingAllowedCwds = [];
-  for (const cwd of readLocalConfig(path).allowedCwds) {
+  for (const cwd of config.allowedCwds) {
     const absolutePath = resolve5(expandUserPath(cwd));
     try {
       const realPath = realpathSync4(absolutePath);
@@ -8103,36 +8349,91 @@ function readConfiguredAllowedCwdDetails(path = localConfigPath()) {
   };
 }
 function addAllowedCwd(pathValue, path = localConfigPath()) {
+  return addAllowedCwdToConfig(pathValue, path);
+}
+function addAllowedCwdForLinzumiUrl(pathValue, linzumiUrl, path = localConfigPath()) {
+  return addAllowedCwdToConfig(pathValue, path, linzumiUrl);
+}
+function addAllowedCwdToConfig(pathValue, path, linzumiUrl) {
   const normalizedPath = realpathSync4(resolve5(expandUserPath(pathValue)));
-  const config = readLocalConfig(path);
+  const config = readLocalConfigSection(path, linzumiUrl);
   const allowedCwds = uniqueStrings([...config.allowedCwds, normalizedPath]);
-  writeLocalConfig({ ...config, version: 1, allowedCwds }, path);
+  writeLocalConfigSection({ ...config, version: 1, allowedCwds }, path, linzumiUrl);
   return allowedCwds;
 }
 function removeAllowedCwd(pathValue, path = localConfigPath()) {
+  return removeAllowedCwdFromConfig(pathValue, path);
+}
+function removeAllowedCwdForLinzumiUrl(pathValue, linzumiUrl, path = localConfigPath()) {
+  return removeAllowedCwdFromConfig(pathValue, path, linzumiUrl);
+}
+function removeAllowedCwdFromConfig(pathValue, path, linzumiUrl) {
   const requestedPath = resolve5(expandUserPath(pathValue));
   const normalizedRequest = realpathOrResolved(requestedPath);
-  const config = readLocalConfig(path);
+  const config = readLocalConfigSection(path, linzumiUrl);
   const allowedCwds = config.allowedCwds.filter((cwd) => {
     const normalizedExisting = realpathOrResolved(cwd);
     return cwd !== pathValue && normalizedExisting !== normalizedRequest;
   });
-  writeLocalConfig({ ...config, version: 1, allowedCwds }, path);
+  writeLocalConfigSection({ ...config, version: 1, allowedCwds }, path, linzumiUrl);
   return allowedCwds;
 }
 function writeLocalConfig(config, path = localConfigPath()) {
+  writeLocalConfigSection(config, path);
+}
+function readLocalConfigFile(path) {
+  if (!existsSync4(path)) {
+    return { version: 1, allowedCwds: [] };
+  }
+  const parsed = JSON.parse(readFileSync4(path, "utf8"));
+  if (!isConfigPayload(parsed)) {
+    throw new Error(`invalid Linzumi config: ${path}`);
+  }
+  return parsed;
+}
+function readLocalConfigSection(path, linzumiUrl) {
+  const parsed = readLocalConfigFile(path);
+  const scopeKey = linzumiUrl === undefined ? prodConfigScope : localConfigScopeKey(linzumiUrl);
+  const section = scopeKey === prodConfigScope ? parsed : parsed[scopeKey] ?? emptySection();
+  if (!isConfigSection(section)) {
+    throw new Error(`invalid Linzumi config section ${scopeKey}: ${path}`);
+  }
+  const allowedCwds = uniqueStrings(section.allowedCwds);
+  return section.machineId === undefined ? { version: 1, allowedCwds } : { version: 1, machineId: section.machineId, allowedCwds };
+}
+function writeLocalConfigSection(config, path, linzumiUrl) {
+  const scopeKey = linzumiUrl === undefined ? prodConfigScope : localConfigScopeKey(linzumiUrl);
+  const nextSection = normalizedConfigSection(config);
+  const next = scopeKey === prodConfigScope ? { ...readLocalConfigFile(path), ...nextSection, version: 1 } : {
+    ...readLocalConfigFile(path),
+    version: 1,
+    [scopeKey]: nextSection
+  };
   mkdirSync5(dirname4(path), { recursive: true });
-  writeFileSync4(path, `${JSON.stringify(config, null, 2)}
+  writeFileSync4(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
 }
 function isConfigPayload(value) {
-  return typeof value === "object" && value !== null && value.version === 1 && Array.isArray(value.allowedCwds) && machineIdValid(value.machineId) && value.allowedCwds.every((cwd) => typeof cwd === "string" && cwd.trim() !== "");
+  return typeof value === "object" && value !== null && value.version === 1 && isConfigSection(value);
+}
+function isConfigSection(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.allowedCwds) && machineIdValid(value.machineId) && value.allowedCwds.every((cwd) => typeof cwd === "string" && cwd.trim() !== "");
+}
+function normalizedConfigSection(config) {
+  if (!isConfigPayload(config)) {
+    throw new Error("invalid Linzumi config");
+  }
+  const allowedCwds = uniqueStrings(config.allowedCwds);
+  return config.machineId === undefined ? { allowedCwds } : { machineId: config.machineId, allowedCwds };
+}
+function emptySection() {
+  return { allowedCwds: [] };
 }
 function machineIdValid(value) {
   return value === undefined || typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 }
-function ensureLocalMachineIdSeed(configPath, createMachineId) {
-  const seedPath = localMachineIdSeedPath(configPath);
+function ensureLocalMachineIdSeed(configPath, createMachineId, linzumiUrl) {
+  const seedPath = localMachineIdSeedPath(configPath, linzumiUrl);
   if (existsSync4(seedPath)) {
     return readMachineIdSeed(seedPath);
   }
@@ -8157,7 +8458,7 @@ function ensureLocalMachineIdSeed(configPath, createMachineId) {
   }
 }
 function readMachineIdSeed(seedPath) {
-  const machineId = readFileSync3(seedPath, "utf8").trim();
+  const machineId = readFileSync4(seedPath, "utf8").trim();
   if (!machineIdValid(machineId)) {
     throw new Error(`invalid Linzumi machine id seed: ${seedPath}`);
   }
@@ -8183,15 +8484,16 @@ function realpathOrResolved(pathValue) {
 }
 
 // src/version.ts
-var linzumiCliVersion = "0.0.43-beta";
+var linzumiCliVersion = "0.0.45-beta";
 var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
 
 // src/runnerLock.ts
-function runnerLockPath(machineId, configPath = localConfigPath()) {
-  return join7(dirname5(configPath), "runners", `${encodeURIComponent(machineId)}.lock`);
+function runnerLockPath(machineId, configPath = localConfigPath(), linzumiUrl) {
+  const lockName = linzumiUrl === undefined ? encodeURIComponent(machineId) : localConfigScopeFileStem(linzumiUrl);
+  return join7(dirname5(configPath), "runners", `${lockName}.lock`);
 }
 function acquireRunnerLock(options) {
-  const path = runnerLockPath(options.machineId, options.configPath);
+  const path = runnerLockPath(options.machineId, options.configPath, options.linzumiUrl);
   const isPidAlive = options.isPidAlive ?? processIsAlive;
   const record = {
     version: 1,
@@ -8200,9 +8502,11 @@ function acquireRunnerLock(options) {
     pid: options.pid ?? process.pid,
     cwd: options.cwd,
     workspace: options.workspace,
+    ...options.linzumiUrl === undefined ? {} : { linzumiUrl: kandanHttpBaseUrl(options.linzumiUrl) },
     startedAt: (options.now ?? (() => new Date))().toISOString(),
     cliVersion: options.cliVersion ?? linzumiCliVersion
   };
+  rejectLiveLegacyProductionRunnerLock(options.machineId, options.configPath, options.linzumiUrl, isPidAlive);
   writeLockOrHandleExisting(path, record, isPidAlive, options.beforeReadExistingLock, options.beforeReplaceStaleLock);
   return {
     path,
@@ -8210,6 +8514,28 @@ function acquireRunnerLock(options) {
     release: () => releaseRunnerLock(path, record)
   };
 }
+function rejectLiveLegacyProductionRunnerLock(machineId, configPath, linzumiUrl, isPidAlive) {
+  if (linzumiUrl === undefined || localConfigScopeKey(linzumiUrl) !== localConfigScopeKey(defaultLinzumiHttpUrl)) {
+    return;
+  }
+  const legacyPath = runnerLockPath(machineId, configPath);
+  const existing = readRunnerLockIfPresent(legacyPath);
+  if (existing === undefined) {
+    return;
+  }
+  if (isPidAlive(existing.pid)) {
+    throw new Error(activeRunnerLockMessage(legacyPath, existing));
+  }
+  withStaleReplacementLock(legacyPath, isPidAlive, () => {
+    const latest = existsSync5(legacyPath) ? readRunnerLock(legacyPath) : undefined;
+    if (latest !== undefined && isPidAlive(latest.pid)) {
+      throw new Error(activeRunnerLockMessage(legacyPath, latest));
+    }
+    if (latest !== undefined) {
+      unlinkSync2(legacyPath);
+    }
+  });
+}
 function writeLockOrHandleExisting(path, record, isPidAlive, beforeReadExistingLock, beforeReplaceStaleLock) {
   if (tryCreateLock(path, record)) {
     return;
@@ -8295,7 +8621,7 @@ function withStaleReplacementLock(path, isPidAlive, callback) {
 function readReplacementLockPidIfPresent(path) {
   let value;
   try {
-    value = readFileSync4(path, "utf8").trim();
+    value = readFileSync5(path, "utf8").trim();
   } catch (error) {
     if (isNodeErrorCode2(error, "ENOENT")) {
       return;
@@ -8335,14 +8661,17 @@ function readRunnerLockIfPresent(path) {
   }
 }
 function readRunnerLock(path) {
-  const parsed = JSON.parse(readFileSync4(path, "utf8"));
+  const parsed = JSON.parse(readFileSync5(path, "utf8"));
   if (!isRunnerLockRecord(parsed)) {
     throw new Error(`invalid Linzumi runner lock: ${path}`);
   }
   return parsed;
 }
 function isRunnerLockRecord(value) {
-  return typeof value === "object" && value !== null && value.version === 1 && typeof value.machineId === "string" && value.machineId.trim() !== "" && typeof value.runnerId === "string" && value.runnerId.trim() !== "" && Number.isInteger(value.pid) && value.pid > 0 && typeof value.cwd === "string" && value.cwd.trim() !== "" && workspaceValid(value.workspace) && typeof value.startedAt === "string" && value.startedAt.trim() !== "" && typeof value.cliVersion === "string" && value.cliVersion.trim() !== "";
+  return typeof value === "object" && value !== null && value.version === 1 && typeof value.machineId === "string" && value.machineId.trim() !== "" && typeof value.runnerId === "string" && value.runnerId.trim() !== "" && Number.isInteger(value.pid) && value.pid > 0 && typeof value.cwd === "string" && value.cwd.trim() !== "" && workspaceValid(value.workspace) && linzumiUrlValid(value.linzumiUrl) && typeof value.startedAt === "string" && value.startedAt.trim() !== "" && typeof value.cliVersion === "string" && value.cliVersion.trim() !== "";
+}
+function linzumiUrlValid(value) {
+  return value === undefined || typeof value === "string" && value.trim() !== "";
 }
 function workspaceValid(value) {
   return value === null || typeof value === "string" && value.trim() !== "";
@@ -8357,8 +8686,10 @@ function processIsAlive(pid) {
 }
 function activeRunnerLockMessage(path, record) {
   const workspace = record.workspace === null ? "workspace: unknown" : `workspace: ${record.workspace}`;
+  const linzumiUrl = record.linzumiUrl === undefined ? undefined : `linzumi url: ${displayLinzumiUrl(record.linzumiUrl)}`;
   return [
-    "another Linzumi runner is already running for this machine",
+    record.linzumiUrl === undefined ? "another Linzumi runner is already running for this machine" : "another Linzumi runner is already running for this Linzumi URL",
+    ...linzumiUrl === undefined ? [] : [linzumiUrl],
     `runner id: ${record.runnerId}`,
     `pid: ${record.pid}`,
     `cwd: ${record.cwd}`,
@@ -8370,6 +8701,12 @@ function activeRunnerLockMessage(path, record) {
   ].join(`
 `);
 }
+function displayLinzumiUrl(linzumiUrl) {
+  if (linzumiUrl === localConfigScopeKey(defaultLinzumiHttpUrl)) {
+    return defaultLinzumiHttpUrl;
+  }
+  return localConfigScopeKey(linzumiUrl) === localConfigScopeKey(defaultLinzumiHttpUrl) ? defaultLinzumiHttpUrl : linzumiUrl;
+}
 function isNodeErrorCode2(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
@@ -8531,6 +8868,7 @@ async function runLocalCodexRunner(options) {
         runnerId: options.runnerId,
         cwd: options.cwd,
         workspace: runnerWorkspaceSlug(options) ?? null,
+        linzumiUrl: options.kandanUrl,
         configPath: options.runnerLockConfigPath
       });
       cleanup.actions.push(() => runnerLock.release());
@@ -8552,6 +8890,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const allowedForwardPorts = options.allowedForwardPorts ?? [];
   const liveForwardPorts = new Set(allowedForwardPorts);
   const managedForwardPorts = new Set;
+  const kandanControlPort = explicitUrlPort(options.kandanUrl);
+  const suppressedForwardPorts = () => suppressedForwardPortsForRunner(kandanControlPort, managedForwardPorts);
   const forwardPortAttributions = new Map;
   const setForwardPortAttribution = (port, attribution) => {
     forwardPortAttributions.set(port, {
@@ -8559,7 +8899,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       codexThreadId: attribution.codexThreadId ?? null,
       channelSlug: attribution.channelSlug ?? null,
       processName: attribution.processName ?? null,
-      processIconKey: attribution.processIconKey ?? null
+      processIconKey: attribution.processIconKey ?? null,
+      localEditor: attribution.localEditor === true
     });
   };
   const clearForwardPortAttribution = (port) => {
@@ -8573,7 +8914,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       codexThreadId: attribution?.codexThreadId ?? null,
       channelSlug: attribution?.channelSlug ?? null,
       processName: attribution?.processName ?? null,
-      processIconKey: attribution?.processIconKey ?? null
+      processIconKey: attribution?.processIconKey ?? null,
+      localEditor: attribution?.localEditor === true
     };
   });
   const allowedCwds = { value: [...options.allowedCwds] };
@@ -8584,11 +8926,35 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     value: { status: "disabled" }
   };
   const localEditorGeneration = { value: 0 };
+  const localEditorForwardState = {
+    watcher: undefined,
+    approvedPorts: new Set,
+    approvedTargets: new Map,
+    dismissedTargets: new Map,
+    pendingRequests: new Map,
+    queuedCandidates: new Map
+  };
   cleanup.actions.push(() => {
     if (localEditorState.value.status === "running") {
       localEditorState.value.process.kill("SIGINT");
       localEditorState.value.collaboration?.process.kill("SIGINT");
     }
+    localEditorForwardState.watcher?.close();
+  });
+  const pendingEditorForwardPortRequests = () => Array.from(localEditorForwardState.pendingRequests.values()).sort((left, right) => left.port - right.port).map((request) => {
+    const processIdentity = guessCanonicalProcessFromCommand(request.command);
+    const label = processIdentity?.appName ?? portForwardPromptLabel(approvedTargetFromRequest(request));
+    return {
+      requestId: request.requestId,
+      port: request.port,
+      pid: request.pid,
+      command: request.command,
+      ...request.cwd === undefined ? {} : { cwd: request.cwd },
+      summary: `Make ${label} on port ${request.port} accessible on Linzumi?`,
+      reason: portForwardPromptReason(approvedTargetFromRequest(request)),
+      ...processIdentity?.appName === undefined ? {} : { processName: processIdentity.appName },
+      ...processIdentity?.iconKey === undefined ? {} : { processIconKey: processIdentity.iconKey }
+    };
   });
   const capabilitiesPayload = () => ({
     codexAppServer: true,
@@ -8600,6 +8966,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     portForwarding: liveForwardPorts.size > 0,
     allowedPorts: Array.from(liveForwardPorts).sort((left, right) => left - right),
     forwardedPortAttributions: buildForwardPortAttributionPayload(),
+    pendingEditorForwardPortRequests: pendingEditorForwardPortRequests(),
     toolStatus: options.dependencyStatus === undefined ? null : dependencyStatusPayload(options.dependencyStatus),
     editorRuntime: options.dependencyStatus?.editorRuntime === undefined ? null : dependencyStatusPayload(options.dependencyStatus).editorRuntime,
     ...localEditorCapabilities(options.editorRuntime, allowedCwds.value, localEditorState.value)
@@ -8611,6 +8978,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const joinPayload = () => ({
     clientName: "kandan-local-codex-runner",
     clientId,
+    runnerPid: process.pid,
     version: linzumiCliVersion,
     workspace: runnerWorkspaceSlug(options) ?? null,
     channel: options.channelSession?.channelSlug ?? null,
@@ -8648,12 +9016,204 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       });
     });
   };
+  const pushEditorPortForwardEvent = (event, payload) => {
+    kandan.push(topic, event, payload).catch((error) => {
+      log(`kandan.${event}_push_failed`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+    });
+  };
+  const revokeEditorForwardPort = (port, reason) => {
+    const target = localEditorForwardState.approvedTargets.get(port);
+    localEditorForwardState.approvedPorts.delete(port);
+    localEditorForwardState.approvedTargets.delete(port);
+    liveForwardPorts.delete(port);
+    clearForwardPortAttribution(port);
+    pushEditorPortForwardEvent("forward_port_revoked", {
+      instanceId,
+      port,
+      ...target === undefined ? {} : {
+        pid: target.pid,
+        command: target.command,
+        ...target.cwd === undefined ? {} : { cwd: target.cwd }
+      },
+      reason,
+      capabilities: revocationCapabilities(capabilitiesPayload(), port)
+    });
+  };
+  const clearEditorPortForwarding = (reason) => {
+    localEditorForwardState.watcher?.close();
+    localEditorForwardState.watcher = undefined;
+    localEditorForwardState.pendingRequests.clear();
+    localEditorForwardState.queuedCandidates.clear();
+    const revokedPorts = Array.from(localEditorForwardState.approvedPorts);
+    for (const port of revokedPorts) {
+      revokeEditorForwardPort(port, reason);
+    }
+    localEditorForwardState.dismissedTargets.clear();
+    return revokedPorts;
+  };
+  const drainQueuedEditorPortForwardPrompt = () => {
+    if (localEditorForwardState.pendingRequests.size > 0 || localEditorForwardState.queuedCandidates.size === 0) {
+      return;
+    }
+    const next = Array.from(localEditorForwardState.queuedCandidates.values()).sort((left, right) => left.port - right.port)[0];
+    if (next === undefined) {
+      return;
+    }
+    localEditorForwardState.queuedCandidates.delete(next.port);
+    publishEditorPortForwardPrompt(next);
+    if (localEditorForwardState.pendingRequests.size === 0) {
+      drainQueuedEditorPortForwardPrompt();
+    }
+  };
+  const publishEditorPortForwardPrompt = (candidate) => {
+    const review = reviewPortForwardCandidate({
+      candidate,
+      threadBound: true,
+      suppressedPorts: new Set(suppressedForwardPorts()),
+      approvedPorts: localEditorForwardState.approvedPorts,
+      approvedTargets: localEditorForwardState.approvedTargets,
+      dismissedTargets: localEditorForwardState.dismissedTargets,
+      pendingRequests: Array.from(localEditorForwardState.pendingRequests.values())
+    });
+    switch (review.type) {
+      case "skip":
+        return;
+      case "remember_approved_target":
+        localEditorForwardState.approvedTargets.set(review.target.port, review.target);
+        return;
+      case "revoke_and_prompt":
+        if (localEditorForwardState.pendingRequests.size > 0) {
+          localEditorForwardState.queuedCandidates.set(candidate.port, candidate);
+          return;
+        }
+        revokeEditorForwardPort(review.revoked.port, review.reason);
+        break;
+      case "prompt":
+        if (localEditorForwardState.pendingRequests.size > 0) {
+          localEditorForwardState.queuedCandidates.set(candidate.port, candidate);
+          return;
+        }
+        break;
+    }
+    const requestId = `editor-port-forward-${randomUUID3()}`;
+    const request = pendingRequestFromCandidate({
+      requestId,
+      sourceSeq: 0,
+      candidate
+    });
+    localEditorForwardState.pendingRequests.set(request.port, request);
+    const processIdentity = guessCanonicalProcessFromCommand(candidate.command);
+    pushEditorPortForwardEvent("forward_port_requested", {
+      instanceId,
+      requestId,
+      source: "local_editor",
+      port: request.port,
+      pid: request.pid,
+      command: request.command,
+      ...request.cwd === undefined ? {} : { cwd: request.cwd },
+      ...processIdentity?.appName === undefined ? {} : { processName: processIdentity.appName },
+      ...processIdentity?.iconKey === undefined ? {} : { processIconKey: processIdentity.iconKey },
+      capabilities: capabilitiesPayload()
+    });
+  };
+  const expireLostEditorPortForwardCandidate = (candidate) => {
+    const queuedCandidate = localEditorForwardState.queuedCandidates.get(candidate.port);
+    if (queuedCandidate !== undefined && sameForwardCandidate(queuedCandidate, candidate)) {
+      localEditorForwardState.queuedCandidates.delete(candidate.port);
+      return;
+    }
+    const pendingRequest = localEditorForwardState.pendingRequests.get(candidate.port);
+    if (pendingRequest !== undefined && sameForwardCandidate(approvedTargetFromRequest(pendingRequest), candidate)) {
+      localEditorForwardState.pendingRequests.delete(candidate.port);
+      pushEditorPortForwardEvent("forward_port_revoked", {
+        instanceId,
+        port: candidate.port,
+        pid: candidate.pid,
+        command: candidate.command,
+        ...candidate.cwd === undefined ? {} : { cwd: candidate.cwd },
+        reason: "listener_exited",
+        capabilities: revocationCapabilities(capabilitiesPayload(), candidate.port)
+      });
+      drainQueuedEditorPortForwardPrompt();
+      return;
+    }
+    if (localEditorForwardState.approvedPorts.has(candidate.port)) {
+      revokeEditorForwardPort(candidate.port, "listener_exited");
+    }
+  };
+  const resolveEditorPortForwardRequest = (control) => {
+    const request = Array.from(localEditorForwardState.pendingRequests.values()).find((request2) => request2.requestId === control.requestId);
+    if (request === undefined) {
+      return;
+    }
+    localEditorForwardState.pendingRequests.delete(request.port);
+    if (control.decision === "deny") {
+      localEditorForwardState.dismissedTargets.set(request.port, approvedTargetFromRequest(request));
+      pushEditorPortForwardEvent("forward_port_resolved", {
+        instanceId,
+        requestId: request.requestId,
+        source: "local_editor",
+        port: request.port,
+        pid: request.pid,
+        command: request.command,
+        ...request.cwd === undefined ? {} : { cwd: request.cwd },
+        decision: "deny",
+        capabilities: capabilitiesPayload()
+      });
+      drainQueuedEditorPortForwardPrompt();
+      return { instanceId, ok: true };
+    }
+    localEditorForwardState.approvedPorts.add(request.port);
+    localEditorForwardState.approvedTargets.set(request.port, approvedTargetFromRequest(request));
+    liveForwardPorts.add(request.port);
+    const processIdentity = guessCanonicalProcessFromCommand(request.command);
+    setForwardPortAttribution(request.port, {
+      localEditor: true,
+      processName: processIdentity?.appName ?? null,
+      processIconKey: processIdentity?.iconKey ?? null
+    });
+    pushEditorPortForwardEvent("forward_port_resolved", {
+      instanceId,
+      requestId: request.requestId,
+      source: "local_editor",
+      port: request.port,
+      pid: request.pid,
+      command: request.command,
+      ...request.cwd === undefined ? {} : { cwd: request.cwd },
+      decision: "approve",
+      capabilities: capabilitiesPayload()
+    });
+    drainQueuedEditorPortForwardPrompt();
+    return { instanceId, ok: true, port: request.port };
+  };
+  const startLocalEditorPortForwardWatcher = (state) => {
+    if (state.process.pid === undefined) {
+      log("port_forward.local_editor_watch_skipped", {
+        reason: "editor_pid_missing"
+      });
+      return;
+    }
+    localEditorForwardState.watcher?.close();
+    localEditorForwardState.watcher = startPortForwardWatcher({
+      rootPid: state.process.pid,
+      onCandidate: publishEditorPortForwardPrompt,
+      onCandidateLost: expireLostEditorPortForwardCandidate,
+      onError: (error) => {
+        log("port_forward.local_editor_watch_failed", {
+          message: error.message
+        });
+      }
+    });
+  };
   const watchLocalEditorExit = (state, generation, initialStatusPushed) => {
     const handleExit = () => {
       if (localEditorGeneration.value !== generation || localEditorState.value.status !== "running" || localEditorState.value.process !== state.process) {
         return;
       }
       localEditorState.value = { status: "disabled" };
+      const revokedEditorPorts = clearEditorPortForwarding("editor_exited");
       liveForwardPorts.delete(state.port);
       managedForwardPorts.delete(state.port);
       if (state.collaboration !== undefined) {
@@ -8666,7 +9226,11 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         cwd: state.cwd,
         capabilities: {
           ...capabilitiesPayload(),
-          revokedPorts: state.collaboration === undefined ? [state.port] : [state.port, state.collaboration.serverPort]
+          revokedPorts: state.collaboration === undefined ? [state.port, ...revokedEditorPorts] : [
+            state.port,
+            state.collaboration.serverPort,
+            ...revokedEditorPorts
+          ]
         }
       });
     };
@@ -8724,7 +9288,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       launchTui: options.launchTui,
       enablePortForwardWatch: true,
       initialForwardPorts: allowedForwardPorts,
-      suppressedForwardPorts: () => Array.from(managedForwardPorts),
+      suppressedForwardPorts,
       onForwardPortApproved: (port, attribution) => {
         liveForwardPorts.add(port);
         setForwardPortAttribution(port, attribution);
@@ -8779,7 +9343,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         launchTui: false,
         enablePortForwardWatch: true,
         initialForwardPorts: allowedForwardPorts,
-        suppressedForwardPorts: () => Array.from(managedForwardPorts),
+        suppressedForwardPorts,
         onForwardPortApproved: (port, attribution) => {
           liveForwardPorts.add(port);
           setForwardPortAttribution(port, attribution);
@@ -8950,6 +9514,11 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         if (result.ok) {
           localEditorGeneration.value += 1;
           const editorGeneration = localEditorGeneration.value;
+          const restartedEditorRevokedPorts = localEditorState.value.status === "running" ? [
+            localEditorState.value.port,
+            ...localEditorState.value.collaboration === undefined ? [] : [localEditorState.value.collaboration.serverPort],
+            ...clearEditorPortForwarding("editor_restarted")
+          ] : [];
           if (localEditorState.value.status === "running") {
             liveForwardPorts.delete(localEditorState.value.port);
             managedForwardPorts.delete(localEditorState.value.port);
@@ -8969,10 +9538,14 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
             instanceId,
             requestId: control.requestId,
             ok: true,
-            capabilities: capabilitiesPayload(),
+            capabilities: {
+              ...capabilitiesPayload(),
+              ...restartedEditorRevokedPorts.length === 0 ? {} : { revokedPorts: restartedEditorRevokedPorts }
+            },
             ...result.event
           });
           if (result.state.status === "running") {
+            startLocalEditorPortForwardWatcher(result.state);
             watchLocalEditorExit(result.state, editorGeneration, initialStatusPushed);
           }
           return initialStatusPushed;
@@ -9005,6 +9578,17 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       pushHeartbeat();
       return;
     }
+    if (isResolvePortForwardRequestControl(control)) {
+      const response = resolveEditorPortForwardRequest(control);
+      if (response !== undefined) {
+        kandan.push(topic, "codex_response", response).catch((error) => {
+          log("kandan.control_response_push_failed", {
+            message: error instanceof Error ? error.message : String(error)
+          });
+        });
+        return;
+      }
+    }
     if (isSetPortForwardEnabledControl(control)) {
       switch (control.enabled) {
         case true:
@@ -9014,6 +9598,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
           liveForwardPorts.delete(control.port);
           managedForwardPorts.delete(control.port);
           clearForwardPortAttribution(control.port);
+          localEditorForwardState.approvedPorts.delete(control.port);
+          localEditorForwardState.approvedTargets.delete(control.port);
           kandan.push(topic, "forward_port_revoked", {
             instanceId,
             port: control.port,
@@ -9205,6 +9791,24 @@ function codexTuiArgs(codexUrl, codexThreadId, session, fast) {
   const overrides = codexTuiConfigArgs(session, fast);
   return codexThreadId === undefined ? ["--remote", codexUrl, ...overrides] : ["resume", "--remote", codexUrl, ...overrides, codexThreadId];
 }
+function suppressedForwardPortsForRunner(kandanControlPort, managedForwardPorts) {
+  const suppressedPorts = new Set(managedForwardPorts);
+  if (kandanControlPort !== undefined) {
+    suppressedPorts.add(kandanControlPort);
+  }
+  return Array.from(suppressedPorts).sort((left, right) => left - right);
+}
+function explicitUrlPort(url) {
+  const parsed = new URL(url);
+  if (parsed.port === "") {
+    return;
+  }
+  const port = Number.parseInt(parsed.port, 10);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    throw new Error(`invalid Kandan URL port: ${url}`);
+  }
+  return port;
+}
 function codexTuiConfigArgs(session, fast) {
   const modelArgs = session?.model === undefined ? [] : ["--model", session.model];
   const reasoningArgs = session?.reasoningEffort === undefined ? [] : ["-c", `model_reasoning_effort="${session.reasoningEffort}"`];
@@ -9621,6 +10225,9 @@ function isUpdateRunnerConfigControl(control) {
 function isSetPortForwardEnabledControl(control) {
   return control.type === "set_port_forward_enabled" && Number.isInteger(control.port) && control.port > 0 && control.port <= 65535;
 }
+function isResolvePortForwardRequestControl(control) {
+  return control.type === "resolve_port_forward_request" && typeof control.requestId === "string" && (control.decision === "approve" || control.decision === "deny");
+}
 function normalizeAllowedCwds(values) {
   return Array.from(new Set(values.flatMap((value) => {
     const normalized = value.trim();
@@ -9656,7 +10263,7 @@ function allowedCwdSuggestions(cwd, allowedCwds) {
 }
 
 // src/authCache.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import { dirname as dirname6, join as join9 } from "node:path";
 function defaultAuthFilePath() {
@@ -9667,7 +10274,7 @@ function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePat
   if (!existsSync6(authFilePath)) {
     return;
   }
-  const authFile = parseAuthFile(readFileSync5(authFilePath, "utf8"));
+  const authFile = parseAuthFile(readFileSync6(authFilePath, "utf8"));
   const kandanBaseUrl = kandanHttpBaseUrl(kandanUrl);
   const entry = authFile.local_codex_runner?.[kandanBaseUrl];
   if (entry === undefined || entry.access_token.trim() === "") {
@@ -9685,7 +10292,7 @@ function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePat
 }
 function writeCachedLocalRunnerToken(args) {
   const authFilePath = args.authFilePath ?? defaultAuthFilePath();
-  const existing = existsSync6(authFilePath) ? parseAuthFile(readFileSync5(authFilePath, "utf8")) : { version: 1 };
+  const existing = existsSync6(authFilePath) ? parseAuthFile(readFileSync6(authFilePath, "utf8")) : { version: 1 };
   const kandanBaseUrl = kandanHttpBaseUrl(args.kandanUrl);
   const issuedAt = new Date;
   const expiresAt = args.expiresInSeconds === undefined ? undefined : new Date(issuedAt.getTime() + args.expiresInSeconds * 1000).toISOString();
@@ -9794,12 +10401,8 @@ async function acquireAndCacheToken(args) {
   return token.accessToken;
 }
 
-// src/defaultUrls.ts
-var defaultLinzumiHttpUrl = "https://serve.linzumi.com";
-var defaultLinzumiWebSocketUrl = "wss://serve.linzumi.com";
-
 // src/kandanTls.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
 import { Agent } from "undici";
 import { WebSocket as WsWebSocket } from "ws";
 function kandanTlsTrustFromEnv() {
@@ -9813,7 +10416,7 @@ function kandanTlsTrustFromCaFile(caFile) {
   if (!existsSync7(trimmed)) {
     throw new Error(`KANDAN_TLS_CA_FILE does not exist: ${trimmed}`);
   }
-  const ca = readFileSync6(trimmed, "utf8");
+  const ca = readFileSync7(trimmed, "utf8");
   return {
     caFile: trimmed,
     ca,
@@ -9842,7 +10445,7 @@ function trustedWebSocketFactory(trust, WebSocketImpl = WsWebSocket) {
 }
 
 // src/agentBootstrap.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "node:fs";
 import { dirname as dirname7, join as join10 } from "node:path";
 import { homedir as homedir7 } from "node:os";
 async function runAgentCliCommand(args, deps = {
@@ -10452,7 +11055,7 @@ function authorizationHeaders(token) {
   return { authorization: `Bearer ${token}` };
 }
 function readOptionalTextFile(path) {
-  return existsSync8(path) ? readFileSync7(path, "utf8") : undefined;
+  return existsSync8(path) ? readFileSync8(path, "utf8") : undefined;
 }
 function writeTextFile(path, content) {
   mkdirSync8(dirname7(path), { recursive: true });
@@ -10532,7 +11135,7 @@ Launch target:
 }
 
 // src/helloLinzumiProject.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "node:fs";
 import { dirname as dirname8, join as join11, resolve as resolve7 } from "node:path";
 import { fileURLToPath } from "node:url";
 var defaultHelloLinzumiProjectDir = "/tmp/hello_linzumi";
@@ -10542,7 +11145,7 @@ var defaultHelloLinzumiPort = 8787;
 var defaultHelloLinzumiHost = "0.0.0.0";
 var markerFile = ".linzumi-demo-project";
 var moduleDir = dirname8(fileURLToPath(import.meta.url));
-var linzumiLogoSvg = readFileSync8(join11(moduleDir, "assets", "linzumi-logo.svg"), "utf8");
+var linzumiLogoSvg = readFileSync9(join11(moduleDir, "assets", "linzumi-logo.svg"), "utf8");
 function createHelloLinzumiProject(input = {}) {
   const options = typeof input === "string" ? { rootPath: input } : input;
   const root = resolveHelloProjectRoot(options);
@@ -10597,7 +11200,7 @@ function assertWritableDemoRoot(root, reset) {
     return;
   }
   const markerPath = join11(root, markerFile);
-  const isDemoRoot = existsSync9(markerPath) && readFileSync8(markerPath, "utf8").trim() === "hello-linzumi";
+  const isDemoRoot = existsSync9(markerPath) && readFileSync9(markerPath, "utf8").trim() === "hello-linzumi";
   if (isDemoRoot && reset) {
     rmSync2(root, { recursive: true, force: true });
     return;
@@ -11100,7 +11703,7 @@ import {
   closeSync as closeSync2,
   mkdirSync as mkdirSync10,
   openSync as openSync3,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   watch,
   writeFileSync as writeFileSync8
 } from "node:fs";
@@ -11185,12 +11788,12 @@ function commanderDaemonStatus(runnerId, statusDir = commanderStatusDir(), proce
   if (!existsSync10(statusFile)) {
     return { status: "missing", runnerId, statusFile };
   }
-  const record = parseRecord(readFileSync9(statusFile, "utf8"));
+  const record = parseRecord(readFileSync10(statusFile, "utf8"));
   return processIsRunning(record.pid) && processMatchesRecord(record, processIdentityReader) ? { status: "running", record } : { status: "stopped", record };
 }
 async function waitForCommanderDaemon(options) {
   const now = options.now ?? (() => Date.now());
-  const readTextFile = options.readTextFile ?? ((path) => existsSync10(path) ? readFileSync9(path, "utf8") : undefined);
+  const readTextFile = options.readTextFile ?? ((path) => existsSync10(path) ? readFileSync10(path, "utf8") : undefined);
   const statusImpl = options.statusImpl ?? commanderDaemonStatus;
   const deadline = now() + options.timeoutMs;
   while (now() <= deadline) {
@@ -11445,7 +12048,7 @@ async function main(args) {
     }
     case "start": {
       const options = await parseStartRunnerArgs(parsed.args);
-      addAllowedCwd(options.cwd);
+      addAllowedCwdForLinzumiUrl(options.cwd, options.kandanUrl);
       await runLocalCodexRunner(withLocalMachineId(options));
       return;
     }
@@ -11548,19 +12151,16 @@ function runHelloCommand(args) {
 `);
 }
 function runPathsCommand(args) {
-  const [subcommand, pathValue, ...rest] = args;
-  if (subcommand === undefined || subcommand === "help" || subcommand === "--help") {
+  const { subcommand, pathValue, linzumiUrl, help } = parsePathsCommandArgs(args);
+  if (help || subcommand === undefined || subcommand === "help") {
     process.stdout.write(pathsHelpText());
     return;
   }
-  if (rest.length > 0) {
-    throw new Error("linzumi paths accepts one path argument");
-  }
   switch (subcommand) {
     case "list": {
-      const config = readLocalConfig();
+      const config = linzumiUrl === undefined ? readLocalConfig() : readLocalConfigForLinzumiUrl(linzumiUrl);
       if (config.allowedCwds.length === 0) {
-        process.stdout.write(`No trusted paths configured in ${localConfigPath()}
+        process.stdout.write(`No trusted paths configured in ${localConfigPath()}${pathsScopeSuffix(linzumiUrl)}
 `);
         return;
       }
@@ -11574,7 +12174,11 @@ function runPathsCommand(args) {
         throw new Error("missing path for linzumi paths add");
       }
       const trustedPath = realpathSync6(resolve9(expandUserPath(pathValue)));
-      addAllowedCwd(pathValue);
+      if (linzumiUrl === undefined) {
+        addAllowedCwd(pathValue);
+      } else {
+        addAllowedCwdForLinzumiUrl(pathValue, linzumiUrl);
+      }
       process.stdout.write(`Trusted ${trustedPath}
 `);
       return;
@@ -11583,7 +12187,11 @@ function runPathsCommand(args) {
       if (pathValue === undefined || pathValue.trim() === "") {
         throw new Error("missing path for linzumi paths remove");
       }
-      removeAllowedCwd(pathValue);
+      if (linzumiUrl === undefined) {
+        removeAllowedCwd(pathValue);
+      } else {
+        removeAllowedCwdForLinzumiUrl(pathValue, linzumiUrl);
+      }
       process.stdout.write(`Removed trusted path ${pathValue}
 `);
       return;
@@ -11592,6 +12200,46 @@ function runPathsCommand(args) {
       throw new Error(`invalid paths command: ${subcommand}`);
   }
 }
+function parsePathsCommandArgs(args) {
+  const positional = [];
+  let linzumiUrl;
+  let help = false;
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    switch (arg) {
+      case "--help":
+        help = true;
+        break;
+      case "--linzumi-url":
+      case "--kandan-url": {
+        const value = args[index + 1];
+        if (value === undefined || value.startsWith("--")) {
+          throw new Error(`missing value for ${arg}`);
+        }
+        linzumiUrl = value;
+        index += 1;
+        break;
+      }
+      default:
+        if (arg !== undefined && arg.startsWith("--")) {
+          throw new Error(`invalid flag: ${arg}`);
+        }
+        positional.push(arg ?? "");
+    }
+  }
+  if (positional.length > 2) {
+    throw new Error("linzumi paths accepts one path argument");
+  }
+  return {
+    subcommand: positional[0],
+    pathValue: positional[1],
+    linzumiUrl,
+    help
+  };
+}
+function pathsScopeSuffix(linzumiUrl) {
+  return linzumiUrl === undefined ? "" : ` for ${linzumiUrl}`;
+}
 async function runCommanderDaemonCommand(args) {
   const [subcommand, ...rest] = args;
   switch (subcommand) {
@@ -11823,7 +12471,7 @@ async function parseAgentRunnerArgs(args, deps = {
   const kandanUrl = stringValue3(values, "linzumi-url") ?? agentApiUrlToKandanUrl(tokenFile.apiUrl);
   const requestedCwdValue = cwdArg ?? stringValue3(values, "cwd");
   const requestedCwd = resolveUserPath(requestedCwdValue ?? process.cwd());
-  const configuredAllowedCwds2 = requestedCwdValue === undefined && !values.has("allowed-cwd") ? readConfiguredAllowedCwdDetails() : { allowedCwds: [], missingAllowedCwds: [] };
+  const configuredAllowedCwds2 = requestedCwdValue === undefined && !values.has("allowed-cwd") ? readConfiguredAllowedCwdDetailsForLinzumiUrl(kandanUrl) : { allowedCwds: [], missingAllowedCwds: [] };
   const allowedCwds = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue3(values, "allowed-cwd"))) : requestedCwdValue === undefined ? configuredAllowedCwds2.allowedCwds.length > 0 ? [...configuredAllowedCwds2.allowedCwds] : assertConfiguredAllowedCwds([requestedCwd]) : assertConfiguredAllowedCwds([requestedCwd]);
   const cwd = allowedCwds[0] ?? requestedCwd;
   const codexBin = stringValue3(values, "codex-bin") ?? "codex";
@@ -11870,7 +12518,7 @@ async function parseAgentRunnerArgs(args, deps = {
   };
 }
 function readAgentTokenTextFile(path) {
-  return existsSync11(path) ? readFileSync10(path, "utf8") : undefined;
+  return existsSync11(path) ? readFileSync11(path, "utf8") : undefined;
 }
 function rejectAgentRunnerTargetingFlags(values) {
   const unsupportedFlags = [
@@ -11954,7 +12602,7 @@ async function parseRunnerArgs(args, deps = {
   const kandanUrl = stringValue3(values, "linzumi-url") ?? defaultLinzumiWebSocketUrl;
   const cwd = stringValue3(values, "cwd") ?? process.cwd();
   const cwdAllowedCwds = assertConfiguredAllowedCwds([cwd]);
-  const localConfiguredAllowedCwds = values.has("allowed-cwd") ? { allowedCwds: [], missingAllowedCwds: [] } : readConfiguredAllowedCwdDetails();
+  const localConfiguredAllowedCwds = values.has("allowed-cwd") ? { allowedCwds: [], missingAllowedCwds: [] } : readConfiguredAllowedCwdDetailsForLinzumiUrl(kandanUrl);
   const configuredAllowedCwds2 = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue3(values, "allowed-cwd"))) : [...localConfiguredAllowedCwds.allowedCwds];
   const codexBin = stringValue3(values, "codex-bin") ?? "codex";
   const customCodeServerBin = stringValue3(values, "code-server-bin");
@@ -12167,7 +12815,7 @@ function parseChannelPath(channel) {
 function withLocalMachineId(options) {
   return {
     ...options,
-    machineId: ensureLocalMachineId()
+    machineId: localConfigScopeKey(options.kandanUrl) === localConfigScopeKey(defaultLinzumiWebSocketUrl) ? ensureLocalMachineId() : ensureLocalMachineIdForLinzumiUrl(options.kandanUrl)
   };
 }
 function required(values, key) {
@@ -12349,13 +12997,13 @@ function pathsHelpText() {
   return `Linzumi trusted paths
 
 Usage:
-  linzumi paths list
-  linzumi paths add <path>
-  linzumi paths remove <path>
+  linzumi paths [--linzumi-url <ws-url>] list
+  linzumi paths [--linzumi-url <ws-url>] add <path>
+  linzumi paths [--linzumi-url <ws-url>] remove <path>
 
-Trusted paths are stored in ~/.linzumi/config.json. linzumi connect always
-trusts its selected cwd for that runner process and also uses configured paths
-unless --allowed-cwd is passed with explicit extra roots.
+Trusted paths are stored in ~/.linzumi/config.json. Production/default paths
+use the root config fields; explicit --linzumi-url paths use a URL-scoped config
+section so local, staging, and production runners do not share trust state.
 `;
 }
 function startHelpText() {