@linzumi/cli 0.0.41-beta → 0.0.43-beta

package/README.md

@@ -63,7 +63,7 @@ Install the CLI or run it with `npx`:
 
 ```bash
 npm install -g @linzumi/cli@latest
-npx -y @linzumi/cli@0.0.41-beta --version
+npx -y @linzumi/cli@0.0.43-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -1,16 +1,16 @@
 // src/index.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync10, readFileSync as readFileSync9, realpathSync as realpathSync6 } from "node:fs";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { existsSync as existsSync11, readFileSync as readFileSync10, 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";
 
 // src/runner.ts
 import { spawn as spawn6 } from "node:child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { realpathSync as realpathSync4 } from "node:fs";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { realpathSync as realpathSync5 } from "node:fs";
 import { hostname as hostname2 } from "node:os";
-import { join as join6, resolve as resolve5 } from "node:path";
+import { join as join8, resolve as resolve6 } from "node:path";
 
 // src/channelSessionSupport.ts
 import { spawnSync } from "node:child_process";
@@ -248,7 +248,7 @@ function codexThreadRuntimeOverrides(options) {
     ...session.model === undefined ? {} : { model: session.model },
     ...session.reasoningEffort === undefined ? {} : { reasoningEffort: session.reasoningEffort },
     ...options.fast === true ? { serviceTier: "fast" } : {},
-    ...session.approvalPolicy === undefined ? {} : { approvalPolicy: session.approvalPolicy },
+    approvalPolicy: codexApprovalPolicyForRequest(session.approvalPolicy, session.sandbox),
     ...session.sandbox === undefined ? {} : { sandbox: session.sandbox }
   };
 }
@@ -259,10 +259,30 @@ function codexTurnRuntimeOverrides(options) {
     ...session.model === undefined ? {} : { model: session.model },
     ...session.reasoningEffort === undefined ? {} : { effort: session.reasoningEffort },
     ...options.fast === true ? { serviceTier: "fast" } : {},
-    ...session.approvalPolicy === undefined ? {} : { approvalPolicy: session.approvalPolicy },
+    approvalPolicy: codexApprovalPolicyForRequest(session.approvalPolicy, session.sandbox),
     ...session.sandbox === undefined ? {} : { sandboxPolicy: codexSandboxPolicy(session.sandbox, options.cwd) }
   };
 }
+function codexApprovalPolicySetting(approvalPolicy, sandbox) {
+  if (approvalPolicy === undefined || approvalPolicy === "default") {
+    return;
+  }
+  return codexApprovalPolicyForRequest(approvalPolicy, sandbox);
+}
+function codexApprovalPolicyForRequest(approvalPolicy, sandbox) {
+  switch (approvalPolicy) {
+    case undefined:
+    case "default":
+      return "on-request";
+    case "never":
+      return sandbox === "danger-full-access" ? "never" : "on-request";
+    case "on-request":
+    case "on-failure":
+      return approvalPolicy;
+    default:
+      throw new Error(`unsupported Codex approval policy: ${approvalPolicy}`);
+  }
+}
 function codexSandboxPolicy(sandbox, cwd) {
   switch (sandbox) {
     case "danger-full-access":
@@ -2441,6 +2461,8 @@ function shellCommandTokens(command) {
 var codexTypingHeartbeatMs = 5000;
 var defaultStreamFlushIntervalMs = 150;
 var maxForwardedTurnIds = 64;
+var maxClaimedKandanMessageKeys = 1024;
+var claimedKandanMessageKeys = new Set;
 async function attachChannelSession(args) {
   const session = args.options.channelSession;
   const chatTopic = `chat:${session.workspaceSlug}:${session.channelSlug}`;
@@ -2589,6 +2611,7 @@ async function attachChannelSession(args) {
       clearPendingStreamFlushTimers(state);
       rejectPendingApprovalRequests(state, new Error("runner closed"));
       await stopCodexTyping(args, state);
+      releaseKandanMessageClaims(state);
     }
   };
 }
@@ -2630,6 +2653,7 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     forwardedTurnIds: new Set,
     forwardingTurnIds: new Set,
     retryableTurnIds: new Set,
+    claimedKandanMessageKeys: new Set,
     localTuiTurnIds: new Set,
     mirroredTuiInputProjections: createBoundedCache(maxForwardedTurnIds),
     pendingTuiInputMirrors: new Map,
@@ -3356,6 +3380,15 @@ async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext
     });
     return;
   }
+  if (!claimKandanMessage(args, state, event)) {
+    args.log("kandan.message_ignored", {
+      seq: event.seq,
+      actor_slug: event.actorSlug ?? null,
+      actor_user_id: event.actorUserId ?? null,
+      reason: "duplicate_message_claim"
+    });
+    return;
+  }
   enqueuePendingKandanMessage(state.queue, {
     seq: event.seq,
     actorSlug: event.actorSlug,
@@ -3372,6 +3405,43 @@ async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext
   await publishKandanMessageState(args, event, { status: "queued" });
   await drainKandanMessageQueue(args, state, payloadContext);
 }
+function kandanMessageClaimKey(args, threadId, seq) {
+  const session = args.options.channelSession;
+  return [
+    args.options.runnerId,
+    args.instanceId,
+    session.workspaceSlug,
+    session.channelSlug,
+    threadId,
+    String(seq)
+  ].join(":");
+}
+function claimKandanMessage(args, state, event) {
+  const threadId = event.threadId;
+  if (threadId === undefined) {
+    return false;
+  }
+  const key = kandanMessageClaimKey(args, threadId, event.seq);
+  if (claimedKandanMessageKeys.has(key)) {
+    return false;
+  }
+  claimedKandanMessageKeys.add(key);
+  state.claimedKandanMessageKeys.add(key);
+  if (state.claimedKandanMessageKeys.size > maxClaimedKandanMessageKeys) {
+    const [expiredKey] = state.claimedKandanMessageKeys;
+    if (expiredKey !== undefined) {
+      state.claimedKandanMessageKeys.delete(expiredKey);
+      claimedKandanMessageKeys.delete(expiredKey);
+    }
+  }
+  return true;
+}
+function releaseKandanMessageClaims(state) {
+  for (const key of state.claimedKandanMessageKeys) {
+    claimedKandanMessageKeys.delete(key);
+  }
+  state.claimedKandanMessageKeys.clear();
+}
 async function startThreadMessageTurn(args, state, payloadContext, message) {
   if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
     throw new Error("cannot start a local Codex turn before thread binding");
@@ -3611,7 +3681,7 @@ async function handleCodexServerRequest(args, state, payloadContext, request) {
   throw new Error(message);
 }
 function codexApprovalRequestCanAutoAccept(settings, method) {
-  return settings.approvalPolicy === "never" && (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval");
+  return settings.approvalPolicy === "never" && settings.sandbox === "danger-full-access" && (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval");
 }
 function codexApprovalRequestCanSurface(method) {
   return method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval";
@@ -5132,20 +5202,27 @@ function runtimeSettingsFromOptions(options) {
   return {
     model: options.channelSession.model,
     reasoningEffort: options.channelSession.reasoningEffort,
-    approvalPolicy: options.channelSession.approvalPolicy,
+    approvalPolicy: codexApprovalPolicySetting(options.channelSession.approvalPolicy, options.channelSession.sandbox),
     sandbox: options.channelSession.sandbox,
     fast: options.fast
   };
 }
 function mergeRuntimeSettings(current, update) {
+  const sandbox = mergeOptionalStringRuntimeSetting(current.sandbox, update, "sandbox");
   return {
     model: mergeOptionalStringRuntimeSetting(current.model, update, "model"),
     reasoningEffort: mergeOptionalStringRuntimeSetting(current.reasoningEffort, update, "reasoningEffort"),
-    approvalPolicy: mergeOptionalStringRuntimeSetting(current.approvalPolicy, update, "approvalPolicy"),
-    sandbox: mergeOptionalStringRuntimeSetting(current.sandbox, update, "sandbox"),
+    approvalPolicy: mergeOptionalApprovalPolicyRuntimeSetting(current.approvalPolicy, update, sandbox),
+    sandbox,
     fast: update.fast ?? current.fast
   };
 }
+function mergeOptionalApprovalPolicyRuntimeSetting(current, update, sandbox) {
+  if (Object.prototype.hasOwnProperty.call(update, "approvalPolicy")) {
+    return codexApprovalPolicySetting(update.approvalPolicy ?? undefined, sandbox);
+  }
+  return codexApprovalPolicySetting(current, sandbox);
+}
 function mergeOptionalStringRuntimeSetting(current, update, key) {
   if (Object.prototype.hasOwnProperty.call(update, key)) {
     return update[key] ?? undefined;
@@ -7947,6 +8024,356 @@ function waitForOpen2(websocket) {
   });
 }
 
+// src/runnerLock.ts
+import {
+  closeSync,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync6,
+  openSync as openSync2,
+  readFileSync as readFileSync4,
+  unlinkSync as unlinkSync2,
+  writeSync
+} from "node:fs";
+import { dirname as dirname5, join as join7 } from "node:path";
+
+// src/localConfig.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  existsSync as existsSync4,
+  linkSync,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync3,
+  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";
+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 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 };
+}
+function ensureLocalMachineId(path = localConfigPath(), createMachineId = randomUUID2) {
+  const config = readLocalConfig(path);
+  if (config.machineId !== undefined) {
+    return config.machineId;
+  }
+  const machineId = ensureLocalMachineIdSeed(path, createMachineId);
+  const latestConfig = readLocalConfig(path);
+  const latestMachineId = latestConfig.machineId;
+  if (latestMachineId !== undefined) {
+    return latestMachineId;
+  }
+  writeLocalConfig({ ...latestConfig, machineId }, path);
+  return machineId;
+}
+function localMachineIdSeedPath(configPath = localConfigPath()) {
+  return join6(dirname4(configPath), `${basename4(configPath)}.machine-id`);
+}
+function readConfiguredAllowedCwdDetails(path = localConfigPath()) {
+  const allowedCwds = [];
+  const missingAllowedCwds = [];
+  for (const cwd of readLocalConfig(path).allowedCwds) {
+    const absolutePath = resolve5(expandUserPath(cwd));
+    try {
+      const realPath = realpathSync4(absolutePath);
+      allowedCwds.push(...realPath === absolutePath ? [realPath] : [realPath, absolutePath]);
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        missingAllowedCwds.push(absolutePath);
+        continue;
+      }
+      throw error;
+    }
+  }
+  return {
+    allowedCwds: uniqueStrings(allowedCwds),
+    missingAllowedCwds: uniqueStrings(missingAllowedCwds)
+  };
+}
+function addAllowedCwd(pathValue, path = localConfigPath()) {
+  const normalizedPath = realpathSync4(resolve5(expandUserPath(pathValue)));
+  const config = readLocalConfig(path);
+  const allowedCwds = uniqueStrings([...config.allowedCwds, normalizedPath]);
+  writeLocalConfig({ ...config, version: 1, allowedCwds }, path);
+  return allowedCwds;
+}
+function removeAllowedCwd(pathValue, path = localConfigPath()) {
+  const requestedPath = resolve5(expandUserPath(pathValue));
+  const normalizedRequest = realpathOrResolved(requestedPath);
+  const config = readLocalConfig(path);
+  const allowedCwds = config.allowedCwds.filter((cwd) => {
+    const normalizedExisting = realpathOrResolved(cwd);
+    return cwd !== pathValue && normalizedExisting !== normalizedRequest;
+  });
+  writeLocalConfig({ ...config, version: 1, allowedCwds }, path);
+  return allowedCwds;
+}
+function writeLocalConfig(config, path = localConfigPath()) {
+  mkdirSync5(dirname4(path), { recursive: true });
+  writeFileSync4(path, `${JSON.stringify(config, 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() !== "");
+}
+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);
+  if (existsSync4(seedPath)) {
+    return readMachineIdSeed(seedPath);
+  }
+  const machineId = createMachineId();
+  if (!machineIdValid(machineId)) {
+    throw new Error(`invalid generated Linzumi machine id: ${machineId}`);
+  }
+  mkdirSync5(dirname4(seedPath), { recursive: true });
+  const tempPath = join6(dirname4(seedPath), `.${basename4(seedPath)}.${process.pid}.${randomUUID2()}.tmp`);
+  writeFileSync4(tempPath, `${machineId}
+`, { encoding: "utf8", flag: "wx" });
+  try {
+    linkSync(tempPath, seedPath);
+    return machineId;
+  } catch (error) {
+    if (isNodeErrorCode(error, "EEXIST")) {
+      return readMachineIdSeed(seedPath);
+    }
+    throw error;
+  } finally {
+    unlinkSync(tempPath);
+  }
+}
+function readMachineIdSeed(seedPath) {
+  const machineId = readFileSync3(seedPath, "utf8").trim();
+  if (!machineIdValid(machineId)) {
+    throw new Error(`invalid Linzumi machine id seed: ${seedPath}`);
+  }
+  return machineId;
+}
+function uniqueStrings(values) {
+  return [
+    ...new Set(values.map((value) => value.trim()).filter((value) => value !== ""))
+  ];
+}
+function isMissingPathError(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "EACCES" || error.code === "ELOOP" || error.code === "EIO");
+}
+function isNodeErrorCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function realpathOrResolved(pathValue) {
+  try {
+    return realpathSync4(resolve5(expandUserPath(pathValue)));
+  } catch (_error) {
+    return resolve5(expandUserPath(pathValue));
+  }
+}
+
+// src/version.ts
+var linzumiCliVersion = "0.0.43-beta";
+var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
+
+// src/runnerLock.ts
+function runnerLockPath(machineId, configPath = localConfigPath()) {
+  return join7(dirname5(configPath), "runners", `${encodeURIComponent(machineId)}.lock`);
+}
+function acquireRunnerLock(options) {
+  const path = runnerLockPath(options.machineId, options.configPath);
+  const isPidAlive = options.isPidAlive ?? processIsAlive;
+  const record = {
+    version: 1,
+    machineId: options.machineId,
+    runnerId: options.runnerId,
+    pid: options.pid ?? process.pid,
+    cwd: options.cwd,
+    workspace: options.workspace,
+    startedAt: (options.now ?? (() => new Date))().toISOString(),
+    cliVersion: options.cliVersion ?? linzumiCliVersion
+  };
+  writeLockOrHandleExisting(path, record, isPidAlive, options.beforeReadExistingLock, options.beforeReplaceStaleLock);
+  return {
+    path,
+    record,
+    release: () => releaseRunnerLock(path, record)
+  };
+}
+function writeLockOrHandleExisting(path, record, isPidAlive, beforeReadExistingLock, beforeReplaceStaleLock) {
+  if (tryCreateLock(path, record)) {
+    return;
+  }
+  beforeReadExistingLock?.();
+  const existing = readRunnerLockIfPresent(path);
+  if (existing === undefined) {
+    if (tryCreateLock(path, record)) {
+      return;
+    }
+    throw new Error(`another Linzumi runner lock appeared while starting: ${path}`);
+  }
+  if (isPidAlive(existing.pid)) {
+    throw new Error(activeRunnerLockMessage(path, existing));
+  }
+  beforeReplaceStaleLock?.();
+  withStaleReplacementLock(path, isPidAlive, () => {
+    const latest = existsSync5(path) ? readRunnerLock(path) : undefined;
+    if (latest !== undefined && isPidAlive(latest.pid)) {
+      throw new Error(activeRunnerLockMessage(path, latest));
+    }
+    if (latest !== undefined) {
+      unlinkSync2(path);
+    }
+    if (!tryCreateLock(path, record)) {
+      throw new Error(`another Linzumi runner lock appeared while starting: ${path}`);
+    }
+  });
+}
+function tryCreateLock(path, record) {
+  mkdirSync6(dirname5(path), { recursive: true });
+  try {
+    const fd = openSync2(path, "wx");
+    try {
+      writeSync(fd, `${JSON.stringify(record, null, 2)}
+`);
+    } finally {
+      closeSync(fd);
+    }
+    return true;
+  } catch (error) {
+    if (isNodeErrorCode2(error, "EEXIST")) {
+      return false;
+    }
+    throw error;
+  }
+}
+function withStaleReplacementLock(path, isPidAlive, callback) {
+  const replacementPath = `${path}.replace`;
+  while (true) {
+    try {
+      const fd = openSync2(replacementPath, "wx");
+      try {
+        writeSync(fd, `${process.pid}
+`);
+        callback();
+      } finally {
+        closeSync(fd);
+        unlinkSync2(replacementPath);
+      }
+      return;
+    } catch (error) {
+      if (isNodeErrorCode2(error, "EEXIST")) {
+        const replacementPid = readReplacementLockPidIfPresent(replacementPath);
+        if (replacementPid === undefined) {
+          continue;
+        }
+        if (isPidAlive(replacementPid)) {
+          throw new Error([
+            "another Linzumi runner is already replacing a stale runner lock",
+            `lock: ${path}`,
+            "Wait for that startup to finish, then retry."
+          ].join(`
+`));
+        }
+        unlinkSync2(replacementPath);
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+function readReplacementLockPidIfPresent(path) {
+  let value;
+  try {
+    value = readFileSync4(path, "utf8").trim();
+  } catch (error) {
+    if (isNodeErrorCode2(error, "ENOENT")) {
+      return;
+    }
+    throw error;
+  }
+  const pid = Number.parseInt(value, 10);
+  if (pid.toString() !== value || pid <= 0) {
+    throw new Error(`invalid Linzumi runner replacement lock: ${path}`);
+  }
+  return pid;
+}
+function releaseRunnerLock(path, record) {
+  const current = readRunnerLockForRelease(path);
+  if (current !== undefined && current.machineId === record.machineId && current.runnerId === record.runnerId && current.pid === record.pid) {
+    unlinkSync2(path);
+  }
+}
+function readRunnerLockForRelease(path) {
+  try {
+    return readRunnerLockIfPresent(path);
+  } catch (_error) {
+    return;
+  }
+}
+function readRunnerLockIfPresent(path) {
+  if (!existsSync5(path)) {
+    return;
+  }
+  try {
+    return readRunnerLock(path);
+  } catch (error) {
+    if (isNodeErrorCode2(error, "ENOENT")) {
+      return;
+    }
+    throw error;
+  }
+}
+function readRunnerLock(path) {
+  const parsed = JSON.parse(readFileSync4(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() !== "";
+}
+function workspaceValid(value) {
+  return value === null || typeof value === "string" && value.trim() !== "";
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return isNodeErrorCode2(error, "ESRCH") ? false : true;
+  }
+}
+function activeRunnerLockMessage(path, record) {
+  const workspace = record.workspace === null ? "workspace: unknown" : `workspace: ${record.workspace}`;
+  return [
+    "another Linzumi runner is already running for this machine",
+    `runner id: ${record.runnerId}`,
+    `pid: ${record.pid}`,
+    `cwd: ${record.cwd}`,
+    workspace,
+    `CLI version: ${record.cliVersion}`,
+    `started at: ${record.startedAt}`,
+    `lock: ${path}`,
+    "Stop that process first, then retry. If the process has already exited, remove the stale lock file and retry."
+  ].join(`
+`);
+}
+function isNodeErrorCode2(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+
 // src/runnerConsoleReporter.ts
 function reportRunnerConsoleEvent(event, payload) {
   const line = formatRunnerConsoleEvent(event, payload);
@@ -7958,7 +8385,15 @@ function reportRunnerConsoleEvent(event, payload) {
 function formatRunnerConsoleEvent(event, payload) {
   switch (event) {
     case "runner.instance_started":
-      return `Runner connected: instance=${text(payload.instanceId)} codex=${text(payload.codexUrl)}`;
+      return connectedRunnerMessage(payload);
+    case "runner.replaced":
+      return [
+        "Runner replaced: another Linzumi CLI connected from this machine.",
+        `New runner: ${text(payload.replacementRunnerId)}`,
+        `Version: ${text(payload.replacementVersion)}`,
+        "This process is exiting."
+      ].join(`
+`);
     case "kandan.message_ignored":
       return `Incoming message from ${sender(payload)}: ignored for reason ${text(payload.reason)}`;
     case "kandan.message_queued":
@@ -7993,6 +8428,40 @@ function formatRunnerConsoleEvent(event, payload) {
       return;
   }
 }
+function connectedRunnerMessage(payload) {
+  return [
+    "Connected to Linzumi",
+    optionalLine("Computer", payload.hostname),
+    optionalLine("Workspace", payload.workspace),
+    `Runner: ${text(payload.runnerId)}`,
+    `CLI: ${text(payload.version)}`,
+    optionalLine("Codex", payload.codexUrl),
+    ...replacementLines(payload.replacedRunners)
+  ].filter((line) => line !== undefined).join(`
+`);
+}
+function optionalLine(label, value) {
+  const normalized = stringValue2(value) ?? numberValue(value)?.toString();
+  return normalized === undefined ? undefined : `${label}: ${normalized}`;
+}
+function replacementLines(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      return [];
+    }
+    const record = entry;
+    const runnerId = stringValue2(record.runnerId);
+    if (runnerId === undefined) {
+      return [];
+    }
+    const version = stringValue2(record.version);
+    const suffix = version === undefined ? "" : ` (CLI ${version})`;
+    return [`Replaced older runner from this machine: ${runnerId}${suffix}`];
+  });
+}
 function sender(payload) {
   const slug = stringValue2(payload.actor_slug);
   const userId = numberValue(payload.actor_user_id);
@@ -8056,6 +8525,21 @@ async function runLocalCodexRunner(options) {
     kandanUrl: options.kandanUrl
   });
   try {
+    if (options.machineId !== undefined) {
+      const runnerLock = acquireRunnerLock({
+        machineId: options.machineId,
+        runnerId: options.runnerId,
+        cwd: options.cwd,
+        workspace: runnerWorkspaceSlug(options) ?? null,
+        configPath: options.runnerLockConfigPath
+      });
+      cleanup.actions.push(() => runnerLock.release());
+      log("runner.lock_acquired", {
+        path: runnerLock.path,
+        machineId: options.machineId,
+        runnerId: options.runnerId
+      });
+    }
     return await openLocalCodexRunner(options, log, cleanup, close);
   } catch (error) {
     await close().catch(() => {
@@ -8123,9 +8607,11 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const kandan = await connectPhoenixClient(options.kandanUrl, options.token, options.socketFactory);
   cleanup.actions.push(() => kandan.close());
   const topic = `local_runner:${options.runnerId}`;
+  const clientId = options.machineId ?? options.runnerId;
   const joinPayload = () => ({
     clientName: "kandan-local-codex-runner",
-    version: "0.0.1",
+    clientId,
+    version: linzumiCliVersion,
     workspace: runnerWorkspaceSlug(options) ?? null,
     channel: options.channelSession?.channelSlug ?? null,
     capabilities: capabilitiesPayload()
@@ -8140,7 +8626,10 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     }
     dispatcher(control);
   });
-  await kandan.join(topic, joinPayload(), { rejoinPayload: joinPayload });
+  const joinResponse = await kandan.join(topic, joinPayload(), {
+    rejoinPayload: joinPayload
+  });
+  const replacedRunners = replacementRunnerSummaries(objectValue(joinResponse)?.replaced_runners);
   const started = options.codexUrl === undefined ? await startOwnedCodexAppServer(options) : undefined;
   if (started !== undefined) {
     cleanup.actions.push(() => {
@@ -8151,7 +8640,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   if (codexUrl === undefined) {
     throw new Error("missing codex app-server websocket URL");
   }
-  const instanceId = `codex-${randomUUID2()}`;
+  const instanceId = `codex-${randomUUID3()}`;
   const publishLocalEditorStatus = (payload) => {
     kandan.push(topic, "local_editor_status", payload).catch((error) => {
       log("kandan.local_editor_status_push_failed", {
@@ -8199,6 +8688,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const runtimeDefaults = runnerRuntimeDefaults(options);
   const instancePayload = {
     instanceId,
+    clientId,
     codexUrl,
     tuiLaunched: options.launchTui,
     cwd: options.cwd,
@@ -8211,7 +8701,15 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     fast: options.fast ?? false
   };
   await kandan.push(topic, "instance_started", instancePayload);
-  log("runner.instance_started", { instanceId, codexUrl });
+  log("runner.instance_started", {
+    runnerId: options.runnerId,
+    hostname: runnerHost,
+    workspace: runnerWorkspaceSlug(options) ?? null,
+    version: linzumiCliVersion,
+    instanceId,
+    codexUrl,
+    replacedRunners
+  });
   const channelSession = options.channelSession === undefined ? undefined : await attachChannelSession({
     kandan,
     codex,
@@ -8312,6 +8810,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   };
   const heartbeatPayload = () => ({
     instanceId,
+    clientId,
     codexUrl,
     cwd: options.cwd,
     hostname: runnerHost,
@@ -8390,6 +8889,20 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   });
   const handleControl = (control) => {
     log("kandan.control", { control });
+    if (control.type === "replace_runner") {
+      log("runner.replaced", {
+        runnerId: options.runnerId,
+        reason: control.reason,
+        replacementRunnerId: control.replacementRunnerId,
+        replacementVersion: control.replacementVersion
+      });
+      close().catch((error) => {
+        log("runner.replace_close_failed", {
+          message: error instanceof Error ? error.message : String(error)
+        });
+      });
+      return;
+    }
     if (!controlTargetsInstance(control, instanceId)) {
       log("kandan.control_ignored", {
         reason: "instance_id_mismatch",
@@ -8604,8 +9117,24 @@ function normalizedWorkDescription(value) {
   const normalized = value?.trim();
   return normalized === undefined || normalized === "" ? undefined : normalized;
 }
+function replacementRunnerSummaries(value) {
+  const entries = arrayValue(value) ?? [];
+  return entries.flatMap((entry) => {
+    const record = objectValue(entry);
+    const runnerId = stringValue(record?.runnerId);
+    if (runnerId === undefined) {
+      return [];
+    }
+    return [
+      {
+        runnerId,
+        version: stringValue(record?.version) ?? null
+      }
+    ];
+  });
+}
 function makeRunnerLogger(options) {
-  return createRunnerLogger(options.logFile ?? join6(options.cwd, ".linzumi-runner.log"), options.launchTui ? undefined : reportRunnerConsoleEvent);
+  return createRunnerLogger(options.logFile ?? join8(options.cwd, ".linzumi-runner.log"), options.launchTui ? undefined : reportRunnerConsoleEvent);
 }
 function installCleanupHandlers(close) {
   const closeAndExit = () => {
@@ -9054,11 +9583,12 @@ function optionalThreadControlField(control, field) {
 }
 function startInstanceRuntimeSettings(options, control) {
   const defaults = runnerRuntimeDefaults(options);
+  const sandbox = control.sandbox ?? defaults.sandbox;
   return {
     model: control.model ?? defaults.model,
     reasoningEffort: control.reasoningEffort ?? defaults.reasoningEffort,
-    approvalPolicy: control.approvalPolicy ?? defaults.approvalPolicy,
-    sandbox: control.sandbox ?? defaults.sandbox,
+    approvalPolicy: codexApprovalPolicyForRequest(control.approvalPolicy ?? defaults.approvalPolicy, sandbox),
+    sandbox,
     fast: control.fast ?? options.fast
   };
 }
@@ -9077,11 +9607,12 @@ function runnerWorkspaceSlug(options) {
 function runnerRuntimeDefaults(options) {
   const session = options.channelSession;
   const defaults = options.runtimeDefaults;
+  const sandbox = defaults?.sandbox ?? session?.sandbox;
   return {
     model: defaults?.model ?? session?.model,
     reasoningEffort: defaults?.reasoningEffort ?? session?.reasoningEffort,
-    approvalPolicy: defaults?.approvalPolicy ?? session?.approvalPolicy,
-    sandbox: defaults?.sandbox ?? session?.sandbox
+    approvalPolicy: codexApprovalPolicySetting(defaults?.approvalPolicy ?? session?.approvalPolicy, sandbox),
+    sandbox
   };
 }
 function isUpdateRunnerConfigControl(control) {
@@ -9100,9 +9631,9 @@ function configuredAllowedCwds(values) {
   const allowedCwds = [];
   const missingAllowedCwds = [];
   for (const value of normalizeAllowedCwds(values)) {
-    const absolutePath = resolve5(expandUserPath(value));
+    const absolutePath = resolve6(expandUserPath(value));
     try {
-      const realPath = realpathSync4(absolutePath);
+      const realPath = realpathSync5(absolutePath);
       allowedCwds.push(...realPath === absolutePath ? [realPath] : [realPath, absolutePath]);
     } catch (error) {
       if (isMissingAllowedCwdError(error)) {
@@ -9125,18 +9656,18 @@ function allowedCwdSuggestions(cwd, allowedCwds) {
 }
 
 // src/authCache.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname4, join as join7 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync5, 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() {
-  const base = process.env.KANDAN_HOME ?? join7(homedir5(), ".kandan");
-  return join7(base, "auth.json");
+  const base = process.env.KANDAN_HOME ?? join9(homedir6(), ".kandan");
+  return join9(base, "auth.json");
 }
 function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePath()) {
-  if (!existsSync4(authFilePath)) {
+  if (!existsSync6(authFilePath)) {
     return;
   }
-  const authFile = parseAuthFile(readFileSync3(authFilePath, "utf8"));
+  const authFile = parseAuthFile(readFileSync5(authFilePath, "utf8"));
   const kandanBaseUrl = kandanHttpBaseUrl(kandanUrl);
   const entry = authFile.local_codex_runner?.[kandanBaseUrl];
   if (entry === undefined || entry.access_token.trim() === "") {
@@ -9154,7 +9685,7 @@ function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePat
 }
 function writeCachedLocalRunnerToken(args) {
   const authFilePath = args.authFilePath ?? defaultAuthFilePath();
-  const existing = existsSync4(authFilePath) ? parseAuthFile(readFileSync3(authFilePath, "utf8")) : { version: 1 };
+  const existing = existsSync6(authFilePath) ? parseAuthFile(readFileSync5(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();
@@ -9170,8 +9701,8 @@ function writeCachedLocalRunnerToken(args) {
       }
     }
   };
-  mkdirSync5(dirname4(authFilePath), { recursive: true });
-  writeFileSync4(authFilePath, `${JSON.stringify(next, null, 2)}
+  mkdirSync7(dirname6(authFilePath), { recursive: true });
+  writeFileSync5(authFilePath, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   return {
     accessToken: args.accessToken,
@@ -9263,102 +9794,12 @@ async function acquireAndCacheToken(args) {
   return token.accessToken;
 }
 
-// src/localConfig.ts
-import {
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync4,
-  realpathSync as realpathSync5,
-  writeFileSync as writeFileSync5
-} from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { dirname as dirname5, resolve as resolve6 } from "node:path";
-function localConfigPath(env = process.env) {
-  const override = env.LINZUMI_CONFIG_FILE;
-  return override !== undefined && override.trim() !== "" ? resolve6(expandUserPath(override)) : resolve6(homedir6(), ".linzumi", "config.json");
-}
-function readLocalConfig(path = localConfigPath()) {
-  if (!existsSync5(path)) {
-    return { version: 1, allowedCwds: [] };
-  }
-  const parsed = JSON.parse(readFileSync4(path, "utf8"));
-  if (!isConfigPayload(parsed)) {
-    throw new Error(`invalid Linzumi config: ${path}`);
-  }
-  return {
-    version: 1,
-    allowedCwds: uniqueStrings(parsed.allowedCwds)
-  };
-}
-function readConfiguredAllowedCwdDetails(path = localConfigPath()) {
-  const allowedCwds = [];
-  const missingAllowedCwds = [];
-  for (const cwd of readLocalConfig(path).allowedCwds) {
-    const absolutePath = resolve6(expandUserPath(cwd));
-    try {
-      const realPath = realpathSync5(absolutePath);
-      allowedCwds.push(...realPath === absolutePath ? [realPath] : [realPath, absolutePath]);
-    } catch (error) {
-      if (isMissingPathError(error)) {
-        missingAllowedCwds.push(absolutePath);
-        continue;
-      }
-      throw error;
-    }
-  }
-  return {
-    allowedCwds: uniqueStrings(allowedCwds),
-    missingAllowedCwds: uniqueStrings(missingAllowedCwds)
-  };
-}
-function addAllowedCwd(pathValue, path = localConfigPath()) {
-  const normalizedPath = realpathSync5(resolve6(expandUserPath(pathValue)));
-  const config = readLocalConfig(path);
-  const allowedCwds = uniqueStrings([...config.allowedCwds, normalizedPath]);
-  writeLocalConfig({ version: 1, allowedCwds }, path);
-  return allowedCwds;
-}
-function removeAllowedCwd(pathValue, path = localConfigPath()) {
-  const requestedPath = resolve6(expandUserPath(pathValue));
-  const normalizedRequest = realpathOrResolved(requestedPath);
-  const config = readLocalConfig(path);
-  const allowedCwds = config.allowedCwds.filter((cwd) => {
-    const normalizedExisting = realpathOrResolved(cwd);
-    return cwd !== pathValue && normalizedExisting !== normalizedRequest;
-  });
-  writeLocalConfig({ version: 1, allowedCwds }, path);
-  return allowedCwds;
-}
-function writeLocalConfig(config, path = localConfigPath()) {
-  mkdirSync6(dirname5(path), { recursive: true });
-  writeFileSync5(path, `${JSON.stringify(config, null, 2)}
-`, "utf8");
-}
-function isConfigPayload(value) {
-  return typeof value === "object" && value !== null && value.version === 1 && Array.isArray(value.allowedCwds) && value.allowedCwds.every((cwd) => typeof cwd === "string" && cwd.trim() !== "");
-}
-function uniqueStrings(values) {
-  return [
-    ...new Set(values.map((value) => value.trim()).filter((value) => value !== ""))
-  ];
-}
-function isMissingPathError(error) {
-  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "EACCES" || error.code === "ELOOP" || error.code === "EIO");
-}
-function realpathOrResolved(pathValue) {
-  try {
-    return realpathSync5(resolve6(expandUserPath(pathValue)));
-  } catch (_error) {
-    return resolve6(expandUserPath(pathValue));
-  }
-}
-
 // src/defaultUrls.ts
 var defaultLinzumiHttpUrl = "https://serve.linzumi.com";
 var defaultLinzumiWebSocketUrl = "wss://serve.linzumi.com";
 
 // src/kandanTls.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
 import { Agent } from "undici";
 import { WebSocket as WsWebSocket } from "ws";
 function kandanTlsTrustFromEnv() {
@@ -9369,10 +9810,10 @@ function kandanTlsTrustFromCaFile(caFile) {
     return;
   }
   const trimmed = caFile.trim();
-  if (!existsSync6(trimmed)) {
+  if (!existsSync7(trimmed)) {
     throw new Error(`KANDAN_TLS_CA_FILE does not exist: ${trimmed}`);
   }
-  const ca = readFileSync5(trimmed, "utf8");
+  const ca = readFileSync6(trimmed, "utf8");
   return {
     caFile: trimmed,
     ca,
@@ -9401,8 +9842,8 @@ function trustedWebSocketFactory(trust, WebSocketImpl = WsWebSocket) {
 }
 
 // src/agentBootstrap.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname6, join as join8 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync7, 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 = {
   fetchImpl: fetch,
@@ -10002,7 +10443,7 @@ function agentTokenFile(flags) {
   return flags.get("agent-token-file") ?? defaultAgentTokenFilePath();
 }
 function defaultAgentTokenFilePath() {
-  return join8(homedir7(), ".linzumi", "agent-token.json");
+  return join10(homedir7(), ".linzumi", "agent-token.json");
 }
 function normalizedApiUrl(apiUrl) {
   return apiUrl.endsWith("/") ? apiUrl : `${apiUrl}/`;
@@ -10011,10 +10452,10 @@ function authorizationHeaders(token) {
   return { authorization: `Bearer ${token}` };
 }
 function readOptionalTextFile(path) {
-  return existsSync7(path) ? readFileSync6(path, "utf8") : undefined;
+  return existsSync8(path) ? readFileSync7(path, "utf8") : undefined;
 }
 function writeTextFile(path, content) {
-  mkdirSync7(dirname6(path), { recursive: true });
+  mkdirSync8(dirname7(path), { recursive: true });
   writeFileSync6(path, content);
 }
 function readStoredAgentTokenFile(path, readTextFile = readOptionalTextFile) {
@@ -10091,8 +10532,8 @@ Launch target:
 }
 
 // src/helloLinzumiProject.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname7, join as join9, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync8, 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";
 var defaultHelloLinzumiProjectName = "hello_linzumi";
@@ -10100,8 +10541,8 @@ var defaultHelloLinzumiParentDir = "/tmp";
 var defaultHelloLinzumiPort = 8787;
 var defaultHelloLinzumiHost = "0.0.0.0";
 var markerFile = ".linzumi-demo-project";
-var moduleDir = dirname7(fileURLToPath(import.meta.url));
-var linzumiLogoSvg = readFileSync7(join9(moduleDir, "assets", "linzumi-logo.svg"), "utf8");
+var moduleDir = dirname8(fileURLToPath(import.meta.url));
+var linzumiLogoSvg = readFileSync8(join11(moduleDir, "assets", "linzumi-logo.svg"), "utf8");
 function createHelloLinzumiProject(input = {}) {
   const options = typeof input === "string" ? { rootPath: input } : input;
   const root = resolveHelloProjectRoot(options);
@@ -10109,9 +10550,9 @@ function createHelloLinzumiProject(input = {}) {
   const host = normalizeHost(options.host);
   assertTcpPort(port);
   assertWritableDemoRoot(root, options.reset === true);
-  mkdirSync8(join9(root, "src"), { recursive: true });
+  mkdirSync9(join11(root, "src"), { recursive: true });
   for (const file of demoFiles({ root, port, host })) {
-    writeFileSync7(join9(root, file.path), file.content, "utf8");
+    writeFileSync7(join11(root, file.path), file.content, "utf8");
   }
   return {
     root,
@@ -10152,11 +10593,11 @@ function assertTcpPort(port) {
   throw new Error("--port must be a TCP port from 1 to 65535");
 }
 function assertWritableDemoRoot(root, reset) {
-  if (!existsSync8(root)) {
+  if (!existsSync9(root)) {
     return;
   }
-  const markerPath = join9(root, markerFile);
-  const isDemoRoot = existsSync8(markerPath) && readFileSync7(markerPath, "utf8").trim() === "hello-linzumi";
+  const markerPath = join11(root, markerFile);
+  const isDemoRoot = existsSync9(markerPath) && readFileSync8(markerPath, "utf8").trim() === "hello-linzumi";
   if (isDemoRoot && reset) {
     rmSync2(root, { recursive: true, force: true });
     return;
@@ -10655,27 +11096,30 @@ To kick the agent off:
 
 // src/commanderDaemon.ts
 import {
-  existsSync as existsSync9,
-  closeSync,
-  mkdirSync as mkdirSync9,
-  openSync as openSync2,
-  readFileSync as readFileSync8,
+  existsSync as existsSync10,
+  closeSync as closeSync2,
+  mkdirSync as mkdirSync10,
+  openSync as openSync3,
+  readFileSync as readFileSync9,
   watch,
   writeFileSync as writeFileSync8
 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname8, join as join10, resolve as resolve8 } from "node:path";
+import { dirname as dirname9, join as join12, resolve as resolve8 } from "node:path";
 import { execFileSync, spawn as spawn7 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var connectedMarker = "Runner connected:";
+var connectedMarkers = ["Connected to Linzumi", "Runner connected:"];
 function commanderStatusDir() {
-  return join10(homedir8(), ".linzumi", "commanders");
+  return join12(homedir8(), ".linzumi", "commanders");
 }
 function commanderStatusFile(runnerId, statusDir = commanderStatusDir()) {
-  return join10(statusDir, `${safeRunnerId(runnerId)}.json`);
+  return join12(statusDir, `${safeRunnerId(runnerId)}.json`);
 }
 function defaultCommanderLogFile(runnerId, statusDir = commanderStatusDir()) {
-  return join10(statusDir, `${safeRunnerId(runnerId)}.log`);
+  return join12(statusDir, `${safeRunnerId(runnerId)}.log`);
+}
+function commanderLogIsConnected(log) {
+  return connectedMarkers.some((marker) => log.includes(marker));
 }
 function startCommanderDaemon(options) {
   const statusDir = options.statusDir ?? commanderStatusDir();
@@ -10693,10 +11137,10 @@ function startCommanderDaemon(options) {
     "--log-file",
     logFile
   ];
-  mkdirSync9(statusDir, { recursive: true });
-  mkdirSync9(dirname8(logFile), { recursive: true });
-  const out = openSync2(logFile, "a");
-  const err = openSync2(logFile, "a");
+  mkdirSync10(statusDir, { recursive: true });
+  mkdirSync10(dirname9(logFile), { recursive: true });
+  const out = openSync3(logFile, "a");
+  const err = openSync3(logFile, "a");
   writeCliAuditEvent("process.spawn", {
     command: nodeBin,
     args: command,
@@ -10715,8 +11159,8 @@ function startCommanderDaemon(options) {
     pid: child.pid,
     purpose: "commander_daemon.start"
   }, { sessionId: options.runnerId });
-  closeSync(out);
-  closeSync(err);
+  closeSync2(out);
+  closeSync2(err);
   child.unref();
   if (child.pid === undefined) {
     throw new Error("commander daemon did not report a pid");
@@ -10738,15 +11182,15 @@ function startCommanderDaemon(options) {
 }
 function commanderDaemonStatus(runnerId, statusDir = commanderStatusDir(), processIdentityReader = readProcessIdentity) {
   const statusFile = commanderStatusFile(runnerId, statusDir);
-  if (!existsSync9(statusFile)) {
+  if (!existsSync10(statusFile)) {
     return { status: "missing", runnerId, statusFile };
   }
-  const record = parseRecord(readFileSync8(statusFile, "utf8"));
+  const record = parseRecord(readFileSync9(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) => existsSync9(path) ? readFileSync8(path, "utf8") : undefined);
+  const readTextFile = options.readTextFile ?? ((path) => existsSync10(path) ? readFileSync9(path, "utf8") : undefined);
   const statusImpl = options.statusImpl ?? commanderDaemonStatus;
   const deadline = now() + options.timeoutMs;
   while (now() <= deadline) {
@@ -10761,12 +11205,12 @@ async function waitForCommanderDaemon(options) {
         if (log === undefined) {
           return { ok: false, reason: "timeout" };
         }
-        if (log.includes(connectedMarker)) {
+        if (commanderLogIsConnected(log)) {
           return { ok: true, record: status.record };
         }
         await waitForFileChangeOrTimeout(status.record.logFile, deadline, now, () => {
           const updatedLog = readTextFile(status.record.logFile);
-          return updatedLog !== undefined && updatedLog.includes(connectedMarker);
+          return updatedLog !== undefined && commanderLogIsConnected(updatedLog);
         });
       }
     }
@@ -10976,7 +11420,7 @@ async function main(args) {
       process.stdout.write(connectGuideText());
       return;
     case "version":
-      process.stdout.write(`linzumi 0.0.41-beta
+      process.stdout.write(`${linzumiCliVersionText}
 `);
       return;
     case "auth":
@@ -10996,18 +11440,18 @@ async function main(args) {
       return;
     case "agentRunner": {
       const options = await parseAgentRunnerArgs(parsed.args);
-      await runLocalCodexRunner(options);
+      await runLocalCodexRunner(withLocalMachineId(options));
       return;
     }
     case "start": {
       const options = await parseStartRunnerArgs(parsed.args);
       addAllowedCwd(options.cwd);
-      await runLocalCodexRunner(options);
+      await runLocalCodexRunner(withLocalMachineId(options));
       return;
     }
     case "run": {
       const options = await parseRunnerArgs(parsed.args);
-      await runLocalCodexRunner(options);
+      await runLocalCodexRunner(withLocalMachineId(options));
       return;
     }
   }
@@ -11318,7 +11762,7 @@ async function parseStartRunnerArgs(args, deps = {
   return {
     kandanUrl,
     token: targetToken,
-    runnerId: stringValue3(values, "runner-id") ?? `runner-${randomUUID3()}`,
+    runnerId: stringValue3(values, "runner-id") ?? `runner-${randomUUID4()}`,
     workspaceSlug: target.workspaceSlug,
     cwd,
     codexBin,
@@ -11406,7 +11850,7 @@ async function parseAgentRunnerArgs(args, deps = {
   return {
     kandanUrl,
     token: tokenFile.commanderToken,
-    runnerId: stringValue3(values, "runner-id") ?? `agent-runner-${randomUUID3()}`,
+    runnerId: stringValue3(values, "runner-id") ?? `agent-runner-${randomUUID4()}`,
     workspaceSlug: tokenFile.workspaceId,
     cwd,
     codexBin,
@@ -11426,7 +11870,7 @@ async function parseAgentRunnerArgs(args, deps = {
   };
 }
 function readAgentTokenTextFile(path) {
-  return existsSync10(path) ? readFileSync9(path, "utf8") : undefined;
+  return existsSync11(path) ? readFileSync10(path, "utf8") : undefined;
 }
 function rejectAgentRunnerTargetingFlags(values) {
   const unsupportedFlags = [
@@ -11502,12 +11946,12 @@ async function parseRunnerArgs(args, deps = {
     process.exit(0);
   }
   if (values.get("version") === true) {
-    process.stdout.write(`linzumi 0.0.41-beta
+    process.stdout.write(`${linzumiCliVersionText}
 `);
     process.exit(0);
   }
-  const channelTarget = parseChannelSessionTarget(values);
-  const kandanUrl = required(values, "linzumi-url");
+  const connectTarget = parseConnectTarget(values);
+  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();
@@ -11518,8 +11962,8 @@ async function parseRunnerArgs(args, deps = {
   const token = await deps.resolveToken({
     kandanUrl,
     explicitToken,
-    workspaceSlug: channelTarget?.workspaceSlug,
-    channelSlug: channelTarget?.channelSlug,
+    workspaceSlug: connectTarget?.workspaceSlug,
+    channelSlug: connectTarget?.channelSlug,
     authFilePath: stringValue3(values, "auth-file"),
     callbackHost: stringValue3(values, "oauth-callback-host"),
     reportRejectedCachedToken: () => {
@@ -11527,7 +11971,7 @@ async function parseRunnerArgs(args, deps = {
 `);
     }
   });
-  const channelSession = parseChannelSession(values, token, channelTarget);
+  const channelSession = parseChannelSession(values, token, connectTarget);
   const editorRuntime = await deps.resolveEditorRuntime({
     kandanUrl,
     token,
@@ -11544,7 +11988,7 @@ async function parseRunnerArgs(args, deps = {
   return {
     kandanUrl,
     token,
-    runnerId: stringValue3(values, "runner-id") ?? `runner-${randomUUID3()}`,
+    runnerId: stringValue3(values, "runner-id") ?? `runner-${randomUUID4()}`,
     cwd,
     codexBin,
     codexUrl: stringValue3(values, "codex-url"),
@@ -11558,7 +12002,7 @@ async function parseRunnerArgs(args, deps = {
     editorRuntime: editorRuntime.runtime,
     socketFactory: trustedWebSocketFactory(kandanTlsTrustFromEnv()),
     dependencyStatus,
-    workspaceSlug: channelSession?.workspaceSlug ?? singleWorkspaceScopeFromAccessToken(token),
+    workspaceSlug: connectTarget?.workspaceSlug ?? singleWorkspaceScopeFromAccessToken(token),
     runtimeDefaults: runnerRuntimeDefaultsFromValues(values),
     channelSession
   };
@@ -11670,7 +12114,7 @@ function resolveUserPath(pathValue) {
   return resolve9(pathValue);
 }
 function parseChannelSession(values, token, target) {
-  if (target === undefined) {
+  if (target === undefined || target.channelSlug === undefined) {
     return;
   }
   const listenUser = stringValue3(values, "listen-user") ?? defaultListenUserFromToken(token);
@@ -11686,7 +12130,7 @@ function parseChannelSession(values, token, target) {
     streamFlushMs: positiveIntegerValue(values, "stream-flush-ms")
   };
 }
-function parseChannelSessionTarget(values) {
+function parseConnectTarget(values) {
   return parseOptionalChannelTarget(values);
 }
 function defaultListenUserFromToken(token) {
@@ -11699,12 +12143,15 @@ function defaultListenUserFromToken(token) {
 function parseOptionalChannelTarget(values) {
   const channel = stringValue3(values, "channel");
   const workspace = stringValue3(values, "workspace");
-  if (channel === undefined && workspace === undefined) {
-    return;
+  if (channel === undefined) {
+    if (workspace === undefined) {
+      return;
+    }
+    return { workspaceSlug: workspace };
   }
-  return channel !== undefined && channel.includes("/") ? parseChannelPath(channel) : {
+  return channel.includes("/") ? parseChannelPath(channel) : {
     workspaceSlug: workspace ?? required(values, "workspace"),
-    channelSlug: channel ?? required(values, "channel")
+    channelSlug: channel
   };
 }
 function parseChannelPath(channel) {
@@ -11717,6 +12164,12 @@ function parseChannelPath(channel) {
     channelSlug: channelSlug.trim()
   };
 }
+function withLocalMachineId(options) {
+  return {
+    ...options,
+    machineId: ensureLocalMachineId()
+  };
+}
 function required(values, key) {
   const value = stringValue3(values, key);
   if (value === undefined) {
@@ -11773,19 +12226,19 @@ Usage:
   linzumi commander <folder> [options]
   linzumi start <folder> [options]
   linzumi paths list|add|remove [path]
-  linzumi connect --linzumi-url <ws-url> --workspace <slug> --channel <slug> [options]
+  linzumi connect --workspace <slug> [--channel <slug>] [options]
   linzumi auth --linzumi-url <ws-url> [--workspace <slug> --channel <slug>]
 
-Required:
+Connection:
   --linzumi-url <ws-url>      Linzumi backend URL, default ${defaultLinzumiWebSocketUrl}
                                 (deprecated alias: --kandan-url)
   --token <jwt>               Optional override token. Otherwise ~/.linzumi/auth.json is validated or OAuth opens.
   --auth-file <path>          Auth cache path, default ~/.linzumi/auth.json
   --oauth-callback-host <ip>  Callback host reachable by your browser
 
-Channel binding:
+Workspace and optional channel binding:
   --workspace <slug>          Workspace slug
-  --channel <slug|w/c>        Channel slug, or workspace/channel
+  --channel <slug|w/c>        Optional channel slug, or workspace/channel
   --linzumi-thread-id <uuid>  Resume an existing Linzumi thread instead of announcing a new root
                                 (deprecated alias: --kandan-thread-id)
   --listen-user <user|all>    User whose replies are accepted, default authenticated user
@@ -11818,8 +12271,9 @@ Examples:
     linzumi commander daemon --runner-id launch-commander
     linzumi start ~/
     linzumi start ~/code/my-app
-    linzumi connect --workspace <your-workspace> --channel <your-channel> --launch-tui
-    linzumi connect --workspace <your-workspace> --channel <your-channel> --model gpt-5 --reasoning-effort low --fast --launch-tui
+    linzumi connect --workspace <your-workspace> --launch-tui
+    linzumi connect --workspace <your-workspace> --model gpt-5 --reasoning-effort low --fast --launch-tui
+    linzumi connect --workspace <your-workspace> --channel <your-channel>
     linzumi auth --workspace <your-workspace> --channel <your-channel>
     linzumi paths add ~/code/my-app
     linzumi paths list
@@ -11829,9 +12283,9 @@ Examples:
       Missing --listen-user and authenticated user is unavailable.
     linzumi connect --token "$TOKEN" --listen-users sean
       Invalid flag: use --listen-user.
-    linzumi connect --workspace <your-workspace> --channel <your-channel> --allowed-cwd /does/not/exist
+    linzumi connect --workspace <your-workspace> --allowed-cwd /does/not/exist
       Invalid --allowed-cwd: allowed cwd roots must exist locally.
-    linzumi connect --workspace <your-workspace> --channel <your-channel> --forward-port vite
+    linzumi connect --workspace <your-workspace> --forward-port vite
       Invalid --forward-port: value must be a TCP port from 1 to 65535.
 `;
 }
@@ -11989,7 +12443,7 @@ space, persists this folder to your trusted-paths list, and starts this
 computer as a local Codex runner.
 
 Advanced (when you already know your workspace and channel):
-  linzumi connect --workspace <your-workspace> --channel <your-channel>
+  linzumi connect --workspace <your-workspace>
 
 For help:
   linzumi connect --help

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.41-beta",
+  "version": "0.0.43-beta",
   "description": "Linzumi CLI — point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {