@chainingintention/pi-web-cn 1.202610.1 → 1.202610.2

package/README.md

@@ -1,49 +1,41 @@
 # PI WEB
 
-This fork is a translation plan for PI WEB. Its goal is to translate the plugin's displayed content into Chinese while preserving the upstream functionality.
+PI WEB 的中文本地化分支，保留上游功能，并将核心界面与内置插件的显示内容本地化为中文。
 
-[![CI](https://github.com/jmfederico/pi-web/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/jmfederico/pi-web/actions/workflows/ci.yml)
+[![CI](https://github.com/nayuto-wakusei/pi-web-ChineseTranslation/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/nayuto-wakusei/pi-web-ChineseTranslation/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/%40chainingintention%2Fpi-web-cn)](https://www.npmjs.com/package/@chainingintention/pi-web-cn)
 [![Node.js](https://img.shields.io/node/v/%40chainingintention%2Fpi-web-cn)](package.json)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-**PI WEB is a web UI for [Pi Coding Agent](https://github.com/earendil-works/pi/tree/main/packages/coding-agent) that keeps agent sessions running in real workspaces on your machine or server.**
+**PI WEB 是 [Pi Coding Agent](https://github.com/earendil-works/pi/tree/main/packages/coding-agent) 的 Web 界面，让代理会话持续运行在机器或服务器的真实工作区中。**
 
-The bundled runtime requires Pi `0.84.x` compatible packages. The session daemon owns its `PI_WEB_DATA_DIR`; use a separate data directory and session endpoint for each concurrently running instance.
+内置运行时支持已测试的 Pi `0.86.1` 或 `0.87.0`。每个会话守护进程独占 `PI_WEB_DATA_DIR`，并发实例必须使用独立数据目录和 daemon endpoint。
 
-Run agents where your code, tools, credentials, and build caches live. Supervise them from any browser.
+让代理在代码、工具、凭据和构建缓存所在的机器工作，从任何浏览器监督。
 
-Website and docs: <https://pi-web.dev/>
+上游网站与文档：<https://pi-web.dev/>。本分支的包名、项目认证与管理隔离等差异以仓库中的[配置参考](docs/config.md)和[插件指南](docs/plugins.md)为准。
 
 ![PI WEB](docs/assets/pi-web-banner.png)
+![PI WEB 桌面截图](docs/assets/pi-web-desktop.png)
 
-![PI WEB desktop screenshot](docs/assets/pi-web-desktop.png)
+## 为什么使用 PI WEB？
 
-## Why PI WEB?
+持久的工作环境适合代理开发。PI WEB 可以：
 
-Agentic development works better when the work environment is persistent.
+- 浏览器断开后继续运行代理会话；
+- 在真实仓库与 Git 工作树中工作；
+- 并行监督多个会话；
+- 在电脑、手机和平板间切换；
+- 使用服务器、工作站或远端开发机运行代理；
+- 从一个界面管理项目、工作区、文件、终端、会话及远端机器。
 
-PI WEB lets you:
+浏览器负责监督，工作留在能够持续运行的机器。
 
-- keep Pi Coding Agent sessions alive after browser disconnects;
-- run agents inside real repositories and git worktrees;
-- supervise multiple sessions in parallel;
-- switch between laptop, phone, tablet, and desktop;
-- use a server, workstation, or remote dev box as your agent runtime;
-- manage projects, workspaces, files, terminals, sessions, and remote machines from one web UI.
+## 快速开始
 
-Your browser is the control surface. The work stays where it can keep running.
+需要 Node.js 22.19.0 或更新版本、npm、为当前用户配置的 Pi Coding Agent `0.86.1` 或 `0.87.0`，以及 Git 和项目所需开发工具。
 
-## Quick start
-
-Requirements:
-
-- Node.js 22.19.0 or newer
-- npm
-- Pi Coding Agent `>=0.82.1 <0.83`, configured for your user
-- git and the development tools your agents need
-
-Install and start PI WEB as per-user services:
+安装并启动用户服务：
 
 ```bash
 npm install -g @chainingintention/pi-web-cn --allow-scripts=node-pty
@@ -51,15 +43,15 @@ pi-web install
 pi-web doctor
 ```
 
-On npm 12, the scoped flag lets `node-pty` prepare its required native module without enabling install scripts for other dependencies.
+npm 12 的限定开关只允许 node-pty 准备所需原生模块，不为其他依赖开启安装脚本。
 
-Then open:
+打开：
 
 ```text
 http://127.0.0.1:8504
 ```
 
-Useful commands:
+常用命令：
 
 ```bash
 pi-web status
@@ -70,120 +62,82 @@ pi-web version
 pi-web uninstall
 ```
 
-<!-- Keep README guidance concise. Put install variants, troubleshooting,
-configuration, and operational details in docs/, then link from here. -->
+安装变体、Pi 包安装、WSL/手动启动与远端访问见[安装指南](https://pi-web.dev/install)。
 
-For more install options, including one-line install, Pi package install, WSL/manual usage, and remote access, see the [installation guide](https://pi-web.dev/install).
-
-## Core model
-
-PI WEB organizes work like this:
+## 核心模型
 
 ```text
-Machine     a local or remote PI WEB runtime endpoint
-Project     a folder on that machine
-Workspace   a git worktree, or the project folder for non-git projects
-Session     a Pi Coding Agent chat running inside a workspace
+Machine     本地或远端 PI WEB 运行时
+Project     该机器上的项目目录
+Workspace   提供器拥有的工作目录；内置 Git 发现工作树，无提供器时使用项目目录
+Session     工作区中运行的 Pi Coding Agent 对话
 ```
 
-A typical flow:
-
-1. Add a project.
-2. Choose a workspace or git worktree.
-3. Start a session.
-4. Let the agent work.
-5. Come back later from any browser.
-
-## Remote-first development
-
-PI WEB is designed for remote AI-driven development.
-
-Instead of tying agent work to your laptop session, run PI WEB on a machine that stays available: a server, desktop, cloud VM, home lab machine, or remote dev box.
-
-Use a private network, SSH tunnel, trusted reverse proxy, or federated PI WEB machine setup when accessing it remotely.
-
-Read more: [Remote-first development](https://pi-web.dev/remote-first)
-
-## Machines and fleets
+典型流程：添加项目 → 选择工作区 → 启动会话 → 让代理工作 → 稍后从任何浏览器返回。
 
-PI WEB can register other PI WEB runtimes as remote machines. One browser-facing PI WEB instance can proxy projects, files, git state, sessions, terminals, activity, Pi package management, and selected-machine settings from trusted remote machines.
+## 远端优先
 
-When a remote machine is selected, Settings tabs label their target. Pi packages, PI WEB plugin enablement, session daemon toggles, external file access, and upload defaults target the selected machine. Gateway/server settings such as host, port, allowed hosts, registered machines/tokens, and keyboard shortcuts stay local to the gateway/browser.
+让代理运行在保持在线的服务器、桌面机、云主机、家用实验室或远端开发机，不依赖笔记本浏览器会话。远端连接使用私有网络、SSH 隧道、可信反向代理或 PI WEB 机器联邦。
 
-Read more: [Fleet and machines guide](https://pi-web.dev/machines)
+详见[远端优先开发](https://pi-web.dev/remote-first)。
 
-## PI WEB plugins
+## 机器与联邦
 
-PI WEB supports trusted browser-side plugins that can add actions, workspace panels, and workspace metadata. Use **Settings → PI WEB plugins** to enable or disable them on the selected machine.
+一个浏览器网关可代理可信远端机器的项目、工作区、文件、Git、会话、终端、活动、Pi 包与设置。设置页标明目标机器：包、插件、daemon 能力、文件访问和上传默认值针对所选机器；网关监听地址/端口/允许主机、机器注册/令牌和快捷键仍在网关。
 
-Pi packages are a separate Pi package-manager concept. A Pi package may include a PI WEB browser plugin, but installing a package and enabling its browser plugin are different operations.
+详见[机器指南](https://pi-web.dev/machines)。
 
-Read more: [PI WEB plugin guide and API](https://pi-web.dev/plugins)
+## PI WEB 插件
 
-## Configuration
+可信插件可提供面板、工具和工作区工作流，从 **设置 → PI WEB 插件** 管理所选机器的启用状态。Pi 包的安装与插件启用是独立操作。服务端插件变更需手动重启会话守护进程，再刷新浏览器；仅 Web 重启或 `/reload` 不会激活。
 
-Global config lives at:
+详见[插件指南](docs/plugins.md)。
 
-```text
-$PI_WEB_CONFIG
-~/.config/pi-web/config.json
-```
-
-Project-local PI WEB config lives at:
-
-```text
-<project>/.pi-web/config.json
-```
+## 配置
 
-Common configuration includes host/port, path access, uploads, PI WEB plugin enablement, shortcuts, and session daemon options. In Settings, machine-affecting config targets the selected machine; gateway host/port/allowed-hosts, remote machine registration, tokens, and keyboard shortcuts stay local.
+机器配置在 `$PI_WEB_CONFIG` 或 `~/.config/pi-web/config.json`，项目配置在 `<project>/.pi-web/config.json`。包括网络、路径访问、上传/附件、插件、快捷键和会话工具。普通模型认证与默认值按项目托管，管理嵌入独立，详见[配置参考](docs/config.md)。
 
-Read more: [Configuration reference](https://pi-web.dev/config)
+## 开发
 
-## Development
-
-Clone the repository and run:
+克隆仓库后：
 
 ```bash
 npm install
 npm run dev
 ```
 
-Open the Vite URL, usually:
-
-```text
-http://localhost:8505
-```
-
-For the split development setup:
+打开 Vite URL，通常为 `http://localhost:8505`。拆分开发启动使用三个独立终端，先启动 Web：
 
 ```bash
-npm run dev:sessiond
 npm run dev:web
+npm run start:sessiond
 npm run dev:client
 ```
 
-Validate changes with:
+daemon 等待 Web 拥有的插件构建就绪，不自动重载。构建/重启顺序见[服务启动说明](https://pi-web.dev/install#manage-services)。
+
+验证改动：
 
 ```bash
 npm run verify
 ```
 
-## Security model
+交付构建与产物检查见[开发检查](docs/development-checks.md)。
 
-PI WEB assumes trusted users, trusted repositories, and trusted server paths.
+## 安全模型
 
-It is not a sandbox, permission system, or multi-tenant platform. Do not expose it directly to the public internet without a trusted network, firewall, VPN, SSH tunnel, or authenticated reverse proxy.
+普通模式假定用户、仓库与服务器路径可信，不是多租户平台或代理沙箱。不要在没有可信网络、防火墙、VPN、SSH 隧道或认证代理时直接暴露到公网。管理嵌入使用独立授权资源、受控工具、沙箱与审计，不与普通模式共享权限。
 
-## Documentation
+## 文档
 
-- [Website](https://pi-web.dev/)
-- [Install](https://pi-web.dev/install)
-- [Remote-first development](https://pi-web.dev/remote-first)
-- [Machines / fleet](https://pi-web.dev/machines)
-- [Configuration](https://pi-web.dev/config)
-- [Plugins](https://pi-web.dev/plugins)
-- [FAQ](https://pi-web.dev/faq)
+- [上游网站](https://pi-web.dev/)
+- [安装](https://pi-web.dev/install)
+- [远端优先](https://pi-web.dev/remote-first)
+- [机器](https://pi-web.dev/machines)
+- [配置](docs/config.md)
+- [插件](docs/plugins.md)
+- [常见问题](https://pi-web.dev/faq)
 
-## License
+## 许可
 
-MIT © 2026 Federico Jaramillo Martinez. See [LICENSE](LICENSE).
+MIT © 2026 Federico Jaramillo Martinez，见 [LICENSE](LICENSE)。

package/dist/.plugins-ready

@@ -0,0 +1 @@
+ready

package/dist/cli.js

@@ -5,19 +5,20 @@ 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 { 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";
-import { inspectInstalledNativeServiceDefinitions, } from "./nativeServices/installedServiceDefinitions.js";
 const PI_WEB_PACKAGE_NAME = "@chainingintention/pi-web-cn";
 const systemdServiceDir = join(homedir(), ".config", "systemd", "user");
 const launchdServiceDir = join(homedir(), "Library", "LaunchAgents");
@@ -53,9 +54,6 @@ function requireServiceBackend(command) {
         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()}`);
 }
-function supportsSystemdUserServices() {
-    return currentServiceBackend()?.kind === "systemd";
-}
 function manualRunAdvice() {
     return [
         "Run PI WEB manually from a checkout:",
@@ -301,15 +299,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) {
@@ -326,8 +324,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);
@@ -619,9 +620,12 @@ async function serviceAction(action) {
             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);
@@ -643,9 +647,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"]);
@@ -679,9 +684,11 @@ 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";
@@ -718,16 +725,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) {
@@ -775,7 +780,7 @@ function printOptionalDoctorChecks() {
         console.log("  PI WEB falls back to a bounded filesystem scan when rg is unavailable.");
     }
 }
-function installedServiceDefinitions(backend, ids) {
+function installedServiceDefinitions(backend, ids, purpose, warn = (message) => { console.warn(`! ${message}`); }) {
     const sources = ids.map((id) => ({
         id,
         path: serviceFilePath(backend, serviceRefs[id]),
@@ -786,10 +791,107 @@ function installedServiceDefinitions(backend, ids) {
         readFile: (path) => readFileSync(path),
         realpath: realpathSync,
         capture: captureInstalledServiceDefinitionCommand,
-    }, "doctor");
+        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,
+    });
+}
+function readinessCliCommandDependencies() {
+    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: doctor,
+        printVersion: async () => { await printPiWebVersionReport(); },
+    };
+}
+function nativeServiceDoctorTarget(backend, ids) {
     const mode = inferInstalledNativeServiceMode(ids);
     if (mode === "ambiguous") {
         return {
@@ -814,7 +916,7 @@ function nativeServiceDoctorTarget(backend) {
             message: `installed ${mode} service set is incomplete; ${missingId} is missing.`,
         };
     }
-    const definitions = installedServiceDefinitions(backend, expectedIds);
+    const definitions = installedServiceDefinitions(backend, expectedIds, "doctor");
     if (!definitions.ok)
         return { kind: "inspection-failure", message: definitions.message };
     if (mode === "development") {
@@ -832,8 +934,8 @@ function nativeServiceDoctorTarget(backend) {
         }
         : { kind: "inspection-failure", message: inspection.message };
 }
-async function printNativeServiceDoctorChecks(backend) {
-    const result = await runNativeServiceDoctor(nativeServiceDoctorTarget(backend), {
+async function printNativeServiceDoctorChecks(backend, installedIds) {
+    const result = await runNativeServiceDoctor(nativeServiceDoctorTarget(backend, installedIds), {
         probe: createNativeServiceAuthoritativeProbe(),
         fileExists: regularFileExists,
     });
@@ -882,9 +984,15 @@ function printPathSetupAdvice(shell = detectServiceShell()) {
         console.log("  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"];
@@ -895,8 +1003,11 @@ 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) {
+    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()}`);
@@ -904,8 +1015,8 @@ async function doctor() {
         console.log(`- Native user service plan checks skipped on ${platformLabel()}; no native-service drift is reported.`);
     }
     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).");
@@ -920,9 +1031,15 @@ async function doctor() {
     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);
+        }
     }
-    if (supportsSystemdUserServices()) {
+    if (backend?.kind === "systemd") {
         const linger = isLingerEnabled();
         if (linger === true) {
             console.log("✓ systemd user lingering enabled");
@@ -942,7 +1059,7 @@ async function doctor() {
     else {
         console.log(`- systemd user lingering skipped on ${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.");
@@ -1002,7 +1119,10 @@ async function main() {
         await install(args);
     else if (command === "uninstall")
         await uninstall();
-    else if (command === "start" || command === "stop" || command === "restart" || command === "status")
+    else if (command === "start" || command === "restart" || command === "doctor" || command === "version") {
+        await runReadinessCliCommand(command, readinessCliCommandDependencies());
+    }
+    else if (command === "stop" || command === "status")
         await serviceAction(command);
     else if (command === "logs")
         logs();
@@ -1012,10 +1132,6 @@ async function main() {
     }
     else if (command === "plugins")
         runPluginRecoveryCli(args, { restartPlan: (context) => sessionDaemonRestartPlan(context) });
-    else if (command === "doctor")
-        await doctor();
-    else if (command === "version")
-        await printPiWebVersionReport();
     else if (command === "--version" || command === "-v")
         console.log(packageVersion());
     else if (command === "help" || command === "--help" || command === "-h")