wtagent 0.2.2 → 0.4.0

package/src/cli/main.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import fs from "node:fs/promises";
 import path from "node:path";
+import { pathToFileURL } from "node:url";
 import { Command } from "commander";
 import { confirm, select } from "@inquirer/prompts";
 import { launchNativeLoginBrowser } from "../browser/native-login.js";
@@ -11,11 +12,11 @@ import {
   getProviderProfileDir,
   isProviderProfileBasename,
   listActiveProviderIds,
-  resolveCliProviderSelection,
   resolveProvider,
 } from "../browser/provider-registry.js";
 import {
   ensureDirectory,
+  formatHomePath,
   getAppDataDir,
   getSessionsDir,
   getTasksDir,
@@ -33,6 +34,7 @@ import { ApprovalStore } from "../policy/approval-store.js";
 import { createDefaultToolRegistry } from "../tools/default-tools.js";
 import { ProcessManager } from "../tools/process-manager.js";
 import { resolveLimits } from "../shared/limits.js";
+import { BrowserAdapterError } from "../shared/errors.js";
 import { EXPORTERS } from "../session/session-export.js";
 import { getPackageVersion } from "../shared/package-info.js";
 import { extractAtMentions } from "./at-files.js";
@@ -45,11 +47,7 @@ import {
   ShellChatInput,
 } from "./prompt-input.js";
 import { createRenderer } from "./render-events.js";
-import {
-  CHATGPT_MODE_CHOICES,
-  modeFromPromptChoice,
-  normalizeConfiguredMode,
-} from "./mode-choice.js";
+import { t } from "./i18n.js";
 import { runSelfUpdate } from "./self-update.js";
 import { runStartupChecks } from "./startup-notices.js";
 
@@ -58,10 +56,6 @@ import { runStartupChecks } from "./startup-notices.js";
 // (each provider logs in independently); an explicit `--profile-dir` still
 // overrides it. Defaults to the ChatGPT profile so callers that predate
 // multi-provider support are unaffected.
-function withResolvedProviderSelection(options) {
-  return { ...options, ...resolveCliProviderSelection(options) };
-}
-
 function resolveRuntimePaths(options, providerId = DEFAULT_PROVIDER) {
   const appDataDir = path.resolve(options.home ?? getAppDataDir());
   return {
@@ -83,15 +77,12 @@ async function assertDirectory(directory) {
 
 async function runLogin(options) {
   assertNativeRuntimeSupported();
-  options = withResolvedProviderSelection(options);
   const provider = resolveProvider(options.model ?? DEFAULT_PROVIDER);
   const { profileDir } = resolveRuntimePaths(options, provider.id);
   const { label, baseUrl } = provider;
   for (;;) {
-    console.log(`Opening native Chrome profile: ${profileDir}`);
-    console.log(
-      `This window has no CDP flags. Finish until ${label} shows your signed-in home/chat history and no Log in button.`,
-    );
+    console.log(t("login.openingProfile", { profileDir }));
+    console.log(t("login.finishSignIn", { provider: label }));
     const browser = await launchNativeLoginBrowser({
       profileDir,
       chromePath: options.chromePath,
@@ -100,13 +91,12 @@ async function runLogin(options) {
 
     try {
       const answer = await promptForText({
-        message:
-          `After the signed-in ${label} home is visible, press Enter here to save and verify`,
+        message: t("login.pressEnterVerify", { provider: label }),
       });
       if (answer == null) {
         return;
       }
-      console.log("Closing native Chrome and saving the dedicated profile...");
+      console.log(t("login.savingProfile"));
       await new Promise((resolve) => setTimeout(resolve, 1_000));
     } finally {
       await browser.close();
@@ -129,16 +119,14 @@ async function runLogin(options) {
         }
       }
       if (authenticated) {
-        console.log(`${label} login verified through a fresh CDP connection.`);
+        console.log(t("login.verified", { provider: label }));
         return;
       }
     } finally {
       await verifier.close();
     }
 
-    console.log(
-      `${label} is still in guest mode. Reopening native Chrome; complete the final ${label} sign-in/continue step.`,
-    );
+    console.log(t("login.stillGuest", { provider: label }));
   }
 }
 
@@ -150,14 +138,13 @@ async function runLogout(options) {
   // `logout` targets one provider's profile; unknown ids are rejected but a
   // "planned" provider is still allowed (its profile may exist from a prior
   // login attempt), so use getProvider rather than resolveProvider.
-  options = withResolvedProviderSelection(options);
   const provider = getProvider(options.model ?? DEFAULT_PROVIDER);
   const { profileDir } = resolveRuntimePaths(options, provider.id);
   const exists = await fs.stat(profileDir)
     .then((stat) => stat.isDirectory())
     .catch(() => false);
   if (!exists) {
-    console.log(`No Chrome profile found at ${profileDir}; already logged out.`);
+    console.log(t("logout.none", { profileDir }));
     return;
   }
 
@@ -168,30 +155,29 @@ async function runLogout(options) {
     .then((stat) => stat.isDirectory())
     .catch(() => false);
   if (!looksLikeProfile && !isProviderProfileBasename(path.basename(profileDir))) {
-    throw new Error(
-      `Refusing to delete ${profileDir}: it does not look like a wtagent Chrome profile.`,
-    );
+    throw new Error(t("logout.refuse", { profileDir }));
   }
 
   if (!options.yes) {
     const confirmed = await confirm({
-      message:
-        `This deletes the local ${provider.label} session (Chrome profile at ${profileDir}) `
-        + "and requires a new login. Continue?",
+      message: t("logout.confirm", {
+        provider: provider.label,
+        profileDir,
+      }),
       default: false,
     });
     if (!confirmed) {
-      console.log("Logout cancelled.");
+      console.log(t("logout.cancelled"));
       return;
     }
   }
 
   await fs.rm(profileDir, { recursive: true, force: true });
-  console.log(`Logged out. Removed ${profileDir}.`);
+  console.log(t("logout.done", { profileDir }));
   console.log(
     provider.id === DEFAULT_PROVIDER
-      ? "Run `wtagent login` to sign in again."
-      : `Run \`wtagent login --model ${provider.id}\` to sign in again.`,
+      ? t("logout.loginAgainDefault")
+      : t("logout.loginAgainProvider", { provider: provider.id }),
   );
 }
 
@@ -231,6 +217,8 @@ class ConversationRunner {
     // The profile dir and adapter follow from it, so resumes reuse the right
     // login even when the CLI is invoked without --model.
     const provider = resolveProvider(session.state.provider ?? DEFAULT_PROVIDER);
+    this.provider = provider;
+    this.interactive = interactive;
     this.paths = resolveRuntimePaths(options, provider.id);
     this.limits = resolveLimits({
       modelTurnTimeoutMs: options.modelTurnTimeoutMs,
@@ -267,20 +255,45 @@ class ConversationRunner {
       policy: new PolicyEngine({ store: this.approvalStore }),
       session: this.session,
       limits: this.limits,
+      postAuthSetup: (
+        this.interactive
+          ? async ({ adapter }) => {
+            this.renderer.stopSpinner();
+            await adapter.restoreWindow?.();
+            try {
+              const answer = await promptForText({
+                message: t("model.chooseInBrowser", {
+                  provider: this.provider.label,
+                }),
+              });
+              if (answer == null) {
+                throw new Error(t("model.setupCancelled"));
+              }
+            } finally {
+              await adapter.minimizeWindow?.();
+            }
+          }
+          : null
+      ),
       approval: async ({ toolCall, reasons }) => {
         this.renderer.stopSpinner();
-        console.log(`\n${"\x1b[33m"}Approval required for ${toolCall.name}:${"\x1b[0m"}`);
+        console.log(
+          `\n${"\x1b[33m"}${t("approval.required", { tool: toolCall.name })}${"\x1b[0m"}`,
+        );
         for (const reason of reasons) {
           console.log(`- ${reason}`);
         }
         console.log(JSON.stringify(toolCall.args, null, 2));
         const choice = await select({
-          message: "How should this action be handled?",
+          message: t("approval.how"),
           choices: [
-            { name: "Allow once", value: "once" },
-            { name: `Always allow ${toolCall.name}`, value: "always-tool" },
-            { name: "Always allow everything", value: "always-all" },
-            { name: "Deny", value: "deny" },
+            { name: t("approval.once"), value: "once" },
+            {
+              name: t("approval.alwaysTool", { tool: toolCall.name }),
+              value: "always-tool",
+            },
+            { name: t("approval.alwaysAll"), value: "always-all" },
+            { name: t("approval.deny"), value: "deny" },
           ],
         });
         if (choice === "deny") {
@@ -289,17 +302,16 @@ class ConversationRunner {
         if (choice === "always-tool") {
           this.approvalStore.setAlwaysAllowedTool(toolCall.name);
           await this.approvalStore.save();
-          console.log(
-            `Saved for this session: ${toolCall.name} will always be allowed `
-            + `(${this.approvalStore.filePath}).`,
-          );
+          console.log(t("approval.savedTool", {
+            tool: toolCall.name,
+            file: formatHomePath(this.approvalStore.filePath),
+          }));
         } else if (choice === "always-all") {
           this.approvalStore.setAlwaysAllowAll();
           await this.approvalStore.save();
-          console.log(
-            `Saved for this session: every tool will always be allowed `
-            + `(${this.approvalStore.filePath}).`,
-          );
+          console.log(t("approval.savedAll", {
+            file: formatHomePath(this.approvalStore.filePath),
+          }));
         }
         return true;
       },
@@ -426,22 +438,28 @@ async function waitForProcessToExit(pid, timeoutMs = 60_000) {
 // session, ask the user how to proceed instead of failing outright: kill the
 // other session, or have the user close its Chrome window so that session
 // fails and releases the profile. Returns true when the turn should be retried.
-async function promptToResolveProfileLock(error) {
+export async function promptToResolveProfileLock(error) {
   const pid = Number(error.details?.pid);
+  if (pid === process.pid) {
+    throw new Error(
+      "The current WTAgent process still holds its browser profile lock. Refusing to terminate itself.",
+      { cause: error },
+    );
+  }
   console.log(`\n${"\x1b[33m"}${error.message}${"\x1b[0m"}`);
   const choice = await promptForSelect({
-    message: "How should this be handled?",
+    message: t("profileLock.how"),
     choices: [
-      { name: "Kill that session and continue", value: "kill" },
-      { name: "I closed its Chrome window; retry", value: "retry" },
-      { name: "Quit", value: "quit" },
+      { name: t("profileLock.kill"), value: "kill" },
+      { name: t("profileLock.retry"), value: "retry" },
+      { name: t("profileLock.quit"), value: "quit" },
     ],
   });
   if (choice == null || choice === "quit") {
     return false;
   }
   if (choice === "kill" && Number.isSafeInteger(pid) && pid > 0) {
-    console.log(`Stopping pid=${pid}...`);
+    console.log(t("profileLock.stopping", { pid }));
     try {
       process.kill(pid, "SIGTERM");
     } catch {
@@ -461,7 +479,7 @@ async function promptToResolveProfileLock(error) {
   return true;
 }
 
-async function executeSession({
+export async function executeSession({
   session,
   options,
   resume = false,
@@ -469,25 +487,28 @@ async function executeSession({
   files = [],
   chatInput = null,
   mode = null,
-}) {
+}, {
+  interactive = !options.once && process.stdin.isTTY && process.stdout.isTTY,
+  createRunner = (config) => new ConversationRunner(config),
+  readNextMessage = promptForNextMessage,
+} = {}) {
   const paths = resolveRuntimePaths(options);
   await ensureDirectory(paths.sessionsDir);
-  const interactive = !options.once && process.stdin.isTTY && process.stdout.isTTY;
-  const runner = new ConversationRunner({ session, options, interactive });
+  const runner = createRunner({ session, options, interactive });
 
   const onInterrupt = () => {
     if (runner.interrupted) {
-      console.log("\nForce quitting.");
+      console.log(`\n${t("session.forceQuit")}`);
       // process.exit skips the finally block, so repeat the session/resume
       // hint here — the user should always know how to continue.
-      console.log(`Session saved at: ${session.directory}`);
+      console.log(t("session.savedAt", { directory: session.directory }));
       printResumeHint(session.sessionId);
       process.exit(130);
     }
     runner.interrupted = true;
     runner.adapter.escCancelRequested = true;
     runner.renderer.stopSpinner();
-    console.log("\nCtrl+C — cancelling. Press again to force quit.");
+    console.log(`\n${t("session.ctrlC")}`);
     process.exitCode = 130;
   };
   process.on("SIGINT", onInterrupt);
@@ -535,23 +556,43 @@ async function executeSession({
         if (!interactive) {
           throw result.error;
         }
-        runner.renderer.hint("Turn cancelled. Type a new message or quit.");
-        turnResume = true;
-        turnInPlaceRecovery = false;
-        continue;
+        runner.renderer.hint(t("session.cancelledHint"));
+        // Fall through to the same input prompt as a completed turn. Never
+        // resume automatically or reuse the cancelled instruction/attachments.
       }
       if (result?.recoveryRequired) {
         if (!interactive) {
           throw result.error;
         }
         runner.renderer.hint(
-          `Type /retry to ask ${runner.renderer.providerLabel} to continue again, enter a new instruction, or quit`,
+          t("session.recoveryHint", {
+            provider: runner.renderer.providerLabel,
+          }),
         );
-        const next = await promptForNextMessage(runner, activeChatInput);
+        const pendingRecovery = session.state.pendingOutbound != null
+          || session.state.pendingAssistantTurn != null;
+        let next;
+        let retryOnly = false;
+        for (;;) {
+          next = await readNextMessage(runner, activeChatInput, {
+            resolveAttachments: !pendingRecovery,
+          });
+          if (next == null) {
+            break;
+          }
+          retryOnly = next.text.trim().toLowerCase() === "/retry";
+          if (!pendingRecovery || retryOnly) {
+            break;
+          }
+          runner.renderer.hint(
+            t("session.recoveryHint", {
+              provider: runner.renderer.providerLabel,
+            }),
+          );
+        }
         if (next == null) {
           break;
         }
-        const retryOnly = next.text.trim().toLowerCase() === "/retry";
         if (!retryOnly) {
           await session.appendInstruction(next.text, { files: next.files });
         }
@@ -574,7 +615,7 @@ async function executeSession({
         (item) => item.status === "running",
       );
       if (running.length > 0) {
-        runner.renderer.hint("Managed processes still running:");
+        runner.renderer.hint(t("session.processesRunning"));
         for (const item of running) {
           runner.renderer.hint(
             `  ${item.processId} pid=${item.pid} ${item.detectedUrls.join(" ")}`,
@@ -582,7 +623,7 @@ async function executeSession({
         }
       }
 
-      const next = await promptForNextMessage(runner, activeChatInput);
+      const next = await readNextMessage(runner, activeChatInput);
       if (next == null) {
         break;
       }
@@ -599,7 +640,7 @@ async function executeSession({
     process.removeListener("SIGINT", onInterrupt);
     activeChatInput?.close();
     await runner.close({ keepBrowser: runFailed });
-    console.log(`Session saved at: ${session.directory}`);
+    console.log(t("session.savedAt", { directory: session.directory }));
     printResumeHint(session.sessionId);
   }
 }
@@ -610,7 +651,7 @@ function printResumeHint(sessionId) {
   const rule = "─".repeat(48);
   console.log("");
   console.log(rule);
-  console.log(`Resume this conversation with: wtagent resume ${sessionId}`);
+  console.log(t("session.resumeWith", { sessionId }));
   console.log(rule);
   console.log("");
 }
@@ -619,12 +660,16 @@ function printResumeHint(sessionId) {
 // re-prompts. Returns null for an explicit exit command, Ctrl+C, Ctrl+D, or EOF;
 // otherwise returns
 // { text, files } where files are resolved @file attachments.
-async function promptForNextMessage(runner, chatInput) {
+async function promptForNextMessage(
+  runner,
+  chatInput,
+  { resolveAttachments = true } = {},
+) {
   for (;;) {
     const answer = chatInput
       ? await chatInput.read()
       : await promptForText({
-        message: "you ›",
+        message: t("task.youPrompt"),
         theme: { prefix: "" },
       });
     if (answer == null) {
@@ -640,7 +685,9 @@ async function promptForNextMessage(runner, chatInput) {
       return null;
     }
     const { text } = classified;
-    const files = await resolveMessageAttachments(runner, text);
+    const files = resolveAttachments
+      ? await resolveMessageAttachments(runner, text)
+      : [];
     return { text, files };
   }
 }
@@ -652,12 +699,16 @@ async function resolveMessageAttachments(runner, text) {
   const { files, missing } = await extractAtMentions(text, projectRoot);
   if (files.length > 0) {
     runner.renderer.hint(
-      `Attaching: ${files.map((file) => file.name).join(", ")}`,
+      t("attachment.attaching", {
+        files: files.map((file) => file.name).join(", "),
+      }),
     );
   }
   if (missing.length > 0) {
     runner.renderer.hint(
-      `Not attached (${missing.map((m) => `${m.requested}: ${m.reason}`).join("; ")})`,
+      t("attachment.notAttached", {
+        details: missing.map((m) => `${m.requested}: ${m.reason}`).join("; "),
+      }),
     );
   }
   return files;
@@ -669,7 +720,7 @@ function isInteractiveSession(options) {
 
 async function promptForUpdate({ currentVersion, latest }) {
   return await promptForConfirm({
-    message: `Update WTAgent from ${currentVersion} to ${latest} now?`,
+    message: t("update.prompt", { currentVersion, latest }),
     default: true,
   });
 }
@@ -692,7 +743,6 @@ async function runUpdate() {
 
 async function runAgent(taskParts, options) {
   assertNativeRuntimeSupported();
-  options = withResolvedProviderSelection(options);
   const projectRoot = path.resolve(options.project ?? process.cwd());
   await assertDirectory(projectRoot);
 
@@ -711,35 +761,6 @@ async function runAgent(taskParts, options) {
     printChatBanner(projectRoot, provider);
   }
 
-  // Mode selection is abstracted per provider: some prompt (ChatGPT's
-  // Pro/Current), others silently apply their configured default at
-  // conversation start (DeepSeek → 专家模式 + 深度思考). The chosen value is
-  // handed to the adapter's selectMode() by the runtime.
-  let requestedMode;
-  if (!provider.promptsForMode) {
-    if (options.mode != null) {
-      console.log(`Note: --mode is ignored for ${provider.label}.`);
-    }
-    requestedMode = provider.defaultMode;
-  } else if (options.mode != null) {
-    requestedMode = normalizeConfiguredMode(options.mode);
-  } else if (interactive) {
-    const modeChoice = await promptForSelect({
-      message: `${provider.label} mode`,
-      choices: CHATGPT_MODE_CHOICES,
-    });
-    if (modeChoice == null) {
-      chatInput?.close();
-      console.log("");
-      return null;
-    }
-    requestedMode = modeFromPromptChoice(modeChoice);
-  } else {
-    // Non-interactive callers cannot answer a picker. Preserve the current web
-    // setting unless they explicitly opt into `--mode Pro`.
-    requestedMode = null;
-  }
-
   // In interactive mode an initial task is optional: the user can just start
   // typing at the prompt. In one-shot mode a task is required.
   let task = taskParts.join(" ").trim();
@@ -747,8 +768,8 @@ async function runAgent(taskParts, options) {
     const initialMessage = interactive
       ? await readChatMessage(() => chatInput.read())
       : await promptForText({
-        message: "Task",
-        validate: (value) => value.trim() ? true : "Please type a message.",
+        message: t("task.prompt"),
+        validate: (value) => value.trim() ? true : t("task.required"),
       });
     if (initialMessage == null) {
       chatInput?.close();
@@ -767,7 +788,7 @@ async function runAgent(taskParts, options) {
     task,
     projectRoot,
     provider: provider.id,
-    mode: requestedMode,
+    mode: null,
   });
 
   // Resolve @file attachments in the opening task, if any. The task itself is
@@ -778,12 +799,14 @@ async function runAgent(taskParts, options) {
     const { files: found, missing } = await extractAtMentions(task, projectRoot);
     files = found;
     if (found.length > 0) {
-      console.log(`Attaching: ${found.map((file) => file.name).join(", ")}`);
+      console.log(t("attachment.attaching", {
+        files: found.map((file) => file.name).join(", "),
+      }));
     }
     if (missing.length > 0) {
-      console.log(
-        `Not attached (${missing.map((m) => `${m.requested}: ${m.reason}`).join("; ")})`,
-      );
+      console.log(t("attachment.notAttached", {
+        details: missing.map((m) => `${m.requested}: ${m.reason}`).join("; "),
+      }));
     }
   }
 
@@ -795,8 +818,8 @@ function printChatBanner(projectRoot, provider) {
   const DIM = "\x1b[2m";
   const RESET = "\x1b[0m";
   console.log("");
-  console.log(`${CYAN}WTAgent${RESET} ${DIM}· ${provider.label} · ${projectRoot}${RESET}`);
-  console.log(`${DIM}Enter sends · Shift+Enter or Ctrl+J newline · ESC cancels processing · multiline paste · ↑/↓ history · "exit", Ctrl+C, or Ctrl+D quits${RESET}`);
+  console.log(`${CYAN}WTAgent${RESET} ${DIM}· ${provider.label} · ${formatHomePath(projectRoot)}${RESET}`);
+  console.log(`${DIM}${t("banner.controls")}${RESET}`);
   console.log("");
 }
 
@@ -819,13 +842,25 @@ async function loadSession(paths, sessionId) {
 
 async function runResume(sessionId, instructionParts, options) {
   assertNativeRuntimeSupported();
-  options = withResolvedProviderSelection(options);
   // Loading only needs the sessions dir (provider-independent); the provider is
   // then read from the session so the run reuses the right adapter + profile.
   const paths = resolveRuntimePaths(options);
   await ensureDirectory(paths.sessionsDir);
   const session = await loadSession(paths, sessionId);
   await assertDirectory(session.state.projectRoot);
+  const instruction = instructionParts.join(" ").trim();
+  if (
+    instruction
+    && (
+      session.state.pendingOutbound != null
+      || session.state.pendingAssistantTurn != null
+    )
+  ) {
+    throw new BrowserAdapterError(
+      "This session has a pending browser handoff. Resume it without an instruction or attachment first.",
+      { code: "RECOVERY_REQUIRES_BARE_RESUME", recoverable: false },
+    );
+  }
 
   const provider = resolveProvider(session.state.provider ?? DEFAULT_PROVIDER);
   // A conversation belongs to one provider. --model on resume is only allowed
@@ -842,49 +877,20 @@ async function runResume(sessionId, instructionParts, options) {
     return null;
   }
 
-  // Like a fresh run, interactive resumes offer a mode choice (prompting
-  // providers only), defaulting to the mode the conversation is already on.
-  // `--mode` overrides it and also works non-interactively. This matters after
-  // a usage limit, where switching thinking levels can get past the block.
-  // Non-prompting providers (e.g. DeepSeek) keep the mode the existing
-  // conversation was created with — it does not need re-asserting on resume.
-  let requestedMode;
-  if (!provider.promptsForMode) {
-    requestedMode = null;
-  } else if (options.mode != null) {
-    requestedMode = normalizeConfiguredMode(options.mode);
-  } else if (
-    !options.once
-    && process.stdin.isTTY
-    && process.stdout.isTTY
-  ) {
-    const modeChoice = await promptForSelect({
-      message: `${provider.label} mode`,
-      choices: CHATGPT_MODE_CHOICES,
-      default: session.state.activeMode === "Pro" ? "pro" : "current",
-    });
-    if (modeChoice == null) {
-      console.log("");
-      return null;
-    }
-    requestedMode = modeFromPromptChoice(modeChoice);
-  } else {
-    requestedMode = null;
-  }
-
-  const instruction = instructionParts.join(" ").trim();
   let files = [];
   if (instruction) {
     const projectRoot = session.state.projectRoot;
     const { files: found, missing } = await extractAtMentions(instruction, projectRoot);
     files = found;
     if (found.length > 0) {
-      console.log(`Attaching: ${found.map((file) => file.name).join(", ")}`);
+      console.log(t("attachment.attaching", {
+        files: found.map((file) => file.name).join(", "),
+      }));
     }
     if (missing.length > 0) {
-      console.log(
-        `Not attached (${missing.map((m) => `${m.requested}: ${m.reason}`).join("; ")})`,
-      );
+      console.log(t("attachment.notAttached", {
+        details: missing.map((m) => `${m.requested}: ${m.reason}`).join("; "),
+      }));
     }
     await session.appendInstruction(instruction, { files });
   }
@@ -895,7 +901,6 @@ async function runResume(sessionId, instructionParts, options) {
     resume: true,
     instruction: instruction || null,
     files,
-    mode: requestedMode,
   });
 }
 
@@ -923,7 +928,7 @@ async function runStatus(sessionId, options) {
     .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
     .slice(0, 20);
   if (sessions.length === 0) {
-    console.log("No sessions found.");
+    console.log(t("status.none"));
     return;
   }
 
@@ -969,74 +974,56 @@ async function runExport(sessionId, options) {
 
 const program = new Command()
   .name("wtagent")
-  .description("Turn your web AI session into a local tool-using agent.")
+  .description(t("app.description"))
   .version(getPackageVersion())
-  .option("--home <path>", "Application data directory")
-  .option("--profile-dir <path>", "Dedicated Chrome profile directory")
-  .option("--chrome-path <path>", "Chrome/Chromium executable")
-  .option("-C, --project <path>", "Project directory", process.cwd())
+  .option("--home <path>", t("option.home"))
+  .option("--profile-dir <path>", t("option.profileDir"))
+  .option("--chrome-path <path>", t("option.chromePath"))
+  .option("-C, --project <path>", t("option.project"), process.cwd())
   .option(
     "--model <provider>",
-    `Web AI provider: ${listActiveProviderIds().join(", ")} (default: ${DEFAULT_PROVIDER})`,
-  )
-  .option(
-    "--mode <name>",
-    "ChatGPT mode (Pro/Current), or a provider alias such as kimi",
-  )
-  .option(
-    "--once",
-    "Run a single request and exit instead of a conversation",
-    false,
-  )
-  .option(
-    "--model-turn-timeout-ms <milliseconds>",
-    "Maximum wait for one model response (default: 10 minutes; 16 minutes for ChatGPT Pro)",
-  )
-  .option(
-    "--no-minimize",
-    "Keep the Chrome window visible instead of minimizing it",
-  )
-  .option("--debug", "Write browser diagnostics", false)
-  .argument(
-    "[task...]",
-    "Initial request (optional; you can also type at the prompt)",
+    t("option.model", {
+      providers: listActiveProviderIds().join(", "),
+      defaultProvider: DEFAULT_PROVIDER,
+    }),
   )
+  .option("--once", t("option.once"), false)
+  .option("--model-turn-timeout-ms <milliseconds>", t("option.timeout"))
+  .option("--no-minimize", t("option.noMinimize"))
+  .option("--debug", t("option.debug"), false)
+  .argument("[task...]", t("argument.task"))
   .action(async (task, _, command) => {
     await runAgent(task, command.optsWithGlobals());
   });
 
 program
   .command("update")
-  .description("Install the latest WTAgent from npm.")
+  .description(t("command.update"))
   .action(async () => runUpdate());
 
 program
   .command("doctor")
-  .description("Check Node, Chrome, and local data directories.")
+  .description(t("command.doctor"))
   .action(async (_, command) => runDoctor(command.optsWithGlobals()));
 
 program
   .command("login")
-  .description("Open the dedicated Chrome profile and wait for provider login (use --model to pick a provider).")
+  .description(t("command.login"))
   .action(async (_, command) => runLogin(command.optsWithGlobals()));
 
 program
   .command("logout")
-  .description("Delete the local Chrome profile to reset a provider session (use --model to pick a provider).")
-  .option("--yes", "Skip the confirmation prompt", false)
+  .description(t("command.logout"))
+  .option("--yes", t("option.yes"), false)
   .action(async (options, command) => {
     await runLogout({ ...command.optsWithGlobals(), ...options });
   });
 
 program
   .command("resume")
-  .description("Continue an existing session or recover an interrupted run.")
-  .argument("<session-id>", "Saved session ID")
-  .argument("[instruction...]", "Optional follow-up instruction")
-  .option(
-    "--mode <name>",
-    "ChatGPT mode (Pro/Current), or a provider alias such as kimi",
-  )
+  .description(t("command.resume"))
+  .argument("<session-id>", t("argument.sessionId"))
+  .argument("[instruction...]", t("argument.instruction"))
   .action(async (sessionId, instruction, _, command) => {
     await runResume(
       sessionId,
@@ -1047,42 +1034,49 @@ program
 
 program
   .command("status")
-  .description("List saved sessions or show one session as JSON.")
-  .argument("[session-id]", "Saved session ID")
+  .description(t("command.status"))
+  .argument("[session-id]", t("argument.sessionId"))
   .action(async (sessionId, _, command) => {
     await runStatus(sessionId, command.optsWithGlobals());
   });
 
 program
   .command("export")
-  .description("Export a saved session to a Codex or Claude Code session.")
-  .argument("<session-id>", "Saved session ID")
-  .option("--format <name>", "codex or claude-code", "codex")
-  .option("-o, --output <path>", "Write to a file instead of stdout")
+  .description(t("command.export"))
+  .argument("<session-id>", t("argument.sessionId"))
+  .option("--format <name>", t("option.format"), "codex")
+  .option("-o, --output <path>", t("option.output"))
   .action(async (sessionId, options, command) => {
     await runExport(sessionId, { ...command.optsWithGlobals(), ...options });
   });
 
-program.parseAsync().catch((error) => {
-  // Expected, actionable failures carry a plain message instead of a stack
-  // trace (e.g. the provider's Chrome profile is locked by another session).
-  if (error?.code === "PROFILE_LOCKED") {
-    console.error(`Error: ${error.message}`);
+// Resolve npm's executable symlink as well as direct `node main.js` invocations.
+// Importing the session runner in tests must not start the CLI.
+const entryPath = process.argv[1]
+  ? await fs.realpath(process.argv[1]).catch(() => null)
+  : null;
+if (entryPath && import.meta.url === pathToFileURL(entryPath).href) {
+  await program.parseAsync().catch((error) => {
+    // Expected, actionable failures carry a plain message instead of a stack
+    // trace (e.g. the provider's Chrome profile is locked by another session).
+    if (error?.code === "PROFILE_LOCKED") {
+      console.error(`Error: ${error.message}`);
+      process.exitCode = 1;
+      return;
+    }
+    console.error(error.stack ?? error.message);
     process.exitCode = 1;
-    return;
-  }
-  console.error(error.stack ?? error.message);
-  process.exitCode = 1;
-}).finally(() => {
-  // By the time every command finishes, all per-command cleanup (browser
-  // detach/close, stdin raw-mode restore, process stop) has already run. A
-  // stray tty handle (e.g. a keypress-machinery listener left behind on a
-  // failed turn) can still pin the event loop, leaving a dead prompt that
-  // never returns to the shell — exit hard instead of relying on the loop
-  // to drain naturally.
-  if (process.exitCode != null && process.exitCode !== 0) {
-    process.stdin.setRawMode?.(false);
-    process.stdin.pause?.();
-    process.exit(process.exitCode);
-  }
-});
+  }).finally(() => {
+    // By the time every command finishes, all per-command cleanup (browser
+    // detach/close, stdin raw-mode restore, process stop) has already run. A
+    // stray tty handle (e.g. a keypress-machinery listener left behind on a
+    // failed turn) can still pin the event loop, leaving a dead prompt that
+    // never returns to the shell — exit hard instead of relying on the loop
+    // to drain naturally.
+    if (process.exitCode != null && process.exitCode !== 0) {
+      process.stdin.setRawMode?.(false);
+      process.stdin.pause?.();
+      process.exit(process.exitCode);
+    }
+  });
+}