@linzumi/cli 0.0.23-beta → 0.0.25-beta

package/README.md

@@ -32,8 +32,20 @@ starts that hot-reload app on your computer, creates the shared support
 channel, starts a Linzumi Codex session in a work thread, and opens the
 browser editor pointed at the demo app.
 
+Terms:
+
+- **Bootstrapper Codex**: the outer Codex started by the pasted command. It
+  sets up Linzumi and local processes, but does not edit the demo app.
+- **Linzumi Commander**: the long-running local bridge started with
+  `linzumi commander`; it owns the secure tunnel, trusted folder, browser
+  editor, and inner Codex launch.
+- **Linzumi Codex session**: the inner agent running inside the Linzumi thread;
+  it edits `/tmp/hello_linzumi` and posts progress.
+- **Human**: the workspace owner who opens the one-time login link and watches
+  the work in `#general` and `#linzumi-support`.
+
 The snippet uses automatic command approval and full local process access
-because the bootstrapper must start a real runner and browser editor on this
+because the bootstrapper must start a real Linzumi Commander and browser editor on this
 computer. It is intentionally not the dangerous sandbox-bypass mode.
 
 Today, your AI coding agent has two homes, both bad.
@@ -104,7 +116,7 @@ stays available for compatibility. The bootstrap agent will confirm your
 email and workspace choice up front, ask for the emailed code after signup
 sends it, say hello to `@sean` in the shared support channel,
 generate `/tmp/hello_linzumi`, start its hot-reload Node server, start the
-runner for that folder, start a Linzumi Codex session in a work thread, and
+Commander for that folder, start a Linzumi Codex session in a work thread, and
 open the browser editor. The Linzumi Codex session then adds confetti to the
 demo page while you watch. Workspace names are plain display names from 2 to
 100 characters; Linzumi generates the URL-safe workspace slug.
@@ -118,24 +130,30 @@ npx -y @linzumi/cli@latest signup --email alice@example.com --workspace-name "Al
 npx -y @linzumi/cli@latest claim --pending <pending_id> --code <XXXX-XXXX>
 npx -y @linzumi/cli@latest channel post <support_channel_id> "Hello @sean, starting this launch run."
 npx -y @linzumi/cli@latest thread new "Hello Linzumi confetti" --message "Preparing the Hello Linzumi demo. Next I will generate /tmp/hello_linzumi, start its hot-reload server bound to 0.0.0.0 on port 8787, and ask Linzumi Codex to add confetti when the page loads."
+commander_id="hello-linzumi-commander-${thread_id%%-*}"
 npx -y @linzumi/cli@latest init-hello-linzumi-demo-app --parent-dir /tmp --name hello_linzumi --host 0.0.0.0 --port 8787 --reset --json
-(cd /tmp/hello_linzumi && npm run dev > /tmp/hello_linzumi/dev.log 2>&1 &)
-npx -y @linzumi/cli@latest agent runner /tmp/hello_linzumi \
-  --runner-id hello-linzumi-agent \
-  --allowed-cwd /tmp/hello_linzumi \
+project_dir="$(cd /tmp/hello_linzumi && pwd -P)"
+(cd "$project_dir" && npm run dev > "$project_dir/dev.log" 2>&1 &)
+npx -y @linzumi/cli@latest commander "$project_dir" \
+  --runner-id "$commander_id" \
+  --allowed-cwd "$project_dir" \
   --forward-port 8787 \
   --sandbox danger-full-access \
   --approval-policy never
 ```
 
-The agent-owned runner reads `~/.linzumi/agent-token.json`, uses the
+The agent-owned Commander reads `~/.linzumi/agent-token.json`, uses the
 workspace/channel scope from the approval flow, trusts only the selected
-folder, advertises the explicit preview port, and listens only to the
-approving human unless `--listen-user` is explicitly passed. The bootstrap
-agent waits for `Runner connected:` before starting Codex in the Linzumi
+folder, marks that same folder trusted in Codex's normal project config so
+Codex does not stop for an interactive trust prompt, advertises the explicit
+preview port, and listens only to the approving human unless `--listen-user` is
+explicitly passed. Use a unique
+Commander id per launch thread; Linzumi stores trusted-folder config per
+Commander id, so reusing an old fixed id can pick up stale allowed-cwd config.
+The bootstrap agent waits for `Runner connected:` before starting Codex in the Linzumi
 thread.
 
-By default, the runner downloads the Linzumi-approved `code-server`
+By default, the Commander downloads the Linzumi-approved `code-server`
 runtime for your platform and verifies its checksum before enabling the
 browser editor. Linux editor launches are wrapped with `bubblewrap`
 (`bwrap`) for filesystem confinement.
@@ -146,21 +164,21 @@ workspace. The claim also provisions `#linzumi-support`, a shared channel
 connected to Linzumi's workspace so our team can see setup issues from our
 side; the bootstrap agent posts a hello there with the printed
 `support_channel_id`.
-Keep demo work in task threads; use the support channel when signup, runner,
+Keep demo work in task threads; use the support channel when signup, Commander,
 preview, or browser-editor setup gets stuck.
 
-Once the runner is online, the bootstrap agent can ask Linzumi to start
+Once the Commander is online, the bootstrap agent can ask Linzumi to start
 Codex and open the browser editor for the same thread and folder:
 
 ```bash
 npx -y @linzumi/cli@latest codex start <thread_id> \
-  --runner hello-linzumi-agent \
-  --cwd /tmp/hello_linzumi \
-  --work-description "Work only in /tmp/hello_linzumi. Add tasteful confetti when the Hello Linzumi page loads, keep the hot-reload app working on port 8787, and post the exact files changed."
+  --runner "$commander_id" \
+  --cwd "$project_dir" \
+  --work-description "Work only in the canonical Hello Linzumi project directory printed by pwd -P for /tmp/hello_linzumi. Add tasteful confetti when the Hello Linzumi page loads, keep the hot-reload app working on port 8787, and post the exact files changed."
 
 npx -y @linzumi/cli@latest editor open <thread_id> \
-  --runner hello-linzumi-agent \
-  --cwd /tmp/hello_linzumi
+  --runner "$commander_id" \
+  --cwd "$project_dir"
 ```
 
 The launch target for this path is zero-to-Hello-Linzumi-editor+preview in
@@ -261,7 +279,7 @@ intentionally. Every action is auditable from the thread.
 ## Pinning a version
 
 ```bash
-npm install -g @linzumi/cli@0.0.23-beta
+npm install -g @linzumi/cli@0.0.25-beta
 linzumi --version
 ```
 
@@ -284,7 +302,7 @@ linzumi connect \
 ### All the flags
 
 ```text
---agent-token-file <path>   Agent token cache for `linzumi agent runner`
+--agent-token-file <path>   Agent token cache for `linzumi commander`
 --oauth-callback-host <ip>  Sign-in callback host your browser can reach
 --codex-bin <path>          Codex executable, default `codex`
 --model <name>              Model requested for Codex sessions and labelled in Linzumi

package/dist/index.js

@@ -1,15 +1,15 @@
 // src/index.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync8, readFileSync as readFileSync7, realpathSync as realpathSync4 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { resolve as resolve6 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, realpathSync as realpathSync5 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/runner.ts
 import { spawn as spawn6 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { hostname as hostname2 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 
 // src/channelSessionSupport.ts
 import { spawnSync } from "node:child_process";
@@ -4209,10 +4209,72 @@ function readyzUrlForWebsocket(websocketUrl) {
   return parsed.toString();
 }
 
-// src/localCapabilities.ts
-import { realpathSync } from "node:fs";
+// src/codexProjectTrust.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  writeFileSync
+} from "node:fs";
 import { homedir } from "node:os";
-import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 } from "node:path";
+import { join as join2, resolve as resolve2 } from "node:path";
+function ensureCodexProjectTrusted(projectPath, options = {}) {
+  const trustedPath = realpathSync(resolve2(projectPath));
+  const configHome = options.configHome ?? process.env.CODEX_HOME ?? join2(homedir(), ".codex");
+  const configPath = join2(configHome, "config.toml");
+  const currentConfig = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+  const nextConfig = codexConfigWithTrustedProject(currentConfig, trustedPath);
+  if (nextConfig !== currentConfig) {
+    mkdirSync(configHome, { recursive: true });
+    writeFileSync(configPath, nextConfig);
+  }
+  return trustedPath;
+}
+function codexConfigWithTrustedProject(config, projectPath) {
+  const header = `[projects.${tomlString(projectPath)}]`;
+  const range = findTableRange(config, header);
+  if (range === undefined) {
+    const separator = config.trim() === "" ? "" : `
+
+`;
+    return `${trimTrailingNewlines(config)}${separator}${header}
+trust_level = "trusted"
+`;
+  }
+  const table = config.slice(range.start, range.end);
+  const trustLine = /^(\s*trust_level\s*=\s*).*(\r?)$/m;
+  const nextTable = trustLine.test(table) ? table.replace(trustLine, '$1"trusted"$2') : table.replace(/\r?\n/, `
+trust_level = "trusted"
+`);
+  return `${config.slice(0, range.start)}${nextTable}${config.slice(range.end)}`;
+}
+function findTableRange(config, header) {
+  const tableHeader = /^\s*\[[^\]]+\]\s*$/gm;
+  let match;
+  while ((match = tableHeader.exec(config)) !== null) {
+    if (match[0].trim() !== header) {
+      continue;
+    }
+    const nextMatch = tableHeader.exec(config);
+    return {
+      start: match.index,
+      end: nextMatch?.index ?? config.length
+    };
+  }
+  return;
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function trimTrailingNewlines(value) {
+  return value.replace(/\r?\n+$/, "");
+}
+
+// src/localCapabilities.ts
+import { realpathSync as realpathSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3 } from "node:path";
 function parseAllowedCwdList(value) {
   if (value === undefined) {
     return [];
@@ -4238,20 +4300,23 @@ function parseAllowedPortList(value) {
   return [...ports].sort((left, right) => left - right);
 }
 function assertConfiguredAllowedCwds(paths) {
-  return paths.map((path) => {
+  const allowed = paths.flatMap((path) => {
     try {
-      return realpathSync(resolve2(expandUserPath(path)));
+      const absolutePath = resolve3(expandUserPath(path));
+      const realPath = realpathSync2(absolutePath);
+      return realPath === absolutePath ? [realPath] : [realPath, absolutePath];
     } catch (_error) {
       throw new Error(`invalid --allowed-cwd: ${path} does not exist`);
     }
   });
+  return Array.from(new Set(allowed));
 }
 function expandUserPath(pathValue) {
   if (pathValue === "~") {
-    return homedir();
+    return homedir2();
   }
   if (pathValue.startsWith("~/")) {
-    return resolve2(homedir(), pathValue.slice(2));
+    return resolve3(homedir2(), pathValue.slice(2));
   }
   return pathValue;
 }
@@ -4264,7 +4329,7 @@ function resolveAllowedCwd(requestedCwd, allowedRoots) {
   }
   let cwd;
   try {
-    cwd = realpathSync(resolve2(requestedCwd));
+    cwd = realpathSync2(resolve3(requestedCwd));
   } catch (_error) {
     return { ok: false, reason: "cwd_not_found" };
   }
@@ -4569,14 +4634,14 @@ var blockedForwardHeaderNames = new Set([
 import { spawn as spawn2 } from "node:child_process";
 import {
   cpSync,
-  existsSync,
-  mkdirSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
   mkdtempSync,
-  realpathSync as realpathSync2,
-  writeFileSync
+  realpathSync as realpathSync3,
+  writeFileSync as writeFileSync2
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { basename as basename3, delimiter, dirname, join as join2 } from "node:path";
+import { basename as basename3, delimiter, dirname, join as join3 } from "node:path";
 function isStartLocalEditorControl(control) {
   return control.type === "start_local_editor";
 }
@@ -4739,17 +4804,17 @@ function codeServerArgs(port, cwd, userDataDir, extensionsDir) {
 }
 function prepareCodeServerProfile(collaboration, editorRuntime) {
   try {
-    const userDataDir = mkdtempSync(join2(tmpdir(), "kandan-local-editor-"));
-    const extensionsDir = join2(userDataDir, "extensions");
-    const collaborationServerDir = join2(userDataDir, "collaboration-server");
-    const userSettingsDir = join2(userDataDir, "User");
-    mkdirSync(userSettingsDir, { recursive: true });
-    mkdirSync(extensionsDir, { recursive: true });
-    mkdirSync(collaborationServerDir, { recursive: true });
+    const userDataDir = mkdtempSync(join3(tmpdir(), "kandan-local-editor-"));
+    const extensionsDir = join3(userDataDir, "extensions");
+    const collaborationServerDir = join3(userDataDir, "collaboration-server");
+    const userSettingsDir = join3(userDataDir, "User");
+    mkdirSync2(userSettingsDir, { recursive: true });
+    mkdirSync2(extensionsDir, { recursive: true });
+    mkdirSync2(collaborationServerDir, { recursive: true });
     if (editorRuntime !== undefined) {
-      installDirectory(editorRuntime.assets.documentStateExtensionDir, join2(extensionsDir, "kandan.document-state-telemetry"));
+      installDirectory(editorRuntime.assets.documentStateExtensionDir, join3(extensionsDir, "kandan.document-state-telemetry"));
     }
-    writeFileSync(join2(userSettingsDir, "settings.json"), JSON.stringify(codeServerSettings(collaboration), null, 2));
+    writeFileSync2(join3(userSettingsDir, "settings.json"), JSON.stringify(codeServerSettings(collaboration), null, 2));
     return { ok: true, userDataDir, extensionsDir, collaborationServerDir };
   } catch (_error) {
     return { ok: false, reason: "code_server_spawn_failed" };
@@ -4764,7 +4829,7 @@ function prepareCodeServerLaunch(options) {
     return filesystemSandboxUnavailable();
   }
   const sandboxExecBin = options.sandboxExecBin ?? "/usr/bin/sandbox-exec";
-  if (!existsSync(sandboxExecBin)) {
+  if (!existsSync2(sandboxExecBin)) {
     return filesystemSandboxUnavailable();
   }
   const codeServerExecutable = resolveCodeServerExecutable(options.codeServerBin, options.envPath ?? process.env.PATH ?? "");
@@ -4818,10 +4883,10 @@ function prepareLinuxCodeServerLaunch(options) {
     options.userDataDir,
     "--setenv",
     "XDG_DATA_HOME",
-    join2(options.userDataDir, "data"),
+    join3(options.userDataDir, "data"),
     "--setenv",
     "XDG_CONFIG_HOME",
-    join2(options.userDataDir, "config"),
+    join3(options.userDataDir, "config"),
     ...readOnlyRoots.flatMap((path) => ["--ro-bind-try", path, path]),
     "--bind",
     options.cwd,
@@ -4894,11 +4959,11 @@ function resolveCodeServerExecutable(command, envPath) {
     if (directory.trim() === "") {
       continue;
     }
-    const candidate = join2(directory, command);
-    if (!existsSync(candidate)) {
+    const candidate = join3(directory, command);
+    if (!existsSync2(candidate)) {
       continue;
     }
-    const realpath = realpathSync2(candidate);
+    const realpath = realpathSync3(candidate);
     return { ok: true, command: realpath, directory: dirname(realpath) };
   }
   return { ok: false };
@@ -4908,7 +4973,7 @@ function hasPathSeparator(path) {
 }
 function safeRealpathDir(path) {
   try {
-    const directory = dirname(realpathSync2(path));
+    const directory = dirname(realpathSync3(path));
     return directory === "/" ? undefined : directory;
   } catch (_error) {
     const directory = dirname(path);
@@ -4917,7 +4982,7 @@ function safeRealpathDir(path) {
 }
 function sandboxPathAliases(path) {
   try {
-    return [path, realpathSync2(path)];
+    return [path, realpathSync3(path)];
   } catch (_error) {
     return [path];
   }
@@ -4971,7 +5036,7 @@ async function startCollaborationSidecar(collaboration, profile, editorRuntime)
       installLocalTarball(editorRuntime.assets.collaborationServerTarball, profile.collaborationServerDir)
     ]);
     const child = spawn2(nodeRuntimeExecutable(), [
-      join2(profile.collaborationServerDir, "open-collaboration-server", "bundle", "app.js"),
+      join3(profile.collaborationServerDir, "open-collaboration-server", "bundle", "app.js"),
       "--hostname",
       "127.0.0.1",
       "--port",
@@ -5017,11 +5082,11 @@ function nodeRuntimeExecutable(env = process.env, execPath = process.execPath) {
   return basename3(execPath).toLowerCase().includes("bun") ? "node" : execPath;
 }
 async function installLocalTarball(archivePath, destinationDir) {
-  mkdirSync(destinationDir, { recursive: true });
+  mkdirSync2(destinationDir, { recursive: true });
   await runProcess("tar", ["-xzf", archivePath, "-C", destinationDir]);
 }
 function installDirectory(sourceDir, destinationDir) {
-  mkdirSync(dirname(destinationDir), { recursive: true });
+  mkdirSync2(dirname(destinationDir), { recursive: true });
   cpSync(sourceDir, destinationDir, { recursive: true });
 }
 function codeServerEnv(env, userDataDir, collaboration) {
@@ -5029,9 +5094,9 @@ function codeServerEnv(env, userDataDir, collaboration) {
   const base = {
     ...hostEnv,
     HOME: userDataDir,
-    XDG_CACHE_HOME: join2(userDataDir, "xdg-cache"),
-    XDG_CONFIG_HOME: join2(userDataDir, "xdg-config"),
-    XDG_DATA_HOME: join2(userDataDir, "xdg-data")
+    XDG_CACHE_HOME: join3(userDataDir, "xdg-cache"),
+    XDG_CONFIG_HOME: join3(userDataDir, "xdg-config"),
+    XDG_DATA_HOME: join3(userDataDir, "xdg-data")
   };
   if (collaboration === undefined) {
     return base;
@@ -5064,14 +5129,14 @@ function sameCollaboration(running, requested) {
   return running.editorSessionId === requested.editorSessionId && running.runtimeSessionId === requested.runtimeSessionId && running.roomId === requested.roomId;
 }
 function runProcess(command, args) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const child = spawn2(command, [...args], {
       stdio: ["ignore", "ignore", "inherit"]
     });
     child.once("error", reject);
     child.once("exit", (code) => {
       if (code === 0) {
-        resolve3();
+        resolve4();
       } else {
         reject(new Error(`${command} exited with ${code ?? "unknown"}`));
       }
@@ -5079,7 +5144,7 @@ function runProcess(command, args) {
   });
 }
 function waitForCodeServerExit(child) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let settled = false;
     const cleanup = () => {
       child.off("exit", onDone);
@@ -5091,7 +5156,7 @@ function waitForCodeServerExit(child) {
       }
       settled = true;
       cleanup();
-      resolve3();
+      resolve4();
     };
     child.once("exit", onDone);
     child.once("close", onDone);
@@ -5103,7 +5168,7 @@ function waitForCodeServerExit(child) {
 function waitForCodeServerReady(port, exited, timeoutMs = 1e4) {
   const deadline = Date.now() + timeoutMs;
   const readyUrl = `http://127.0.0.1:${port}/`;
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let settled = false;
     let timer;
     const finish = (result) => {
@@ -5114,7 +5179,7 @@ function waitForCodeServerReady(port, exited, timeoutMs = 1e4) {
       if (timer !== undefined) {
         clearTimeout(timer);
       }
-      resolve3(result);
+      resolve4(result);
     };
     const scheduleCheck = () => {
       timer = setTimeout(checkReady, 50);
@@ -5143,7 +5208,7 @@ function waitForCodeServerReady(port, exited, timeoutMs = 1e4) {
 function waitForCollaborationServerReady(port, exited, timeoutMs = 1e4) {
   const deadline = Date.now() + timeoutMs;
   const readyUrl = `http://127.0.0.1:${port}/api/login/initial`;
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let settled = false;
     let timer;
     const finish = (result) => {
@@ -5154,7 +5219,7 @@ function waitForCollaborationServerReady(port, exited, timeoutMs = 1e4) {
       if (timer !== undefined) {
         clearTimeout(timer);
       }
-      resolve3(result);
+      resolve4(result);
     };
     const scheduleCheck = () => {
       timer = setTimeout(checkReady, 50);
@@ -5181,7 +5246,7 @@ function waitForCollaborationServerReady(port, exited, timeoutMs = 1e4) {
   });
 }
 function waitForCodeServerSpawn(child) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let settled = false;
     const cleanup = () => {
       child.off("spawn", onSpawn);
@@ -5193,7 +5258,7 @@ function waitForCodeServerSpawn(child) {
       }
       settled = true;
       cleanup();
-      resolve3("spawned");
+      resolve4("spawned");
     };
     const onError = () => {
       if (settled) {
@@ -5201,7 +5266,7 @@ function waitForCodeServerSpawn(child) {
       }
       settled = true;
       cleanup();
-      resolve3("failed");
+      resolve4("failed");
     };
     child.once("spawn", onSpawn);
     child.once("error", onError);
@@ -5222,16 +5287,16 @@ import { createHash as createHash2 } from "node:crypto";
 import {
   createReadStream,
   createWriteStream,
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
   mkdtempSync as mkdtempSync2,
-  readFileSync,
+  readFileSync as readFileSync2,
   renameSync,
   rmSync,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join3, resolve as resolve3 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname2, join as join4, resolve as resolve4 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 
@@ -5402,7 +5467,7 @@ function stringBodyField(body, key) {
   return typeof value === "string" && value.trim() !== "" ? value : undefined;
 }
 function startCallbackServer(args) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let resolveCallback;
     let rejectCallback;
     const callbackPromise = new Promise((callbackResolve, callbackReject) => {
@@ -5454,7 +5519,7 @@ function startCallbackServer(args) {
         reject(new Error("local runner OAuth callback server did not bind to a TCP port"));
         return;
       }
-      resolve3({
+      resolve4({
         redirectUri: `http://${args.host}:${address.port}/callback`,
         waitForCallback: () => callbackPromise,
         close: () => {
@@ -5505,12 +5570,12 @@ function escapeHtml(value) {
 function openBrowser(url) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const child = spawn3(command, args, { stdio: "ignore", detached: true });
-    child.on("error", () => resolve3());
+    child.on("error", () => resolve4());
     child.on("spawn", () => {
       child.unref();
-      resolve3();
+      resolve4();
     });
   });
 }
@@ -5693,14 +5758,14 @@ function normalizeRuntimeAssets(value) {
 }
 function installedRuntime(cacheRoot, manifest) {
   const runtimeRoot = runtimeInstallRoot(cacheRoot, manifest);
-  const manifestPath = join3(runtimeRoot, manifest.manifestPath);
-  const codeServerBin = join3(runtimeRoot, manifest.codeServerBinPath);
+  const manifestPath = join4(runtimeRoot, manifest.manifestPath);
+  const codeServerBin = join4(runtimeRoot, manifest.codeServerBinPath);
   const assets = verifiedRuntimeAssetPaths(runtimeRoot, manifest);
-  if (!existsSync2(manifestPath) || !existsSync2(codeServerBin) || assets === undefined) {
+  if (!existsSync3(manifestPath) || !existsSync3(codeServerBin) || assets === undefined) {
     return { ok: false };
   }
   try {
-    const installed = JSON.parse(readFileSync(manifestPath, "utf8"));
+    const installed = JSON.parse(readFileSync2(manifestPath, "utf8"));
     if (isJsonObject(installed) && installed.version === manifest.version && installed.platform === manifest.platform && (installed.archiveSha256 === undefined || installed.archiveSha256 === manifest.archiveSha256)) {
       return {
         ok: true,
@@ -5718,10 +5783,10 @@ function installedRuntime(cacheRoot, manifest) {
   return { ok: false };
 }
 async function installRuntime(args) {
-  mkdirSync2(args.cacheRoot, { recursive: true });
-  const tempRoot = mkdtempSync2(join3(args.cacheRoot, ".install-"));
-  const archivePath = join3(tempRoot, "runtime.tar.gz");
-  const extractRoot = join3(tempRoot, "runtime");
+  mkdirSync3(args.cacheRoot, { recursive: true });
+  const tempRoot = mkdtempSync2(join4(args.cacheRoot, ".install-"));
+  const archivePath = join4(tempRoot, "runtime.tar.gz");
+  const extractRoot = join4(tempRoot, "runtime");
   try {
     const downloaded = await downloadArchive({
       kandanUrl: args.kandanUrl,
@@ -5733,7 +5798,7 @@ async function installRuntime(args) {
     if (!downloaded.ok) {
       return downloaded;
     }
-    mkdirSync2(extractRoot, { recursive: true });
+    mkdirSync3(extractRoot, { recursive: true });
     if (!await args.extractArchive(archivePath, extractRoot)) {
       return { ok: false, reason: "archive_extract_failed" };
     }
@@ -5746,14 +5811,14 @@ async function installRuntime(args) {
     if (!assetsInstalled) {
       return { ok: false, reason: "install_failed" };
     }
-    const manifestPath = join3(extractRoot, args.manifest.manifestPath);
-    const codeServerBin = join3(extractRoot, args.manifest.codeServerBinPath);
+    const manifestPath = join4(extractRoot, args.manifest.manifestPath);
+    const codeServerBin = join4(extractRoot, args.manifest.codeServerBinPath);
     const assets = verifiedRuntimeAssetPaths(extractRoot, args.manifest);
-    if (!existsSync2(codeServerBin) || assets === undefined) {
+    if (!existsSync3(codeServerBin) || assets === undefined) {
       return { ok: false, reason: "invalid_archive" };
     }
-    mkdirSync2(dirname2(manifestPath), { recursive: true });
-    writeFileSync2(manifestPath, JSON.stringify({
+    mkdirSync3(dirname2(manifestPath), { recursive: true });
+    writeFileSync3(manifestPath, JSON.stringify({
       version: args.manifest.version,
       platform: args.manifest.platform,
       archiveSha256: args.manifest.archiveSha256,
@@ -5764,18 +5829,18 @@ async function installRuntime(args) {
     }, null, 2));
     const targetRoot = runtimeInstallRoot(args.cacheRoot, args.manifest);
     rmSync(targetRoot, { recursive: true, force: true });
-    mkdirSync2(dirname2(targetRoot), { recursive: true });
+    mkdirSync3(dirname2(targetRoot), { recursive: true });
     renameSync(extractRoot, targetRoot);
     return {
       ok: true,
       runtime: {
         mode: "server_managed",
         root: targetRoot,
-        codeServerBin: join3(targetRoot, args.manifest.codeServerBinPath),
+        codeServerBin: join4(targetRoot, args.manifest.codeServerBinPath),
         assets: {
-          collaborationExtensionTarball: join3(targetRoot, "kandan", "editor_extensions", "typefox.open-collaboration-tools.tar.gz"),
-          collaborationServerTarball: join3(targetRoot, "kandan", "editor_servers", "open-collaboration-server.tar.gz"),
-          documentStateExtensionDir: join3(targetRoot, "kandan", "editor_extensions", "kandan.document-state-telemetry")
+          collaborationExtensionTarball: join4(targetRoot, "kandan", "editor_extensions", "typefox.open-collaboration-tools.tar.gz"),
+          collaborationServerTarball: join4(targetRoot, "kandan", "editor_servers", "open-collaboration-server.tar.gz"),
+          documentStateExtensionDir: join4(targetRoot, "kandan", "editor_extensions", "kandan.document-state-telemetry")
         }
       }
     };
@@ -5787,7 +5852,7 @@ async function installRuntime(args) {
 }
 async function materializeRuntimeAssets(args) {
   for (const asset of args.manifest.assets) {
-    const targetPath = join3(args.runtimeRoot, asset.path);
+    const targetPath = join4(args.runtimeRoot, asset.path);
     try {
       const bytes = await runtimeAssetBytes({
         kandanUrl: args.kandanUrl,
@@ -5797,8 +5862,8 @@ async function materializeRuntimeAssets(args) {
       if (bytes === undefined) {
         continue;
       }
-      mkdirSync2(dirname2(targetPath), { recursive: true });
-      writeFileSync2(targetPath, bytes);
+      mkdirSync3(dirname2(targetPath), { recursive: true });
+      writeFileSync3(targetPath, bytes);
     } catch (_error) {
       return false;
     }
@@ -5857,17 +5922,17 @@ function fileSha256(path) {
   });
 }
 function runtimeInstallRoot(cacheRoot, manifest) {
-  return resolve3(cacheRoot, manifest.platform, manifest.archiveSha256);
+  return resolve4(cacheRoot, manifest.platform, manifest.archiveSha256);
 }
 function verifiedRuntimeAssetPaths(runtimeRoot, manifest) {
-  const collaborationExtensionTarball = join3(runtimeRoot, "kandan", "editor_extensions", "typefox.open-collaboration-tools.tar.gz");
-  const collaborationServerTarball = join3(runtimeRoot, "kandan", "editor_servers", "open-collaboration-server.tar.gz");
-  const documentStateExtensionDir = join3(runtimeRoot, "kandan", "editor_extensions", "kandan.document-state-telemetry");
+  const collaborationExtensionTarball = join4(runtimeRoot, "kandan", "editor_extensions", "typefox.open-collaboration-tools.tar.gz");
+  const collaborationServerTarball = join4(runtimeRoot, "kandan", "editor_servers", "open-collaboration-server.tar.gz");
+  const documentStateExtensionDir = join4(runtimeRoot, "kandan", "editor_extensions", "kandan.document-state-telemetry");
   const codeServerRoot = codeServerRuntimeRoot(manifest.codeServerBinPath);
   const requiredPaths = [
     manifest.codeServerBinPath,
-    join3(codeServerRoot, "lib", "vscode", "node_modules", "vsda", "rust", "web", "vsda.js"),
-    join3(codeServerRoot, "lib", "vscode", "node_modules", "vsda", "rust", "web", "vsda_bg.wasm"),
+    join4(codeServerRoot, "lib", "vscode", "node_modules", "vsda", "rust", "web", "vsda.js"),
+    join4(codeServerRoot, "lib", "vscode", "node_modules", "vsda", "rust", "web", "vsda_bg.wasm"),
     "kandan/editor_extensions/typefox.open-collaboration-tools.tar.gz",
     "kandan/editor_servers/open-collaboration-server.tar.gz",
     "kandan/editor_extensions/kandan.document-state-telemetry/package.json",
@@ -5879,15 +5944,15 @@ function verifiedRuntimeAssetPaths(runtimeRoot, manifest) {
     if (expectedSha256 === undefined && relativePath !== manifest.codeServerBinPath) {
       return;
     }
-    const absolutePath = join3(runtimeRoot, relativePath);
-    if (!existsSync2(absolutePath)) {
+    const absolutePath = join4(runtimeRoot, relativePath);
+    if (!existsSync3(absolutePath)) {
       return;
     }
     if (expectedSha256 !== undefined && fileSha256Sync(absolutePath) !== expectedSha256) {
       return;
     }
   }
-  if (!existsSync2(collaborationExtensionTarball) || !existsSync2(collaborationServerTarball)) {
+  if (!existsSync3(collaborationExtensionTarball) || !existsSync3(collaborationServerTarball)) {
     return;
   }
   return {
@@ -5908,10 +5973,10 @@ function manifestAssetChecksums(assets) {
   return checksums;
 }
 function fileSha256Sync(path) {
-  return createHash2("sha256").update(readFileSync(path)).digest("hex");
+  return createHash2("sha256").update(readFileSync2(path)).digest("hex");
 }
 function defaultEditorRuntimeCacheRoot() {
-  return join3(homedir2(), ".linzumi", "editor-runtimes");
+  return join4(homedir3(), ".linzumi", "editor-runtimes");
 }
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim() !== "" ? value.trim() : undefined;
@@ -5923,7 +5988,7 @@ function sha256String(value) {
 
 // src/dependencyStatus.ts
 function probeTool(command, cwd) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const child = spawn5(command, ["--version"], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -5937,7 +6002,7 @@ function probeTool(command, cwd) {
       }
       resolved = true;
       clearTimeout(timeout);
-      resolve4(status);
+      resolve5(status);
     };
     const timeout = setTimeout(() => {
       child.kill("SIGKILL");
@@ -6084,8 +6149,8 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new
     pending.clear();
   };
   const resetReady = () => {
-    state.ready = new Promise((resolve4, reject) => {
-      state.resolveReady = resolve4;
+    state.ready = new Promise((resolve5, reject) => {
+      state.resolveReady = resolve5;
       state.rejectReady = reject;
     });
   };
@@ -6120,8 +6185,8 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new
     const ref = String(state.nextRef);
     state.nextRef += 1;
     const frame = [null, ref, topic, event, payload];
-    return new Promise((resolve4, reject) => {
-      pending.set(ref, { event, resolve: resolve4, reject });
+    return new Promise((resolve5, reject) => {
+      pending.set(ref, { event, resolve: resolve5, reject });
       websocket.send(JSON.stringify(frame));
     });
   };
@@ -6257,8 +6322,8 @@ function isKandanControl(value) {
   return isJsonObject(value) && typeof value.type === "string";
 }
 function waitForOpen2(websocket) {
-  return new Promise((resolve4, reject) => {
-    websocket.addEventListener("open", () => resolve4(), { once: true });
+  return new Promise((resolve5, reject) => {
+    websocket.addEventListener("open", () => resolve5(), { once: true });
     websocket.addEventListener("error", () => reject(new Error("websocket open failed")), {
       once: true
     });
@@ -6269,9 +6334,9 @@ function waitForOpen2(websocket) {
 import { openSync } from "node:fs";
 import { createWriteStream as createWriteStream2 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
-import { mkdirSync as mkdirSync3 } from "node:fs";
+import { mkdirSync as mkdirSync4 } from "node:fs";
 function createRunnerLogger(logFile, consoleReporter) {
-  mkdirSync3(dirname3(logFile), { recursive: true });
+  mkdirSync4(dirname3(logFile), { recursive: true });
   const fd = openSync(logFile, "a");
   const stream = createWriteStream2("", { fd, flags: "a", autoClose: true });
   const logger = (event, payload) => {
@@ -6288,9 +6353,9 @@ function closeStream(stream) {
   if (stream.closed || stream.destroyed) {
     return Promise.resolve();
   }
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     stream.once("error", reject);
-    stream.end(resolve4);
+    stream.end(resolve5);
   });
 }
 
@@ -6459,11 +6524,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     dispatcher(control);
   });
   await kandan.join(topic, joinPayload(), { rejoinPayload: joinPayload });
-  const started = options.codexUrl === undefined ? await startCodexAppServer(options.codexBin, options.cwd, {
-    model: options.channelSession?.model,
-    reasoningEffort: options.channelSession?.reasoningEffort,
-    fast: options.fast
-  }) : undefined;
+  const started = options.codexUrl === undefined ? await startOwnedCodexAppServer(options) : undefined;
   if (started !== undefined) {
     cleanup.actions.push(() => {
       started.process.kill("SIGINT");
@@ -6790,7 +6851,7 @@ function normalizedWorkDescription(value) {
   return normalized === undefined || normalized === "" ? undefined : normalized;
 }
 function makeRunnerLogger(options) {
-  return createRunnerLogger(options.logFile ?? join4(options.cwd, ".linzumi-runner.log"), options.launchTui ? undefined : reportRunnerConsoleEvent);
+  return createRunnerLogger(options.logFile ?? join5(options.cwd, ".linzumi-runner.log"), options.launchTui ? undefined : reportRunnerConsoleEvent);
 }
 function installCleanupHandlers(close) {
   const closeAndExit = () => {
@@ -6867,6 +6928,9 @@ async function applyControl(codex, instanceId, options, allowedCwds, control) {
           error: cwd.reason
         };
       }
+      if (options.codexUrl === undefined) {
+        ensureCodexProjectTrusted(cwd.cwd);
+      }
       const response = await codex.request("thread/start", {
         cwd: cwd.cwd,
         serviceName: "kandan-local-runner",
@@ -6951,6 +7015,14 @@ async function applyControl(codex, instanceId, options, allowedCwds, control) {
       return { instanceId, controlType: control.type, skipped: true };
   }
 }
+async function startOwnedCodexAppServer(options) {
+  ensureCodexProjectTrusted(options.cwd);
+  return await startCodexAppServer(options.codexBin, options.cwd, {
+    model: options.channelSession?.model,
+    reasoningEffort: options.channelSession?.reasoningEffort,
+    fast: options.fast
+  });
+}
 function isUpdateRunnerConfigControl(control) {
   return control.type === "update_runner_config";
 }
@@ -6965,18 +7037,18 @@ function allowedCwdSuggestions(cwd, allowedCwds) {
 }
 
 // src/authCache.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname4, join as join6 } from "node:path";
 function defaultAuthFilePath() {
-  const base = process.env.KANDAN_HOME ?? join5(homedir3(), ".kandan");
-  return join5(base, "auth.json");
+  const base = process.env.KANDAN_HOME ?? join6(homedir4(), ".kandan");
+  return join6(base, "auth.json");
 }
 function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePath()) {
-  if (!existsSync3(authFilePath)) {
+  if (!existsSync4(authFilePath)) {
     return;
   }
-  const authFile = parseAuthFile(readFileSync2(authFilePath, "utf8"));
+  const authFile = parseAuthFile(readFileSync3(authFilePath, "utf8"));
   const kandanBaseUrl = kandanHttpBaseUrl(kandanUrl);
   const entry = authFile.local_codex_runner?.[kandanBaseUrl];
   if (entry === undefined || entry.access_token.trim() === "") {
@@ -6994,7 +7066,7 @@ function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePat
 }
 function writeCachedLocalRunnerToken(args) {
   const authFilePath = args.authFilePath ?? defaultAuthFilePath();
-  const existing = existsSync3(authFilePath) ? parseAuthFile(readFileSync2(authFilePath, "utf8")) : { version: 1 };
+  const existing = existsSync4(authFilePath) ? parseAuthFile(readFileSync3(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();
@@ -7010,8 +7082,8 @@ function writeCachedLocalRunnerToken(args) {
       }
     }
   };
-  mkdirSync4(dirname4(authFilePath), { recursive: true });
-  writeFileSync3(authFilePath, `${JSON.stringify(next, null, 2)}
+  mkdirSync5(dirname4(authFilePath), { recursive: true });
+  writeFileSync4(authFilePath, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   return {
     accessToken: args.accessToken,
@@ -7104,18 +7176,18 @@ async function acquireAndCacheToken(args) {
 }
 
 // src/localConfig.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync3, realpathSync as realpathSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname5, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync4, realpathSync as realpathSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname5, resolve as resolve5 } from "node:path";
 function localConfigPath(env = process.env) {
   const override = env.LINZUMI_CONFIG_FILE;
-  return override !== undefined && override.trim() !== "" ? resolve4(expandUserPath(override)) : resolve4(homedir4(), ".linzumi", "config.json");
+  return override !== undefined && override.trim() !== "" ? resolve5(expandUserPath(override)) : resolve5(homedir5(), ".linzumi", "config.json");
 }
 function readLocalConfig(path = localConfigPath()) {
-  if (!existsSync4(path)) {
+  if (!existsSync5(path)) {
     return { version: 1, allowedCwds: [] };
   }
-  const parsed = JSON.parse(readFileSync3(path, "utf8"));
+  const parsed = JSON.parse(readFileSync4(path, "utf8"));
   if (!isConfigPayload(parsed)) {
     throw new Error(`invalid Linzumi config: ${path}`);
   }
@@ -7127,21 +7199,21 @@ function readLocalConfig(path = localConfigPath()) {
 function readConfiguredAllowedCwds(path = localConfigPath()) {
   return readLocalConfig(path).allowedCwds.map((cwd) => {
     try {
-      return realpathSync3(resolve4(expandUserPath(cwd)));
+      return realpathSync4(resolve5(expandUserPath(cwd)));
     } catch (_error) {
       throw new Error(`invalid Linzumi config allowed path: ${cwd} does not exist`);
     }
   });
 }
 function addAllowedCwd(pathValue, path = localConfigPath()) {
-  const normalizedPath = realpathSync3(resolve4(expandUserPath(pathValue)));
+  const normalizedPath = realpathSync4(resolve5(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 = resolve4(expandUserPath(pathValue));
+  const requestedPath = resolve5(expandUserPath(pathValue));
   const normalizedRequest = realpathOrResolved(requestedPath);
   const config = readLocalConfig(path);
   const allowedCwds = config.allowedCwds.filter((cwd) => {
@@ -7152,8 +7224,8 @@ function removeAllowedCwd(pathValue, path = localConfigPath()) {
   return allowedCwds;
 }
 function writeLocalConfig(config, path = localConfigPath()) {
-  mkdirSync5(dirname5(path), { recursive: true });
-  writeFileSync4(path, `${JSON.stringify(config, null, 2)}
+  mkdirSync6(dirname5(path), { recursive: true });
+  writeFileSync5(path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 function isConfigPayload(value) {
@@ -7164,14 +7236,14 @@ function uniqueStrings(values) {
 }
 function realpathOrResolved(pathValue) {
   try {
-    return realpathSync3(resolve4(expandUserPath(pathValue)));
+    return realpathSync4(resolve5(expandUserPath(pathValue)));
   } catch (_error) {
-    return resolve4(expandUserPath(pathValue));
+    return resolve5(expandUserPath(pathValue));
   }
 }
 
 // src/kandanTls.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
 import { Agent } from "undici";
 import { WebSocket as WsWebSocket } from "ws";
 function kandanTlsTrustFromEnv() {
@@ -7182,10 +7254,10 @@ function kandanTlsTrustFromCaFile(caFile) {
     return;
   }
   const trimmed = caFile.trim();
-  if (!existsSync5(trimmed)) {
+  if (!existsSync6(trimmed)) {
     throw new Error(`KANDAN_TLS_CA_FILE does not exist: ${trimmed}`);
   }
-  const ca = readFileSync4(trimmed, "utf8");
+  const ca = readFileSync5(trimmed, "utf8");
   return {
     caFile: trimmed,
     ca,
@@ -7214,9 +7286,9 @@ function trustedWebSocketFactory(trust, WebSocketImpl = WsWebSocket) {
 }
 
 // src/agentBootstrap.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname6, join as join6 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname6, join as join7 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 var defaultApiUrl = "https://serve.linzumi.com";
 async function runAgentCliCommand(args, deps = {
   fetchImpl: fetch,
@@ -7699,7 +7771,7 @@ function agentTokenFile(flags) {
   return flags.get("agent-token-file") ?? defaultAgentTokenFilePath();
 }
 function defaultAgentTokenFilePath() {
-  return join6(homedir5(), ".linzumi", "agent-token.json");
+  return join7(homedir6(), ".linzumi", "agent-token.json");
 }
 function normalizedApiUrl(apiUrl) {
   return apiUrl.endsWith("/") ? apiUrl : `${apiUrl}/`;
@@ -7708,11 +7780,11 @@ function authorizationHeaders(token) {
   return { authorization: `Bearer ${token}` };
 }
 function readOptionalTextFile(path) {
-  return existsSync6(path) ? readFileSync5(path, "utf8") : undefined;
+  return existsSync7(path) ? readFileSync6(path, "utf8") : undefined;
 }
 function writeTextFile(path, content) {
-  mkdirSync6(dirname6(path), { recursive: true });
-  writeFileSync5(path, content);
+  mkdirSync7(dirname6(path), { recursive: true });
+  writeFileSync6(path, content);
 }
 function readStoredAgentTokenFile(path, readTextFile = readOptionalTextFile) {
   const content = readTextFile(path);
@@ -7773,8 +7845,8 @@ Launch target:
 }
 
 // src/helloLinzumiProject.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname7, join as join7, resolve as resolve5 } from "node:path";
+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 join8, resolve as resolve6 } from "node:path";
 import { fileURLToPath } from "node:url";
 var defaultHelloLinzumiProjectDir = "/tmp/hello_linzumi";
 var defaultHelloLinzumiProjectName = "hello_linzumi";
@@ -7783,7 +7855,7 @@ var defaultHelloLinzumiPort = 8787;
 var defaultHelloLinzumiHost = "0.0.0.0";
 var markerFile = ".linzumi-demo-project";
 var moduleDir = dirname7(fileURLToPath(import.meta.url));
-var linzumiLogoSvg = readFileSync6(join7(moduleDir, "assets", "linzumi-logo.svg"), "utf8");
+var linzumiLogoSvg = readFileSync7(join8(moduleDir, "assets", "linzumi-logo.svg"), "utf8");
 function createHelloLinzumiProject(input = {}) {
   const options = typeof input === "string" ? { rootPath: input } : input;
   const root = resolveHelloProjectRoot(options);
@@ -7791,9 +7863,9 @@ function createHelloLinzumiProject(input = {}) {
   const host = normalizeHost(options.host);
   assertTcpPort(port);
   assertWritableDemoRoot(root, options.reset === true);
-  mkdirSync7(join7(root, "src"), { recursive: true });
+  mkdirSync8(join8(root, "src"), { recursive: true });
   for (const file of demoFiles({ root, port, host })) {
-    writeFileSync6(join7(root, file.path), file.content, "utf8");
+    writeFileSync7(join8(root, file.path), file.content, "utf8");
   }
   return {
     root,
@@ -7808,10 +7880,10 @@ function resolveHelloProjectRoot(options) {
     throw new Error("linzumi init-hello-linzumi-demo-app accepts either --dir or --parent-dir/--name, not both");
   }
   if (options.rootPath !== undefined) {
-    return resolve5(options.rootPath);
+    return resolve6(options.rootPath);
   }
   const name = normalizeProjectName(options.name ?? defaultHelloLinzumiProjectName);
-  return resolve5(options.parentDir ?? defaultHelloLinzumiParentDir, name);
+  return resolve6(options.parentDir ?? defaultHelloLinzumiParentDir, name);
 }
 function normalizeProjectName(value) {
   const name = value.trim();
@@ -7834,11 +7906,11 @@ function assertTcpPort(port) {
   throw new Error("--port must be a TCP port from 1 to 65535");
 }
 function assertWritableDemoRoot(root, reset) {
-  if (!existsSync7(root)) {
+  if (!existsSync8(root)) {
     return;
   }
-  const markerPath = join7(root, markerFile);
-  const isDemoRoot = existsSync7(markerPath) && readFileSync6(markerPath, "utf8").trim() === "hello-linzumi";
+  const markerPath = join8(root, markerFile);
+  const isDemoRoot = existsSync8(markerPath) && readFileSync7(markerPath, "utf8").trim() === "hello-linzumi";
   if (isDemoRoot && reset) {
     rmSync2(root, { recursive: true, force: true });
     return;
@@ -8388,7 +8460,7 @@ function isMainModule() {
   if (scriptPath === undefined) {
     return false;
   }
-  return fileURLToPath2(import.meta.url) === resolve6(scriptPath);
+  return fileURLToPath2(import.meta.url) === resolve7(scriptPath);
 }
 async function main(args) {
   const parsed = parseCommand(args);
@@ -8397,7 +8469,7 @@ async function main(args) {
       process.stdout.write(connectGuideText());
       return;
     case "version":
-      process.stdout.write(`linzumi 0.0.23-beta
+      process.stdout.write(`linzumi 0.0.25-beta
 `);
       return;
     case "auth":
@@ -8452,6 +8524,7 @@ function parseCommand(args) {
     case "agent":
       return rest[0] === "runner" ? { command: "agentRunner", args: rest.slice(1) } : { command: "agent", args: rest };
     case "agent-runner":
+    case "commander":
       return { command: "agentRunner", args: rest };
     case "signup":
     case "claim":
@@ -8531,7 +8604,7 @@ function runPathsCommand(args) {
       if (pathValue === undefined || pathValue.trim() === "") {
         throw new Error("missing path for linzumi paths add");
       }
-      const trustedPath = realpathSync4(resolve6(expandUserPath(pathValue)));
+      const trustedPath = realpathSync5(resolve7(expandUserPath(pathValue)));
       addAllowedCwd(pathValue);
       process.stdout.write(`Trusted ${trustedPath}
 `);
@@ -8686,7 +8759,7 @@ async function parseAgentRunnerArgs(args, deps = {
   }
   rejectAgentRunnerTargetingFlags(values);
   if (cwdArg !== undefined && values.has("cwd")) {
-    throw new Error("linzumi agent runner accepts either <folder> or --cwd, not both");
+    throw new Error("linzumi commander accepts either <folder> or --cwd, not both");
   }
   const tokenFilePath = stringValue3(values, "agent-token-file") ?? defaultAgentTokenFilePath();
   const tokenFile = readStoredAgentTokenFile(tokenFilePath, deps.readTextFile);
@@ -8747,19 +8820,19 @@ async function parseAgentRunnerArgs(args, deps = {
   };
 }
 function readAgentTokenTextFile(path) {
-  return existsSync8(path) ? readFileSync7(path, "utf8") : undefined;
+  return existsSync9(path) ? readFileSync8(path, "utf8") : undefined;
 }
 function rejectAgentRunnerTargetingFlags(values) {
   const unsupportedFlags = ["workspace", "channel", "token", "auth-file", "oauth-callback-host"].filter((flag) => values.has(flag));
   if (unsupportedFlags.length > 0) {
-    throw new Error(`linzumi agent runner uses the claimed agent token scope; remove ${unsupportedFlags.map((flag) => `--${flag}`).join(", ")}.`);
+    throw new Error(`linzumi commander uses the claimed agent token scope; remove ${unsupportedFlags.map((flag) => `--${flag}`).join(", ")}.`);
   }
 }
 function requiredStoredAgentChannel(channelId) {
   if (channelId !== undefined) {
     return channelId;
   }
-  throw new Error("agent token file is missing channelId; rerun linzumi claim before starting an agent runner");
+  throw new Error("agent token file is missing channelId; rerun linzumi claim before starting a Commander");
 }
 function requiredStoredOwnerUsername(ownerUsername) {
   if (ownerUsername !== undefined) {
@@ -8817,7 +8890,7 @@ async function parseRunnerArgs(args, deps = {
     process.exit(0);
   }
   if (values.get("version") === true) {
-    process.stdout.write(`linzumi 0.0.23-beta
+    process.stdout.write(`linzumi 0.0.25-beta
 `);
     process.exit(0);
   }
@@ -8936,12 +9009,12 @@ function rejectStartTargetingFlags(values) {
 }
 function resolveUserPath(pathValue) {
   if (pathValue === "~") {
-    return homedir6();
+    return homedir7();
   }
   if (pathValue.startsWith("~/")) {
-    return resolve6(homedir6(), pathValue.slice(2));
+    return resolve7(homedir7(), pathValue.slice(2));
   }
-  return resolve6(pathValue);
+  return resolve7(pathValue);
 }
 function parseChannelSession(values, token, target) {
   if (target === undefined) {
@@ -9039,7 +9112,7 @@ Usage:
   linzumi inbox <thread_id> --since-last
   linzumi done <thread_id> --message <message>
   linzumi init-hello-linzumi-demo-app
-  linzumi agent runner <folder> [options]
+  linzumi commander <folder> [options]
   linzumi start <folder> [options]
   linzumi paths list|add|remove [path]
   linzumi connect --kandan-url <ws-url> --workspace <slug> --channel <slug> [options]
@@ -9081,7 +9154,7 @@ Examples:
     linzumi post thr_abc123 "PR is open"
     linzumi done thr_abc123 --message "Done: https://github.com/example/repo/pull/1"
     linzumi init-hello-linzumi-demo-app
-    linzumi agent runner ~/code/my-app --runner-id launch-agent-runner
+    linzumi commander ~/code/my-app --runner-id launch-commander
     linzumi start ~/
     linzumi start ~/code/my-app
     linzumi connect --workspace <your-workspace> --channel <your-channel> --launch-tui
@@ -9173,13 +9246,14 @@ Examples:
 `;
 }
 function agentRunnerHelpText() {
-  return `Linzumi agent-owned local runner
+  return `Linzumi Commander
 
 Usage:
+  linzumi commander <folder> [options]
   linzumi agent runner <folder> [options]
 
 What it does:
-  Starts this computer as the claimed agent's scoped local runner. The command
+  Starts this computer as the claimed agent's scoped Linzumi Commander. The command
   reads ~/.linzumi/agent-token.json, uses its workspace/channel scope, trusts
   only the selected folder by default, and listens only to the owning human
   recorded during claim unless --listen-user is passed.
@@ -9187,7 +9261,7 @@ What it does:
 Options:
   --agent-token-file <path>   Agent token cache, default ~/.linzumi/agent-token.json
   --kandan-url <ws-url>       Kandan websocket base URL. Defaults deterministically from the stored apiUrl.
-  --runner-id <id>            Stable local runner id
+  --runner-id <id>            Stable Commander id
   --codex-bin <path>          Codex executable, default codex
   --code-server-bin <path>    Custom development code-server executable. By default Kandan installs the approved editor runtime.
   --listen-user <user>        Human whose replies Codex may accept, default owner from claim
@@ -9197,11 +9271,11 @@ Options:
   --approval-policy <value>   Approval-policy metadata shown in Kandan
   --forward-port <ports>      Comma-separated local TCP ports Kandan may expose as previews
   --allowed-cwd <paths>       Override the selected folder with comma-separated trusted roots
-  --fast                      Mark this runner as low-latency/fast in Kandan
+  --fast                      Mark this Commander as low-latency/fast in Linzumi
 
 Examples:
-  linzumi agent runner "$PWD" --runner-id hello-world-agent
-  linzumi agent runner ~/code/my-app --kandan-url ws://127.0.0.1:4162 --runner-id local-qa-agent
+  linzumi commander "$PWD" --runner-id hello-world-commander
+  linzumi commander ~/code/my-app --kandan-url ws://127.0.0.1:4162 --runner-id local-qa-commander
 `;
 }
 function connectGuideText() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.23-beta",
+  "version": "0.0.25-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": {