@linzumi/cli 0.0.49-beta → 0.0.51-beta

package/README.md

@@ -62,7 +62,7 @@ Install the CLI or run it with `npx`:
 ```bash
 npm install -g @linzumi/cli@latest
 npx -y @linzumi/cli@latest signup
-npx -y @linzumi/cli@0.0.49-beta --version
+npx -y @linzumi/cli@0.0.51-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -10152,7 +10152,7 @@ function realpathOrResolved(pathValue) {
 }
 
 // src/version.ts
-var linzumiCliVersion = "0.0.49-beta";
+var linzumiCliVersion = "0.0.51-beta";
 var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
 
 // src/runnerLock.ts
@@ -11364,6 +11364,7 @@ async function discoverCodexThreads(codex, cwd) {
     preview: stringValue(thread.preview) ?? "",
     cwd: stringValue(thread.cwd) ?? "",
     source: stringValue(thread.source) ?? "",
+    createdAt: integerValue(thread.createdAt) ?? stringValue(thread.createdAt) ?? null,
     updatedAt: integerValue(thread.updatedAt) ?? null,
     status: objectValue(thread.status) ?? null
   })).filter((thread) => thread.id !== "");
@@ -11747,6 +11748,22 @@ ${args.developerPrompt}
 `;
   const linzumiContext = args.linzumiContext === undefined ? "" : `
 ${formatLinzumiConversationContextForPrompt(args.linzumiContext)}
+`;
+  const reviewGuidance = `
+<linzumi_pr_review_guidance>
+For frontend or other user-visible changes, ask whether the user wants
+screenshot or screen-recording proof, ideally before/after when that helps
+review the change. Screen recordings should be WebM or MP4. When the user asks
+you to open or update a PR, attach or link that proof in the PR when feasible,
+and state the exact blocker when it is not feasible.
+</linzumi_pr_review_guidance>
+
+<linzumi_user_visible_writing_guide>
+When you write user-visible UI, status, error, or PR-review copy, keep it short,
+direct, and focused on the user's outcome. Avoid implementation-heavy sentences,
+stacked clauses, and internal mechanics unless the user explicitly needs that
+detail.
+</linzumi_user_visible_writing_guide>
 `;
   return `<context>
 You are a Linzumi Codex session launched by the Linzumi Commander.
@@ -11791,6 +11808,7 @@ GOOD preview command: npm run dev -- --host 0.0.0.0 --port 8787
 BAD preview command: npm run dev -- --host 127.0.0.1
 </examples>
 ${linzumiContext}
+${reviewGuidance}
 ${customPrompt}
 <task_reminder>
 You are the Commander-launched Linzumi Codex session. Do the implementation
@@ -14879,13 +14897,15 @@ var esm_default4 = createPrompt((config, done) => {
 `).trimEnd();
   return `${lines}${cursorHide}`;
 });
-// src/signupMockFlow.ts
+// src/signupFlow.ts
 import { spawn as spawn7 } from "node:child_process";
 import {
+  closeSync as closeSync2,
   existsSync as existsSync10,
   constants as fsConstants,
   mkdirSync as mkdirSync10,
   mkdtempSync as mkdtempSync3,
+  openSync as openSync3,
   readFileSync as readFileSync10,
   readdirSync,
   rmSync as rmSync3,
@@ -14916,7 +14936,8 @@ function createSignupServerClient(args) {
       method: "POST",
       body: {
         email: request.email,
-        mode: request.mode
+        mode: request.mode,
+        selected_tasks: request.selectedTasks ?? []
       },
       render: renderEmailCodeStart
     }),
@@ -15185,7 +15206,7 @@ function booleanValue(record, key) {
   throw new Error(`signup ${key} was incomplete`);
 }
 
-// src/signupMockFlow.ts
+// src/signupFlow.ts
 var commanderConnectedMarkers = [
   "Connected to Linzumi",
   "Runner connected:",
@@ -15216,7 +15237,7 @@ secure mission control for all your agents on your computers
 `;
 var logoTagline = "secure mission control for all your agents on your computers";
 var signupCancelMessage = "Y'all come back soon, ya hear?";
-function signupMockHelpText() {
+function signupHelpText() {
   return [
     "Usage:",
     "  linzumi signup",
@@ -15286,7 +15307,7 @@ function comparableServiceUrl(value) {
     return trimmed.replace(/\/+$/u, "");
   }
 }
-async function runSignupMockFlow(deps = {}) {
+async function runSignupFlow(deps = {}) {
   const input = deps.input ?? defaultStdin;
   const output = deps.output ?? defaultStdout;
   const prompts = deps.prompts ?? inquirerPrompts(input, output);
@@ -15363,18 +15384,25 @@ async function runSignupMockFlow(deps = {}) {
     projectDiscovery: { type: "ready", codeRoot: guessedCodeRoot, projects }
   });
   const selectedProjectPaths = await prompts.projectPicker({
-    message: "Which projects would you like to add to Linzumi Mission Control?",
+    message: "Pick the first folders where Linzumi should start agents",
     projects,
     defaultSelectedPaths: defaultSelectedProjectPaths(forceSignup ? [] : readConfiguredProjectPaths(serviceUrl))
   });
-  if (selectedProjectPaths.length === 0) {
+  const projectPreparation = prepareSelectedSignupProjects(selectedProjectPaths, projects);
+  if (projectPreparation.type === "failed") {
+    writeProjectPreparationFailure(output, projectPreparation.message);
+    writeDebugLaunchPayload(output, state, debugLaunchPayload);
+    return;
+  }
+  const preparedProjectPaths = projectPreparation.selectedProjectPaths;
+  if (preparedProjectPaths.length === 0) {
     writeNoProjectsFound(output);
     writeDebugLaunchPayload(output, state, debugLaunchPayload);
     return;
   }
   state = updateSignupState(state, {
     currentStep: "tasks",
-    selectedProjectPaths
+    selectedProjectPaths: preparedProjectPaths
   });
   writeSignupScreen(output, state);
   writePreflightSummary(output, state);
@@ -15407,7 +15435,8 @@ async function runSignupMockFlow(deps = {}) {
   writeSelectedProjectsSummary(output, state);
   writeSelectedTasksSummary(output, state);
   const projectGitEmails = await projectGitEmailsPromise;
-  const globalGitEmail = configuredGitEmailFromPreflights(state.preflightChecks);
+  const configuredGitEmail = configuredGitEmailFromPreflights(state.preflightChecks);
+  const globalGitEmail = configuredGitEmail !== undefined && usefulSuggestedEmail(configuredGitEmail) ? configuredGitEmail : undefined;
   const emailCandidates = globalGitEmail === undefined ? uniqueDefinedEmails(projectGitEmails) : [];
   state = updateSignupState(state, { projectGitEmails, emailCandidates });
   const reusedSignupAuth = state.reusedSignupAuth;
@@ -15421,7 +15450,8 @@ async function runSignupMockFlow(deps = {}) {
     state = updateSignupState(state, { currentStep: "code", email });
     const codeRequest = signupServerClient === undefined ? { type: "sent", request: { pendingId: "mock", email } } : await startEmailCodeForSignup(signupServerClient, {
       email,
-      mode: "existing_or_create"
+      mode: "existing_or_create",
+      selectedTasks: selectedTaskTitlesFromState(state)
     });
     if (codeRequest.type === "failed") {
       state = updateSignupState(state, {
@@ -15771,13 +15801,22 @@ function writeProjectPickerIntro(output, state) {
   if (!preflightsFinished(state)) {
     return;
   }
-  writeBoundedLine(output, blue("2) Where should Linzumi let your Codex agents work?"));
+  writeBoundedLine(output, blue("2) Where should Linzumi let your Codex agents start?"));
+  writeWrappedPrefixMessage(output, "   ", "Pick the first local folders for Mission Control. You can add or remove folders later.", muted);
 }
 function writeNoProjectsFound(output) {
   output.write(`${blue("?")} No projects found yet
 
 `);
 }
+function writeProjectPreparationFailure(output, message) {
+  output.write(`
+`);
+  writeBoundedLine(output, blue("We couldn't prepare that project"));
+  writeStatusMessage(output, red("x"), message);
+  writeBoundedLine(output, muted("   Choose another folder or move the conflicting demo directory, then retry:"));
+  writeBoundedLine(output, blue("   npx -y @linzumi/cli@latest signup"));
+}
 function writeSelectedProjectsSummary(output, state) {
   const selectedProjects = selectedProjectsFromState(state);
   output.write(`
@@ -15822,7 +15861,7 @@ function signupProgressRows(state) {
       checked: selectedTaskTitlesFromState(state).length > 0
     },
     {
-      label: "We'll launch you into Mission Control with your work already running",
+      label: "Mission Control will open with your work already running",
       checked: state.currentStep === "launch"
     }
   ];
@@ -15891,7 +15930,7 @@ async function chooseTasks(prompts, output, tasks) {
   output.write(`
 `);
   writeBoundedLine(output, blue("4) What should your Codex agents start working on?"));
-  writeBoundedLine(output, muted("   Pick up to 5 starting tasks for Linzumi Mission Control."));
+  writeBoundedLine(output, muted("   Pick up to 5 small starter tasks. These just get agents moving."));
   writeBoundedLine(output, muted("   Select suggested tasks, or choose the last row to type your own task."));
   const customTaskChoice = "__custom_task__";
   const checkedTasks = await prompts.checkbox({
@@ -15961,7 +16000,7 @@ function writeLaunchSummary(output, state) {
     writeBoundedLine(output, blue("   npx -y @linzumi/cli@latest signup"));
     return;
   }
-  writeBoundedLine(output, blue("7) We'll launch you into Mission Control with your work already running"));
+  writeBoundedLine(output, blue("7) Mission Control will open with your work already running"));
   const taskCount = selectedTaskTitlesFromState(state).length;
   writeBoundedLine(output, muted(`   Starting ${taskCount} ${taskCount === 1 ? "task" : "tasks"} and saying hello to the Linzumi team...`));
   state.starterTaskLaunches.forEach((launch) => {
@@ -16037,12 +16076,20 @@ async function defaultSignupCommanderLauncher(args) {
     };
   }
   const logFile = signupCommanderLaunchLogFile(runnerId);
+  let stdoutFd;
+  let stderrFd;
   try {
     mkdirSync10(dirname9(logFile), { recursive: true });
+    stdoutFd = openSync3(logFile, "a");
+    stderrFd = openSync3(logFile, "a");
     const child = spawn7(processExecPath, signupCommanderConnectSpawnArgs(args, runnerId, logFile, scriptPath), {
       detached: true,
-      stdio: "ignore"
+      stdio: ["ignore", stdoutFd, stderrFd]
     });
+    closeSync2(stdoutFd);
+    closeSync2(stderrFd);
+    stdoutFd = undefined;
+    stderrFd = undefined;
     child.unref();
     const connected = await waitForSignupCommanderConnection(logFile, 30000);
     if (!connected) {
@@ -16067,6 +16114,9 @@ async function defaultSignupCommanderLauncher(args) {
       restartCommand,
       error: error instanceof Error ? error.message : String(error)
     };
+  } finally {
+    closeFileDescriptor(stdoutFd);
+    closeFileDescriptor(stderrFd);
   }
 }
 async function waitForSignupCommanderConnection(logFile, timeoutMs) {
@@ -16093,6 +16143,14 @@ function readTextFile(path) {
     return;
   }
 }
+function closeFileDescriptor(fd) {
+  if (fd === undefined) {
+    return;
+  }
+  try {
+    closeSync2(fd);
+  } catch (_error) {}
+}
 async function waitForSignupCommanderLogChange(logFile, deadline, ready2) {
   const remaining = Math.max(0, deadline - Date.now());
   await new Promise((resolve9) => {
@@ -16152,8 +16210,6 @@ function signupCommanderConnectSpawnArgs(args, runnerId, logFile, scriptPath) {
     args.serviceUrl,
     "--workspace",
     args.workspaceSlug,
-    "--channel",
-    args.officeChannelSlug,
     "--runner-id",
     runnerId,
     "--log-file",
@@ -16624,6 +16680,40 @@ function projectPickerRows(projects, selectedPaths, pathInput) {
   const recentRows = projects.filter((project) => !selectedPaths.has(project.path)).slice(0, remainingCount).map((project) => ({ project, selected: false }));
   return [...selectedRows, ...recentRows];
 }
+function prepareSelectedSignupProjects(selectedProjectPaths, projects) {
+  const normalizedPaths = selectedProjectPaths.map(normalizeProjectPath);
+  const selectedProjectByPath = new Map(normalizedPaths.map((path) => [
+    path,
+    projectFromKnownOrPath(projects, path)
+  ]));
+  for (const [path, project] of selectedProjectByPath) {
+    if (project.source === "hello_linzumi_demo") {
+      try {
+        createHelloLinzumiProject({ rootPath: path });
+      } catch (error) {
+        return {
+          type: "failed",
+          message: demoProjectCreateFailureMessage(path, error)
+        };
+      }
+    }
+  }
+  return {
+    type: "ready",
+    selectedProjectPaths: Array.from(new Set(normalizedPaths))
+  };
+}
+function demoProjectCreateFailureMessage(path, error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  return `The Hello Linzumi demo project could not be created at ${path}. ${detail}`;
+}
+function helloLinzumiDemoProjectOption() {
+  return {
+    path: normalizeProjectPath(defaultHelloLinzumiProjectDir),
+    language: "Demo",
+    source: "hello_linzumi_demo"
+  };
+}
 function renderProjectPickerRow(row, index, state) {
   const active = index === state.highlightIndex;
   const marker = active ? blue("›") : " ";
@@ -16631,11 +16721,12 @@ function renderProjectPickerRow(row, index, state) {
   const gitHead = row.project.gitHead;
   const sha = truncateEnd(gitHead?.sha ?? "-----", 5);
   const date = gitHead?.date ?? "----------";
-  const message = gitHead?.message ?? "";
+  const message = gitHead?.message ?? (row.project.source === "hello_linzumi_demo" ? "Create a safe demo app" : "");
   return `   ${marker}${selected} ${truncateMiddle(row.project.path, 41).padEnd(41, " ")} ${sha.padEnd(5, " ")} ${date.padEnd(10, " ")} ${truncateEnd(message, 34)}`;
 }
 function projectFromKnownOrPath(projects, path) {
-  return projects.find((project) => project.path === path) ?? customProjectOption(path);
+  const normalizedPath = normalizeProjectPath(path);
+  return projects.find((project) => project.path === normalizedPath) ?? (normalizedPath === normalizeProjectPath(defaultHelloLinzumiProjectDir) ? helloLinzumiDemoProjectOption() : undefined) ?? customProjectOption(normalizedPath);
 }
 function selectedProjectsFromState(state) {
   if (state.projectDiscovery.type !== "ready") {
@@ -16866,7 +16957,8 @@ function uniqueEmails(emails) {
 }
 function usefulSuggestedEmail(email) {
   const normalizedEmail = email.trim().toLocaleLowerCase();
-  return !(normalizedEmail === "noreply@github.com" || normalizedEmail.endsWith("@users.noreply.github.com") || normalizedEmail.endsWith("@noreply.github.com"));
+  const domain = normalizedEmail.split("@")[1] ?? "";
+  return !(normalizedEmail === "noreply@github.com" || normalizedEmail.endsWith("@users.noreply.github.com") || normalizedEmail.endsWith("@noreply.github.com") || domain === "localhost" || domain.endsWith(".local"));
 }
 function configuredGitEmailFromPreflights(checks) {
   const gitEmailCheck = checks.find((check2) => check2.id === "git_email");
@@ -16945,8 +17037,9 @@ function defaultPreflightRuntime() {
   };
 }
 function defaultProjectDiscoveryRuntime() {
+  const cwd = process.cwd();
   return {
-    discoverProjects: async (homeDir) => discoverProjectsFromGuessedRoots(homeDir)
+    discoverProjects: async (homeDir) => discoverProjectsFromSignupRoots(homeDir, cwd)
   };
 }
 function defaultTaskSuggestionRuntime() {
@@ -17093,7 +17186,7 @@ async function resolveSignupCodexCommand(env = process.env, homeDir = homedir8()
       "Set LINZUMI_SIGNUP_CODEX_BIN to a working Codex executable or install Codex in a home-managed location such as ~/.volta/bin/codex."
     ].join(" "));
   }
-  throw new Error("Codex task suggestions could not find Codex. Set LINZUMI_SIGNUP_CODEX_BIN to a working Codex executable.");
+  throw new Error("Codex task suggestions could not find Codex. Install Codex first, or set LINZUMI_SIGNUP_CODEX_BIN to a working Codex executable.");
 }
 function firstConfiguredValue(values) {
   return values.find((value) => value !== undefined && value.trim() !== "");
@@ -17439,6 +17532,33 @@ function discoverProjectsUnderRoot(codeRoot) {
     gitHead: cachedGitHeadSummary(project.path)
   })).sort(sortProjectsByRecentGitCommit).slice(0, 20);
 }
+function discoverProjectsFromSignupRoots(homeDir, cwd) {
+  const currentProjects = discoverProjectsFromCurrentDirectory(cwd);
+  const guessedProjects = discoverProjectsFromGuessedRoots(homeDir);
+  const demoProject = helloLinzumiDemoProjectOption();
+  const [firstCurrentProject, ...remainingCurrentProjects] = currentProjects;
+  const seenPaths = new Set;
+  return [
+    ...firstCurrentProject === undefined ? [] : [firstCurrentProject],
+    demoProject,
+    ...remainingCurrentProjects,
+    ...guessedProjects
+  ].filter((project) => {
+    if (seenPaths.has(project.path)) {
+      return false;
+    }
+    seenPaths.add(project.path);
+    return true;
+  }).slice(0, 24);
+}
+function discoverProjectsFromCurrentDirectory(cwd) {
+  const normalizedCwd = normalizeProjectPath(cwd);
+  const cwdProject = directoryExists(normalizedCwd) ? [customProjectOption(normalizedCwd)] : [];
+  const gitRoot = gitTopLevel(normalizedCwd);
+  const gitRootProject = gitRoot !== undefined && gitRoot !== normalizedCwd ? [customProjectOption(gitRoot)] : [];
+  const childProjects = discoverProjectsUnderRoot(normalizedCwd);
+  return [...cwdProject, ...gitRootProject, ...childProjects];
+}
 function discoverProjectsFromGuessedRoots(homeDir) {
   const guessedRoots = ["src", "code", "projects"].map((name) => join12(homeDir, name));
   const projects = guessedRoots.flatMap((root) => discoverProjectsUnderRoot(root));
@@ -17451,6 +17571,9 @@ function discoverProjectsFromGuessedRoots(homeDir) {
     return true;
   }).sort(sortProjectsByRecentGitCommit).slice(0, 20);
 }
+function gitTopLevel(cwd) {
+  return spawnSyncGit(["rev-parse", "--show-toplevel"], cwd);
+}
 function sortProjectsByRecentGitCommit(left, right) {
   const leftTimestamp = left.gitHead?.timestamp ?? 0;
   const rightTimestamp = right.gitHead?.timestamp ?? 0;
@@ -17580,9 +17703,9 @@ function renderPreflightRow(check2, spinnerFrame, columns) {
 // src/commanderDaemon.ts
 import {
   existsSync as existsSync11,
-  closeSync as closeSync2,
+  closeSync as closeSync3,
   mkdirSync as mkdirSync11,
-  openSync as openSync3,
+  openSync as openSync4,
   readFileSync as readFileSync11,
   watch as watch2,
   writeFileSync as writeFileSync9
@@ -17622,8 +17745,8 @@ function startCommanderDaemon(options) {
   ];
   mkdirSync11(statusDir, { recursive: true });
   mkdirSync11(dirname10(logFile), { recursive: true });
-  const out = openSync3(logFile, "a");
-  const err = openSync3(logFile, "a");
+  const out = openSync4(logFile, "a");
+  const err = openSync4(logFile, "a");
   writeCliAuditEvent("process.spawn", {
     command: nodeBin,
     args: command,
@@ -17642,8 +17765,8 @@ function startCommanderDaemon(options) {
     pid: child.pid,
     purpose: "commander_daemon.start"
   }, { sessionId: options.runnerId });
-  closeSync2(out);
-  closeSync2(err);
+  closeSync3(out);
+  closeSync3(err);
   child.unref();
   if (child.pid === undefined) {
     throw new Error("commander daemon did not report a pid");
@@ -17917,12 +18040,12 @@ async function main(args) {
       return;
     case "signupMock":
       if (parsed.args.includes("--help") || parsed.args.includes("-h")) {
-        process.stdout.write(signupMockHelpText());
+        process.stdout.write(signupHelpText());
         return;
       }
       {
         const options = parseSignupTuiOptions(parsed.args);
-        await runSignupMockFlow({
+        await runSignupFlow({
           forceSignup: options.forceSignup,
           serviceUrl: options.serviceUrl,
           openBrowser: false,
@@ -17933,12 +18056,12 @@ async function main(args) {
       return;
     case "signup":
       if (parsed.args.includes("--help") || parsed.args.includes("-h")) {
-        process.stdout.write(signupMockHelpText());
+        process.stdout.write(signupHelpText());
         return;
       }
       {
         const options = parseSignupTuiOptions(parsed.args);
-        await runSignupMockFlow({
+        await runSignupFlow({
           forceSignup: options.forceSignup,
           serviceUrl: options.serviceUrl,
           openBrowser: options.openBrowser,
@@ -18516,7 +18639,8 @@ async function parseRunnerArgs(args, deps = {
 `);
     process.exit(0);
   }
-  const connectTarget = parseConnectTarget(values);
+  rejectConnectChannelFlags(values);
+  const workspaceSlug = stringValue4(values, "workspace");
   const kandanUrl = stringValue4(values, "linzumi-url") ?? defaultLinzumiWebSocketUrl;
   const cwd = stringValue4(values, "cwd") ?? process.cwd();
   const cwdAllowedCwds = assertConfiguredAllowedCwds([cwd]);
@@ -18528,8 +18652,7 @@ async function parseRunnerArgs(args, deps = {
   const token = await deps.resolveToken({
     kandanUrl,
     explicitToken,
-    workspaceSlug: connectTarget?.workspaceSlug,
-    channelSlug: connectTarget?.channelSlug,
+    workspaceSlug,
     authFilePath: stringValue4(values, "auth-file"),
     callbackHost: stringValue4(values, "oauth-callback-host"),
     reportRejectedCachedToken: () => {
@@ -18537,7 +18660,6 @@ async function parseRunnerArgs(args, deps = {
 `);
     }
   });
-  const channelSession = parseChannelSession(values, token, connectTarget);
   const editorRuntime = await deps.resolveEditorRuntime({
     kandanUrl,
     token,
@@ -18568,9 +18690,8 @@ async function parseRunnerArgs(args, deps = {
     editorRuntime: editorRuntime.runtime,
     socketFactory: trustedWebSocketFactory(kandanTlsTrustFromEnv()),
     dependencyStatus,
-    workspaceSlug: connectTarget?.workspaceSlug ?? singleWorkspaceScopeFromAccessToken(token),
-    runtimeDefaults: runnerRuntimeDefaultsFromValues(values),
-    channelSession
+    workspaceSlug: workspaceSlug ?? singleWorkspaceScopeFromAccessToken(token),
+    runtimeDefaults: runnerRuntimeDefaultsFromValues(values)
   };
 }
 function runnerRuntimeDefaultsFromValues(values) {
@@ -18667,7 +18788,7 @@ function stripDaemonSupervisorFlags(args) {
 function rejectStartTargetingFlags(values) {
   const unsupportedFlags = ["workspace", "channel"].filter((flag) => values.has(flag));
   if (unsupportedFlags.length > 0) {
-    throw new Error(`linzumi start chooses its workspace during browser onboarding; remove ${unsupportedFlags.map((flag) => `--${flag}`).join(", ")} or use linzumi connect for an explicit workspace/channel.`);
+    throw new Error(`linzumi start chooses its workspace during browser onboarding; remove ${unsupportedFlags.map((flag) => `--${flag}`).join(", ")} or use linzumi connect --workspace for an explicit workspace.`);
   }
 }
 function resolveUserPath(pathValue) {
@@ -18679,26 +18800,6 @@ function resolveUserPath(pathValue) {
   }
   return resolve10(pathValue);
 }
-function parseChannelSession(values, token, target) {
-  if (target === undefined || target.channelSlug === undefined) {
-    return;
-  }
-  const listenUser = stringValue4(values, "listen-user") ?? defaultListenUserFromToken(token);
-  return {
-    workspaceSlug: target.workspaceSlug,
-    channelSlug: target.channelSlug,
-    kandanThreadId: stringValue4(values, "linzumi-thread-id"),
-    listenUser,
-    model: stringValue4(values, "model"),
-    reasoningEffort: stringValue4(values, "reasoning-effort"),
-    sandbox: stringValue4(values, "sandbox"),
-    approvalPolicy: stringValue4(values, "approval-policy"),
-    streamFlushMs: positiveIntegerValue2(values, "stream-flush-ms")
-  };
-}
-function parseConnectTarget(values) {
-  return parseOptionalChannelTarget(values);
-}
 function defaultListenUserFromToken(token) {
   const username = identityFromAccessToken(token).actorUsername;
   if (username !== undefined) {
@@ -18706,6 +18807,17 @@ function defaultListenUserFromToken(token) {
   }
   throw new Error("missing --listen-user and authenticated user is unavailable");
 }
+function rejectConnectChannelFlags(values) {
+  const unsupportedFlags = [
+    "channel",
+    "linzumi-thread-id",
+    "listen-user"
+  ].filter((flag) => values.has(flag));
+  if (unsupportedFlags.length === 0) {
+    return;
+  }
+  throw new Error(`linzumi connect starts a workspace Commander; remove ${unsupportedFlags.map((flag) => `--${flag}`).join(", ")}.`);
+}
 function parseOptionalChannelTarget(values) {
   const channel = stringValue4(values, "channel");
   const workspace = stringValue4(values, "workspace");
@@ -18792,7 +18904,7 @@ Usage:
   linzumi commander <folder> [options]
   linzumi start <folder> [options]
   linzumi paths list|add|remove [path]
-  linzumi connect --workspace <slug> [--channel <slug>] [options]
+  linzumi connect --workspace <slug> [options]
   linzumi auth --linzumi-url <ws-url> [--workspace <slug> --channel <slug>]
 
 Connection:
@@ -18802,12 +18914,8 @@ Connection:
   --auth-file <path>          Auth cache path, default ~/.linzumi/auth.json
   --oauth-callback-host <ip>  Callback host reachable by your browser
 
-Workspace and optional channel binding:
+Workspace:
   --workspace <slug>          Workspace slug
-  --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
 
 Codex:
   --cwd <path>                Working directory for Codex, default current directory
@@ -18839,16 +18947,15 @@ Examples:
     linzumi start ~/code/my-app
     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
 
   Bad:
-    linzumi connect --token not-a-jwt --workspace <your-workspace> --channel <your-channel>
-      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>
+      Invalid: Commanders connect to workspaces, not channels.
+    linzumi connect --token "$TOKEN" --listen-user sean
+      Invalid: Commanders connect to workspaces, not individual channel listeners.
     linzumi connect --workspace <your-workspace> --allowed-cwd /does/not/exist
       Invalid --allowed-cwd: allowed cwd roots must exist locally.
     linzumi connect --workspace <your-workspace> --forward-port vite

package/package.json

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