@chainingintention/pi-web-cn 2.0.0 → 2.202610.1

package/dist/cli.js

@@ -1,20 +1,26 @@
 #!/usr/bin/env node
+import { loadNodeTranslator } from "./localization.js";
+import { runPiWebUpdate } from "./piWebUpdate.js";
+import { createTranslator } from "./shared/i18n.js";
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { homedir, userInfo } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { defaultPiWebConfigPath, defaultPiWebDataDir, effectivePiWebConfig, examplePiWebConfig } from "./config.js";
+import { defaultPiWebConfigPath, defaultPiWebDataDir, examplePiWebConfig } from "./config.js";
 import { piWebDockerCommand } from "./docker/piWebDockerCommandPlan.js";
+import { ownEnvironmentValue } from "./environment.js";
+import { PI_WEB_PI_PACKAGE_DIR_ENV } from "./piRuntime.js";
 import { runPluginRecoveryCli } from "./pluginRecoveryCli.js";
-import { packageVersion, printPiWebVersionReport, probeRunningComponentReady, runningComponentsReady } from "./piWebVersionReport.js";
+import { packageVersion, printPiWebVersionReport, probeRunningComponentReady, runningComponentsReady, } from "./piWebVersionReport.js";
 import { checkNodePtyDarwinSpawnHelper, formatNodePtyDarwinSpawnHelperCheck } from "./server/diagnostics/nodePtySpawnHelper.js";
 import { checkNodePtyNativeModule, formatNodePtyNativeModuleCheck } from "./server/diagnostics/nodePtyNativeModule.js";
-import { launchdBootoutArgs, launchdServiceTarget, orderServices, performServiceAction, serviceStartOrder, serviceStopOrder, settleLaunchdServiceUnload, startLaunchdService, } from "./nativeServices/serviceAction.js";
 import { installNativeServiceCandidate, nativeServiceInstallFailureNeedsPathAdvice, } from "./nativeServices/serviceInstall.js";
+import { launchdBootoutArgs, launchdServiceTarget, orderServices, performServiceAction, serviceStartOrder, serviceStopOrder, settleLaunchdServiceUnload, startLaunchdService, } from "./nativeServices/serviceAction.js";
 import { minimumSupportedNodeVersion, nativeServiceManagerRefs, productionNativeServiceIds, } from "./nativeServices/servicePlan.js";
-import { formatNativeServiceDoctorResult, inferInstalledNativeServiceMode, inspectInstalledDevelopmentServiceInput, inspectInstalledProductionServiceContext, runNativeServiceDoctor, } from "./nativeServices/serviceDoctor.js";
+import { inspectInstalledNativeServiceDefinitions, } from "./nativeServices/installedServiceDefinitions.js";
+import { formatNativeServiceDoctorResult, inferInstalledNativeServiceMode, inspectInstalledDevelopmentServiceInput, inspectInstalledProductionServiceContext, runNativeServiceDoctor, selectManagedNativeServiceConfig, } from "./nativeServices/serviceDoctor.js";
 import { createNativeServiceAuthoritativeProbe, nativeServicePrerequisiteShellCheck, } from "./nativeServices/serviceProbe.js";
 import { renderLaunchdPlist, renderSystemdUnit } from "./nativeServices/serviceRendering.js";
 const PI_WEB_PACKAGE_NAME = "@chainingintention/pi-web-cn";
@@ -46,25 +52,22 @@ export function serviceBackendForPlatform(platform) {
 function currentServiceBackend() {
     return serviceBackendForPlatform(process.platform);
 }
-function requireServiceBackend(command) {
+function requireServiceBackend(command, t = createTranslator("en", {})) {
     const backend = currentServiceBackend();
     if (backend !== undefined)
         return backend;
-    throw new Error(`\`${command}\` requires a supported per-user service manager (systemd user services or LaunchAgents) and is not supported on ${platformLabel()}.\n\n${manualRunAdvice()}`);
+    throw new Error(t("service.unsupported", "`{command}` requires a supported per-user service manager (systemd user services or LaunchAgents) and is not supported on {platform}.\n\n{advice}", { command, platform: platformLabel(), advice: manualRunAdvice(t) }));
 }
-function supportsSystemdUserServices() {
-    return currentServiceBackend()?.kind === "systemd";
-}
-function manualRunAdvice() {
+function manualRunAdvice(t = createTranslator("en", {})) {
     return [
-        "Run PI WEB manually from a checkout:",
+        t("manual.checkout", "Run PI WEB manually from a checkout:"),
         "  npm run start:sessiond",
         "  PI_WEB_PORT=8504 npm start",
         "",
-        "For development in one terminal:",
+        t("manual.singleTerminal", "For development in one terminal:"),
         "  npm run dev",
         "",
-        "For split development, keep sessiond separate and run web/API plus Vite UI separately:",
+        t("manual.split", "For split development, keep sessiond separate and run web/API plus Vite UI separately:"),
         "  npm run dev:sessiond",
         "  npm run dev:web",
         "  npm run dev:client",
@@ -86,6 +89,15 @@ function capture(command, args) {
     const stderr = outputText(result.stderr);
     return { status: result.status ?? 1, stdout: outputText(result.stdout), stderr: stderr === "" ? errorMessage : stderr };
 }
+function captureInstalledServiceDefinitionCommand(command, args) {
+    const result = spawnSync(command, args);
+    return {
+        status: result.status ?? 1,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        spawnError: result.error instanceof Error ? result.error.message : "",
+    };
+}
 function runQuiet(command, args) {
     return capture(command, args).status;
 }
@@ -105,7 +117,7 @@ function isLingerEnabled() {
         return false;
     return undefined;
 }
-function parseInstallOptions(args) {
+function parseInstallOptions(args, t = createTranslator("en", {})) {
     const options = { host: "127.0.0.1", port: "8504", mode: "production" };
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
@@ -114,7 +126,7 @@ function parseInstallOptions(args) {
         if (arg === "--host") {
             const value = args[i + 1];
             if (value === undefined)
-                throw new Error("--host requires a value");
+                throw new Error(t("install.hostRequired", "--host requires a value"));
             options.host = value;
             i += 1;
         }
@@ -124,7 +136,7 @@ function parseInstallOptions(args) {
         else if (arg === "--port") {
             const value = args[i + 1];
             if (value === undefined)
-                throw new Error("--port requires a value");
+                throw new Error(t("install.portRequired", "--port requires a value"));
             options.port = value;
             i += 1;
         }
@@ -134,7 +146,7 @@ function parseInstallOptions(args) {
         else if (arg === "--config") {
             const value = args[i + 1];
             if (value === undefined)
-                throw new Error("--config requires a value");
+                throw new Error(t("install.configRequired", "--config requires a value"));
             options.config = value;
             i += 1;
         }
@@ -148,7 +160,7 @@ function parseInstallOptions(args) {
             // Accepted for backwards-compatible readability; PI WEB chooses the native user service backend automatically.
         }
         else {
-            throw new Error(`Unknown install option: ${arg}`);
+            throw new Error(t("install.unknownOption", "Unknown install option: {arg}", { arg: arg }));
         }
     }
     return options;
@@ -204,8 +216,12 @@ function describeServiceShell() {
     }
     return shell.detectedExecutable === null ? shell.name : `${shell.name} (${shell.detectedExecutable})`;
 }
-function configEnvironment(options, configPath) {
-    return options.config === undefined ? {} : { PI_WEB_CONFIG: configPath };
+export function nativeServiceEnvironment(configPath, env = process.env) {
+    const environment = configPath === undefined ? {} : { PI_WEB_CONFIG: configPath };
+    const piPackageDir = ownEnvironmentValue(env, PI_WEB_PI_PACKAGE_DIR_ENV);
+    if (piPackageDir !== undefined && piPackageDir !== "")
+        environment[PI_WEB_PI_PACKAGE_DIR_ENV] = piPackageDir;
+    return environment;
 }
 function serviceRefList(ids) {
     return ids.map((id) => serviceRefs[id]);
@@ -225,14 +241,14 @@ function stopOrder(refs) {
 function devRootPath() {
     return resolve(process.cwd());
 }
-function validateDevCheckout(root) {
+function validateDevCheckout(root, t) {
     const packageJsonPath = join(root, "package.json");
     if (!existsSync(packageJsonPath)) {
-        throw new Error(`Development mode must be installed from a PI WEB checkout. Missing package.json: ${packageJsonPath}`);
+        throw new Error(t("install.checkoutMissing", "Development mode must be installed from a PI WEB checkout. Missing package.json: {path}", { path: packageJsonPath }));
     }
     const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
     if (!isRecord(parsed) || parsed["name"] !== PI_WEB_PACKAGE_NAME) {
-        throw new Error(`Development mode must be installed from a PI WEB checkout. ${packageJsonPath} is not ${PI_WEB_PACKAGE_NAME}.`);
+        throw new Error(t("install.checkoutWrong", "Development mode must be installed from a PI WEB checkout. {path} is not {packageName}.", { path: packageJsonPath, packageName: PI_WEB_PACKAGE_NAME }));
     }
 }
 function launchdLogPath(ref) {
@@ -291,15 +307,15 @@ function currentLaunchdServiceTarget(ref) {
 function launchdActionContext() {
     return { domain: launchdDomain(), plistPath: launchdPlistPath };
 }
-function serviceActionDeps(backend) {
+function serviceActionDeps(backend, probeEnvironment = process.env) {
     return {
         run: (command, args) => run(command, args),
         runQuiet,
-        sleep: (ms) => new Promise((resolvePromise) => {
-            setTimeout(resolvePromise, ms);
+        sleep: (ms) => new Promise((resolve) => {
+            setTimeout(resolve, ms);
         }),
         isServiceRunning: (ref) => runtimeStatus(backend, ref).health === "running",
-        isComponentReady: probeRunningComponentReady,
+        isComponentReady: (component) => probeRunningComponentReady(component, { configEnv: probeEnvironment }),
     };
 }
 async function installLaunchdServices(plan) {
@@ -316,8 +332,11 @@ async function installLaunchdServices(plan) {
         const plistPath = join(launchdServiceDir, service.manager.launchdPlistName);
         await writeFile(plistPath, renderLaunchdPlist(plan, service, logDir));
     }
+    // Settle each bootout before deciding bootstrap vs kickstart: acting on a
+    // label launchd is still asynchronously unloading races the teardown and can
+    // lose the service entirely (the same defect the restart path had).
     const context = launchdActionContext();
-    const deps = serviceActionDeps(plan.backend);
+    const deps = serviceActionDeps(plan.backend, { ...process.env, ...plan.services[0]?.environment });
     for (const service of plan.services) {
         const ref = serviceRefFromPlan(service.id, service.manager);
         await settleLaunchdServiceUnload(currentLaunchdServiceTarget(ref), deps);
@@ -352,12 +371,12 @@ async function uninstallNativeServices(backend) {
     else
         await uninstallLaunchdServices();
 }
-function serviceDisplayName(ref) {
+function serviceDisplayName(ref, t = createTranslator("en", {})) {
     if (ref.id === "sessiond")
-        return "session daemon";
+        return t("service.sessiond", "session daemon");
     if (ref.id === "uiDev")
-        return "UI/API dev server";
-    return "web server";
+        return t("service.uiDev", "UI/API dev server");
+    return t("service.web", "web server");
 }
 function statusServiceRefs(backend) {
     const ids = installedServiceIds(backend);
@@ -371,20 +390,20 @@ function statusServiceRefs(backend) {
         return productionServiceRefs();
     return serviceRefList(["sessiond"]);
 }
-function serviceInstallMode(backend) {
+function serviceInstallMode(backend, t) {
     const ids = installedServiceIds(backend);
     if (ids.size === 0)
-        return "not installed";
+        return t("service.notInstalled", "not installed");
     const hasSessiond = ids.has("sessiond");
     const hasWeb = ids.has("web");
     const hasUiDev = ids.has("uiDev");
     if (hasWeb && hasUiDev)
-        return "mixed";
+        return t("service.mixed", "mixed");
     if (hasUiDev)
-        return hasSessiond ? "development" : "development (incomplete)";
+        return hasSessiond ? t("service.development", "development") : t("service.developmentIncomplete", "development (incomplete)");
     if (hasWeb)
-        return hasSessiond ? "production" : "production (incomplete)";
-    return "partial";
+        return hasSessiond ? t("service.production", "production") : t("service.productionIncomplete", "production (incomplete)");
+    return t("service.partial", "partial");
 }
 function makeServiceRuntimeStatus(ref, health, detail, target, filePath, pid) {
     return {
@@ -451,25 +470,25 @@ function launchdRuntimeStatus(backend, ref) {
 function runtimeStatus(backend, ref) {
     return backend.kind === "systemd" ? systemdRuntimeStatus(backend, ref) : launchdRuntimeStatus(backend, ref);
 }
-function printServiceStatus(status) {
+function printServiceStatus(status, t = createTranslator("en", {})) {
     const icon = status.health === "running" ? "✓" : "✗";
     const pid = status.pid === undefined ? "" : `, pid ${status.pid}`;
-    console.log(`${icon} ${serviceDisplayName(status.ref)}: ${status.detail} (${status.target}${pid})`);
+    console.log(`${icon} ${serviceDisplayName(status.ref, t)}: ${status.detail} (${status.target}${pid})`);
     if (status.health === "not-installed")
-        console.log(`  missing service file: ${status.filePath}`);
+        console.log(t("status.missingFile", "  missing service file: {filePath}", { filePath: status.filePath }));
 }
-function printServiceStatusReport(backend) {
+function printServiceStatusReport(backend, t = createTranslator("en", {})) {
     const refs = statusServiceRefs(backend);
-    console.log(`PI WEB services: ${serviceInstallMode(backend)} (${backend.label})`);
+    console.log(t("status.services", "PI WEB services: {mode} ({backend})", { mode: serviceInstallMode(backend, t), backend: backend.label }));
     if (refs.length === 0) {
-        console.log("✗ no PI WEB service files found");
-        console.log("  Run `pi-web install` or `pi-web install --dev`.");
+        console.log(t("status.noServices", "✗ no PI WEB service files found"));
+        console.log(t("status.installAdvice", "  Run `pi-web install` or `pi-web install --dev`."));
         return false;
     }
     const statuses = refs.map((ref) => runtimeStatus(backend, ref));
     for (const status of statuses)
-        printServiceStatus(status);
-    console.log("\nUse `pi-web logs` for service logs.");
+        printServiceStatus(status, t);
+    console.log(t("status.logsAdvice", "\nUse `pi-web logs` for service logs."));
     return statuses.every((status) => status.health === "running");
 }
 function configuredServiceCommand(name) {
@@ -497,7 +516,7 @@ function productionNativeServicePlanInput(backend, shell, environment) {
 }
 function nativeServiceInstallCandidate(options, backend, configPath, devRoot) {
     const shell = detectServiceShell();
-    const environment = configEnvironment(options, configPath);
+    const environment = nativeServiceEnvironment(options.config === undefined ? undefined : configPath);
     if (options.mode === "production") {
         return {
             mode: "production",
@@ -516,17 +535,17 @@ function nativeServiceInstallCandidate(options, backend, configPath, devRoot) {
         },
     };
 }
-function printNativeServiceInstallFailure(failure) {
+function printNativeServiceInstallFailure(failure, t) {
     if (failure.kind === "plan-resolution") {
         for (const item of failure.failures) {
             if (item.kind === "probe-infrastructure") {
-                console.log(`✗ Service-manager probe infrastructure failure (${item.reason}): ${item.message}`);
+                console.log(t("install.probeFailure", "✗ Service-manager probe infrastructure failure ({reason}): {message}", { reason: item.reason, message: item.message }));
             }
             else if (item.kind === "entrypoint-inspection-failure") {
-                console.log(`✗ Could not inspect bundled ${item.serviceId} entrypoint ${item.entrypointPath}: ${item.message}`);
+                console.log(t("install.entrypointFailure", "✗ Could not inspect bundled {service} entrypoint {path}: {message}", { service: item.serviceId, path: item.entrypointPath, message: item.message }));
             }
             else {
-                console.log(`✗ ${item.namedCommand} is unavailable to the service manager, and bundled entrypoint ${item.bundledEntrypointPath} is missing.`);
+                console.log(t("install.commandMissing", "✗ {command} is unavailable to the service manager, and bundled entrypoint {path} is missing.", { command: item.namedCommand, path: item.bundledEntrypointPath }));
                 if (item.namedCommandFailure !== null)
                     console.log(`  ${item.namedCommandFailure}`);
             }
@@ -535,7 +554,7 @@ function printNativeServiceInstallFailure(failure) {
     }
     for (const item of failure.failures) {
         if (item.kind === "probe-infrastructure") {
-            console.log(`✗ Service-manager probe infrastructure failure (${item.reason}): ${item.message}`);
+            console.log(t("install.probeFailure", "✗ Service-manager probe infrastructure failure ({reason}): {message}", { reason: item.reason, message: item.message }));
         }
         else {
             console.log(`✗ ${item.prerequisite.description}`);
@@ -544,19 +563,19 @@ function printNativeServiceInstallFailure(failure) {
         }
     }
 }
-async function install(args) {
-    const backend = requireServiceBackend("pi-web install");
-    const options = parseInstallOptions(args);
+async function install(args, t = createTranslator("en", {})) {
+    const backend = requireServiceBackend("pi-web install", t);
+    const options = parseInstallOptions(args, t);
     const devRoot = options.mode === "dev" ? devRootPath() : undefined;
     if (devRoot !== undefined)
-        validateDevCheckout(devRoot);
+        validateDevCheckout(devRoot, t);
     const configPath = installConfigPath(options);
     const candidate = nativeServiceInstallCandidate(options, backend, configPath, devRoot);
-    console.log(`Running PI WEB ${options.mode} install preflight checks...`);
-    console.log(`Service backend: ${backend.label}`);
-    console.log(`Service shell: ${describeServiceShell()}`);
-    if (!printNodePtyNativeModuleCheck()) {
-        throw new Error("Install preflight checks failed without changing config or services. Fix the failure above, then run `pi-web doctor` for more detail.");
+    console.log(t("install.preflight", "Running PI WEB {mode} install preflight checks...", { mode: options.mode }));
+    console.log(t("service.backend", "Service backend: {label}", { label: backend.label }));
+    console.log(t("service.shell", "Service shell: {value}", { value: describeServiceShell() }));
+    if (!printNodePtyNativeModuleCheck(t)) {
+        throw new Error(t("install.preflightFailed", "Install preflight checks failed without changing config or services. Fix the failure above, then run `pi-web doctor` for more detail."));
     }
     const result = await installNativeServiceCandidate(candidate, {
         probe: createNativeServiceAuthoritativeProbe(),
@@ -565,53 +584,56 @@ async function install(args) {
         replaceServices: installNativeServices,
     });
     if (!result.ok) {
-        printNativeServiceInstallFailure(result.failure);
+        printNativeServiceInstallFailure(result.failure, t);
         if (nativeServiceInstallFailureNeedsPathAdvice(result.failure))
-            printPathSetupAdvice();
-        throw new Error("Install preflight checks failed without changing config or services. Fix the failure above, then run `pi-web doctor` for more detail.");
+            printPathSetupAdvice(undefined, t);
+        throw new Error(t("install.preflightFailed", "Install preflight checks failed without changing config or services. Fix the failure above, then run `pi-web doctor` for more detail."));
     }
     for (const service of result.plan.services.filter((item) => item.strategy.kind === "configured-override")) {
-        console.log(`! ${service.description} uses a configured command override; preflight did not execute that arbitrary command.`);
+        console.log(t("install.overrideSkipped", "! {service} uses a configured command override; preflight did not execute that arbitrary command.", { service: service.description }));
     }
-    console.log(`\nPI WEB ${options.mode} services are installed and starting.`);
-    console.log(`Config: ${configPath}`);
+    console.log(t("install.started", "\nPI WEB {mode} services are installed and starting.", { mode: options.mode }));
+    console.log(t("install.config", "Config: {configPath}", { configPath: configPath }));
     if (options.mode === "dev") {
-        console.log("Open: http://127.0.0.1:8505");
+        console.log(t("install.open", "Open: {url}", { url: "http://127.0.0.1:8505" }));
     }
     else {
-        console.log(`Open: http://${options.host === "0.0.0.0" ? "127.0.0.1" : options.host}:${options.port}`);
+        console.log(t("install.open", "Open: {url}", { url: `http://${options.host === "0.0.0.0" ? "127.0.0.1" : options.host}:${options.port}` }));
     }
     if (backend.kind === "systemd") {
         const linger = isLingerEnabled();
         if (linger === false) {
-            console.log("\nRecommended for server use: keep user services running after logout/reboot:");
+            console.log(t("install.lingerAdvice", "\nRecommended for server use: keep user services running after logout/reboot:"));
             console.log(`  sudo loginctl enable-linger ${userInfo().username}`);
         }
         else if (linger === undefined) {
-            console.log("\nRecommended for server use: enable systemd user lingering so services survive logout/reboot:");
+            console.log(t("install.enableLinger", "\nRecommended for server use: enable systemd user lingering so services survive logout/reboot:"));
             console.log(`  sudo loginctl enable-linger ${userInfo().username}`);
         }
     }
-    console.log("\nUseful commands:");
+    console.log(t("install.commands", "\nUseful commands:"));
     console.log("  pi-web status");
     console.log("  pi-web logs");
     console.log("  pi-web restart");
 }
-async function uninstall() {
-    const backend = requireServiceBackend("pi-web uninstall");
+async function uninstall(t = createTranslator("en", {})) {
+    const backend = requireServiceBackend("pi-web uninstall", t);
     await uninstallNativeServices(backend);
-    console.log(`PI WEB ${backend.label} removed. Production and development service files were removed; config and data were left in place.`);
+    console.log(t("uninstall.done", "PI WEB {label} removed. Production and development service files were removed; config and data were left in place.", { label: backend.label }));
 }
-async function serviceAction(action) {
+async function serviceAction(action, t = createTranslator("en", {})) {
     const backend = requireServiceBackend(`pi-web ${action}`);
     if (action === "status") {
-        if (!printServiceStatusReport(backend))
+        if (!printServiceStatusReport(backend, t))
             process.exitCode = 1;
         return;
     }
+    await performLifecycleServiceAction(backend, action, process.env);
+}
+async function performLifecycleServiceAction(backend, action, probeEnvironment) {
     const refs = installedServiceRefs(backend);
     const input = { backend, action, refs, launchdContext: launchdActionContext() };
-    const result = await performServiceAction(input, serviceActionDeps(backend));
+    const result = await performServiceAction(input, serviceActionDeps(backend, probeEnvironment));
     if (result.unreadyServices.length > 0) {
         for (const ref of result.unreadyServices) {
             const target = backend.kind === "systemd" ? ref.systemdName : currentLaunchdServiceTarget(ref);
@@ -633,9 +655,10 @@ export function sessionDaemonRestartPlan(options = {}) {
     const dockerMode = activeDockerMode(env);
     const runCommand = options.runCommand ?? ((command, args) => { run(command, args, { check: true }); });
     if (dockerMode !== undefined) {
+        const command = piWebDockerCommand(dockerMode, "restart-sessiond");
         return {
             kind: "automatic",
-            command: piWebDockerCommand(dockerMode, "restart-sessiond"),
+            command,
             guidance: "Run the Docker control command from the PI WEB Docker host.",
             perform: () => {
                 runCommand("pi-web-docker", [...(dockerMode === "dev" ? ["--dev"] : []), "restart-sessiond"]);
@@ -669,15 +692,17 @@ export function sessionDaemonRestartPlan(options = {}) {
     };
 }
 function activeDockerMode(env) {
-    if (!truthyEnvValue(env["PI_WEB_DOCKER_RUNTIME"]))
+    if (!truthyEnvValue(ownEnvironmentValue(env, "PI_WEB_DOCKER_RUNTIME")))
         return undefined;
-    return env["PI_WEB_DOCKER_MODE"] === "dev" ? "dev" : "runtime";
+    if (ownEnvironmentValue(env, "PI_WEB_DOCKER_MODE") === "dev")
+        return "dev";
+    return "runtime";
 }
 function truthyEnvValue(value) {
     return value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false";
 }
-function logs() {
-    const backend = requireServiceBackend("pi-web logs");
+function logs(t = createTranslator("en", {})) {
+    const backend = requireServiceBackend("pi-web logs", t);
     const refs = installedServiceRefs(backend);
     if (backend.kind === "systemd") {
         run("journalctl", ["--user", ...refs.flatMap((ref) => ["-u", ref.systemdName]), "-f"]);
@@ -708,16 +733,14 @@ export function nodeVersionCheck() {
         description: `node >= ${minimumSupportedNodeVersion}`,
     });
 }
-export function agentCommandForChecks(env = process.env) {
-    return effectivePiWebConfig({ env }).config.agent.command;
-}
-function generalDoctorChecks() {
+export function generalDoctorChecks() {
     const shell = serviceShellLabel();
-    const agentCommand = agentCommandForChecks();
     return [
         [`Caller login ${shell} can find node >= ${minimumSupportedNodeVersion}`, serviceShellCommand(nodeVersionCheck())],
         [`Caller login ${shell} can find npm`, serviceShellCommand(commandWithVersionCheck("npm"))],
-        [`Caller login ${shell} can find ${agentCommand}`, serviceShellCommand(commandWithVersionCheck(agentCommand))],
+        // Sessions run on the bundled pi SDK; the only CLI check is a hardcoded
+        // `pi` PATH probe — nothing names or locates a configurable command.
+        [`Caller login ${shell} can find pi`, serviceShellCommand(commandWithVersionCheck("pi"))],
     ];
 }
 function runChecks(checks) {
@@ -748,7 +771,7 @@ function optionalDoctorChecks() {
     const shell = serviceShellLabel();
     return [[`Caller login ${shell} can find optional ripgrep (rg)`, serviceShellCommand(commandCheck("rg"))]];
 }
-function printOptionalDoctorChecks() {
+function printOptionalDoctorChecks(t = createTranslator("en", {})) {
     let missingOptionalTool = false;
     for (const [label, command] of optionalDoctorChecks()) {
         const [bin, ...args] = command;
@@ -761,30 +784,145 @@ function printOptionalDoctorChecks() {
         printCheckOutput(result.stdout || result.stderr);
     }
     if (missingOptionalTool) {
-        console.log("  Install ripgrep, or make rg visible to the service shell, for faster all-file @ suggestions.");
-        console.log("  PI WEB falls back to a bounded filesystem scan when rg is unavailable.");
+        console.log(t("doctor.ripgrep", "  Install ripgrep, or make rg visible to the service shell, for faster all-file @ suggestions."));
+        console.log(t("doctor.scanFallback", "  PI WEB falls back to a bounded filesystem scan when rg is unavailable."));
     }
 }
-function installedServiceDefinitions(backend, ids) {
-    return ids.map((id) => ({
+function installedServiceDefinitions(backend, ids, purpose, warn = (message) => { console.warn(`! ${message}`); }) {
+    const sources = ids.map((id) => ({
         id,
-        contents: readFileSync(serviceFilePath(backend, serviceRefs[id]), "utf8"),
+        path: serviceFilePath(backend, serviceRefs[id]),
+        systemdName: serviceRefs[id].systemdName,
+        launchdTarget: currentLaunchdServiceTarget(serviceRefs[id]),
     }));
+    return inspectInstalledNativeServiceDefinitions(backend, sources, {
+        readFile: (path) => readFileSync(path),
+        realpath: realpathSync,
+        capture: captureInstalledServiceDefinitionCommand,
+        warn,
+    }, purpose);
+}
+/** Build an isolated probe environment without mutating the caller or process. */
+export function managedServiceProbeEnvironment(backend, definitions, callerEnvironment) {
+    const selection = selectManagedNativeServiceConfig(backend, definitions, ownEnvironmentValue(callerEnvironment, "PI_WEB_CONFIG"));
+    if (!selection.ok)
+        return selection;
+    if (selection.value.source === "installed") {
+        return {
+            ok: true,
+            value: { ...callerEnvironment, PI_WEB_CONFIG: selection.value.configPath },
+        };
+    }
+    if (selection.value.source === "default" && definitions.length > 0) {
+        // An own empty value preserves default resolution while masking any
+        // prototype-inherited PI_WEB_CONFIG from downstream environment lookups.
+        return { ok: true, value: { ...callerEnvironment, PI_WEB_CONFIG: "" } };
+    }
+    return { ok: true, value: callerEnvironment };
+}
+export function installedServiceProbeEnvironment(backend, ids, callerEnvironment, purpose, inspectDefinitions = installedServiceDefinitions) {
+    // The explicit caller override wins without requiring installed definitions
+    // to be readable or canonical.
+    const callerConfigPath = ownEnvironmentValue(callerEnvironment, "PI_WEB_CONFIG");
+    if (callerConfigPath !== undefined && callerConfigPath !== "") {
+        return { ok: true, value: callerEnvironment };
+    }
+    if (ids.size === 0)
+        return { ok: true, value: callerEnvironment };
+    const definitions = inspectDefinitions(backend, [...ids], purpose);
+    if (!definitions.ok)
+        return definitions;
+    return managedServiceProbeEnvironment(backend, definitions.value, callerEnvironment);
 }
-function nativeServiceDoctorTarget(backend) {
-    const ids = installedServiceIds(backend);
+function managedServiceProbeFailure(backend, message) {
+    return [
+        `Could not select managed PI_WEB_CONFIG from installed ${backend.label}: ${message}`,
+        "Repair the reported service-manager override or definition, then re-run `pi-web install` (or `pi-web install --dev`); a nonempty PI_WEB_CONFIG explicitly overrides managed config selection for this command.",
+    ].join("\n");
+}
+/**
+ * Dispatch commands whose probes may need managed config. The service-manager,
+ * definition, lifecycle, doctor, and version boundaries are injected so this
+ * exact orchestration can be tested without mutating live services or process
+ * environment.
+ */
+export async function runReadinessCliCommand(command, dependencies) {
+    if (command === "version") {
+        await dependencies.printVersion();
+        return;
+    }
+    const environment = dependencies.environment;
+    if (command === "start" || command === "restart") {
+        const backend = dependencies.requireBackend(`pi-web ${command}`);
+        const installedIds = dependencies.installedServiceIds(backend);
+        const probeEnvironment = installedServiceProbeEnvironment(backend, installedIds, environment, command, dependencies.inspectDefinitions);
+        if (!probeEnvironment.ok)
+            throw new Error(managedServiceProbeFailure(backend, probeEnvironment.message));
+        await dependencies.runLifecycle(backend, command, probeEnvironment.value);
+        return;
+    }
+    const backend = dependencies.currentBackend();
+    const installedIds = backend === undefined
+        ? new Set()
+        : dependencies.installedServiceIds(backend);
+    let versionReportOptions = { configEnv: environment };
+    let managedInspectionFailed = false;
+    if (backend !== undefined && activeDockerMode(environment) === undefined) {
+        const probeEnvironment = installedServiceProbeEnvironment(backend, installedIds, environment, "doctor", dependencies.inspectDefinitions);
+        if (probeEnvironment.ok) {
+            versionReportOptions = { configEnv: probeEnvironment.value };
+        }
+        else {
+            managedInspectionFailed = true;
+            versionReportOptions = { webEndpointError: managedServiceProbeFailure(backend, probeEnvironment.message) };
+        }
+    }
+    await dependencies.runDoctor({
+        backend,
+        installedIds,
+        environment,
+        versionReportOptions,
+        managedInspectionFailed,
+    });
+}
+export function parseVersionOptions(args, t = createTranslator("en", {})) {
+    if (args.length === 0)
+        return {};
+    if (args.length === 1 && args[0] === "--check")
+        return { check: true };
+    throw new Error(t("version.usage", "Usage: pi-web version [--check]"));
+}
+function readinessCliCommandDependencies(t = createTranslator("en", {}), versionOptions = {}) {
+    return {
+        environment: process.env,
+        currentBackend: currentServiceBackend,
+        requireBackend: requireServiceBackend,
+        installedServiceIds,
+        // Doctor inspects again when building its native-service checks. Report
+        // warnings there, including when an explicit config bypasses selection here.
+        inspectDefinitions: (backend, ids, purpose) => installedServiceDefinitions(backend, ids, purpose, purpose === "doctor" ? () => { } : undefined),
+        runLifecycle: performLifecycleServiceAction,
+        runDoctor: (context) => doctor(context, t),
+        printVersion: async () => {
+            const report = await printPiWebVersionReport({ ...versionOptions, translator: t });
+            if (report.release?.status === "error")
+                process.exitCode = 1;
+        },
+    };
+}
+function nativeServiceDoctorTarget(backend, ids, t = createTranslator("en", {})) {
     const mode = inferInstalledNativeServiceMode(ids);
     if (mode === "ambiguous") {
         return {
             kind: "inspection-failure",
-            message: `installed service IDs do not identify one mode (${[...ids].join(", ") || "none"}).`,
+            message: t("doctor.ambiguousMode", "installed service IDs do not identify one mode ({ids}).", { ids: [...ids].join(", ") || "none" }),
         };
     }
     if (mode === "none") {
         return {
             kind: "prospective-production",
             input: productionNativeServicePlanInput(backend, detectServiceShell(), {}),
-            reason: "no installed service strategy is available",
+            reason: t("doctor.noStrategy", "no installed service strategy is available"),
         };
     }
     const expectedIds = mode === "production"
@@ -794,46 +932,39 @@ function nativeServiceDoctorTarget(backend) {
     if (missingId !== undefined) {
         return {
             kind: "inspection-failure",
-            message: `installed ${mode} service set is incomplete; ${missingId} is missing.`,
-        };
-    }
-    let definitions;
-    try {
-        definitions = installedServiceDefinitions(backend, expectedIds);
-    }
-    catch (error) {
-        return {
-            kind: "inspection-failure",
-            message: error instanceof Error ? error.message : String(error),
+            message: t("doctor.incompleteSet", "installed {mode} service set is incomplete; {service} is missing.", { mode, service: missingId }),
         };
     }
+    const definitions = installedServiceDefinitions(backend, expectedIds, "doctor");
+    if (!definitions.ok)
+        return { kind: "inspection-failure", message: definitions.message };
     if (mode === "development") {
-        const inspection = inspectInstalledDevelopmentServiceInput(backend, definitions);
+        const inspection = inspectInstalledDevelopmentServiceInput(backend, definitions.value);
         return inspection.ok
             ? { kind: "installed-development", input: inspection.value }
             : { kind: "inspection-failure", message: inspection.message };
     }
-    const inspection = inspectInstalledProductionServiceContext(backend, definitions);
+    const inspection = inspectInstalledProductionServiceContext(backend, definitions.value);
     return inspection.ok
         ? {
             kind: "prospective-production",
             input: productionNativeServicePlanInput(backend, inspection.value.shell, inspection.value.environment),
-            reason: "installed executable strategy is not recorded",
+            reason: t("doctor.unrecordedStrategy", "installed executable strategy is not recorded"),
         }
         : { kind: "inspection-failure", message: inspection.message };
 }
-async function printNativeServiceDoctorChecks(backend) {
-    const result = await runNativeServiceDoctor(nativeServiceDoctorTarget(backend), {
+async function printNativeServiceDoctorChecks(backend, installedIds, t = createTranslator("en", {})) {
+    const result = await runNativeServiceDoctor(nativeServiceDoctorTarget(backend, installedIds, t), {
         probe: createNativeServiceAuthoritativeProbe(),
         fileExists: regularFileExists,
     });
-    const report = formatNativeServiceDoctorResult(result);
+    const report = formatNativeServiceDoctorResult(result, t);
     for (const line of report.lines)
         console.log(line);
-    printCallerContextComparisons(report);
+    printCallerContextComparisons(report, t);
     return report;
 }
-function printCallerContextComparisons(report) {
+function printCallerContextComparisons(report, t) {
     if (report.plan === null || report.failedPrerequisites.length === 0)
         return;
     const seen = new Set();
@@ -844,7 +975,11 @@ function printCallerContextComparisons(report) {
         const service = report.plan.services.find((candidate) => candidate.prerequisites.some((item) => item.id === prerequisite.id));
         const command = nativeServicePrerequisiteShellCheck(report.plan.shell.name, prerequisite);
         const result = captureServiceShell(report.plan.shell, command, service?.workingDirectory ?? null);
-        console.log(`  Caller-invoked ${report.plan.shell.name} -lc ${result.status === 0 ? "satisfies" : "also does not satisfy"} ${prerequisite.description}; the service-manager result is authoritative.`);
+        console.log(t("doctor.callerComparison", "  Caller-invoked {shell} -lc {outcome} {requirement}; the service-manager result is authoritative.", {
+            shell: report.plan.shell.name,
+            outcome: result.status === 0 ? t("doctor.satisfies", "satisfies") : t("doctor.unsatisfied", "also does not satisfy"),
+            requirement: prerequisite.description,
+        }));
     }
 }
 function captureServiceShell(shell, command, workingDirectory) {
@@ -856,25 +991,31 @@ function captureServiceShell(shell, command, workingDirectory) {
 function shellQuoteFor(shell, value) {
     return shell === "fish" ? fishSingleQuote(value) : shellSingleQuote(value);
 }
-function printPathSetupAdvice(shell = detectServiceShell()) {
-    console.log("\nPATH setup advice:");
+function printPathSetupAdvice(shell = detectServiceShell(), t = createTranslator("en", {})) {
+    console.log(t("doctor.pathAdvice", "\nPATH setup advice:"));
     if (shell.name === "bash") {
-        console.log("  Detected bash. Put PATH setup for node/version managers/tools in ~/.bash_profile or ~/.profile.");
-        console.log("  If ~/.bash_profile exists, bash will not read ~/.profile unless you source it from ~/.bash_profile.");
-        console.log("  Do not rely only on ~/.bashrc or prompt hooks for tools needed by services or agents.");
+        console.log(t("doctor.bashPath", "  Detected bash. Put PATH setup for node/version managers/tools in ~/.bash_profile or ~/.profile."));
+        console.log(t("doctor.bashProfile", "  If ~/.bash_profile exists, bash will not read ~/.profile unless you source it from ~/.bash_profile."));
+        console.log(t("doctor.bashHooks", "  Do not rely only on ~/.bashrc or prompt hooks for tools needed by services or agents."));
     }
     else if (shell.name === "zsh") {
-        console.log("  Detected zsh. Put PATH setup for node/version managers/tools in ~/.zprofile, not only ~/.zshrc.");
-        console.log("  Avoid relying on prompt hooks; PI WEB services run non-interactive login shells.");
+        console.log(t("doctor.zshPath", "  Detected zsh. Put PATH setup for node/version managers/tools in ~/.zprofile, not only ~/.zshrc."));
+        console.log(t("doctor.promptHooks", "  Avoid relying on prompt hooks; PI WEB services run non-interactive login shells."));
     }
     else {
-        console.log("  Detected fish. Prefer universal PATH setup such as `fish_add_path -U ...` for tools needed by services or agents.");
-        console.log("  Avoid relying on prompt hooks; PI WEB services run non-interactive login shells.");
+        console.log(t("doctor.fishPath", "  Detected fish. Prefer universal PATH setup such as `fish_add_path -U ...` for tools needed by services or agents."));
+        console.log(t("doctor.promptHooks", "  Avoid relying on prompt hooks; PI WEB services run non-interactive login shells."));
     }
 }
-export function doctorExitCode(generalReadinessOk, nativeServicePlanOk, nodePtyRuntimeOk, runningComponentsOk) {
-    return generalReadinessOk && nativeServicePlanOk && nodePtyRuntimeOk && runningComponentsOk ? 0 : 1;
-}
+/**
+ * Running components an installed deployment must keep ready: the API-serving
+ * component whenever the web or UI dev service file is installed (the version
+ * endpoint probes the API port in both modes), and the session daemon whenever
+ * its service file is installed. Docker deployments have no native service
+ * files, so the Docker runtime marker expects both components. A machine with
+ * nothing installed expects nothing: doctor's manual-run guidance stays a
+ * passing outcome there.
+ */
 export function expectedRunningComponents(installedServices, env) {
     if (activeDockerMode(env) !== undefined)
         return ["web", "sessiond"];
@@ -885,76 +1026,85 @@ export function expectedRunningComponents(installedServices, env) {
         expected.push("sessiond");
     return expected;
 }
-async function doctor() {
-    const backend = currentServiceBackend();
+export function doctorExitCode(generalReadinessOk, nativeServicePlanOk, nodePtyRuntimeOk, runningComponentsOk) {
+    return generalReadinessOk && nativeServicePlanOk && nodePtyRuntimeOk && runningComponentsOk ? 0 : 1;
+}
+async function doctor(context, t = createTranslator("en", {})) {
+    const { backend, installedIds, environment, versionReportOptions, managedInspectionFailed } = context;
     console.log(`Platform: ${platformLabel()}`);
     console.log(`Service backend: ${backend?.label ?? "manual run only"}`);
     console.log(`Service shell: ${describeServiceShell()}`);
     if (backend === undefined) {
-        console.log(`- Native user service plan checks skipped on ${platformLabel()}; no native-service drift is reported.`);
+        console.log(t("doctor.nativeSkipped", "- Native user service plan checks skipped on {value}; no native-service drift is reported.", { value: platformLabel() }));
     }
     console.log("");
-    const runningVersionInfo = await printPiWebVersionReport();
-    const expectedComponents = expectedRunningComponents(backend === undefined ? new Set() : installedServiceIds(backend), process.env);
+    const runningVersionInfo = await printPiWebVersionReport(versionReportOptions);
+    const expectedComponents = expectedRunningComponents(installedIds, environment);
     const runningComponentsOk = runningComponentsReady(runningVersionInfo, expectedComponents);
     if (!runningComponentsOk) {
         console.log("\n✗ Installed PI WEB services are unavailable or stale (see \"Running services\" above).");
         console.log("  Run `pi-web restart`, then check `pi-web status`.");
     }
-    console.log("\nGeneral login-shell readiness (separate from native-service requirements):");
+    console.log(t("doctor.loginShell", "\nGeneral login-shell readiness (separate from native-service requirements):"));
     const generalReadinessOk = runChecks(generalDoctorChecks());
-    printOptionalDoctorChecks();
-    console.log("\nNative terminal runtime readiness:");
-    const nodePtyNativeModuleOk = printNodePtyNativeModuleCheck();
-    const nodePtySpawnHelperOk = nodePtyNativeModuleOk ? printNodePtyDarwinSpawnHelperCheck() : true;
+    printOptionalDoctorChecks(t);
+    console.log(t("doctor.terminal", "\nNative terminal runtime readiness:"));
+    const nodePtyNativeModuleOk = printNodePtyNativeModuleCheck(t);
+    const nodePtySpawnHelperOk = nodePtyNativeModuleOk ? printNodePtyDarwinSpawnHelperCheck(t) : true;
     let nativeServiceReport = null;
     if (backend !== undefined) {
         console.log("\nNative service plan checks (service-manager context):");
-        nativeServiceReport = await printNativeServiceDoctorChecks(backend);
+        if (managedInspectionFailed) {
+            console.log("✗ Installed native-service plan could not be inspected consistently with the readiness probe (see \"Running services\" above).");
+            console.log("  Repair the reported service-manager definition before relying on doctor results.");
+        }
+        else {
+            nativeServiceReport = await printNativeServiceDoctorChecks(backend, installedIds, t);
+        }
     }
-    if (supportsSystemdUserServices()) {
+    if (backend?.kind === "systemd") {
         const linger = isLingerEnabled();
         if (linger === true) {
-            console.log("✓ systemd user lingering enabled");
+            console.log(t("doctor.lingerEnabled", "✓ systemd user lingering enabled"));
         }
         else if (linger === false) {
-            console.log("✗ systemd user lingering disabled");
-            console.log(`  Recommended on servers: sudo loginctl enable-linger ${userInfo().username}`);
+            console.log(t("doctor.lingerDisabled", "✗ systemd user lingering disabled"));
+            console.log(t("doctor.lingerCommand", "  Recommended on servers: sudo loginctl enable-linger {username}", { username: userInfo().username }));
         }
         else {
-            console.log("? systemd user lingering unknown");
-            console.log(`  Recommended on servers: sudo loginctl enable-linger ${userInfo().username}`);
+            console.log(t("doctor.lingerUnknown", "? systemd user lingering unknown"));
+            console.log(t("doctor.lingerCommand", "  Recommended on servers: sudo loginctl enable-linger {username}", { username: userInfo().username }));
         }
     }
     else if (backend?.kind === "launchd") {
-        console.log("- user services start at login with LaunchAgents");
+        console.log(t("doctor.launchAgents", "- user services start at login with LaunchAgents"));
     }
     else {
-        console.log(`- systemd user lingering skipped on ${platformLabel()}`);
+        console.log(t("doctor.lingerSkipped", "- systemd user lingering skipped on {value}", { value: platformLabel() }));
     }
-    const nativeServicePlanOk = nativeServiceReport?.ok ?? true;
+    const nativeServicePlanOk = !managedInspectionFailed && (nativeServiceReport?.ok ?? true);
     const pathFailure = !generalReadinessOk || nativeServiceReport?.pathAdviceRecommended === true;
     if (pathFailure) {
-        console.log("\nIf a command works in your terminal but fails in the service-manager check, compare the caller and manager contexts above.");
+        console.log(t("doctor.compareContexts", "\nIf a command works in your terminal but fails in the service-manager check, compare the caller and manager contexts above."));
         const adviceShell = nativeServiceReport?.pathAdviceRecommended === true && nativeServiceReport.adviceShell !== null
             ? nativeServiceReport.adviceShell
             : detectServiceShell();
-        printPathSetupAdvice(adviceShell);
+        printPathSetupAdvice(adviceShell, t);
     }
     if (generalReadinessOk && backend === undefined) {
-        console.log(`\n${manualRunAdvice()}`);
+        console.log(`\n${manualRunAdvice(t)}`);
     }
     if (doctorExitCode(generalReadinessOk, nativeServicePlanOk, nodePtyNativeModuleOk && nodePtySpawnHelperOk, runningComponentsOk) !== 0)
         process.exitCode = 1;
 }
-function printNodePtyNativeModuleCheck() {
-    const result = formatNodePtyNativeModuleCheck(checkNodePtyNativeModule());
+function printNodePtyNativeModuleCheck(t) {
+    const result = formatNodePtyNativeModuleCheck(checkNodePtyNativeModule(), t);
     for (const line of result.lines)
         console.log(line);
     return result.ok;
 }
-function printNodePtyDarwinSpawnHelperCheck() {
-    const result = formatNodePtyDarwinSpawnHelperCheck(checkNodePtyDarwinSpawnHelper());
+function printNodePtyDarwinSpawnHelperCheck(t) {
+    const result = formatNodePtyDarwinSpawnHelperCheck(checkNodePtyDarwinSpawnHelper(), t);
     for (const line of result.lines)
         console.log(line);
     return result.ok;
@@ -962,8 +1112,8 @@ function printNodePtyDarwinSpawnHelperCheck() {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function help() {
-    console.log(`PI WEB
+export function cliHelp(t) {
+    return t("help", `PI WEB
 
 Usage:
   pi-web install [--dev] [--host 127.0.0.1] [--port 8504] [--config ~/.config/pi-web/config.json]
@@ -973,7 +1123,8 @@ Usage:
   pi-web plugins safe-start show|clear|set <bundled-only|none> [--config <path>] [--restart]
   pi-web audit <command> [options]
   pi-web doctor
-  pi-web version
+  pi-web update [--yes] [--force]
+  pi-web version [--check]
 
 Audit commands:
   pi-web audit list|stats|export|prune|vacuum
@@ -987,31 +1138,37 @@ Development service install from a checkout:
 `);
 }
 async function main() {
+    const t = loadNodeTranslator("cli");
     const [command = "help", ...args] = process.argv.slice(2);
     if (command === "install")
-        await install(args);
+        await install(args, t);
     else if (command === "uninstall")
-        await uninstall();
-    else if (command === "start" || command === "stop" || command === "restart" || command === "status")
-        await serviceAction(command);
+        await uninstall(t);
+    else if (command === "update")
+        await runPiWebUpdate(args);
+    else if (command === "start" || command === "restart" || command === "doctor" || command === "version") {
+        await runReadinessCliCommand(command, readinessCliCommandDependencies(t, command === "version" ? parseVersionOptions(args, t) : {}));
+    }
+    else if (command === "stop" || command === "status")
+        await serviceAction(command, t);
     else if (command === "logs")
-        logs();
+        logs(t);
+    else if (command === "workspaces") {
+        const { runWorkspaceNotificationCli } = await import("./workspaceNotificationCli.js");
+        await runWorkspaceNotificationCli(args);
+    }
     else if (command === "audit") {
         const { runNormalToolAuditCommand } = await import("./server/audit/normalToolAuditCli.js");
         runNormalToolAuditCommand(args);
     }
     else if (command === "plugins")
-        runPluginRecoveryCli(args, { restartPlan: (context) => sessionDaemonRestartPlan(context) });
-    else if (command === "doctor")
-        await doctor();
-    else if (command === "version")
-        await printPiWebVersionReport();
+        runPluginRecoveryCli(args, { restartPlan: (context) => sessionDaemonRestartPlan(context) }, t);
     else if (command === "--version" || command === "-v")
         console.log(packageVersion());
     else if (command === "help" || command === "--help" || command === "-h")
-        help();
+        console.log(cliHelp(t));
     else
-        throw new Error(`Unknown command: ${command}`);
+        throw new Error(t("cli.unknownCommand", "Unknown command: {command}", { command: command }));
 }
 export function isCliEntrypoint(entrypoint = process.argv[1], modulePath = fileURLToPath(import.meta.url)) {
     if (entrypoint === undefined)