@remotedraw/cli 0.1.2 → 0.2.0

package/dist/cli.js

@@ -3,22 +3,42 @@ import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import path from "node:path";
 import process from "node:process";
+import { fileURLToPath } from "node:url";
 import { emitKeypressEvents } from "node:readline";
 import { createInterface } from "node:readline/promises";
 import { createWizardTerminal, runSetupWizard, } from "./setup-wizard.js";
-import { assertEnvCanAcceptProvisioning, currentCliAccount, globalConfigPath, loginToRemoteDraw, logoutFromRemoteDraw, provisionRemoteDrawProject, remoteDrawApiBaseUrl, writeProvisionedProjectSetup, } from "./cloud.js";
+import { assertEnvCanAcceptProvisioning, currentCliAccount, DEFAULT_REMOTEDRAW_API_BASE_URL, globalConfigPath, loginToRemoteDraw, logoutFromRemoteDraw, provisionRemoteDrawProject, readStoredLanguage, remoteDrawApiBaseUrl, writeStoredLanguage, writeProvisionedProjectSetup, } from "./cloud.js";
+import { LANGUAGE_ENV_VARS, SOURCE_LOCALE, extractLanguageFlag, languageChoices, languagePromptMessage, localeEndonym, normalizeLocale, resolveLocale, setActiveLocale, supportedLocaleList, SUPPORTED_LOCALES, systemLocaleHint, t, } from "./i18n.js";
+import { CliError, cliError } from "./errors.js";
+import { AGENT_SKILL_MARKDOWN } from "./generated/agent-skill.js";
+import { reportCliCrash } from "./telemetry.js";
+import { checkForUpdate, CLI_PACKAGE_NAME, detectInstallMethod, installMethodDisplay, runInstall, } from "./update.js";
 const packageMetadata = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 export const CLI_VERSION = typeof packageMetadata.version === "string"
     ? packageMetadata.version
     : "unknown";
-const targetChoices = ["web", "desktop", "ios", "headless"];
-const senderChoices = [
+// Generated manifests may only name packages this repository actually
+// publishes, at a range those published versions satisfy. "latest" used to be
+// written here, which resolved to nothing at all while the SDK packages were
+// private, and would silently accept a future breaking major once they were
+// not. tests/generated-manifest.test.ts cross-checks every range below against
+// the workspace manifests.
+export const REMOTEDRAW_SDK_RANGE = "^0.1.0";
+export const REMOTEDRAW_CLI_RANGE = "^0.2.0";
+export const targetChoices = ["web", "desktop", "ios", "headless"];
+export const senderChoices = [
     "remotedraw-ios",
     "embedded-web",
     "own-ios",
     "headless",
 ];
-const sdkChoices = ["react", "svelte", "js", "swift", "headless"];
+export const sdkChoices = [
+    "react",
+    "svelte",
+    "js",
+    "swift",
+    "headless",
+];
 const presetChoices = [
     "signature",
     "initials",
@@ -38,15 +58,16 @@ const exampleChoices = [
     "ios-owned-sender",
 ];
 const packageManagerChoices = ["npm", "pnpm", "yarn", "bun"];
-const apiEndpointChoices = ["deployment", "local"];
 export function createNodeRuntime() {
     const cwd = process.cwd();
     const env = cliEnvironmentForWorkspace(cwd, process.env);
     return {
         cwd,
         env,
+        binPath: process.argv[1] ?? fileURLToPath(import.meta.url),
         isInteractive: Boolean(process.stdin.isTTY && process.stderr.isTTY),
         exists: existsSync,
+        spawnCommand: runChildCommand,
         readFile: async (filePath) => {
             return await readFile(filePath, "utf8");
         },
@@ -78,10 +99,22 @@ export function cliEnvironmentForWorkspace(cwd, env, exists = existsSync) {
         ? { ...env, REMOTEDRAW_API_BASE_URL: env.CONVEX_SITE_URL }
         : env;
 }
+async function runChildCommand(command, args) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: "inherit",
+            // Windows resolves npm/pnpm/yarn through .cmd shims, which need a shell.
+            shell: process.platform === "win32",
+            windowsHide: true,
+        });
+        child.once("error", reject);
+        child.once("close", (code) => resolve({ exitCode: code ?? 1 }));
+    });
+}
 async function openExternalUrl(url) {
     const parsed = new URL(url);
     if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
-        throw new Error("Only HTTP(S) URLs can be opened.");
+        throw new Error(t("error.httpUrlsOnly"));
     }
     const [command, args] = process.platform === "darwin"
         ? ["open", [url]]
@@ -132,10 +165,10 @@ function createTerminalPrompter(input, output) {
 }
 function terminalSelect(input, output, options) {
     if (options.choices.length === 0) {
-        throw new Error(`No choices available for ${options.message}.`);
+        throw new Error(t("error.noChoices", { message: options.message }));
     }
     if (!input.isTTY || !output.isTTY || !input.setRawMode) {
-        throw new Error("Interactive setup requires a TTY.");
+        throw new Error(t("error.interactiveNeedsTty"));
     }
     const defaultIndex = Math.max(0, options.choices.findIndex((choiceOption) => choiceOption.value === options.defaultValue));
     let selectedIndex = defaultIndex;
@@ -154,7 +187,7 @@ function terminalSelect(input, output, options) {
             const selected = options.choices[selectedIndex];
             cleanup();
             clearRendered(output, renderedLines);
-            output.write(`${style("cyan", "?")} ${options.message} ${style("green", selected.label)}\n`);
+            output.write(`${style("green", "✓")} ${options.message} ${style("green", selected.label)}\n`);
             resolve(selected.value);
         };
         const fail = () => {
@@ -197,18 +230,25 @@ function terminalSelect(input, output, options) {
     });
 }
 function selectPromptLines(options, selectedIndex) {
-    const lines = [`${style("cyan", "?")} ${options.message}`];
+    const lines = [`${style("cyan", "?")} ${style("bold", options.message)}`];
     if (options.helperText)
         lines.push(style("dim", options.helperText));
     for (const [index, choiceOption] of options.choices.entries()) {
         const selected = index === selectedIndex;
+        const marker = selected ? style("cyan", "❯ ◉") : style("dim", "  ○");
         const label = selected
             ? style("bold", choiceOption.label)
             : choiceOption.label;
         const hint = choiceOption.hint ? ` ${style("dim", choiceOption.hint)}` : "";
-        lines.push(`${selected ? ">" : " "} ${label}${hint}`);
-    }
-    lines.push(style("dim", "Use up/down arrows, then Enter."));
+        lines.push(`${marker} ${label}${hint}`);
+    }
+    // Rendered in the active locale, which for the language question itself is
+    // English — nothing has been chosen yet at that point.
+    lines.push([
+        `${style("dim", "↑/↓")} ${t("prompt.control.move")}`,
+        `${style("dim", "Enter")} ${t("prompt.control.select")}`,
+        `${style("dim", "Ctrl+C")} ${t("prompt.control.quit")}`,
+    ].join(" · "));
     return lines;
 }
 function clearRendered(output, lineCount) {
@@ -224,13 +264,61 @@ function style(kind, value) {
     };
     return `${codes[kind]}${value}\x1b[0m`;
 }
+/**
+ * How the locale for this run was decided. Only `language` reports it, but it
+ * has to be recorded where the decision is actually made.
+ */
+let resolvedLocaleSource = "default";
+/**
+ * The language the CLI's *chrome* resolved to. It can differ from the active
+ * locale on a machine-readable run, which is forced to English — `language`
+ * must still report what the reader actually chose.
+ */
+let resolvedChromeLocale = SOURCE_LOCALE;
 export async function runCli(args, runtime = createNodeRuntime()) {
+    // The language flag is global, so it is taken out before per-command parsing
+    // — which rejects any option the command has not declared.
+    const { value: languageFlag, rest: cliArgs } = extractLanguageFlag(args);
     try {
-        const command = args[0];
-        const commandArgs = args.slice(1);
+        const stored = await readStoredLanguage(runtime);
+        const resolution = resolveLocale({
+            flag: languageFlag,
+            env: runtime.env,
+            stored,
+        });
+        if (!resolution.ok) {
+            // Report the bad value in whatever language the reader already chose,
+            // falling back to English when they have not chosen one.
+            setActiveLocale(normalizeLocale(stored) ?? SOURCE_LOCALE);
+            const message = t("language.unknown", {
+                value: resolution.value,
+                supported: supportedLocaleList(),
+                variable: LANGUAGE_ENV_VARS[0],
+            });
+            return requestedJsonOutput(args)
+                ? jsonFailure("language", new Error(message))
+                : fail(message);
+        }
+        // Machine-readable output is a data interchange format, not chrome: it
+        // stays English so an agent quoting a label back to its user does not
+        // suddenly speak the operator's language. `--language` on the same
+        // invocation is a deliberate request and does localize it; an ambient
+        // stored choice or environment variable does not.
+        const machineReadable = machineReadableOutput(cliArgs);
+        const effectiveLocale = machineReadable && resolution.source !== "flag"
+            ? SOURCE_LOCALE
+            : resolution.locale;
+        setActiveLocale(effectiveLocale);
+        resolvedChromeLocale = resolution.locale;
+        resolvedLocaleSource = resolution.source;
+        // Unresolved means "never asked". Interactive entry points ask; every
+        // other invocation — CI, a pipe, an agent shelling out — stays English.
+        const askLanguage = resolution.needsPrompt;
+        const command = cliArgs[0];
+        const commandArgs = cliArgs.slice(1);
         if (command == null) {
             if (runtime.wizardTerminal) {
-                return await setupWizardCommand(runtime);
+                return await setupWizardCommand(runtime, askLanguage);
             }
             return ok(mainHelpText());
         }
@@ -245,6 +333,8 @@ export async function runCli(args, runtime = createNodeRuntime()) {
                 return ok(guideText());
             case "options":
                 return optionsCommand(commandArgs);
+            case "language":
+                return await languageCommand(commandArgs, runtime);
             case "login":
                 return await loginCommand(commandArgs, runtime);
             case "logout":
@@ -252,9 +342,11 @@ export async function runCli(args, runtime = createNodeRuntime()) {
             case "whoami":
                 return await whoamiCommand(commandArgs, runtime);
             case "new":
-                return await newCommand(commandArgs, runtime);
+                return await newCommand(commandArgs, runtime, askLanguage);
             case "init":
                 return await initCommand(commandArgs, runtime);
+            case "update":
+                return await updateCommand(commandArgs, runtime);
             case "doctor":
                 return await doctorCommand(commandArgs, runtime);
             case "dev":
@@ -267,20 +359,36 @@ export async function runCli(args, runtime = createNodeRuntime()) {
                 return await agentCommand(commandArgs, runtime);
             default:
                 return requestedJsonOutput(args)
-                    ? jsonFailure(command, new Error(`Unknown command "${command}". Run remotedraw --help.`))
-                    : fail(`Unknown command "${command}". Run remotedraw --help.`);
+                    ? jsonFailure(command, new Error(t("error.unknownCommand", { command })))
+                    : fail(t("error.unknownCommand", { command }));
         }
     }
     catch (error) {
+        // Only genuine faults land here: a bad flag or an unknown command returns a
+        // `fail(...)` result instead of throwing, so this path is not user error.
+        const command = cliArgs[0] ?? "help";
+        await reportCliCrash(error, command, cliTelemetryEnvironment(runtime));
         return requestedJsonOutput(args)
-            ? jsonFailure(args[0] ?? "help", error)
+            ? jsonFailure(command, error)
             : fail(errorMessage(error));
     }
 }
-async function setupWizardCommand(runtime) {
+function cliTelemetryEnvironment(runtime) {
+    return {
+        env: runtime.env,
+        version: CLI_VERSION,
+        platform: process.platform,
+        nodeVersion: process.versions.node,
+        fetch: runtime.fetch,
+    };
+}
+async function setupWizardCommand(runtime, askLanguage) {
     const terminal = runtime.wizardTerminal;
     if (!terminal)
         return ok(mainHelpText());
+    // Before login, before the first field: nothing the reader has to understand
+    // is printed until the language is settled.
+    await ensureLanguageChosen(runtime, askLanguage);
     if (!cloudSetupDisabled(runtime)) {
         const apiBaseUrl = remoteDrawApiBaseUrl(runtime.env);
         await loginToRemoteDraw(runtime, apiBaseUrl);
@@ -305,6 +413,121 @@ async function setupWizardCommand(runtime) {
     });
     return { exitCode: result.exitCode, stdout: "" };
 }
+/**
+ * The language question, asked once and only where a human is already being
+ * prompted. The question itself is built from every locale's own word for
+ * "Language" and lists endonyms, so it reads before any language is chosen.
+ */
+async function ensureLanguageChosen(runtime, askLanguage) {
+    if (!askLanguage)
+        return;
+    const prompts = runtime.prompts;
+    // No TTY, no question: piped and CI runs must never block on this.
+    if (!prompts || runtime.isInteractive !== true)
+        return;
+    let chosen;
+    try {
+        chosen = await prompts.select({
+            message: languagePromptMessage(),
+            defaultValue: systemLocaleHint(runtime.env) ?? SOURCE_LOCALE,
+            choices: languageChoices(),
+        });
+    }
+    catch {
+        // A prompter that cannot run (stdin is not a real terminal after all)
+        // means English, never a failed command over a preference question.
+        return;
+    }
+    const locale = normalizeLocale(chosen) ?? SOURCE_LOCALE;
+    await applyLanguage(runtime, locale);
+}
+/** Sets the locale for the rest of this run and remembers it for later ones. */
+async function applyLanguage(runtime, locale) {
+    setActiveLocale(locale);
+    resolvedChromeLocale = locale;
+    resolvedLocaleSource = "prompt";
+    try {
+        await writeStoredLanguage(runtime, locale);
+    }
+    catch (error) {
+        // An unwritable config is worth saying out loud, but it must not abort the
+        // command the reader actually asked for.
+        runtime.notify?.(t("language.saveFailed", {
+            reason: errorMessage(error),
+            language: localeEndonym(locale),
+        }));
+    }
+}
+async function languageCommand(args, runtime) {
+    const parsed = parseArgs(args, { values: ["format"], booleans: ["help"] });
+    if (parsed.booleans.has("help"))
+        return ok(languageHelpText());
+    const format = outputFormat(parsed);
+    const requested = parsed.positionals[0];
+    if (requested != null) {
+        const locale = normalizeLocale(requested);
+        if (!locale) {
+            const message = t("language.unknown", {
+                value: requested,
+                supported: supportedLocaleList(),
+                variable: LANGUAGE_ENV_VARS[0],
+            });
+            return format === "json"
+                ? jsonFailure("language", new Error(message))
+                : fail(message);
+        }
+        await applyLanguage(runtime, locale);
+        return format === "json"
+            ? jsonResult({ ok: true, command: "language", language: locale })
+            : ok(t("language.saved", { language: localeEndonym(locale) }));
+    }
+    if (format !== "json" && runtime.prompts && runtime.isInteractive === true) {
+        const chosen = await runtime.prompts.select({
+            message: languagePromptMessage(),
+            defaultValue: resolvedChromeLocale,
+            choices: languageChoices(),
+        });
+        const locale = normalizeLocale(chosen) ?? SOURCE_LOCALE;
+        await applyLanguage(runtime, locale);
+        return ok(t("language.saved", { language: localeEndonym(locale) }));
+    }
+    const current = resolvedChromeLocale;
+    if (format === "json") {
+        return jsonResult({
+            ok: true,
+            command: "language",
+            language: current,
+            source: resolvedLocaleSource,
+            available: SUPPORTED_LOCALES.map((locale) => ({
+                code: locale,
+                endonym: localeEndonym(locale),
+            })),
+        });
+    }
+    return ok([
+        t("language.current", {
+            language: localeEndonym(current),
+            locale: current,
+        }),
+        languageSourceLine(runtime),
+        "",
+        t("language.available"),
+        ...SUPPORTED_LOCALES.map((locale) => `  ${locale.padEnd(6)} ${localeEndonym(locale)}`),
+    ].join("\n"));
+}
+function languageSourceLine(runtime) {
+    if (resolvedLocaleSource === "flag")
+        return t("language.source.flag");
+    if (resolvedLocaleSource === "env") {
+        const variable = LANGUAGE_ENV_VARS.find((name) => runtime.env[name]?.trim()) ??
+            LANGUAGE_ENV_VARS[0];
+        return t("language.source.env", { variable });
+    }
+    if (resolvedLocaleSource === "config" || resolvedLocaleSource === "prompt") {
+        return t("language.source.config", { path: globalConfigPath(runtime) });
+    }
+    return t("language.source.default");
+}
 function ok(stdout) {
     return { exitCode: 0, stdout: ensureTrailingNewline(stdout) };
 }
@@ -316,6 +539,12 @@ function jsonResult(value, exitCode = 0) {
 }
 function jsonFailure(command, error) {
     const message = errorMessage(error);
+    // A declared code survives translation; the substring heuristic below is
+    // only a fallback for errors raised outside the catalog (a failed fetch, a
+    // filesystem fault) and is matched against English internals.
+    if (error instanceof CliError) {
+        return jsonResult({ ok: false, command, error: { code: error.code, message } }, 1);
+    }
     const code = message.includes("required")
         ? "MISSING_ARGUMENT"
         : message.includes(" requires ") || message.includes("only supported")
@@ -329,6 +558,14 @@ function jsonFailure(command, error) {
                         : "COMMAND_FAILED";
     return jsonResult({ ok: false, command, error: { code, message } }, 1);
 }
+/**
+ * True when this invocation asks for output meant to be parsed rather than
+ * read: `--format json` on any command, or `create-input --json`.
+ */
+function machineReadableOutput(args) {
+    return (requestedJsonOutput(args) ||
+        args.some((argument) => argument === "--json"));
+}
 function requestedJsonOutput(args) {
     return args.some((argument, index) => argument === "--format=json" ||
         (argument === "--format" && args[index + 1] === "json"));
@@ -346,31 +583,34 @@ function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 function mainHelpText() {
+    const command = (name, description) => `  ${name.padEnd(14)} ${description}`;
     return [
-        "RemoteDraw CLI",
-        "",
-        "Usage:",
-        "  remotedraw <command> [options]",
-        "",
-        "Commands:",
-        "  guide          Choose an integration path and SDK.",
-        "  options        Print setup choices and compatibility metadata.",
-        "  login          Authorize this computer through the dashboard.",
-        "  logout         Revoke and remove this computer's CLI credential.",
-        "  whoami         Show the signed-in RemoteDraw account.",
-        "  new            Create a new app with RemoteDraw starter code.",
-        "  init           Add RemoteDraw starter code to an existing project.",
-        "  dev            Print the local sandbox workflow for an integration.",
-        "  doctor         Check project config, packages, and environment variables.",
-        "  create-input   Create or print a test input request payload.",
-        "  examples       List or install example projects.",
-        "  agent          Print or install the RemoteDraw agent skill.",
-        "",
-        "Start here:",
+        t("help.title"),
+        "",
+        t("word.usage"),
+        t("help.usage.main"),
+        "",
+        t("word.commands"),
+        command("guide", t("help.command.guide")),
+        command("options", t("help.command.options")),
+        command("language", t("help.command.language")),
+        command("login", t("help.command.login")),
+        command("logout", t("help.command.logout")),
+        command("whoami", t("help.command.whoami")),
+        command("new", t("help.command.new")),
+        command("init", t("help.command.init")),
+        command("dev", t("help.command.dev")),
+        command("doctor", t("help.command.doctor")),
+        command("update", t("help.command.update")),
+        command("create-input", t("help.command.createInput")),
+        command("examples", t("help.command.examples")),
+        command("agent", t("help.command.agent")),
+        "",
+        t("help.startHere"),
         "  remotedraw guide",
         "  remotedraw login",
         "  remotedraw new",
-        "  remotedraw new --app-name MijnApp --target web --sender remotedraw-ios --sdk react",
+        "  remotedraw new --app-name MyApp --target web --sender remotedraw-ios --sdk react",
         "  remotedraw init --target web --sender embedded-web --sdk react",
     ].join("\n");
 }
@@ -385,39 +625,39 @@ function optionsCommand(args) {
     if (outputFormat(parsed) === "json")
         return jsonResult(catalog);
     return ok([
-        "RemoteDraw setup options",
+        t("options.title"),
         "",
         ...catalog.fields.flatMap((field) => [
             `${field.label} (${field.flag})`,
             ...field.options.map((option) => `  ${option.value}: ${option.details.summary}`),
             "",
         ]),
-        "For machine-readable metadata: remotedraw options --format json",
+        t("options.machineReadable"),
     ].join("\n"));
 }
 function guideText() {
     return [
-        "RemoteDraw integration guide",
+        t("guide.title"),
         "",
-        "Choose the surface your customer already has:",
-        "  Web app receiver + RemoteDraw iOS app sender",
+        t("guide.intro"),
+        t("guide.path.webIos"),
         "    remotedraw init --target web --sender remotedraw-ios --sdk react --preset signature",
         "",
-        "  Web app receiver + your own web sender UI",
+        t("guide.path.webOwned"),
         "    remotedraw init --target web --sender embedded-web --sdk react --preset sketch",
         "",
-        "  Svelte app receiver + RemoteDraw iOS app sender",
+        t("guide.path.svelteIos"),
         "    remotedraw init --target web --sender remotedraw-ios --sdk svelte --preset signature",
         "",
-        "  Desktop app receiver with raw HTTP",
+        t("guide.path.desktop"),
         "    remotedraw init --target desktop --sender remotedraw-ios --sdk js --preset sketch",
         "",
-        "  Your own iOS sender app",
+        t("guide.path.ownIos"),
         "    remotedraw init --target ios --sender own-ios --sdk swift --preset sketch",
         "",
-        "API keys stay on trusted backend code. Receivers get receiver tokens, senders get join URLs or sender tokens.",
-        "remotedraw new and init create a dashboard project, mint a project-scoped development API key, and write it to .env.local by default.",
-        "Use --offline when you intentionally want local scaffolding only.",
+        t("guide.note.keys"),
+        t("guide.note.provisioning"),
+        t("guide.note.offline"),
     ].join("\n");
 }
 async function loginCommand(args, runtime) {
@@ -435,11 +675,9 @@ async function loginCommand(args, runtime) {
         ...(deviceName == null ? {} : { deviceName }),
     });
     return ok([
-        result.alreadyLoggedIn
-            ? "Already logged in."
-            : "RemoteDraw login complete.",
+        result.alreadyLoggedIn ? t("login.already") : t("login.complete"),
         accountSummary(result.account),
-        `Credential: ${globalConfigPath(runtime)}`,
+        t("login.credential", { path: globalConfigPath(runtime) }),
     ].join("\n"));
 }
 async function logoutCommand(args, runtime) {
@@ -452,8 +690,8 @@ async function logoutCommand(args, runtime) {
     const apiBaseUrl = remoteDrawApiBaseUrl(runtime.env, readString(parsed, "api-base-url"));
     const result = await logoutFromRemoteDraw(runtime, apiBaseUrl);
     return ok(result.hadCredential
-        ? `Logged out from ${apiBaseUrl}.`
-        : `No stored credential for ${apiBaseUrl}.`);
+        ? t("logout.done", { url: apiBaseUrl })
+        : t("logout.none", { url: apiBaseUrl }));
 }
 async function whoamiCommand(args, runtime) {
     const parsed = parseArgs(args, {
@@ -465,15 +703,15 @@ async function whoamiCommand(args, runtime) {
     const apiBaseUrl = remoteDrawApiBaseUrl(runtime.env, readString(parsed, "api-base-url"));
     const account = await currentCliAccount(runtime, apiBaseUrl);
     if (!account) {
-        return fail(`Not logged in to ${apiBaseUrl}. Run remotedraw login.`);
+        return fail(t("whoami.notLoggedIn", { url: apiBaseUrl }));
     }
-    return ok([accountSummary(account), `API: ${apiBaseUrl}`].join("\n"));
+    return ok([accountSummary(account), t("whoami.api", { url: apiBaseUrl })].join("\n"));
 }
 function accountSummary(account) {
-    const identity = account.email || account.name || "RemoteDraw user";
+    const identity = account.email || account.name || t("whoami.anonymous");
     return `${identity} (${account.tenantSlug})`;
 }
-async function newCommand(args, runtime) {
+async function newCommand(args, runtime, askLanguage = false) {
     const parsed = parseArgs(args, {
         values: [
             "app-name",
@@ -491,8 +729,13 @@ async function newCommand(args, runtime) {
     if (parsed.booleans.has("help"))
         return ok(newHelpText());
     const format = outputFormat(parsed);
-    const plan = !parsed.booleans.has("non-interactive") &&
-        shouldPromptForNewProject(parsed, runtime)
+    const interactive = !parsed.booleans.has("non-interactive") &&
+        shouldPromptForNewProject(parsed, runtime);
+    // Only ask when this run was going to prompt anyway; a fully flagged
+    // `new` stays as non-interactive as the caller wrote it.
+    if (interactive)
+        await ensureLanguageChosen(runtime, askLanguage);
+    const plan = interactive
         ? await promptForNewProject(parsed, runtime)
         : planFromArgs(parsed, {
             appNameRequired: true,
@@ -517,7 +760,7 @@ async function newCommand(args, runtime) {
     }
     return format === "json"
         ? jsonResult(scaffoldJsonResult("new", plan, outputDir, written, parsed, provisioning, offline, dryRun))
-        : ok(scaffoldSummary("Created", plan, outputDir, written, dryRun) +
+        : ok(scaffoldSummary(t("scaffold.verb.created"), plan, outputDir, written, dryRun) +
             cloudSetupSummary(provisioning, offline, dryRun));
 }
 export async function createRemoteDrawProject(plan, outputDir, runtime, options = {}) {
@@ -574,7 +817,7 @@ async function initCommand(args, runtime) {
     }
     return format === "json"
         ? jsonResult(scaffoldJsonResult("init", plan, outputDir, written, parsed, provisioning, offline, dryRun))
-        : ok(scaffoldSummary("Initialized", plan, outputDir, written, dryRun) +
+        : ok(scaffoldSummary(t("scaffold.verb.initialized"), plan, outputDir, written, dryRun) +
             cloudSetupSummary(provisioning, offline, dryRun));
 }
 function cloudSetupDisabled(runtime) {
@@ -596,16 +839,16 @@ function cloudSetupSummary(provisioning, offline, dryRun) {
     if (dryRun)
         return "";
     if (offline) {
-        return "\n\nCloud setup skipped (--offline). Run remotedraw init later to create a dashboard project.";
+        return `\n\n${t("cloud.skipped")}`;
     }
     if (!provisioning)
         return "";
     return [
         "",
         "",
-        `Dashboard project: ${provisioning.project.dashboardUrl}`,
-        "Development API key: written to .env.local (server-side only)",
-        `Project ID: ${provisioning.project.id}`,
+        t("cloud.dashboardProject", { url: provisioning.project.dashboardUrl }),
+        t("cloud.devKey"),
+        t("cloud.projectId", { id: provisioning.project.id }),
     ].join("\n");
 }
 const DOCTOR_PROBE_TIMEOUT_MS = 8_000;
@@ -614,7 +857,7 @@ function probeFailureMessage(error) {
 }
 async function probeApiHealth(runtime, apiBaseUrl) {
     if (!runtime.fetch) {
-        return { ok: false, message: "this runtime cannot make network requests" };
+        return { ok: false, message: t("doctor.probe.noNetwork") };
     }
     try {
         const response = await runtime.fetch(`${apiBaseUrl}/health`, {
@@ -637,7 +880,7 @@ async function probeApiHealth(runtime, apiBaseUrl) {
  */
 async function probeApiKey(runtime, apiBaseUrl, apiKey) {
     if (!runtime.fetch) {
-        return { ok: false, message: "This runtime cannot make network requests." };
+        return { ok: false, message: t("doctor.probe.noNetworkKey") };
     }
     try {
         const response = await runtime.fetch(`${apiBaseUrl}/v1/sessions/list`, {
@@ -657,7 +900,7 @@ async function probeApiKey(runtime, apiBaseUrl, apiKey) {
         catch {
             return {
                 ok: false,
-                message: `Deployment returned a non-JSON response (HTTP ${response.status}).`,
+                message: t("doctor.probe.nonJson", { status: response.status }),
             };
         }
         if (!response.ok) {
@@ -667,7 +910,7 @@ async function probeApiKey(runtime, apiBaseUrl, apiKey) {
                 typeof payload.error?.message ===
                     "string"
                 ? payload.error.message
-                : `Deployment rejected the key (HTTP ${response.status}).`;
+                : t("doctor.probe.rejected", { status: response.status });
             return { ok: false, message };
         }
         const items = typeof payload === "object" && payload !== null && "items" in payload
@@ -679,9 +922,111 @@ async function probeApiKey(runtime, apiBaseUrl, apiKey) {
         return { ok: false, message: probeFailureMessage(error) };
     }
 }
+/**
+ * npm never refreshes a globally installed binary on its own, so staying
+ * current is an explicit step. This command makes that step one word.
+ */
+async function updateCommand(args, runtime) {
+    const parsed = parseArgs(args, {
+        values: ["format"],
+        booleans: ["check", "help"],
+    });
+    if (parsed.booleans.has("help"))
+        return ok(updateHelpText());
+    const format = outputFormat(parsed);
+    const checkOnly = parsed.booleans.has("check");
+    const method = detectInstallMethod(runtime.binPath ?? "");
+    const command = installMethodDisplay(method);
+    // `remotedraw update` is an explicit request, so it ignores the cache and the
+    // ambient opt-outs that only silence the passive notice.
+    const check = await checkForUpdate(runtime, CLI_VERSION, { force: true });
+    if (!check) {
+        const message = t("update.unreachable", {
+            package: CLI_PACKAGE_NAME,
+            command,
+        });
+        return format === "json"
+            ? jsonFailure("update", new Error(message))
+            : fail(message);
+    }
+    if (!check.updateAvailable) {
+        const message = t("update.alreadyLatest", {
+            package: CLI_PACKAGE_NAME,
+            version: check.current,
+        });
+        return format === "json"
+            ? jsonResult({ ok: true, command: "update", ...check, updated: false })
+            : ok(message);
+    }
+    if (checkOnly || method.ephemeral) {
+        const message = method.ephemeral
+            ? [
+                t("update.available", {
+                    current: check.current,
+                    latest: check.latest,
+                }),
+                t("update.ephemeral", { package: CLI_PACKAGE_NAME }),
+            ].join("\n")
+            : [
+                t("update.available", {
+                    current: check.current,
+                    latest: check.latest,
+                }),
+                t("update.runToInstall", { command }),
+            ].join("\n");
+        return format === "json"
+            ? jsonResult({
+                ok: true,
+                command: "update",
+                ...check,
+                updated: false,
+                installCommand: command,
+                ephemeral: method.ephemeral,
+            })
+            : ok(message);
+    }
+    const install = await runInstall(runtime, method);
+    if (!install.ran) {
+        const message = t("update.availableRun", {
+            current: check.current,
+            latest: check.latest,
+            command,
+        });
+        return format === "json"
+            ? jsonResult({
+                ok: true,
+                command: "update",
+                ...check,
+                updated: false,
+                installCommand: command,
+            })
+            : ok(message);
+    }
+    if (install.exitCode !== 0) {
+        const message = t("update.failed", {
+            command,
+            code: install.exitCode,
+        });
+        return format === "json"
+            ? jsonFailure("update", new Error(message))
+            : fail(message);
+    }
+    return format === "json"
+        ? jsonResult({
+            ok: true,
+            command: "update",
+            ...check,
+            updated: true,
+            installCommand: command,
+        })
+        : ok(t("update.done", {
+            package: CLI_PACKAGE_NAME,
+            version: check.latest,
+        }));
+}
 async function doctorCommand(args, runtime) {
     const parsed = parseArgs(args, {
-        values: ["path", "format"],
+        values: ["path", "format", "api-base-url"],
         booleans: ["help", "offline"],
     });
     if (parsed.booleans.has("help"))
@@ -693,67 +1038,89 @@ async function doctorCommand(args, runtime) {
     const projectEnv = await environmentForProject(dir, runtime);
     const configPath = path.join(dir, "remotedraw.config.json");
     const packagePath = path.join(dir, "package.json");
-    const envApiBaseUrl = projectEnv.REMOTEDRAW_API_BASE_URL;
-    const normalizedEnvApiBaseUrl = envApiBaseUrl == null || !isHttpOrigin(envApiBaseUrl)
-        ? undefined
-        : normalizedOrigin(envApiBaseUrl);
+    const apiBaseUrl = resolveDoctorApiBaseUrl(projectEnv, readString(parsed, "api-base-url"));
+    const normalizedEnvApiBaseUrl = apiBaseUrl.state === "ok" ? apiBaseUrl.url : undefined;
     const envApiKey = projectEnv.REMOTEDRAW_API_KEY;
-    const lines = ["RemoteDraw doctor", ""];
+    const lines = [t("doctor.title"), ""];
     const checks = [];
     const addCheck = (state, label, message) => {
         checks.push({ state, label, message });
         lines.push(statusLine(state, label, message));
     };
     const hasConfig = await runtime.exists(configPath);
-    addCheck(hasConfig ? "ok" : "warn", "remotedraw.config.json", hasConfig
-        ? "Project is linked to a local integration profile."
-        : "Run remotedraw init to create one.");
+    addCheck(hasConfig ? "ok" : "warn", "remotedraw.config.json", hasConfig ? t("doctor.config.ok") : t("doctor.config.missing"));
     const packageJson = (await runtime.exists(packagePath))
         ? await readJsonFile(packagePath, runtime)
         : null;
-    addCheck(packageJson ? "ok" : "warn", "package.json", packageJson
-        ? "Package metadata found."
-        : "No package.json found in this directory.");
+    addCheck(packageJson ? "ok" : "warn", "package.json", packageJson ? t("doctor.package.ok") : t("doctor.package.missing"));
     const config = hasConfig ? await readJsonFile(configPath, runtime) : null;
     const sdk = stringFromRecord(config, "sdk");
-    if (sdk === "react") {
-        addCheck(hasDependency(packageJson, "@remotedraw/react") ? "ok" : "warn", "@remotedraw/react", hasDependency(packageJson, "@remotedraw/react")
-            ? "React SDK dependency is installed in package.json."
-            : "Install @remotedraw/react or rerun remotedraw init.");
-    }
-    addCheck(normalizedEnvApiBaseUrl ? "ok" : "warn", "REMOTEDRAW_API_BASE_URL", normalizedEnvApiBaseUrl
-        ? `Using ${normalizedEnvApiBaseUrl}.`
-        : "Set this to your Convex site origin, for example https://<deployment>.convex.site.");
+    const sdkPackage = sdkPackageName(sdk);
+    if (sdkPackage) {
+        const installed = hasDependency(packageJson, sdkPackage);
+        addCheck(installed ? "ok" : "warn", sdkPackage, installed
+            ? t("doctor.sdk.ok", { package: sdkPackage })
+            : t("doctor.sdk.missing", {
+                package: sdkPackage,
+                range: REMOTEDRAW_SDK_RANGE,
+            }));
+    }
+    addCheck(apiBaseUrl.state === "ok"
+        ? "ok"
+        : apiBaseUrl.state === "placeholder"
+            ? "warn"
+            : "error", "REMOTEDRAW_API_BASE_URL", doctorApiBaseUrlMessage(apiBaseUrl));
     addCheck(envApiKey?.startsWith("rd_sk_") ? "ok" : "warn", "REMOTEDRAW_API_KEY", envApiKey?.startsWith("rd_sk_")
-        ? "Server-side API key shape looks correct."
-        : "Keep an rd_sk_... key in backend secrets only.");
+        ? t("doctor.apiKey.ok")
+        : t("doctor.apiKey.missing"));
     // The checks above only prove the strings look right. A revoked key, a URL
     // pointing at the wrong deployment, and an exhausted credit balance all pass
     // them, so doctor also asks the deployment itself.
     if (offline) {
-        addCheck("warn", "deployment", "Skipped network checks (--offline). Rerun without --offline to verify the key against the deployment.");
+        addCheck("warn", t("doctor.label.deployment"), t("doctor.network.offline"));
     }
     else if (!normalizedEnvApiBaseUrl) {
-        addCheck("warn", "deployment", "Skipped network checks because REMOTEDRAW_API_BASE_URL is not set.");
+        addCheck("warn", t("doctor.label.deployment"), t("doctor.network.noOrigin"));
     }
     else {
         const health = await probeApiHealth(runtime, normalizedEnvApiBaseUrl);
-        addCheck(health.ok ? "ok" : "error", "deployment reachable", health.ok
-            ? `${normalizedEnvApiBaseUrl} answered /health.`
-            : `${normalizedEnvApiBaseUrl} did not answer /health: ${health.message}`);
+        addCheck(health.ok ? "ok" : "error", t("doctor.label.deploymentReachable"), health.ok
+            ? t("doctor.health.ok", { url: normalizedEnvApiBaseUrl })
+            : t("doctor.health.failed", {
+                url: normalizedEnvApiBaseUrl,
+                reason: health.message,
+            }));
         if (!envApiKey?.startsWith("rd_sk_")) {
-            addCheck("warn", "API key accepted", "Skipped because no rd_sk_... key was found in this project's environment.");
+            addCheck("warn", t("doctor.label.apiKeyAccepted"), t("doctor.key.skippedNoKey"));
         }
         else if (!health.ok) {
-            addCheck("warn", "API key accepted", "Skipped because the deployment did not answer.");
+            addCheck("warn", t("doctor.label.apiKeyAccepted"), t("doctor.key.skippedNoHealth"));
         }
         else {
             const probe = await probeApiKey(runtime, normalizedEnvApiBaseUrl, envApiKey);
-            addCheck(probe.ok ? "ok" : "error", "API key accepted", probe.ok
-                ? `Key is live. ${probe.sessionCount} recent API ${probe.sessionCount === 1 ? "session" : "sessions"} visible.`
+            addCheck(probe.ok ? "ok" : "error", t("doctor.label.apiKeyAccepted"), probe.ok
+                ? t(probe.sessionCount === 1
+                    ? "doctor.key.liveOne"
+                    : "doctor.key.liveMany", { count: probe.sessionCount })
                 : probe.message);
         }
     }
+    // A stale global install is the quietest failure mode there is: npm pins the
+    // binary at install time and never revisits it, so doctor has to say so.
+    if (offline) {
+        addCheck("warn", t("doctor.label.cliVersion"), t("doctor.version.offline", { version: CLI_VERSION }));
+    }
+    else {
+        const update = await checkForUpdate(runtime, CLI_VERSION, { force: true });
+        addCheck(!update || !update.updateAvailable ? "ok" : "warn", t("doctor.label.cliVersion"), !update
+            ? t("doctor.version.unknown", { version: CLI_VERSION })
+            : update.updateAvailable
+                ? t("doctor.version.stale", {
+                    current: update.current,
+                    latest: update.latest,
+                })
+                : t("doctor.version.latest", { current: update.current }));
+    }
     return format === "json"
         ? jsonResult({
             ok: true,
@@ -775,23 +1142,22 @@ async function devCommand(args, runtime) {
     const projectEnv = await environmentForProject(dir, runtime);
     const apiBaseUrl = readString(parsed, "api-base-url") ??
         projectEnv.REMOTEDRAW_API_BASE_URL ??
-        "http://localhost:3210";
+        DEFAULT_REMOTEDRAW_API_BASE_URL;
     return ok([
-        "RemoteDraw local development workflow",
+        t("dev.title"),
         "",
-        `API base URL: ${apiBaseUrl}`,
+        t("dev.apiBaseUrl", { url: apiBaseUrl }),
         "",
-        "1. Start the RemoteDraw API/web service for local testing.",
-        "   Inside this repository: bun run dev:codex",
+        t("dev.hosted"),
         "",
-        "2. Start your app's dev server.",
-        "   Use the package manager and dev script generated by remotedraw new/init.",
+        t("dev.step1"),
+        t("dev.step1.detail"),
         "",
-        "3. Create a test input request from trusted backend code.",
+        t("dev.step2"),
         `   remotedraw create-input --preset signature --api-base-url ${apiBaseUrl}`,
         "",
-        "4. Show the returned HTTPS joinUrl in your receiver UI.",
-        "   Use the RemoteDraw iOS app for remotedraw-ios sender flows, or EmbeddedSender for owned web sender flows.",
+        t("dev.step3"),
+        t("dev.step3.detail"),
     ].join("\n"));
 }
 async function createInputCommand(args, runtime) {
@@ -812,7 +1178,7 @@ async function createInputCommand(args, runtime) {
     const preset = choice(readString(parsed, "preset") ?? "signature", presetChoices, "preset");
     const apiBaseUrl = readString(parsed, "api-base-url") ??
         projectEnv.REMOTEDRAW_API_BASE_URL ??
-        "https://<deployment>.convex.site";
+        DEFAULT_REMOTEDRAW_API_BASE_URL;
     const payload = createSessionPayload({
         preset,
         label: readString(parsed, "label") ?? labelForPreset(preset),
@@ -822,9 +1188,9 @@ async function createInputCommand(args, runtime) {
     if (parsed.booleans.has("execute")) {
         const apiKey = readString(parsed, "api-key") ?? projectEnv.REMOTEDRAW_API_KEY;
         if (!runtime.fetch)
-            throw new Error("This runtime cannot execute HTTP requests.");
+            throw new Error(t("createInput.error.noFetch"));
         if (!apiKey?.startsWith("rd_sk_")) {
-            throw new Error("create-input --execute requires --api-key or REMOTEDRAW_API_KEY with an rd_sk_... server key.");
+            throw new Error(t("createInput.error.noKey"));
         }
         const response = await runtime.fetch(`${normalizedOrigin(apiBaseUrl)}/v1/sessions`, {
             method: "POST",
@@ -836,20 +1202,20 @@ async function createInputCommand(args, runtime) {
         });
         const text = await response.text();
         if (!response.ok)
-            throw new Error(text || `RemoteDraw API returned ${response.status}.`);
+            throw new Error(text || t("createInput.error.apiStatus", { status: response.status }));
         return ok(text);
     }
     if (parsed.booleans.has("json")) {
         return ok(JSON.stringify(payload, null, 2));
     }
     return ok([
-        "RemoteDraw test input request",
+        t("createInput.title"),
         "",
-        "Create this from trusted backend code. Do not run API-key requests in a browser client.",
+        t("createInput.warning"),
         "",
         curlForCreateInput(apiBaseUrl, payload),
         "",
-        "Use --json to print only the request body or --execute to call the API with REMOTEDRAW_API_KEY.",
+        t("createInput.footer"),
     ].join("\n"));
 }
 async function examplesCommand(args, runtime) {
@@ -862,14 +1228,14 @@ async function examplesCommand(args, runtime) {
     const example = readString(parsed, "install");
     if (example == null || parsed.booleans.has("list")) {
         return ok([
-            "RemoteDraw examples",
+            t("examples.title"),
             "",
-            "  react-ios           Web receiver using the RemoteDraw iOS app as sender.",
-            "  react-owned-sender  Web receiver plus EmbeddedSender for owned web input.",
-            "  raw-http            Package-free backend/receiver/sender route fixtures.",
-            "  ios-owned-sender    Swift join-link and sender request helper starter.",
+            `  ${"react-ios".padEnd(19)} ${t("examples.reactIos")}`,
+            `  ${"react-owned-sender".padEnd(19)} ${t("examples.reactOwnedSender")}`,
+            `  ${"raw-http".padEnd(19)} ${t("examples.rawHttp")}`,
+            `  ${"ios-owned-sender".padEnd(19)} ${t("examples.iosOwnedSender")}`,
             "",
-            "Install one:",
+            t("examples.installOne"),
             "  remotedraw examples --install react-ios --path ./remotedraw-react-ios",
         ].join("\n"));
     }
@@ -887,7 +1253,7 @@ async function examplesCommand(args, runtime) {
         dryRun,
         force: parsed.booleans.has("force"),
     });
-    return ok(scaffoldSummary("Installed example", plan, outputDir, written, dryRun));
+    return ok(scaffoldSummary(t("scaffold.verb.installedExample"), plan, outputDir, written, dryRun));
 }
 async function agentCommand(args, runtime) {
     const parsed = parseArgs(args, {
@@ -901,15 +1267,18 @@ async function agentCommand(args, runtime) {
     const targetDir = readString(parsed, "path");
     if (targetDir == null) {
         return ok([
-            "RemoteDraw agent setup",
+            t("agent.title"),
             "",
-            "Use this when an AI coding agent needs to add RemoteDraw to a customer app.",
+            t("agent.intro"),
             "",
-            "Print the skill:",
+            t("agent.printSkill"),
             "  remotedraw agent --print-skill",
             "",
-            "Install the skill file:",
-            "  remotedraw agent --path ~/.codex/skills/remotedraw",
+            t("agent.installSkill"),
+            // Agent runtimes read skills from a per-project directory. `~/.codex`
+            // is the retired location and installing there reaches nothing.
+            "  remotedraw agent --path .agents/skills/remotedraw",
+            "  remotedraw agent --path .claude/skills/remotedraw",
         ].join("\n"));
     }
     const outputDir = resolveAgentPath(targetDir, runtime);
@@ -917,7 +1286,7 @@ async function agentCommand(args, runtime) {
     if (!parsed.booleans.has("dry-run") &&
         !parsed.booleans.has("force") &&
         (await runtime.exists(outputFile))) {
-        throw new Error("SKILL.md already exists. Pass --force to replace it.");
+        throw new Error(t("agent.error.exists"));
     }
     if (!parsed.booleans.has("dry-run")) {
         await runtime.mkdir(outputDir);
@@ -925,127 +1294,150 @@ async function agentCommand(args, runtime) {
     }
     return ok([
         parsed.booleans.has("dry-run")
-            ? `Would write ${outputFile}`
-            : `Installed RemoteDraw agent skill at ${outputFile}`,
+            ? t("agent.wouldWrite", { path: outputFile })
+            : t("agent.installed", { path: outputFile }),
         "",
-        "Next:",
-        "  Ask your agent to use the RemoteDraw skill before editing API, CLI, sender, receiver, or iOS integration code.",
+        t("word.next"),
+        t("agent.next"),
     ].join("\n"));
 }
 function newHelpText() {
+    const option = (flag, description) => `  ${flag.padEnd(25)} ${description}`;
     return [
-        "Usage:",
-        "  remotedraw new",
-        "  remotedraw new --app-name <name> [options]",
-        "",
-        "Run without options for the interactive setup flow.",
-        "",
-        "Options:",
-        "  --path <dir>              Output directory. Defaults to an app-name slug.",
-        "  --target <kind>           web, desktop, ios, or headless.",
-        "  --sender <kind>           remotedraw-ios, embedded-web, own-ios, or headless.",
-        "  --sdk <kind>              react, svelte, js, swift, or headless.",
-        "  --preset <kind>           signature or sketch. Legacy API presets remain accepted for existing integrations.",
-        "  --package-manager <name>  npm, pnpm, yarn, or bun.",
-        "  --api-base-url <url>      Default API origin for generated config.",
-        "  --force                   Overwrite generated files and existing RemoteDraw .env.local values.",
-        "  --offline                 Scaffold locally without login, dashboard project, or API key creation.",
-        "  --non-interactive         Never prompt; fail when required input is missing.",
-        "  --format <text|json>      Human-readable or machine-readable result.",
-        "  --dry-run                 Print files that would be written.",
+        t("word.usage"),
+        t("new.help.usage.bare"),
+        t("new.help.usage.named"),
+        "",
+        t("new.help.interactive"),
+        "",
+        t("word.options"),
+        option("--path <dir>", t("new.help.option.path")),
+        option("--target <kind>", t("new.help.option.target")),
+        option("--sender <kind>", t("new.help.option.sender")),
+        option("--sdk <kind>", t("new.help.option.sdk")),
+        option("--preset <kind>", t("new.help.option.preset")),
+        option("--package-manager <name>", t("new.help.option.packageManager")),
+        option("--api-base-url <url>", t("new.help.option.apiBaseUrl")),
+        option("--force", t("new.help.option.force")),
+        option("--offline", t("new.help.option.offline")),
+        option("--non-interactive", t("new.help.option.nonInteractive")),
+        option("--format <text|json>", t("new.help.option.format")),
+        option("--dry-run", t("new.help.option.dryRun")),
+        option("--language <code>", t("new.help.option.language")),
     ].join("\n");
 }
 function initHelpText() {
     return [
-        "Usage:",
-        "  remotedraw init [options]",
+        t("word.usage"),
+        t("init.help.usage"),
         "",
-        "Options match remotedraw new. init writes remotedraw.config.json, .env.example, and src/remotedraw starter files into an existing project.",
+        t("init.help.body"),
     ].join("\n");
 }
-function loginHelpText() {
+function languageHelpText() {
     return [
-        "Authorize the RemoteDraw CLI",
+        t("language.help.title"),
+        "",
+        t("word.usage"),
+        t("language.help.usage.list"),
+        t("language.help.usage.set"),
         "",
-        "Usage:",
-        "  remotedraw login [--no-open] [--force] [--api-base-url <origin>]",
+        t("language.help.body"),
+        t("language.help.override"),
         "",
-        "The browser confirms your account. A revocable CLI credential is stored in your user config directory, never in the project.",
+        t("language.available"),
+        ...SUPPORTED_LOCALES.map((locale) => `  ${locale.padEnd(6)} ${localeEndonym(locale)}`),
     ].join("\n");
 }
-function logoutHelpText() {
+function loginHelpText() {
     return [
-        "Revoke the RemoteDraw CLI credential",
+        t("login.help.title"),
         "",
-        "Usage:",
-        "  remotedraw logout [--api-base-url <origin>]",
+        t("word.usage"),
+        t("login.help.usage"),
+        "",
+        t("login.help.body"),
     ].join("\n");
 }
+function logoutHelpText() {
+    return [t("logout.help.title"), "", t("word.usage"), t("logout.help.usage")].join("\n");
+}
 function whoamiHelpText() {
+    return [t("whoami.help.title"), "", t("word.usage"), t("whoami.help.usage")].join("\n");
+}
+function doctorHelpText() {
     return [
-        "Show the active RemoteDraw CLI account",
-        "",
-        "Usage:",
-        "  remotedraw whoami [--api-base-url <origin>]",
+        t("word.usage"),
+        t("doctor.help.usage"),
+        "",
+        t("doctor.help.checks"),
+        t("doctor.help.baseUrl", { url: DEFAULT_REMOTEDRAW_API_BASE_URL }),
+        t("doctor.help.network"),
+        t("doctor.help.version"),
+        t("doctor.help.offline"),
     ].join("\n");
 }
-function doctorHelpText() {
+function updateHelpText() {
     return [
-        "Usage:",
-        "  remotedraw doctor [--path <dir>] [--format text|json] [--offline]",
+        t("word.usage"),
+        t("update.help.usage"),
         "",
-        "Checks local config, package.json dependencies, and the REMOTEDRAW_API_BASE_URL / REMOTEDRAW_API_KEY environment variables.",
-        "Then reaches the deployment: GET /health, and a free POST /v1/sessions/list to confirm the API key is live.",
-        "Pass --offline to skip the network checks.",
+        t("update.help.body", { package: CLI_PACKAGE_NAME }),
+        t("update.help.global"),
+        t("update.help.check"),
+        "",
+        t("update.help.silence"),
     ].join("\n");
 }
 function optionsHelpText() {
     return [
-        "Usage:",
+        t("word.usage"),
         "  remotedraw options [--format text|json]",
         "",
-        "Prints every setup choice, compatibility rule, default, explanation, and documentation URL.",
+        t("options.help.body"),
     ].join("\n");
 }
 function devHelpText() {
     return [
-        "Usage:",
-        "  remotedraw dev [--api-base-url <url>]",
+        t("word.usage"),
+        t("dev.help.usage"),
         "",
-        "Prints the local test workflow for pairing, input request creation, and receiver rendering.",
+        t("dev.help.body"),
     ].join("\n");
 }
 function createInputHelpText() {
+    const option = (flag, description) => `  ${flag.padEnd(21)} ${description}`;
     return [
-        "Usage:",
-        "  remotedraw create-input [--preset signature] [--json|--curl|--execute]",
-        "",
-        "Options:",
-        "  --preset <kind>       Session/input preset.",
-        "  --label <text>        Receiver target label.",
-        "  --external-id <id>    App-owned correlation id.",
-        "  --api-base-url <url>  RemoteDraw API origin.",
-        "  --api-key <key>       Server API key for --execute.",
-        "  --expires-in-ms <n>   Optional session TTL.",
+        t("word.usage"),
+        t("createInput.help.usage"),
+        "",
+        t("word.options"),
+        option("--preset <kind>", t("createInput.help.option.preset")),
+        option("--label <text>", t("createInput.help.option.label")),
+        option("--external-id <id>", t("createInput.help.option.externalId")),
+        option("--api-base-url <url>", t("createInput.help.option.apiBaseUrl")),
+        option("--api-key <key>", t("createInput.help.option.apiKey")),
+        option("--expires-in-ms <n>", t("createInput.help.option.expiresInMs")),
     ].join("\n");
 }
 function examplesHelpText() {
     return [
-        "Usage:",
-        "  remotedraw examples [--list]",
-        "  remotedraw examples --install <example> --path <dir>",
+        t("word.usage"),
+        t("examples.help.usage.list"),
+        t("examples.help.usage.install"),
         "",
-        `Examples: ${exampleChoices.join(", ")}`,
+        t("word.examples", { list: exampleChoices.join(", ") }),
     ].join("\n");
 }
 function agentHelpText() {
     return [
-        "Usage:",
-        "  remotedraw agent",
-        "  remotedraw agent --print-skill",
-        "  remotedraw agent --path <dir> [--force] [--dry-run]",
+        t("word.usage"),
+        t("agent.help.usage.bare"),
+        t("agent.help.usage.print"),
+        t("agent.help.usage.install"),
         "",
-        "Writes a SKILL.md file that tells coding agents how to choose an SDK, use the CLI, keep API keys server-side, and verify RemoteDraw integrations.",
+        t("agent.help.body"),
+        t("agent.help.paths"),
     ].join("\n");
 }
 function parseArgs(args, allowed) {
@@ -1068,17 +1460,17 @@ function parseArgs(args, allowed) {
         const inlineValue = equalsIndex === -1 ? undefined : withoutPrefix.slice(equalsIndex + 1);
         if (booleanFlags.has(name)) {
             if (inlineValue != null) {
-                throw new Error(`--${name} does not accept a value.`);
+                throw cliError("INVALID_ARGUMENT", "error.optionNoValue", { name });
             }
             booleans.add(name);
             continue;
         }
         if (!valueFlags.has(name)) {
-            throw new Error(`Unsupported option "--${name}".`);
+            throw cliError("INVALID_ARGUMENT", "error.unsupportedOption", { name });
         }
         const value = inlineValue ?? args[index + 1];
         if (value == null || value.startsWith("--")) {
-            throw new Error(`--${name} requires a value.`);
+            throw cliError("MISSING_ARGUMENT", "error.optionNeedsValue", { name });
         }
         values.set(name, value);
         if (inlineValue == null)
@@ -1095,7 +1487,7 @@ function optionalInteger(value) {
         return undefined;
     const number = Number(value);
     if (!Number.isInteger(number) || number <= 0) {
-        throw new Error("--expires-in-ms requires a positive integer.");
+        throw cliError("INVALID_ARGUMENT", "error.expiresInMs");
     }
     return number;
 }
@@ -1112,16 +1504,16 @@ async function promptForNewProject(parsed, runtime) {
             defaultAppName: "RemoteDraw app",
         });
     }
-    await prompts.intro?.("RemoteDraw project setup");
+    await prompts.intro?.(t("prompt.intro.setup"));
     const appName = readString(parsed, "app-name") ??
         (await prompts.text({
-            message: "Project name",
+            message: t("field.appName"),
             defaultValue: "RemoteDraw App",
             validate: validateProjectName,
         }));
     const target = readString(parsed, "target") == null
         ? await prompts.select({
-            message: "Project type",
+            message: t("field.target"),
             defaultValue: "web",
             choices: targetPromptChoices(),
         })
@@ -1134,25 +1526,19 @@ async function promptForNewProject(parsed, runtime) {
         : choice(readString(parsed, "sdk"), sdkChoices, "sdk");
     const preset = readString(parsed, "preset") == null
         ? await prompts.select({
-            message: "Starter experience",
+            message: t("field.preset"),
             defaultValue: "signature",
             choices: presetPromptChoices(),
         })
         : choice(readString(parsed, "preset"), presetChoices, "preset");
     const packageManager = readString(parsed, "package-manager") == null
         ? await prompts.select({
-            message: "Package manager",
+            message: t("field.packageManager"),
             defaultValue: "npm",
             choices: packageManagerPromptChoices(),
         })
         : choice(readString(parsed, "package-manager"), packageManagerChoices, "package-manager");
-    const apiBaseUrl = readString(parsed, "api-base-url") ??
-        apiBaseUrlForEndpoint(await prompts.select({
-            message: "API endpoint",
-            helperText: "Use the placeholder unless you are wiring local dev now.",
-            defaultValue: "deployment",
-            choices: apiEndpointPromptChoices(),
-        }));
+    const apiBaseUrl = readString(parsed, "api-base-url") ?? DEFAULT_REMOTEDRAW_API_BASE_URL;
     validatePlan({ target, sender, sdk });
     return {
         appName,
@@ -1166,13 +1552,13 @@ async function promptForNewProject(parsed, runtime) {
     };
 }
 function validateProjectName(value) {
-    return value.trim() === "" ? "Enter a project name." : undefined;
+    return value.trim() === "" ? t("field.appName.error") : undefined;
 }
 async function promptForSender(prompts, target) {
     const choices = senderPromptChoices(target);
     return await prompts.select({
-        message: "Phone sender",
-        helperText: "Choose where drawing input will run.",
+        message: t("field.sender"),
+        helperText: t("field.sender.helper"),
         defaultValue: defaultPromptValue(defaultSenderForTarget(target), choices),
         choices,
     });
@@ -1180,8 +1566,8 @@ async function promptForSender(prompts, target) {
 async function promptForSdk(prompts, target, sender) {
     const choices = sdkPromptChoices(target, sender);
     return await prompts.select({
-        message: "UI framework / SDK",
-        helperText: "Pick the SDK that matches your receiver UI.",
+        message: t("field.sdk"),
+        helperText: t("field.sdk.helper"),
         defaultValue: defaultPromptValue(defaultSdkForChoices(target, sender), choices),
         choices,
     });
@@ -1193,10 +1579,10 @@ function defaultPromptValue(preferred, choices) {
 }
 function targetPromptChoices() {
     return [
-        { value: "web", label: "Web app" },
-        { value: "desktop", label: "Desktop or custom app" },
-        { value: "ios", label: "iOS sender app" },
-        { value: "headless", label: "Headless service" },
+        { value: "web", label: t("choice.target.web.label") },
+        { value: "desktop", label: t("choice.target.desktop.label") },
+        { value: "ios", label: t("choice.target.ios.label") },
+        { value: "headless", label: t("choice.target.headless.label") },
     ];
 }
 const DOCS_INTEGRATION_PATHS = "https://docs.remotedraw.com/docs#paths";
@@ -1204,103 +1590,112 @@ const DOCS_SDKS = "https://docs.remotedraw.com/docs/sdks#components";
 const DOCS_PAYLOADS = "https://docs.remotedraw.com/docs/api#payloads";
 const DOCS_ENDPOINTS = "https://docs.remotedraw.com/docs/api#endpoints";
 const DOCS_AUTH = "https://docs.remotedraw.com/docs/api#auth";
-const targetWizardDetails = {
-    web: {
-        summary: "Voor webapps met een tekenoppervlak in de browser.",
-        explanation: "Kies dit als je website of webapp de tekeningen toont. De telefoon kan de RemoteDraw-iOS-app of een ingebouwde webzender gebruiken.",
-        docsUrl: DOCS_INTEGRATION_PATHS,
-        docsLabel: "Webapp-docs openen",
-    },
-    desktop: {
-        summary: "Voor desktopapps en andere maatwerkinterfaces.",
-        explanation: "Kies dit voor Electron, Tauri, een native desktopapp of een bestaande niet-webinterface. Je koppelt de ontvanger via de JavaScript-client of HTTP-API.",
-        docsUrl: DOCS_INTEGRATION_PATHS,
-        docsLabel: "Desktop-docs openen",
-    },
-    ios: {
-        summary: "Voor een eigen iOS-app die als telefoonzender werkt.",
-        explanation: "Kies dit als je zelf de native tekenervaring, navigatie en vormgeving op de iPhone beheert. De wizard maakt Swift-helpers aan.",
-        docsUrl: DOCS_INTEGRATION_PATHS,
-        docsLabel: "iOS-docs openen",
-    },
-    headless: {
-        summary: "Voor backends, automatisering en diensten zonder interface.",
-        explanation: "Kies dit als je sessies en tekengegevens rechtstreeks via de HTTP-API verwerkt en geen standaard ontvanger- of zenderinterface nodig hebt.",
-        docsUrl: DOCS_ENDPOINTS,
-        docsLabel: "Headless-docs openen",
-    },
-};
+// Detail bundles are built per call, not frozen at module load: the active
+// locale is only known once `runCli` has parsed the flag, the environment, and
+// the stored choice.
+function targetWizardDetails() {
+    return {
+        web: {
+            summary: t("choice.target.web.summary"),
+            explanation: t("choice.target.web.explanation"),
+            docsUrl: DOCS_INTEGRATION_PATHS,
+            docsLabel: t("choice.target.web.docs"),
+        },
+        desktop: {
+            summary: t("choice.target.desktop.summary"),
+            explanation: t("choice.target.desktop.explanation"),
+            docsUrl: DOCS_INTEGRATION_PATHS,
+            docsLabel: t("choice.target.desktop.docs"),
+        },
+        ios: {
+            summary: t("choice.target.ios.summary"),
+            explanation: t("choice.target.ios.explanation"),
+            docsUrl: DOCS_INTEGRATION_PATHS,
+            docsLabel: t("choice.target.ios.docs"),
+        },
+        headless: {
+            summary: t("choice.target.headless.summary"),
+            explanation: t("choice.target.headless.explanation"),
+            docsUrl: DOCS_ENDPOINTS,
+            docsLabel: t("choice.target.headless.docs"),
+        },
+    };
+}
 function wizardChoices(choices, details) {
-    return dutchWizardChoices(choices).map((choiceOption) => ({
+    return choices.map((choiceOption) => ({
         ...choiceOption,
         details: details[choiceOption.value],
     }));
 }
-const senderWizardDetails = {
-    "remotedraw-ios": {
-        summary: "De officiële RemoteDraw-app is de tekenzender op de telefoon.",
-        explanation: "Dit is de snelste route. Je ontvanger toont een QR-code of deelnamelink; de RemoteDraw-iOS-app verzorgt de tekeninterface en synchronisatie.",
-        docsUrl: DOCS_INTEGRATION_PATHS,
-        docsLabel: "iOS-zenderdocs openen",
-    },
-    "embedded-web": {
-        summary: "Een webzender die onderdeel is van je eigen product.",
-        explanation: "Kies dit als je de telefooninterface zelf wilt vormgeven in React of een andere webstack. Je app verwerkt de deelnamelink en zenderstatus.",
-        docsUrl: DOCS_INTEGRATION_PATHS,
-        docsLabel: "Webzenderdocs openen",
-    },
-    "own-ios": {
-        summary: "Een native iOS-zender die je volledig zelf beheert.",
-        explanation: "Kies dit voor eigen navigatie, branding, pushberichten of app-routing. Je ontvangt Swift-helpers voor deelnamelinks en zenderverzoeken.",
-        docsUrl: DOCS_INTEGRATION_PATHS,
-        docsLabel: "Swift-zenderdocs openen",
-    },
-    headless: {
-        summary: "Een eigen zender zonder door RemoteDraw geleverde interface.",
-        explanation: "Kies dit als je rechtstreeks met de HTTP-zenderroutes werkt, bijvoorbeeld vanuit automatisering, hardware of een volledig eigen client.",
-        docsUrl: DOCS_ENDPOINTS,
-        docsLabel: "HTTP-zenderdocs openen",
-    },
-};
-const sdkWizardDetails = {
-    react: {
-        summary: "React-componenten voor koppeling, ontvanger en zender.",
-        explanation: "Kies dit voor React of Next.js. De starter gebruikt de componenten en hooks van @remotedraw/react voor sessiestatus en live tekeningen.",
-        docsUrl: DOCS_SDKS,
-        docsLabel: "React SDK-docs openen",
-    },
-    svelte: {
-        summary: "Een Svelte-store bovenop de frameworkvrije client.",
-        explanation: "Kies dit voor Svelte of SvelteKit. Je beheert zelf de markup en bindt sessie-, teken- en zenderstatus via de Svelte-store.",
-        docsUrl: DOCS_SDKS,
-        docsLabel: "Svelte SDK-docs openen",
-    },
-    js: {
-        summary: "Frameworkvrije JavaScript-clients en protocoltypen.",
-        explanation: "Kies dit voor desktopapps, andere webframeworks of maatwerkclients. De starter gebruikt fetch en de gedeelde RemoteDraw-contracten.",
-        docsUrl: DOCS_ENDPOINTS,
-        docsLabel: "JavaScript-docs openen",
-    },
-    swift: {
-        summary: "Native Swift-helpers voor een eigen iOS-zender.",
-        explanation: "Kies dit als je zender in Swift of SwiftUI bouwt. De starter bevat parsing van deelnamelinks en getypeerde zenderverzoeken.",
-        docsUrl: DOCS_SDKS,
-        docsLabel: "Swift SDK-docs openen",
-    },
-    headless: {
-        summary: "Alleen configuratie, zonder UI-pakket.",
-        explanation: "Kies dit als een andere taal of eigen client de HTTP-API aanroept. De wizard voegt geen frameworkafhankelijkheid toe.",
-        docsUrl: DOCS_ENDPOINTS,
-        docsLabel: "HTTP API-docs openen",
-    },
-};
+function senderWizardDetails() {
+    return {
+        "remotedraw-ios": {
+            summary: t("choice.sender.remotedrawIos.summary"),
+            explanation: t("choice.sender.remotedrawIos.explanation"),
+            docsUrl: DOCS_INTEGRATION_PATHS,
+            docsLabel: t("choice.sender.remotedrawIos.docs"),
+        },
+        "embedded-web": {
+            summary: t("choice.sender.embeddedWeb.summary"),
+            explanation: t("choice.sender.embeddedWeb.explanation"),
+            docsUrl: DOCS_INTEGRATION_PATHS,
+            docsLabel: t("choice.sender.embeddedWeb.docs"),
+        },
+        "own-ios": {
+            summary: t("choice.sender.ownIos.summary"),
+            explanation: t("choice.sender.ownIos.explanation"),
+            docsUrl: DOCS_INTEGRATION_PATHS,
+            docsLabel: t("choice.sender.ownIos.docs"),
+        },
+        headless: {
+            summary: t("choice.sender.headless.summary"),
+            explanation: t("choice.sender.headless.explanation"),
+            docsUrl: DOCS_ENDPOINTS,
+            docsLabel: t("choice.sender.headless.docs"),
+        },
+    };
+}
+function sdkWizardDetails() {
+    return {
+        react: {
+            summary: t("choice.sdk.react.summary"),
+            explanation: t("choice.sdk.react.explanation"),
+            docsUrl: DOCS_SDKS,
+            docsLabel: t("choice.sdk.react.docs"),
+        },
+        svelte: {
+            summary: t("choice.sdk.svelte.summary"),
+            explanation: t("choice.sdk.svelte.explanation"),
+            docsUrl: DOCS_SDKS,
+            docsLabel: t("choice.sdk.svelte.docs"),
+        },
+        js: {
+            summary: t("choice.sdk.js.summary"),
+            explanation: t("choice.sdk.js.explanation"),
+            docsUrl: DOCS_ENDPOINTS,
+            docsLabel: t("choice.sdk.js.docs"),
+        },
+        swift: {
+            summary: t("choice.sdk.swift.summary"),
+            explanation: t("choice.sdk.swift.explanation"),
+            docsUrl: DOCS_SDKS,
+            docsLabel: t("choice.sdk.swift.docs"),
+        },
+        headless: {
+            summary: t("choice.sdk.headless.summary"),
+            explanation: t("choice.sdk.headless.explanation"),
+            docsUrl: DOCS_ENDPOINTS,
+            docsLabel: t("choice.sdk.headless.docs"),
+        },
+    };
+}
 function senderPromptChoices(target) {
     if (target === "ios") {
         return [
             {
                 value: "own-ios",
-                label: "Own iOS sender",
-                hint: "Use Swift join-link and sender request helpers.",
+                label: t("choice.sender.ownIos.label"),
+                hint: t("choice.sender.ownIos.hint"),
             },
         ];
     }
@@ -1308,8 +1703,8 @@ function senderPromptChoices(target) {
         return [
             {
                 value: "headless",
-                label: "Headless/custom sender",
-                hint: "No hosted phone UI.",
+                label: t("choice.sender.headless.label"),
+                hint: t("choice.sender.headless.hint.noUi"),
             },
         ];
     }
@@ -1317,26 +1712,26 @@ function senderPromptChoices(target) {
         return [
             {
                 value: "remotedraw-ios",
-                label: "RemoteDraw iOS app",
-                hint: "Show a join URL or QR code from your receiver.",
+                label: t("choice.sender.remotedrawIos.label"),
+                hint: t("choice.sender.remotedrawIos.hint.joinUrl"),
             },
             {
                 value: "headless",
-                label: "Headless/custom sender",
-                hint: "Build directly on the HTTP sender routes.",
+                label: t("choice.sender.headless.label"),
+                hint: t("choice.sender.headless.hint.httpRoutes"),
             },
         ];
     }
     return [
         {
             value: "remotedraw-ios",
-            label: "RemoteDraw iOS app",
-            hint: "Fastest path: scan the receiver QR code.",
+            label: t("choice.sender.remotedrawIos.label"),
+            hint: t("choice.sender.remotedrawIos.hint.scan"),
         },
         {
             value: "embedded-web",
-            label: "Own web sender",
-            hint: "Use a web sender component or raw sender helpers.",
+            label: t("choice.sender.embeddedWeb.label"),
+            hint: t("choice.sender.embeddedWeb.hint"),
         },
     ];
 }
@@ -1345,8 +1740,8 @@ function sdkPromptChoices(target, sender) {
         return [
             {
                 value: "swift",
-                label: "Swift helpers",
-                hint: "For customer-owned iOS sender apps.",
+                label: t("choice.sdk.swift.label"),
+                hint: t("choice.sdk.swift.hint"),
             },
         ];
     }
@@ -1354,13 +1749,13 @@ function sdkPromptChoices(target, sender) {
         return [
             {
                 value: "js",
-                label: "JavaScript client",
-                hint: "Framework-free HTTP clients and protocol types.",
+                label: t("choice.sdk.js.label.client"),
+                hint: t("choice.sdk.js.hint.client"),
             },
             {
                 value: "headless",
-                label: "Config only",
-                hint: "No UI package dependency.",
+                label: t("choice.sdk.headless.label"),
+                hint: t("choice.sdk.headless.hint"),
             },
         ];
     }
@@ -1368,26 +1763,26 @@ function sdkPromptChoices(target, sender) {
         return [
             {
                 value: "js",
-                label: "JavaScript client",
-                hint: "Framework-free HTTP clients and protocol types.",
+                label: t("choice.sdk.js.label.client"),
+                hint: t("choice.sdk.js.hint.client"),
             },
         ];
     }
     return [
         {
             value: "react",
-            label: "React SDK",
-            hint: "Receiver, pairing, and optional embedded sender components.",
+            label: t("choice.sdk.react.label"),
+            hint: t("choice.sdk.react.hint"),
         },
         {
             value: "svelte",
-            label: "Svelte SDK",
-            hint: "Svelte receiver store plus shared HTTP clients.",
+            label: t("choice.sdk.svelte.label"),
+            hint: t("choice.sdk.svelte.hint"),
         },
         {
             value: "js",
-            label: "No framework",
-            hint: "Framework-free clients and raw HTTP starter files.",
+            label: t("choice.sdk.js.label.noFramework"),
+            hint: t("choice.sdk.js.hint.noFramework"),
         },
     ];
 }
@@ -1395,13 +1790,13 @@ function presetPromptChoices() {
     return [
         {
             value: "signature",
-            label: "Signature strip",
-            hint: "Product-ready branded field with exact surface mapping.",
+            label: t("choice.preset.signature.label"),
+            hint: t("choice.preset.signature.hint"),
         },
         {
             value: "sketch",
-            label: "Custom drawing surface",
-            hint: "Flexible normalized input for your own receiver UI.",
+            label: t("choice.preset.sketch.label"),
+            hint: t("choice.preset.sketch.hint"),
         },
     ];
 }
@@ -1411,122 +1806,98 @@ function packageManagerPromptChoices() {
         label: packageManager,
     }));
 }
-function apiEndpointPromptChoices() {
-    return [
-        {
-            value: "deployment",
-            label: "Deployment URL placeholder",
-            hint: "Fill in your Convex site origin later.",
+function presetWizardDetails() {
+    return {
+        signature: {
+            summary: t("choice.preset.signature.summary"),
+            explanation: t("choice.preset.signature.explanation"),
+            docsUrl: DOCS_PAYLOADS,
+            docsLabel: t("choice.preset.signature.docs"),
         },
-        {
-            value: "local",
-            label: "Local dev server",
-            hint: "Use http://localhost:3210.",
+        initials: {
+            summary: t("choice.preset.initials.summary"),
+            explanation: t("choice.preset.initials.explanation"),
+            docsUrl: DOCS_PAYLOADS,
+            docsLabel: t("choice.preset.initials.docs"),
         },
-    ];
+        approval: {
+            summary: t("choice.preset.approval.summary"),
+            explanation: t("choice.preset.approval.explanation"),
+            docsUrl: DOCS_PAYLOADS,
+            docsLabel: t("choice.preset.approval.docs"),
+        },
+        sketch: {
+            summary: t("choice.preset.sketch.summary"),
+            explanation: t("choice.preset.sketch.explanation"),
+            docsUrl: DOCS_PAYLOADS,
+            docsLabel: t("choice.preset.sketch.docs"),
+        },
+        photoMarkup: {
+            summary: t("choice.preset.photoMarkup.summary"),
+            explanation: t("choice.preset.photoMarkup.explanation"),
+            docsUrl: DOCS_PAYLOADS,
+            docsLabel: t("choice.preset.photoMarkup.docs"),
+        },
+        pdfMarkup: {
+            summary: t("choice.preset.pdfMarkup.summary"),
+            explanation: t("choice.preset.pdfMarkup.explanation"),
+            docsUrl: DOCS_PAYLOADS,
+            docsLabel: t("choice.preset.pdfMarkup.docs"),
+        },
+        mapMarkup: {
+            summary: t("choice.preset.mapMarkup.summary"),
+            explanation: t("choice.preset.mapMarkup.explanation"),
+            docsUrl: DOCS_PAYLOADS,
+            docsLabel: t("choice.preset.mapMarkup.docs"),
+        },
+        screenMarkup: {
+            summary: t("choice.preset.screenMarkup.summary"),
+            explanation: t("choice.preset.screenMarkup.explanation"),
+            docsUrl: DOCS_PAYLOADS,
+            docsLabel: t("choice.preset.screenMarkup.docs"),
+        },
+        designReview: {
+            summary: t("choice.preset.designReview.summary"),
+            explanation: t("choice.preset.designReview.explanation"),
+            docsUrl: DOCS_PAYLOADS,
+            docsLabel: t("choice.preset.designReview.docs"),
+        },
+        pointer: {
+            summary: t("choice.preset.pointer.summary"),
+            explanation: t("choice.preset.pointer.explanation"),
+            docsUrl: DOCS_PAYLOADS,
+            docsLabel: t("choice.preset.pointer.docs"),
+        },
+    };
+}
+function packageManagerWizardDetails() {
+    return {
+        npm: {
+            summary: t("choice.packageManager.npm.summary"),
+            explanation: t("choice.packageManager.npm.explanation"),
+            docsUrl: "https://docs.npmjs.com/",
+            docsLabel: t("choice.packageManager.npm.docs"),
+        },
+        pnpm: {
+            summary: t("choice.packageManager.pnpm.summary"),
+            explanation: t("choice.packageManager.pnpm.explanation"),
+            docsUrl: "https://pnpm.io/",
+            docsLabel: t("choice.packageManager.pnpm.docs"),
+        },
+        yarn: {
+            summary: t("choice.packageManager.yarn.summary"),
+            explanation: t("choice.packageManager.yarn.explanation"),
+            docsUrl: "https://yarnpkg.com/getting-started/usage",
+            docsLabel: t("choice.packageManager.yarn.docs"),
+        },
+        bun: {
+            summary: t("choice.packageManager.bun.summary"),
+            explanation: t("choice.packageManager.bun.explanation"),
+            docsUrl: "https://bun.com/docs/pm/cli/install",
+            docsLabel: t("choice.packageManager.bun.docs"),
+        },
+    };
 }
-const presetWizardDetails = {
-    signature: {
-        summary: "De productklare RemoteDraw-handtekeningstrook.",
-        explanation: "Kies dit voor de complete, merkbare SignatureStrip met een exact passend telefoonoppervlak. Je kunt logo, tekst, kleur en omliggende formulier-UI aanpassen.",
-        docsUrl: DOCS_PAYLOADS,
-        docsLabel: "Handtekeningdocs openen",
-    },
-    initials: {
-        summary: "Een klein tekenveld voor initialen.",
-        explanation: "Gebruik dit wanneer iemand op één of meerdere plekken korte initialen moet plaatsen, bijvoorbeeld bij documentcontrole.",
-        docsUrl: DOCS_PAYLOADS,
-        docsLabel: "Initialendocs openen",
-    },
-    approval: {
-        summary: "Vrije tekeninvoer voor een visueel akkoord.",
-        explanation: "Gebruik dit voor goedkeuringen waarbij een vink, paraaf of korte markering voldoende is en je workflow de status beheert.",
-        docsUrl: DOCS_PAYLOADS,
-        docsLabel: "Goedkeuringsdocs openen",
-    },
-    sketch: {
-        summary: "Genormaliseerde invoer voor een eigen ontvangeroppervlak.",
-        explanation: "Kies dit wanneer jouw product de foto, kaart, PDF, canvas of andere receiver-UI beheert. RemoteDraw levert de invoerprimitieven zonder een voorgeschreven componentontwerp.",
-        docsUrl: DOCS_PAYLOADS,
-        docsLabel: "Schetsdocs openen",
-    },
-    photoMarkup: {
-        summary: "Aantekeningen bovenop een foto.",
-        explanation: "Gebruik dit voor inspecties, feedback of aanwijzingen op beeldmateriaal. Je app levert de foto en bewaart de relatie met de tekeningen.",
-        docsUrl: DOCS_PAYLOADS,
-        docsLabel: "Fotoannotatiedocs openen",
-    },
-    pdfMarkup: {
-        summary: "Aantekeningen op een PDF-pagina.",
-        explanation: "Gebruik dit voor documentreview. Je app rendert de juiste pagina en koppelt RemoteDraw-coördinaten aan die vaste weergave.",
-        docsUrl: DOCS_PAYLOADS,
-        docsLabel: "PDF-annotatiedocs openen",
-    },
-    mapMarkup: {
-        summary: "Tekeningen en aanwijzingen op een kaart.",
-        explanation: "Gebruik dit voor routes, locaties of ruimtelijke feedback. Je app beheert de kaart en viewport; RemoteDraw synchroniseert de invoer.",
-        docsUrl: DOCS_PAYLOADS,
-        docsLabel: "Kaartannotatiedocs openen",
-    },
-    screenMarkup: {
-        summary: "Aantekeningen op een scherm of applicatieweergave.",
-        explanation: "Gebruik dit voor support, demo's en UI-feedback. Je ontvanger levert het schermbeeld waarop de telefoonmarkeringen worden geprojecteerd.",
-        docsUrl: DOCS_PAYLOADS,
-        docsLabel: "Schermaantekeningdocs openen",
-    },
-    designReview: {
-        summary: "Gerichte visuele feedback op een ontwerp.",
-        explanation: "Gebruik dit voor ontwerpbeoordelingen met pijlen, vormen en vrije lijnen. Je product beheert opmerkingen, versies en besluitvorming.",
-        docsUrl: DOCS_PAYLOADS,
-        docsLabel: "Ontwerpbeoordelingsdocs openen",
-    },
-    pointer: {
-        summary: "Live aanwijzen zonder blijvende tekening.",
-        explanation: "Gebruik dit voor presentaties en begeleiding waarbij de telefoon als aanwijzer dient en beweging belangrijker is dan opgeslagen inkt.",
-        docsUrl: DOCS_PAYLOADS,
-        docsLabel: "Aanwijzerdocs openen",
-    },
-};
-const packageManagerWizardDetails = {
-    npm: {
-        summary: "De standaard package manager die met Node.js wordt geleverd.",
-        explanation: "Kies npm als je project package-lock.json gebruikt of geen voorkeur heeft. De wizard gebruikt npm voor installatie- en vervolgopdrachten.",
-        docsUrl: "https://docs.npmjs.com/",
-        docsLabel: "npm-docs openen",
-    },
-    pnpm: {
-        summary: "Een snelle package manager met een gedeelde pakketopslag.",
-        explanation: "Kies pnpm als je project pnpm-lock.yaml gebruikt, strikte dependency-isolatie wenst of al deel is van een pnpm-workspace.",
-        docsUrl: "https://pnpm.io/",
-        docsLabel: "pnpm-docs openen",
-    },
-    yarn: {
-        summary: "Een package manager met workspace- en Plug'n'Play-ondersteuning.",
-        explanation: "Kies Yarn als je project yarn.lock gebruikt. De wizard sluit aan op de bestaande Yarn-versie en projectconfiguratie.",
-        docsUrl: "https://yarnpkg.com/getting-started/usage",
-        docsLabel: "Yarn-docs openen",
-    },
-    bun: {
-        summary: "De snelle package manager die onderdeel is van de Bun-runtime.",
-        explanation: "Kies Bun als je project bun.lock gebruikt of Bun al inzet voor scripts, tests en installatie van dependencies.",
-        docsUrl: "https://bun.com/docs/pm/cli/install",
-        docsLabel: "Bun-docs openen",
-    },
-};
-const apiEndpointWizardDetails = {
-    deployment: {
-        summary: "Een tijdelijke URL die je later door je echte API-origin vervangt.",
-        explanation: "Kies dit voor een nieuw project dat nog niet aan een lokale server is gekoppeld. De gegenereerde configuratie bevat een duidelijke deployment-placeholder.",
-        docsUrl: DOCS_AUTH,
-        docsLabel: "Deploymentdocs openen",
-    },
-    local: {
-        summary: "Verbind met de lokale API op http://localhost:3210.",
-        explanation: "Kies dit wanneer je RemoteDraw lokaal draait en de ontvanger op dezelfde computer de ontwikkelserver kan bereiken.",
-        docsUrl: DOCS_AUTH,
-        docsLabel: "Lokale API-docs openen",
-    },
-};
 function agentOptionCatalog() {
     const catalogOption = (choiceOption, compatibility) => ({
         value: choiceOption.value,
@@ -1535,13 +1906,13 @@ function agentOptionCatalog() {
         details: choiceOption.details,
         ...(compatibility ?? {}),
     });
-    const targets = wizardChoices(targetPromptChoices(), targetWizardDetails);
+    const targets = wizardChoices(targetPromptChoices(), targetWizardDetails());
     const senders = senderChoices.map((value) => {
         const compatibleTargets = targetChoices.filter((target) => senderPromptChoices(target).some((option) => option.value === value));
         const prompt = compatibleTargets
             .flatMap((target) => senderPromptChoices(target))
             .find((option) => option.value === value);
-        return catalogOption(wizardChoices([prompt], senderWizardDetails)[0], {
+        return catalogOption(wizardChoices([prompt], senderWizardDetails())[0], {
             compatibleTargets,
         });
     });
@@ -1551,7 +1922,7 @@ function agentOptionCatalog() {
             : []));
         const firstPlan = compatiblePlans[0];
         const prompt = sdkPromptChoices(firstPlan.target, firstPlan.sender).find((option) => option.value === value);
-        return catalogOption(wizardChoices([prompt], sdkWizardDetails)[0], {
+        return catalogOption(wizardChoices([prompt], sdkWizardDetails())[0], {
             compatiblePlans,
         });
     });
@@ -1563,7 +1934,7 @@ function agentOptionCatalog() {
             {
                 key: "appName",
                 flag: "--app-name",
-                label: "Projectnaam",
+                label: t("field.appName"),
                 kind: "text",
                 requiredFor: ["new"],
                 options: [],
@@ -1571,48 +1942,44 @@ function agentOptionCatalog() {
             {
                 key: "target",
                 flag: "--target",
-                label: "Projecttype",
+                label: t("field.target"),
                 kind: "select",
                 options: targets.map((option) => catalogOption(option)),
             },
             {
                 key: "sender",
                 flag: "--sender",
-                label: "Telefoonzender",
+                label: t("field.sender"),
                 kind: "select",
                 options: senders,
             },
             {
                 key: "sdk",
                 flag: "--sdk",
-                label: "UI-framework / SDK",
+                label: t("field.sdk"),
                 kind: "select",
                 options: sdks,
             },
             {
                 key: "preset",
                 flag: "--preset",
-                label: "Startpunt",
+                label: t("field.preset"),
                 kind: "select",
-                options: wizardChoices(presetPromptChoices(), presetWizardDetails).map((option) => catalogOption(option)),
+                options: wizardChoices(presetPromptChoices(), presetWizardDetails()).map((option) => catalogOption(option)),
             },
             {
                 key: "packageManager",
                 flag: "--package-manager",
-                label: "Pakketbeheerder",
+                label: t("field.packageManager"),
                 kind: "select",
-                options: wizardChoices(packageManagerPromptChoices(), packageManagerWizardDetails).map((option) => catalogOption(option)),
+                options: wizardChoices(packageManagerPromptChoices(), packageManagerWizardDetails()).map((option) => catalogOption(option)),
             },
             {
                 key: "apiBaseUrl",
                 flag: "--api-base-url",
-                label: "API-eindpunt",
-                kind: "select",
-                options: wizardChoices(apiEndpointPromptChoices(), apiEndpointWizardDetails).map((option) => ({
-                    ...catalogOption(option),
-                    endpoint: option.value,
-                    value: apiBaseUrlForEndpoint(option.value),
-                })),
+                label: t("field.apiBaseUrl"),
+                kind: "text",
+                options: [],
             },
         ],
         defaults: {
@@ -1624,7 +1991,7 @@ function agentOptionCatalog() {
             ]))),
             preset: "signature",
             packageManager: "npm",
-            apiBaseUrl: "https://<deployment>.convex.site",
+            apiBaseUrl: DEFAULT_REMOTEDRAW_API_BASE_URL,
         },
         safety: {
             dryRunFlag: "--dry-run",
@@ -1634,11 +2001,6 @@ function agentOptionCatalog() {
         },
     };
 }
-function apiBaseUrlForEndpoint(endpoint) {
-    if (endpoint === "local")
-        return "http://localhost:3210";
-    return "https://<deployment>.convex.site";
-}
 export function projectSetupDefinition() {
     return {
         defaults: {
@@ -1648,52 +2010,8 @@ export function projectSetupDefinition() {
             sdk: "react",
             preset: "signature",
             packageManager: "npm",
-            apiEndpoint: "deployment",
         },
-        fields: [
-            {
-                key: "appName",
-                label: "Projectnaam",
-                kind: "text",
-                validate: validateWizardProjectName,
-            },
-            {
-                key: "target",
-                label: "Projecttype",
-                kind: "select",
-                choices: () => wizardChoices(targetPromptChoices(), targetWizardDetails),
-            },
-            {
-                key: "sender",
-                label: "Telefoonzender",
-                kind: "select",
-                choices: (values) => wizardChoices(senderPromptChoices(choice(values.target, targetChoices, "target")), senderWizardDetails),
-            },
-            {
-                key: "sdk",
-                label: "UI-framework / SDK",
-                kind: "select",
-                choices: (values) => wizardChoices(sdkPromptChoices(choice(values.target, targetChoices, "target"), choice(values.sender, senderChoices, "sender")), sdkWizardDetails),
-            },
-            {
-                key: "preset",
-                label: "Startpunt",
-                kind: "select",
-                choices: () => wizardChoices(presetPromptChoices(), presetWizardDetails),
-            },
-            {
-                key: "packageManager",
-                label: "Pakketbeheerder",
-                kind: "select",
-                choices: () => wizardChoices(packageManagerPromptChoices(), packageManagerWizardDetails),
-            },
-            {
-                key: "apiEndpoint",
-                label: "API-eindpunt",
-                kind: "select",
-                choices: () => wizardChoices(apiEndpointPromptChoices(), apiEndpointWizardDetails),
-            },
-        ],
+        fields: projectSetupFields(),
         normalize(values, changed) {
             const next = { ...values };
             const target = choice(next.target, targetChoices, "target");
@@ -1713,76 +2031,63 @@ export function projectSetupDefinition() {
         },
         review(values) {
             const plan = planFromWizardValues(values);
+            const label = (key, fallback) => wizardChoiceLabel(key, values) ?? fallback;
             return [
-                ["Project", plan.appName],
-                ["Map", plan.slug],
-                ["Projecttype", plan.target],
-                ["Telefoonzender", plan.sender],
-                ["SDK", plan.sdk],
-                ["Startpunt", plan.preset],
-                ["Pakketbeheerder", plan.packageManager],
-                ["API-eindpunt", plan.apiBaseUrl],
+                [t("field.project"), plan.appName],
+                [t("field.folder"), `./${plan.slug}`],
+                [t("field.target"), label("target", plan.target)],
+                [t("field.sender"), label("sender", plan.sender)],
+                [t("field.sdkShort"), label("sdk", plan.sdk)],
+                [t("field.packageManager"), label("packageManager", plan.packageManager)],
+                [t("field.apiBaseUrl"), plan.apiBaseUrl],
             ];
         },
     };
 }
+function projectSetupFields() {
+    return [
+        {
+            key: "appName",
+            label: t("field.appName"),
+            kind: "text",
+            validate: validateWizardProjectName,
+            preview: (values) => values.appName.trim() === ""
+                ? undefined
+                : t("field.appName.preview", { slug: slugify(values.appName) }),
+        },
+        {
+            key: "target",
+            label: t("field.target"),
+            kind: "select",
+            choices: () => wizardChoices(targetPromptChoices(), targetWizardDetails()),
+        },
+        {
+            key: "sender",
+            label: t("field.sender"),
+            kind: "select",
+            choices: (values) => wizardChoices(senderPromptChoices(choice(values.target, targetChoices, "target")), senderWizardDetails()),
+        },
+        {
+            key: "sdk",
+            label: t("field.sdk"),
+            kind: "select",
+            choices: (values) => wizardChoices(sdkPromptChoices(choice(values.target, targetChoices, "target"), choice(values.sender, senderChoices, "sender")), sdkWizardDetails()),
+        },
+        {
+            key: "packageManager",
+            label: t("field.packageManager"),
+            kind: "select",
+            choices: () => wizardChoices(packageManagerPromptChoices(), packageManagerWizardDetails()),
+        },
+    ];
+}
+function wizardChoiceLabel(key, values) {
+    const field = projectSetupFields().find((entry) => entry.key === key);
+    return field?.choices?.(values).find((option) => option.value === values[key])
+        ?.label;
+}
 function validateWizardProjectName(value) {
-    return value.trim() === "" ? "Voer een projectnaam in." : undefined;
-}
-const dutchWizardText = {
-    "Web app": "Webapp",
-    "Desktop or custom app": "Desktop- of maatwerkapp",
-    "iOS sender app": "iOS-zenderapp",
-    "Headless service": "Headless-service",
-    "Own iOS sender": "Eigen iOS-zender",
-    "Use Swift join-link and sender request helpers.": "Gebruik Swift-helpers voor deelnamelinks en zenderverzoeken.",
-    "Headless/custom sender": "Headless- of maatwerkzender",
-    "No hosted phone UI.": "Geen gehoste telefooninterface.",
-    "RemoteDraw iOS app": "RemoteDraw-iOS-app",
-    "Show a join URL or QR code from your receiver.": "Toon vanuit je ontvanger een deelname-URL of QR-code.",
-    "Build directly on the HTTP sender routes.": "Bouw rechtstreeks op de HTTP-zenderroutes.",
-    "Fastest path: scan the receiver QR code.": "Snelste route: scan de QR-code van de ontvanger.",
-    "Own web sender": "Eigen webzender",
-    "Use a web sender component or raw sender helpers.": "Gebruik een webzendercomponent of losse zenderhelpers.",
-    "Swift helpers": "Swift-helpers",
-    "For customer-owned iOS sender apps.": "Voor iOS-zenderapps in eigen beheer.",
-    "JavaScript client": "JavaScript-client",
-    "Framework-free HTTP clients and protocol types.": "Frameworkvrije HTTP-clients en protocoltypen.",
-    "Config only": "Alleen configuratie",
-    "No UI package dependency.": "Geen afhankelijkheid van een UI-pakket.",
-    "Receiver, pairing, and optional embedded sender components.": "Componenten voor ontvanger, koppeling en optionele ingebouwde zender.",
-    "Svelte receiver store plus shared HTTP clients.": "Svelte-store voor de ontvanger met gedeelde HTTP-clients.",
-    "No framework": "Geen framework",
-    "Framework-free clients and raw HTTP starter files.": "Frameworkvrije clients en kale HTTP-startbestanden.",
-    "Signature strip": "Handtekeningstrook",
-    "Product-ready branded field with exact surface mapping.": "Productklaar merkveld met exacte oppervlaktekoppeling.",
-    "Custom drawing surface": "Eigen tekenoppervlak",
-    "Flexible normalized input for your own receiver UI.": "Flexibele genormaliseerde invoer voor je eigen ontvanger-UI.",
-    Signature: "Handtekening",
-    Initials: "Initialen",
-    Approval: "Goedkeuring",
-    Sketch: "Schets",
-    "Photo markup": "Fotoannotatie",
-    "PDF markup": "PDF-annotatie",
-    "Map markup": "Kaartannotatie",
-    "Screen markup": "Schermaantekening",
-    "Design review": "Ontwerpbeoordeling",
-    Pointer: "Aanwijzer",
-    "Deployment URL placeholder": "Tijdelijke deployment-URL",
-    "Fill in your Convex site origin later.": "Vul later de oorsprong van je Convex-site in.",
-    "Local dev server": "Lokale ontwikkelserver",
-    "Use http://localhost:3210.": "Gebruik http://localhost:3210.",
-};
-function dutchWizardChoices(choices) {
-    return choices.map((choiceOption) => ({
-        ...choiceOption,
-        label: dutchWizardText[choiceOption.label] ?? choiceOption.label,
-        ...(choiceOption.hint == null
-            ? {}
-            : {
-                hint: dutchWizardText[choiceOption.hint] ?? choiceOption.hint,
-            }),
-    }));
+    return value.trim() === "" ? t("field.appName.error") : undefined;
 }
 function planFromWizardValues(values) {
     const appName = values.appName.trim();
@@ -1797,11 +2102,11 @@ function planFromWizardValues(values) {
         sdk,
         preset: choice(values.preset, presetChoices, "preset"),
         packageManager: choice(values.packageManager, packageManagerChoices, "package-manager"),
-        apiBaseUrl: apiBaseUrlForEndpoint(choice(values.apiEndpoint, apiEndpointChoices, "api endpoint")),
+        apiBaseUrl: DEFAULT_REMOTEDRAW_API_BASE_URL,
     };
     const nameError = validateProjectName(plan.appName);
     if (nameError)
-        throw new Error(nameError);
+        throw cliError("MISSING_ARGUMENT", "field.appName.error");
     validatePlan(plan);
     return plan;
 }
@@ -1810,7 +2115,7 @@ function planFromArgs(parsed, options) {
         options.defaults?.appName ??
         options.defaultAppName;
     if (options.appNameRequired && !readString(parsed, "app-name")) {
-        throw new Error("--app-name is required.");
+        throw cliError("MISSING_ARGUMENT", "error.appNameRequired");
     }
     const target = choice(readString(parsed, "target") ?? options.defaults?.target ?? "web", targetChoices, "target");
     const sender = choice(readString(parsed, "sender") ??
@@ -1825,7 +2130,7 @@ function planFromArgs(parsed, options) {
         "npm", packageManagerChoices, "package-manager");
     const apiBaseUrl = readString(parsed, "api-base-url") ??
         options.defaults?.apiBaseUrl ??
-        "https://<deployment>.convex.site";
+        DEFAULT_REMOTEDRAW_API_BASE_URL;
     validatePlan({ target, sender, sdk });
     return {
         appName,
@@ -1854,22 +2159,26 @@ function defaultSdkForChoices(target, sender) {
 }
 function validatePlan(plan) {
     if (plan.sender === "own-ios" && plan.sdk !== "swift") {
-        throw new Error("--sender own-ios requires --sdk swift.");
+        throw cliError("INVALID_COMBINATION", "error.plan.ownIosNeedsSwift");
     }
     if (plan.sdk === "swift" && plan.sender !== "own-ios") {
-        throw new Error("--sdk swift is only supported with --sender own-ios.");
+        throw cliError("INVALID_COMBINATION", "error.plan.swiftNeedsOwnIos");
     }
     if (plan.target === "ios" && plan.sender !== "own-ios") {
-        throw new Error("--target ios requires --sender own-ios.");
+        throw cliError("INVALID_COMBINATION", "error.plan.iosNeedsOwnIos");
     }
     if (plan.sender === "headless" && plan.sdk === "react") {
-        throw new Error("--sender headless requires --sdk js or --sdk headless.");
+        throw cliError("INVALID_COMBINATION", "error.plan.headlessSenderSdk");
     }
 }
 function choice(value, choices, label) {
     if (choices.includes(value))
         return value;
-    throw new Error(`Unknown ${label} "${value}". Expected one of: ${choices.join(", ")}.`);
+    throw cliError("INVALID_ARGUMENT", "error.unknownChoice", {
+        label,
+        value,
+        expected: choices.join(", "),
+    });
 }
 function resolveOutputDir(cwd, parsed, fallback) {
     const requestedPath = readString(parsed, "path") ?? parsed.positionals[0] ?? fallback ?? ".";
@@ -1891,6 +2200,11 @@ function newProjectFiles(plan) {
         files.set("tsconfig.json", reactTsconfig());
         files.set("vite.config.ts", reactViteConfig());
     }
+    else if (plan.sdk !== "swift") {
+        // Without this the starter shipped a TypeScript toolchain and nothing to
+        // point it at, so `tsc` had no config and no way to resolve node globals.
+        files.set("tsconfig.json", nodeTsconfig());
+    }
     return files;
 }
 function initProjectFiles(plan, packageJsonAlreadyExists) {
@@ -1905,7 +2219,7 @@ function initProjectFiles(plan, packageJsonAlreadyExists) {
         files.set("src/remotedraw/createRemoteDrawSession.ts", reactBackendSessionTs(plan));
         files.set("src/remotedraw/RemoteDrawReceiver.tsx", reactReceiverTsx());
         if (plan.sender === "embedded-web") {
-            files.set("src/remotedraw/RemoteDrawEmbeddedSender.tsx", reactEmbeddedSenderTsx());
+            files.set("src/remotedraw/useRemoteDrawSender.ts", reactSenderTsx());
         }
     }
     else if (plan.sdk === "svelte") {
@@ -1945,7 +2259,9 @@ async function assertProjectFilesWritable(files, outputDir, runtime, dryRun, for
         return;
     for (const relativePath of files.keys()) {
         if (await runtime.exists(path.join(outputDir, relativePath))) {
-            throw new Error(`Refusing to overwrite ${relativePath}. Pass --force to replace generated files.`);
+            throw cliError("FILE_CONFLICT", "error.refuseOverwrite", {
+                file: relativePath,
+            });
         }
     }
 }
@@ -2014,25 +2330,30 @@ function hasDependency(packageJson, dependencyName) {
     return (isRecord(packageJson.dependencies) &&
         typeof packageJson.dependencies[dependencyName] === "string");
 }
+/**
+ * The RemoteDraw package an sdk choice installs, if any. The js starter calls
+ * the HTTP API with plain fetch and takes only the request/response contract
+ * from `@remotedraw/protocol`; the headless and swift starters take nothing.
+ */
+function sdkPackageName(sdk) {
+    if (sdk === "react")
+        return "@remotedraw/react";
+    if (sdk === "svelte")
+        return "@remotedraw/svelte";
+    if (sdk === "js")
+        return "@remotedraw/protocol";
+    return undefined;
+}
 function dependenciesForPlan(plan) {
+    const sdkPackage = sdkPackageName(plan.sdk);
+    const dependencies = sdkPackage
+        ? { [sdkPackage]: REMOTEDRAW_SDK_RANGE }
+        : {};
     if (plan.sdk === "react") {
-        return {
-            "@remotedraw/react": "latest",
-            react: "^19.0.0",
-            "react-dom": "^19.0.0",
-        };
-    }
-    if (plan.sdk === "svelte") {
-        return {
-            "@remotedraw/svelte": "latest",
-        };
-    }
-    if (plan.sdk === "js") {
-        return {
-            "@remotedraw/protocol": "latest",
-        };
+        dependencies.react = "^19.0.0";
+        dependencies["react-dom"] = "^19.0.0";
     }
-    return {};
+    return dependencies;
 }
 function newPackageJson(plan) {
     const dependencies = dependenciesForPlan(plan);
@@ -2048,15 +2369,24 @@ function newPackageJson(plan) {
             },
             dependencies,
             devDependencies: {
+                // src/remotedraw/createRemoteDrawSession.ts reads process.env, so the
+                // starter cannot typecheck without node types.
+                "@types/node": "^25.0.0",
                 "@types/react": "^19.0.0",
                 "@types/react-dom": "^19.0.0",
-                "@vitejs/plugin-react": "latest",
+                "@vitejs/plugin-react": "^6.0.0",
                 typescript: "^6.0.0",
-                vite: "latest",
+                vite: "^8.0.0",
             },
         };
     }
-    return initPackageJson(plan);
+    const manifest = initPackageJson(plan);
+    if (plan.sdk === "swift")
+        return manifest;
+    return {
+        ...manifest,
+        scripts: { ...manifest.scripts, typecheck: "tsc --noEmit" },
+    };
 }
 function initPackageJson(plan) {
     return {
@@ -2069,14 +2399,21 @@ function initPackageJson(plan) {
             "remotedraw:create-input": "remotedraw create-input --preset " + plan.preset,
         },
         dependencies: dependenciesForPlan(plan),
-        devDependencies: {
-            typescript: "^6.0.0",
-        },
+        // The scripts above shell out to `remotedraw`, so the CLI has to be a real
+        // dependency of the project instead of an assumed global install. The swift
+        // starter writes no TypeScript, so it gets no TypeScript toolchain.
+        devDependencies: plan.sdk === "swift"
+            ? { "@remotedraw/cli": REMOTEDRAW_CLI_RANGE }
+            : {
+                "@remotedraw/cli": REMOTEDRAW_CLI_RANGE,
+                "@types/node": "^25.0.0",
+                typescript: "^6.0.0",
+            },
     };
 }
 function configJson(plan) {
     return {
-        $schema: "https://remotedraw.app/schemas/remotedraw.config.json",
+        $schema: "https://www.remotedraw.com/schemas/remotedraw.config.json",
         appName: plan.appName,
         environment: "dev",
         target: plan.target,
@@ -2088,7 +2425,7 @@ function configJson(plan) {
 }
 function envExample(plan) {
     return [
-        "# RemoteDraw API origin. Use your Convex site URL in production.",
+        "# RemoteDraw API origin. The hosted RemoteDraw API; leave as-is unless RemoteDraw support tells you otherwise.",
         `REMOTEDRAW_API_BASE_URL=${plan.apiBaseUrl}`,
         "",
         "# Non-secret dashboard project identifier. remotedraw new/init fills this in.",
@@ -2176,7 +2513,7 @@ function reactReceiverTsx() {
         "import {",
         "  RemoteDrawProvider,",
         "  RemoteDrawReceiver,",
-        "  SubmissionStatus,",
+        "  RemoteDrawSessionControls,",
         "  createHttpReceiverClient,",
         '} from "@remotedraw/react";',
         'import type { CreateSessionResponse } from "@remotedraw/react";',
@@ -2201,36 +2538,130 @@ function reactReceiverTsx() {
         "      receiver={receiver}",
         "    >",
         '      <RemoteDrawReceiver aria-label="RemoteDraw receiver surface" />',
-        '      <SubmissionStatus metadataKeys={["externalId", "senderLabel"]} />',
+        "      <RemoteDrawSessionControls />",
         "    </RemoteDrawProvider>",
         "  );",
         "}",
         "",
     ].join("\n");
 }
-function reactEmbeddedSenderTsx() {
+function reactSenderTsx() {
+    // Headless on purpose: the ready-made web sender is the hosted /join page
+    // (the QR / Universal Link target). This starter is for products that must
+    // host the pad themselves — RemoteDraw transports normalized points while
+    // the canvas, tools, and styling stay app-owned.
     return [
-        'import { EmbeddedSender, createHttpSenderClient } from "@remotedraw/react";',
-        "",
-        "type RemoteDrawEmbeddedSenderPanelProps = {",
-        "  apiBaseUrl: string;",
-        "  joinTokenOrUrl: string;",
-        "};",
+        'import { useEffect, useMemo, useRef, useState } from "react";',
+        "import {",
+        "  createHttpSenderClient,",
+        "  createPacedDraftQueue,",
+        "  draftPointsForTransport,",
+        "  joinTokenFromInput,",
+        '} from "@remotedraw/react";',
+        "import type {",
+        "  DraftInputUpdate,",
+        "  JoinSessionResponse,",
+        "  NormalizedPoint,",
+        '} from "@remotedraw/react";',
         "",
-        "export function RemoteDrawEmbeddedSenderPanel({",
-        "  apiBaseUrl,",
-        "  joinTokenOrUrl,",
-        "}: RemoteDrawEmbeddedSenderPanelProps) {",
-        "  return (",
-        "    <EmbeddedSender",
-        "      client={createHttpSenderClient(apiBaseUrl)}",
-        "      initialJoinToken={joinTokenOrUrl}",
-        "      autoJoin",
-        '      device={{ platform: "web", displayName: "Embedded sender" }}',
-        '      submitMetadata={{ senderLabel: "Embedded sender" }}',
-        '      submitLabel="Done"',
-        "    />",
+        "// Headless RemoteDraw sender. The hosted /join page is the ready-made",
+        "// pad; use this hook when the drawing surface must live inside your own",
+        "// page. Points are normalized 0..1; the canvas and tools stay yours.",
+        "export function useRemoteDrawSender(",
+        "  apiBaseUrl: string,",
+        "  joinTokenOrUrl: string,",
+        ") {",
+        "  const client = useMemo(",
+        "    () => createHttpSenderClient(apiBaseUrl),",
+        "    [apiBaseUrl],",
         "  );",
+        "  const [joined, setJoined] = useState<JoinSessionResponse | null>(null);",
+        "  const [error, setError] = useState<string | null>(null);",
+        "  const joinedRef = useRef<JoinSessionResponse | null>(null);",
+        "  const sequenceRef = useRef(0);",
+        "  // Drafts are throttled and latest-only: never POST every pointer event.",
+        "  const draftQueue = useMemo(",
+        "    () =>",
+        "      createPacedDraftQueue<DraftInputUpdate>({",
+        "        intervalMs: 32,",
+        "        run: async (request) => {",
+        "          await client.updateDraft?.(request);",
+        "        },",
+        "      }),",
+        "    [client],",
+        "  );",
+        "",
+        "  useEffect(() => {",
+        "    const joinToken = joinTokenFromInput(joinTokenOrUrl);",
+        "    if (!joinToken) {",
+        '      setError("Join token is required.");',
+        "      return;",
+        "    }",
+        "    let cancelled = false;",
+        "    client",
+        "      .join?.({",
+        "        joinToken,",
+        '        device: { platform: "web", displayName: "Embedded sender" },',
+        "      })",
+        "      .then((result) => {",
+        "        if (cancelled || !result) return;",
+        "        // Resuming a token must continue its sequence: the server drops",
+        "        // anything at or below the last sequence it has seen.",
+        "        sequenceRef.current = result.lastSequence ?? 0;",
+        "        joinedRef.current = result;",
+        "        setJoined(result);",
+        "      })",
+        "      .catch((caught: unknown) => {",
+        "        if (!cancelled) setError(String(caught));",
+        "      });",
+        "    return () => {",
+        "      cancelled = true;",
+        "    };",
+        "  }, [client, joinTokenOrUrl]);",
+        "",
+        "  return {",
+        "    joined,",
+        "    error,",
+        "    /** Call on pointermove with the whole in-progress stroke. */",
+        "    previewDraft(points: NormalizedPoint[]) {",
+        "      const senderToken = joinedRef.current?.senderToken;",
+        "      if (!senderToken || points.length === 0) return;",
+        "      draftQueue.offer(() => ({",
+        "        senderToken,",
+        "        sequence: ++sequenceRef.current,",
+        '        tool: "freehand" as const,',
+        '        pointerType: "touch" as const,',
+        "        points: draftPointsForTransport(points),",
+        "        occurredAt: Date.now(),",
+        "      }));",
+        "    },",
+        "    /** Call once on pointer-up with a stable id per stroke. */",
+        "    async commitStroke(points: NormalizedPoint[], clientStrokeId: string) {",
+        "      const senderToken = joinedRef.current?.senderToken;",
+        "      if (!senderToken || points.length < 2) return;",
+        "      draftQueue.clear();",
+        "      await client.commitStroke?.({",
+        "        senderToken,",
+        "        clientStrokeId,",
+        "        sequence: ++sequenceRef.current,",
+        '        tool: "freehand",',
+        '        pointerType: "touch",',
+        "        points,",
+        "        occurredAt: Date.now(),",
+        "      });",
+        "    },",
+        "    /** Call when the sender-side workflow is complete. */",
+        "    async submit(metadata?: Record<string, string>) {",
+        "      const senderToken = joinedRef.current?.senderToken;",
+        "      if (!senderToken) return;",
+        "      await client.submit?.({",
+        "        senderToken,",
+        "        clientSubmissionId: crypto.randomUUID(),",
+        "        occurredAt: Date.now(),",
+        "        ...(metadata ? { metadata } : {}),",
+        "      });",
+        "    },",
+        "  };",
         "}",
         "",
     ].join("\n");
@@ -2308,11 +2739,24 @@ function svelteReceiverSvelte() {
     ].join("\n");
 }
 function rawHttpSessionTs(plan) {
+    // The js starter declares @remotedraw/protocol, so it uses it: the contract
+    // types are the whole reason that dependency is there. The headless starter
+    // declares nothing and stays import-free.
+    const typed = plan.sdk === "js";
     return [
+        ...(typed
+            ? [
+                "import type {",
+                "  CreateSessionRequest,",
+                "  CreateSessionResponse,",
+                '} from "@remotedraw/protocol";',
+                "",
+            ]
+            : []),
         "const apiBaseUrl = process.env.REMOTEDRAW_API_BASE_URL;",
         "const apiKey = process.env.REMOTEDRAW_API_KEY;",
         "",
-        "export function createRemoteDrawSessionRequest() {",
+        `export function createRemoteDrawSessionRequest()${typed ? ": CreateSessionRequest" : ""} {`,
         "  return " +
             JSON.stringify(createSessionPayload({
                 preset: plan.preset,
@@ -2322,7 +2766,7 @@ function rawHttpSessionTs(plan) {
             ";",
         "}",
         "",
-        "export async function createRemoteDrawSession() {",
+        `export async function createRemoteDrawSession()${typed ? ": Promise<CreateSessionResponse>" : ""} {`,
         "  if (!apiBaseUrl || !apiKey) {",
         '    throw new Error("Set REMOTEDRAW_API_BASE_URL and REMOTEDRAW_API_KEY in backend secrets.");',
         "  }",
@@ -2336,7 +2780,9 @@ function rawHttpSessionTs(plan) {
         "    body: JSON.stringify(createRemoteDrawSessionRequest()),",
         "  });",
         "  if (!response.ok) throw new Error(await response.text());",
-        "  return await response.json();",
+        typed
+            ? "  return (await response.json()) as CreateSessionResponse;"
+            : "  return await response.json();",
         "}",
         "",
     ].join("\n");
@@ -2546,6 +2992,9 @@ function reactTsconfig() {
         '    "target": "ES2022",',
         '    "useDefineForClassFields": true,',
         '    "lib": ["ES2022", "DOM", "DOM.Iterable"],',
+        // vite/client declares the CSS side-effect import in src/main.tsx; node
+        // covers the process.env reads in the backend session helper.
+        '    "types": ["node", "vite/client"],',
         '    "allowJs": false,',
         '    "skipLibCheck": true,',
         '    "esModuleInterop": true,',
@@ -2563,6 +3012,26 @@ function reactTsconfig() {
         "",
     ].join("\n");
 }
+function nodeTsconfig() {
+    return [
+        "{",
+        '  "compilerOptions": {',
+        '    "target": "ES2022",',
+        '    "lib": ["ES2022", "DOM"],',
+        '    "types": ["node"],',
+        '    "module": "ESNext",',
+        '    "moduleResolution": "Bundler",',
+        '    "strict": true,',
+        '    "skipLibCheck": true,',
+        '    "resolveJsonModule": true,',
+        '    "isolatedModules": true,',
+        '    "noEmit": true',
+        "  },",
+        '  "include": ["src"]',
+        "}",
+        "",
+    ].join("\n");
+}
 function reactViteConfig() {
     return [
         'import react from "@vitejs/plugin-react";',
@@ -2716,10 +3185,10 @@ function shellQuote(value) {
 function normalizedOrigin(value) {
     const parsed = new URL(value);
     if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
-        throw new Error("Expected an HTTP(S) API base URL.");
+        throw cliError("INVALID_ARGUMENT", "error.expectedHttpOrigin");
     }
     if (parsed.pathname !== "/" || parsed.search || parsed.hash) {
-        throw new Error("Expected API base URL to be an origin without a path, query, or hash.");
+        throw cliError("INVALID_ARGUMENT", "error.expectedBareOrigin");
     }
     return parsed.origin;
 }
@@ -2734,95 +3203,80 @@ function resolveAgentPath(value, runtime) {
     if (value.startsWith("~/")) {
         const home = runtime.env.HOME;
         if (home == null) {
-            throw new Error("Cannot expand ~ because HOME is not set.");
+            throw cliError("INVALID_ARGUMENT", "error.noHome");
         }
         return path.join(home, value.slice(2));
     }
     return path.resolve(runtime.cwd, value);
 }
+/**
+ * The skill a coding agent installs is the same file this repository
+ * documents. `docs/agents/remotedraw/SKILL.md` is the single source; the
+ * module below is generated from it by `bun run generate:skill`, and
+ * tests/agent-skill.test.ts fails if the two drift apart again.
+ */
 export function agentSkillMarkdown() {
-    return [
-        "---",
-        "name: remotedraw",
-        "description: Add RemoteDraw phone input to customer apps with the RemoteDraw CLI, public API, React SDK, raw HTTP, or customer-owned iOS sender flow.",
-        "---",
-        "",
-        "# RemoteDraw Agent Skill",
-        "",
-        "Use this skill when a user asks to create, initialize, debug, or review a RemoteDraw integration.",
-        "",
-        "## Decision Flow",
-        "",
-        "1. Identify the receiver surface: web app, desktop app, iOS app, or headless/backend workflow.",
-        "2. Identify the sender surface: RemoteDraw iOS app, embedded web sender, customer-owned iOS sender, or raw/headless sender.",
-        "3. Pick the SDK path:",
-        "   - React SDK: web receiver and optional embedded web sender.",
-        "   - Plain JavaScript/raw HTTP: non-React web, desktop, backend, or custom clients.",
-        "   - Swift: customer-owned iOS sender apps.",
-        "4. Pick a supported starter: signature for the product-ready SignatureStrip, or sketch for a receiver UI owned by the integrating app. Configure target kind and descriptors directly for photos, PDFs, maps, screens, and other custom surfaces.",
-        "",
-        "## CLI First",
-        "",
-        "Read the machine-readable option catalog before choosing a plan:",
-        "",
-        "```sh",
-        "remotedraw options --format json",
-        "```",
-        "",
-        "Initialize a project with the closest supported path:",
-        "",
-        "```sh",
-        "remotedraw init --target web --sender remotedraw-ios --sdk react --preset signature",
-        "remotedraw init --target web --sender embedded-web --sdk react --preset sketch",
-        "remotedraw init --target desktop --sender remotedraw-ios --sdk js --preset sketch",
-        "remotedraw init --target ios --sender own-ios --sdk swift --preset sketch",
-        "```",
-        "",
-        "By default, new/init create the dashboard project and a project-scoped development API key, then write REMOTEDRAW_API_BASE_URL, REMOTEDRAW_PROJECT_ID, and REMOTEDRAW_API_KEY to a gitignored .env.local. Use --offline only when cloud setup is intentionally out of scope.",
-        "",
-        "Agents must use explicit non-interactive dry runs before changing a project:",
-        "",
-        "```sh",
-        "remotedraw init --non-interactive --offline --dry-run --format json --target web --sender remotedraw-ios --sdk react --preset signature --package-manager npm",
-        "# Inspect plan, files, defaultsApplied, and warnings before applying.",
-        "remotedraw init --non-interactive --offline --format json --target web --sender remotedraw-ios --sdk react --preset signature --package-manager npm",
-        "remotedraw doctor --format json",
-        "remotedraw create-input --preset signature --json",
-        "```",
-        "",
-        "Do not use the interactive wizard, synthesize arrow-key input, or scrape human-formatted output. If receiver, sender, or preset intent is ambiguous, ask the user instead of guessing. Never pass --force unless overwrite scope was explicitly approved.",
-        "",
-        "## Security Rules",
-        "",
-        "- Keep `rd_sk_...` API keys in trusted backend secrets only.",
-        "- Keep the account-level `rd_cli_...` credential in the user config directory; never copy it into a project. Use REMOTEDRAW_CLI_TOKEN only as an explicitly managed CI secret.",
-        "- Never place API keys in browser bundles, mobile clients, screenshots, logs, or generated examples.",
-        "- Public clients should receive only `joinUrl`, `joinToken`, `receiverToken`, or `senderToken` values scoped to the session.",
-        "- Production QR codes should use HTTPS `joinUrl` values. Do not make the custom scheme the primary QR target.",
-        "",
-        "## API Contract",
-        "",
-        "- Backend creates sessions with `POST /v1/sessions`.",
-        "- Receiver clients read `POST /v1/receiver/session`, `/drawings`, `/drafts`, and `/senders` with a receiver token.",
-        "- Sender clients join with `POST /v1/join`, stream mutable drafts to `/v1/sender/draft`, commit durable strokes to `/v1/sender/commit`, and finish with `/v1/sender/submit`.",
-        "- Custom senders should throttle draft updates, coalesce to the latest pending preview, and commit one durable stroke on pointer-up with a stable `clientStrokeId`.",
-        "",
-        "## Verification",
-        "",
-        "After changes, run the narrowest relevant checks first:",
-        "",
-        "```sh",
-        "remotedraw doctor",
-        "bun run test:api",
-        "bun run typecheck",
-        "```",
-        "",
-        "For customer-owned iOS sender helpers in this repo, also run:",
-        "",
-        "```sh",
-        "bun run ios:kit:test",
-        "```",
-    ].join("\n");
+    return AGENT_SKILL_MARKDOWN;
+}
+/**
+ * Doctor used to read REMOTEDRAW_API_BASE_URL raw and call an unset value a
+ * problem, which disagreed with login/whoami/new — those all fall back to the
+ * production API. Resolving it the same way here keeps every command pointed at
+ * one deployment, and reporting the source explains a non-production URL
+ * instead of leaving the reader to guess where it came from.
+ */
+function resolveDoctorApiBaseUrl(projectEnv, requested) {
+    const explicit = requested ?? projectEnv.REMOTEDRAW_API_BASE_URL;
+    const source = requested == null ? "project" : "flag";
+    if (explicit == null || explicit.trim() === "") {
+        return {
+            state: "ok",
+            url: DEFAULT_REMOTEDRAW_API_BASE_URL,
+            source: "default",
+            isProductionDefault: true,
+        };
+    }
+    // `init --offline` writes the literal placeholder, so an unreplaced value is
+    // an expected next step rather than a mistake.
+    if (explicit.includes("<"))
+        return { state: "placeholder", value: explicit };
+    if (!isHttpOrigin(explicit)) {
+        return { state: "invalid", value: explicit, source };
+    }
+    const url = normalizedOrigin(explicit);
+    return {
+        state: "ok",
+        url,
+        source,
+        isProductionDefault: url === DEFAULT_REMOTEDRAW_API_BASE_URL,
+    };
+}
+function doctorApiBaseUrlMessage(resolved) {
+    if (resolved.state === "placeholder") {
+        return t("doctor.baseUrl.placeholder", {
+            value: resolved.value,
+            defaultUrl: DEFAULT_REMOTEDRAW_API_BASE_URL,
+        });
+    }
+    if (resolved.state === "invalid") {
+        return t("doctor.baseUrl.invalid", {
+            value: resolved.value,
+            defaultUrl: DEFAULT_REMOTEDRAW_API_BASE_URL,
+        });
+    }
+    if (resolved.source === "default") {
+        return t("doctor.baseUrl.default", { url: resolved.url });
+    }
+    const origin = resolved.source === "flag"
+        ? t("doctor.baseUrl.origin.flag")
+        : t("doctor.baseUrl.origin.project");
+    return resolved.isProductionDefault
+        ? t("doctor.baseUrl.production", { url: resolved.url, origin })
+        : t("doctor.baseUrl.override", {
+            url: resolved.url,
+            origin,
+            defaultUrl: DEFAULT_REMOTEDRAW_API_BASE_URL,
+        });
 }
 function isHttpOrigin(value) {
     if (value == null || value.includes("<"))
@@ -2863,24 +3317,27 @@ function planDefaultsForExample(example) {
     };
 }
 function scaffoldSummary(verb, plan, outputDir, written, dryRun) {
-    const nextCommandPrefix = dryRun ? "Would write" : "Wrote";
     return [
-        `${verb} RemoteDraw ${plan.target} integration in ${outputDir}`,
-        "",
-        "Choices:",
-        `  App: ${plan.appName}`,
-        `  SDK: ${plan.sdk}`,
-        `  Sender: ${plan.sender}`,
-        `  Starter: ${plan.preset}`,
-        "",
-        `${nextCommandPrefix}:`,
+        t("scaffold.headline", {
+            verb,
+            target: plan.target,
+            dir: outputDir,
+        }),
+        "",
+        t("scaffold.choices"),
+        t("scaffold.choice.app", { value: plan.appName }),
+        t("scaffold.choice.sdk", { value: plan.sdk }),
+        t("scaffold.choice.sender", { value: plan.sender }),
+        t("scaffold.choice.starter", { value: plan.preset }),
+        "",
+        dryRun ? t("scaffold.wouldWrite") : t("scaffold.wrote"),
         ...written.map((file) => `  ${file}`),
         "",
-        "Next:",
-        `  1. ${installCommand(plan.packageManager)}`,
-        "  2. Set REMOTEDRAW_API_BASE_URL and REMOTEDRAW_API_KEY in backend secrets.",
-        "  3. Create an input request from backend code or run remotedraw create-input --json.",
-        "  4. Render the returned HTTPS joinUrl in your receiver UI.",
+        t("word.next"),
+        t("scaffold.next.install", { command: installCommand(plan.packageManager) }),
+        t("scaffold.next.secrets"),
+        t("scaffold.next.createInput"),
+        t("scaffold.next.render"),
     ].join("\n");
 }
 function scaffoldJsonResult(command, plan, outputDir, files, parsed, provisioning, offline, dryRun) {
@@ -2898,16 +3355,12 @@ function scaffoldJsonResult(command, plan, outputDir, files, parsed, provisionin
         .map(([field, , value]) => ({ field, value }));
     const warnings = [
         ...(plan.apiBaseUrl.includes("<deployment>")
-            ? ["Replace the deployment API placeholder before making live requests."]
+            ? [t("cloud.warning.placeholder")]
             : []),
         ...(offline
-            ? [
-                "Cloud provisioning was skipped; no dashboard project or API key was created.",
-            ]
+            ? [t("cloud.warning.offline")]
             : dryRun
-                ? [
-                    "Cloud authentication and provisioning were not executed during dry-run.",
-                ]
+                ? [t("cloud.warning.dryRun")]
                 : []),
     ];
     return {