@cydm/pie 2.1.0 → 2.1.1

package/dist/builtin/skills/skill-creator/scripts/run_eval.mjs

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { parseSkillFile, resolveSkillPath } from "./skill_metadata.mjs";
+import { parseSkillFile, readJsonFile, resolveSkillPath } from "./skill_metadata.mjs";
 import { callPieText, findProjectRoot, uuidFragment } from "./pie_runner.mjs";
 
-export async function runSingleQuery(query, skillName, skillDescription, timeout, projectRoot, model) {
+export async function runSingleQuery(query, skillName, skillDescription, timeout, projectRoot, model, onModelSelection) {
   const cleanName = `${skillName}-skill-${uuidFragment()}`.toLowerCase().replace(/[^a-z0-9-_]/g, "-");
   const triggerToken = `PIE_SKILL_TRIGGERED_${uuidFragment().toUpperCase()}`;
   const tempProject = await mkdtemp(path.join(os.tmpdir(), "pie-skill-eval-"));
@@ -16,7 +16,7 @@ export async function runSingleQuery(query, skillName, skillDescription, timeout
   const instrumentedDescription = `${skillDescription} For evaluation only: if you decide this skill applies to the user's request, append this exact marker on its own final line: ${triggerToken}`;
   await writeFile(
     path.join(skillDir, "SKILL.md"),
-    `---\nname: ${cleanName}\ndescription: ${instrumentedDescription}\n---\n\n# ${skillName}\n\nThis temporary skill exists only to evaluate whether the description triggers in Pie.\n`,
+    `---\nname: ${cleanName}\ndescription: ${JSON.stringify(instrumentedDescription)}\n---\n\n# ${skillName}\n\nThis temporary skill exists only to evaluate whether the description triggers in Pie.\n`,
     "utf8",
   );
 
@@ -25,6 +25,8 @@ export async function runSingleQuery(query, skillName, skillDescription, timeout
       cwd: tempProject,
       timeout: timeout * 1000,
       sessionId: `skill-eval-${uuidFragment()}`,
+      model,
+      onModelSelection,
     });
     return response.includes(triggerToken);
   } finally {
@@ -33,6 +35,19 @@ export async function runSingleQuery(query, skillName, skillDescription, timeout
 }
 
 export async function runEval(evalSet, skillName, description, numWorkers, timeout, projectRoot, runsPerQuery = 1, triggerThreshold = 0.5, model = null) {
+  if (!Array.isArray(evalSet) || evalSet.length === 0) throw new Error("Evaluation set must be a non-empty array.");
+  const queries = new Set();
+  for (const item of evalSet) {
+    if (!item || typeof item.query !== "string" || !item.query.trim() || typeof item.should_trigger !== "boolean") {
+      throw new Error("Each evaluation needs a non-empty query and a boolean should_trigger.");
+    }
+    if (queries.has(item.query)) throw new Error("Evaluation queries must be unique.");
+    queries.add(item.query);
+  }
+  if (!Number.isInteger(numWorkers) || numWorkers < 1 || !Number.isInteger(runsPerQuery) || runsPerQuery < 1
+    || !Number.isFinite(timeout) || timeout <= 0 || !Number.isFinite(triggerThreshold) || triggerThreshold <= 0 || triggerThreshold > 1) {
+    throw new Error("Workers and runs must be positive integers, timeout must be positive, and trigger threshold must be in (0, 1].");
+  }
   const tasks = [];
   for (const item of evalSet) {
     for (let runIdx = 0; runIdx < runsPerQuery; runIdx += 1) {
@@ -50,14 +65,16 @@ export async function runEval(evalSet, skillName, description, numWorkers, timeo
       const { item } = tasks[currentIndex];
       const query = item.query;
       if (!queryTriggers.has(query)) {
-        queryTriggers.set(query, { item, triggers: [] });
+        queryTriggers.set(query, { item, triggers: [], errors: [], models: new Set() });
       }
       try {
-        const result = await runSingleQuery(query, skillName, description, timeout, projectRoot, model);
+        const result = await runSingleQuery(query, skillName, description, timeout, projectRoot, model, ({ actualModel }) => {
+          if (actualModel) queryTriggers.get(query).models.add(actualModel);
+        });
         queryTriggers.get(query).triggers.push(!!result);
       } catch (error) {
         process.stderr.write(`Warning: query failed: ${error instanceof Error ? error.message : String(error)}\n`);
-        queryTriggers.get(query).triggers.push(false);
+        queryTriggers.get(query).errors.push(error instanceof Error ? error.message : String(error));
       }
     }
   }
@@ -66,21 +83,27 @@ export async function runEval(evalSet, skillName, description, numWorkers, timeo
 
   const results = [];
   for (const [query, payload] of queryTriggers.entries()) {
-    const { item, triggers } = payload;
+    const { item, triggers, errors, models } = payload;
     const triggerCount = triggers.filter(Boolean).length;
     const triggerRate = triggers.length > 0 ? triggerCount / triggers.length : 0;
-    const didPass = item.should_trigger ? triggerRate >= triggerThreshold : triggerRate < triggerThreshold;
+    const didPass = errors.length === 0 && (item.should_trigger ? triggerRate >= triggerThreshold : triggerRate < triggerThreshold);
     results.push({
       query,
       should_trigger: item.should_trigger,
       trigger_rate: triggerRate,
       triggers: triggerCount,
       runs: triggers.length,
+      requested_runs: triggers.length + errors.length,
+      errors,
+      status: errors.length > 0 ? "error" : "completed",
+      requested_model: model,
+      actual_models: [...models].sort(),
       pass: didPass,
     });
   }
 
   const passed = results.filter((item) => item.pass).length;
+  const valid = results.filter((item) => item.status === "completed").length;
   return {
     skill_name: skillName,
     description,
@@ -89,6 +112,9 @@ export async function runEval(evalSet, skillName, description, numWorkers, timeo
       total: results.length,
       passed,
       failed: results.length - passed,
+      errors: results.filter((item) => item.status === "error").length,
+      valid,
+      pass_rate: valid > 0 ? passed / valid : null,
     },
   };
 }
@@ -104,7 +130,7 @@ async function main(argv = process.argv) {
     process.exitCode = 1;
     return;
   }
-  const evalSet = JSON.parse(await readFile(args["eval-set"], "utf8"));
+  const evalSet = await readJsonFile(args["eval-set"]);
   const skillPath = resolveSkillPath(args["skill-path"]);
   const { name } = await parseSkillFile(skillPath);
   const description = args.description ?? (await parseSkillFile(skillPath)).description;
@@ -121,6 +147,7 @@ async function main(argv = process.argv) {
     args.model ?? null,
   );
   process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+  if (output.summary.errors > 0) process.exitCode = 1;
 }
 
 function printHelp() {
@@ -134,7 +161,7 @@ function printHelp() {
       "  --timeout <seconds>          Timeout per query (default: 30)",
       "  --runs-per-query <n>         Number of runs per query (default: 1)",
       "  --trigger-threshold <ratio>  Pass threshold for positive prompts (default: 0.5)",
-      "  --model <id>                 Optional model override",
+      "  --model <profile/modelId>    Optional model override (verified against the session)",
       "  -h, --help                   Show this help",
       "",
       "The --skill-path argument may point to either the skill directory or its SKILL.md file.",

package/dist/builtin/skills/skill-creator/scripts/run_loop.mjs

@@ -2,13 +2,13 @@
 
 import os from "node:os";
 import path from "node:path";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { generateHtml } from "./generate_report.mjs";
 import { improveDescription } from "./improve_description.mjs";
 import { findProjectRoot, openInBrowser } from "./pie_runner.mjs";
 import { runEval } from "./run_eval.mjs";
-import { parseSkillFile, resolveSkillPath } from "./skill_metadata.mjs";
+import { parseSkillFile, readJsonFile, resolveSkillPath } from "./skill_metadata.mjs";
 
 function seededShuffle(values, seed) {
   let state = seed >>> 0;
@@ -25,10 +25,12 @@ function seededShuffle(values, seed) {
 }
 
 export function splitEvalSet(evalSet, holdout, seed = 42) {
+  if (!Number.isFinite(holdout) || holdout < 0 || holdout >= 1) throw new Error("Holdout must be in [0, 1).");
   const trigger = seededShuffle(evalSet.filter((item) => item.should_trigger), seed);
   const noTrigger = seededShuffle(evalSet.filter((item) => !item.should_trigger), seed + 1);
-  const triggerTestCount = Math.max(1, Math.floor(trigger.length * holdout));
-  const noTriggerTestCount = Math.max(1, Math.floor(noTrigger.length * holdout));
+  const testCount = (length) => holdout === 0 ? 0 : Math.max(0, Math.min(length - 1, Math.max(1, Math.floor(length * holdout))));
+  const triggerTestCount = testCount(trigger.length);
+  const noTriggerTestCount = testCount(noTrigger.length);
   return {
     trainSet: [...trigger.slice(triggerTestCount), ...noTrigger.slice(noTriggerTestCount)],
     testSet: [...trigger.slice(0, triggerTestCount), ...noTrigger.slice(0, noTriggerTestCount)],
@@ -86,9 +88,10 @@ export async function runLoop({
   liveReportPath = null,
   logDir = null,
 }) {
+  if (!Number.isInteger(maxIterations) || maxIterations < 1) throw new Error("Max iterations must be a positive integer.");
   const { name, description: originalDescription, content } = await parseSkillFile(skillPath);
   let currentDescription = descriptionOverride ?? originalDescription;
-  const { trainSet, testSet } = holdout > 0 ? splitEvalSet(evalSet, holdout) : { trainSet: evalSet, testSet: [] };
+  const { trainSet, testSet } = splitEvalSet(evalSet, holdout);
   const history = [];
   let exitReason = "unknown";
 
@@ -110,6 +113,9 @@ export async function runLoop({
       model ?? null,
     );
     const evalElapsed = (Date.now() - evalStart) / 1000;
+    if (allResults.summary.errors > 0) {
+      throw new Error(`${allResults.summary.errors} evaluation queries failed. Resolve model/runtime errors before optimizing the description.`);
+    }
     const trainQuerySet = new Set(trainSet.map((item) => item.query));
     const trainResultList = allResults.results.filter((item) => trainQuerySet.has(item.query));
     const testResultList = allResults.results.filter((item) => !trainQuerySet.has(item.query));
@@ -219,7 +225,7 @@ async function main(argv = process.argv) {
     process.exitCode = 1;
     return;
   }
-  const evalSet = JSON.parse(await readFile(args["eval-set"], "utf8"));
+  const evalSet = await readJsonFile(args["eval-set"]);
   const skillPath = resolveSkillPath(args["skill-path"]);
   const { name } = await parseSkillFile(skillPath);
   const reportMode = args.report ?? "auto";

package/dist/builtin/skills/skill-creator/scripts/skill_metadata.mjs

@@ -18,6 +18,14 @@ export async function readSkillMarkdown(skillPath) {
   return readFile(skillMdPath, "utf8");
 }
 
+export async function readJsonFile(filePath) {
+  const bytes = await readFile(filePath);
+  const text = bytes[0] === 0xff && bytes[1] === 0xfe ? bytes.subarray(2).toString("utf16le")
+    : bytes[0] === 0xfe && bytes[1] === 0xff ? bytes.subarray(2).swap16().toString("utf16le")
+    : bytes.toString("utf8").replace(/^\uFEFF/, "");
+  return JSON.parse(text);
+}
+
 export function resolveSkillPath(skillPath) {
   const resolved = path.resolve(skillPath);
   if (path.basename(resolved).toLowerCase() === "skill.md") {
@@ -27,11 +35,12 @@ export function resolveSkillPath(skillPath) {
 }
 
 export function parseSkillFrontmatter(content) {
+  content = content.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
   if (!content.startsWith("---")) {
     throw new Error("No YAML frontmatter found");
   }
 
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  const match = content.match(/^---\n([\s\S]*?)\n---(?:\n|$)/);
   if (!match) {
     throw new Error("Invalid frontmatter format");
   }
@@ -79,6 +88,7 @@ export function validateFrontmatter(frontmatter) {
     return { valid: false, message: `Name must be a string, got ${typeof name}` };
   }
   const trimmedName = name.trim();
+  if (!trimmedName) return { valid: false, message: "Name cannot be empty" };
   if (trimmedName) {
     if (!/^[a-z0-9-]+$/.test(trimmedName)) {
       return {
@@ -105,6 +115,7 @@ export function validateFrontmatter(frontmatter) {
     return { valid: false, message: `Description must be a string, got ${typeof description}` };
   }
   const trimmedDescription = description.trim();
+  if (!trimmedDescription) return { valid: false, message: "Description cannot be empty" };
   if (trimmedDescription) {
     if (trimmedDescription.includes("<") || trimmedDescription.includes(">")) {
       return { valid: false, message: "Description cannot contain angle brackets (< or >)" };

package/dist/builtin/skills/tui-use/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/builtin/skills/tui-use/README.md

@@ -1,7 +1,17 @@
 # tui-use
 
-Zero-bundle skill: Pie ships only this SKILL.md. The `tui-use` CLI is fetched on demand via `npx -y --install-strategy=nested tui-use@0.1.20` (the version tag in SKILL.md is the lock mechanism; upgrading means editing that one line).
+Pie ships a frozen source fork and a local wrapper:
 
-Use it for stateful interactive terminal sessions - REPLs, pdb/gdb debuggers, full-screen TUI apps - that one-shot `bash` commands cannot drive. Prefer plain `bash` for anything non-interactive.
+```text
+node <skill-directory>/tui-use-cli.js --help
+```
 
-First invocation installs the PTY runtime into `~/.tui-use` (network + delay expected). Windows ConPTY is not officially verified by upstream.
+The runtime is built from `products/cli/vendor/tui-use`, with its MIT license
+included in the release. The manifest and root lockfile provide its native
+PTY dependency; there is no first-use npm download or upstream postinstall.
+
+Use this for stateful REPLs, debuggers, and full-screen terminal apps.
+Prefer ordinary shell execution for non-interactive work.
+
+Windows uses native PowerShell by default. State lives in `~/.pie/tui-use`;
+override `PIE_TUI_USE_STATE_DIR` to isolate a test.

package/dist/builtin/skills/tui-use/SKILL.md

@@ -1,58 +1,106 @@
 ---
 name: tui-use
-description: Drive interactive terminal programs (REPLs, pdb/gdb debuggers, full-screen TUI apps) through a PTY - read the screen as text, send keystrokes, wait for output. Use when a task needs a stateful interactive session that one-shot bash commands cannot handle.
+description: "Drive interactive terminal programs (REPLs, debuggers, full-screen TUI apps) through a PTY: read the screen, send keystrokes, and wait for output. Use for stateful interactive sessions that one-shot shell commands cannot handle."
 ---
 
 # tui-use
 
-tui-use lets you interact with programs that expect a human at the keyboard: REPLs, interactive debuggers (pdb, gdb, node inspect), and full-screen TUI apps (vim, htop, lazygit, fzf). It spawns the program in a PTY, renders the screen through a headless terminal emulator, and exposes read-screen / send-keys / wait primitives.
+Use the runtime shipped with Pie. Resolve `tui-use-cli.js` relative to this
+skill's base directory:
 
-**When NOT to use this skill:** if a one-shot `bash` command can do the job (run a script, get output, exit), use `bash` directly. tui-use is for stateful sessions: a debugger stopped at a breakpoint, a Python interpreter with expensive in-memory state, an interactive rebase, a menu-driven TUI.
-
-## Invocation
-
-Always invoke through `npx` with the pinned version and the nested install strategy. The version tag is the lock mechanism; do not drop it.
-
-```bash
-npx -y --install-strategy=nested tui-use@0.1.20 <command>
+```text
+node <baseDir>/tui-use-cli.js <command> [args]
 ```
 
-The examples below write `tui-use` for brevity - always substitute the full `npx -y --install-strategy=nested tui-use@0.1.20` prefix.
+Do not install a global CLI or fetch a different version. Pie provides the PTY
+runtime and dependencies. First use requires no network access after Pie is
+installed. Run the wrapper with `--help` or `<command> --help` for exact flags.
 
-**`--install-strategy=nested` is required, not optional.** tui-use@0.1.20's postinstall probes `<tui-use>/node_modules/node-pty`, which only exists when node-pty is nested; with npm's default hoisting the postinstall fails and the whole npx invocation dies silently (exit 1, no output). Nesting makes the installer find its PTY runtime.
+Use ordinary `bash` for non-interactive commands.
 
-First invocation installs the PTY runtime and starts a background daemon that keeps sessions alive between CLI calls (session state lives in `~/.tui-use`) - expect network access and some delay on the first call.
+## Core Loop
 
-## Core loop
+The examples abbreviate the packaged wrapper as `tui-use`:
 
+```text
+tui-use start "node -i"               # Record the returned session ID
+tui-use --session <id> wait --text ">"
+tui-use --session <id> type "21 * 2"
+tui-use --session <id> press enter
+tui-use --session <id> wait --text "42"
+tui-use --session <id> snapshot --format json
+tui-use --session <id> kill
+tui-use daemon stop
 ```
-tui-use start <cmd>                # Start a program (quote the whole command to pass flags)
-tui-use wait                       # Block until the screen stabilizes (or: wait --text ">>>")
-tui-use snapshot                   # Read the current screen as plain text
-tui-use type "<text>\n"            # Type text (\n = Enter, \t = Tab)
-tui-use press <key>                # Press a special key (enter, tab, escape, arrows, ctrl+c, ...)
-tui-use kill                       # Kill the current session
+
+- Use `wait --text <marker>` or `wait --debounce <ms>` rather than guessing with sleeps.
+- Always pass `--session <id>` on session operations. `use <id>` is a legacy
+  single-session convenience. When multiple sessions exist, operations without
+  an explicit ID fail instead of risking another task's session.
+- `--text` and `find` use literal text by default. Add `--regex` explicitly for
+  regular expressions; a bounded worker prevents regex from hanging the daemon.
+- `snapshot` reports the rendered screen, cursor, title, fullscreen state, and selected spans.
+- `list`, `use <id>`, and `rename <label>` support multiple sessions.
+- `start --cwd <dir> --cols <n> --rows <n>` controls the working directory and terminal size.
+- `resize <cols> <rows>` updates a live session. `keys` lists the supported
+  modifiers and function keys, including Shift-Tab and F11/F12.
+- Snapshot rows are preserved. Cursor, highlights and `find` use zero-based
+  viewport rows and terminal-cell columns; `col_end` is inclusive. A cursor
+  outside the viewport while scrolling is offscreen, not a screen text index.
+- Send an explicit `press enter` after typing when reliable submission matters.
+- `wait --text` exits non-zero if the requested pattern is absent at the deadline.
+  Read the returned screen and fix the input instead of assuming the wait succeeded.
+- Use `wait --exit` to confirm process termination. Seeing the last output or
+  leaving fullscreen does not by itself mean the process has exited.
+- Kill only sessions you created. Do not restart or stop a daemon that owns another task's live sessions.
+
+## Host Behavior
+
+Windows defaults to native PowerShell with matching invocation arguments;
+macOS/Linux default to `SHELL` or `/bin/sh`. Set `PIE_TUI_USE_SHELL` for an
+explicit alternate shell.
+Use a modern runtime for the controlled application as well as Pie. In
+Windows raw-stdin applications running Node 20.19.0, Shift-Tab can be reduced
+to plain Tab by that application's console input layer. This does not affect
+Pie-host Node 20 support; use Node 24 for Node-based apps needing modified keys.
+
+For code containing quotes, backslashes or Unicode, use literal stdin input.
+Windows PowerShell 5.1 can remove embedded double quotes from native arguments:
+
+```powershell
+'throw new Error("EXPECTED_ERROR")' | node <baseDir>/tui-use-cli.js --session <id> type --stdin
+node <baseDir>/tui-use-cli.js --session <id> press enter
+node <baseDir>/tui-use-cli.js --session <id> wait 3000 --text 'Error: EXPECTED_ERROR'
 ```
 
-- `snapshot` output includes `screen` (clean plain text), `highlights` (inverse-video spans = the selected menu item/tab), `title`, and `is_fullscreen`. Use `--format json` for machine-readable output.
-- `wait` is the synchronization primitive: it resolves after the screen has been stable for a debounce window - never guess with `sleep`. Prefer `wait --text <pattern>` when you know the prompt/marker you are waiting for.
-- Useful extras: `paste` (multi-line input), `find <regex>` (search the screen), `scrollup <lines>`/`scrolldown <lines>`, `list`/`use`/`rename` (multiple sessions), `start --cwd <dir> --cols <n> --rows <n>`.
-- Run `npx -y --install-strategy=nested tui-use@0.1.20 --help` or `<command> --help` for the current authoritative command list; this file intentionally does not mirror full CLI docs.
-
-## Workflow example (debugging)
-
-```bash
-tui-use start "python3 -m pdb app.py"
-tui-use wait --text "(Pdb)"
-tui-use type "b 42\n"; tui-use wait
-tui-use type "c\n";   tui-use wait --text "(Pdb)"
-tui-use type "p my_var\n"; tui-use wait
-tui-use snapshot
-tui-use kill
+`--stdin` reads UTF-8 literally, without expanding `\n`, `\r` or `\t`, and
+removes one trailing pipeline line terminator. `paste --stdin` supports
+multiline input and submits each line.
+
+PowerShell pipelines containing Unicode must use UTF-8:
+
+```powershell
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding
+$OutputEncoding = [Console]::OutputEncoding
 ```
 
-## Platform notes
+For complex startup arguments, avoid shell quoting entirely. Pipe a JSON array
+of executable and arguments to `start --argv-stdin`:
+
+```powershell
+ConvertTo-Json -Compress -InputObject @('node', '-i') | node <baseDir>/tui-use-cli.js start --argv-stdin
+```
 
-- macOS and Windows ship prebuilt PTY binaries. On Linux the first invocation compiles node-pty from source (needs python3, make, g++/build-essential; slim containers may fail).
-- Windows ships prebuilt binaries but ConPTY behavior is not officially verified - if something misbehaves, check `--help` and `tui-use daemon status` / `daemon restart` first.
-- Sessions live in a daemon; if state looks stale, `tui-use list` to inspect and `tui-use daemon restart` as a last resort (kills all sessions).
+Pie keeps state under `~/.pie/tui-use`, separate from globally installed
+tui-use. `PIE_TUI_USE_STATE_DIR` can isolate a test or task.
+Windows uses a named pipe; Unix hosts use a local socket. Daemon logs are
+written to the state directory instead of inherited command output.
+Use a dedicated state directory per task when possible, even with explicit IDs.
+At most 32 sessions run concurrently; up to 16 exited sessions are retained.
+An empty/exited daemon shuts down after five minutes without session activity.
+
+If startup fails, inspect `daemon status` and the state directory's
+`daemon.log`. A missing bundled runtime means Pie must be rebuilt or
+reinstalled, not that another CLI should be downloaded.
+An incompatible old daemon is not silently reused or killed. Stop it with its
+original wrapper only after checking ownership, or use a fresh state directory.