dahrk-node 0.1.14 → 0.1.16

package/dist/main.js

@@ -2,7 +2,7 @@
 
 // src/main.ts
 import { execFileSync as execFileSync9 } from "child_process";
-import { existsSync as existsSync14, realpathSync as realpathSync5 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync11, realpathSync as realpathSync5 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
 import { homedir as homedir7, platform as osPlatform4 } from "os";
 import { basename as basename2, join as join17 } from "path";
@@ -506,9 +506,9 @@ var userMsg = (text) => ({
 });
 var sessionIdOf = (msg) => "session_id" in msg && typeof msg.session_id === "string" ? msg.session_id : void 0;
 var policyCanUseTool = async (ctx, toolName, input) => {
-  const verdict = ctx.authorizeToolUse?.(toolName, input);
-  if (verdict?.verdict === "deny") {
-    return { behavior: "deny", message: verdict.reason ?? `tool "${toolName}" denied by policy ${verdict.policy}` };
+  const verdict2 = ctx.authorizeToolUse?.(toolName, input);
+  if (verdict2?.verdict === "deny") {
+    return { behavior: "deny", message: verdict2.reason ?? `tool "${toolName}" denied by policy ${verdict2.policy}` };
   }
   return { behavior: "allow", updatedInput: input };
 };
@@ -801,15 +801,15 @@ function createClaudeRunner() {
         })
       };
       try {
-        let out = "";
+        let out2 = "";
         const q = query({ prompt: SUMMARISE_PROMPT, options });
         active = q;
         for await (const msg of q) {
           const found = sessionIdOf(msg);
           if (found) sessionId = found;
-          if (msg.type === "result" && msg.subtype === "success") out += msg.result;
+          if (msg.type === "result" && msg.subtype === "success") out2 += msg.result;
         }
-        return out.trim() || "(no summary produced)";
+        return out2.trim() || "(no summary produced)";
       } catch (e) {
         return `(summary unavailable: ${e.message})`;
       } finally {
@@ -1311,15 +1311,15 @@ function createPiRunner(deps = {}) {
       const s = session;
       if (s.agent) s.agent.state.tools = [];
       const state = newPiBufferState();
-      let out;
+      let out2;
       const unsub = s.subscribe((ev) => {
         const r = consumePiEvent(ev, state, true);
-        if (r.responseText) out = r.responseText;
+        if (r.responseText) out2 = r.responseText;
       });
       try {
         await s.prompt(SUMMARISE_PROMPT);
         captureSessionId(s);
-        return (out ?? "").trim() || "(no summary produced)";
+        return (out2 ?? "").trim() || "(no summary produced)";
       } catch (e) {
         return `(summary unavailable: ${e.message})`;
       } finally {
@@ -1354,7 +1354,9 @@ async function defaultCreatePiSession(ctx) {
   let model;
   if (ctx.config.model) {
     const resolved = resolveCliModel({ cliModel: ctx.config.model, modelRegistry });
-    if (!resolved?.error) model = resolved?.model;
+    if (!resolved?.error) {
+      model = pickAuthedModel(resolved?.model, modelRegistry.getAvailable());
+    }
   }
   const stageComplete = defineTool({
     name: PI_STAGE_COMPLETE_TOOL,
@@ -1379,6 +1381,17 @@ var PROVIDER_BY_ENV = {
   GEMINI_API_KEY: "google",
   GOOGLE_API_KEY: "google"
 };
+function modelFamily(id) {
+  const last = id.split(".").pop() ?? id;
+  return last.replace(/-v\d+:\d+$/, "").toLowerCase();
+}
+function pickAuthedModel(resolved, available) {
+  if (!resolved || !available?.length) return resolved;
+  const providers = new Set(available.map((m) => m.provider));
+  if (providers.has(resolved.provider)) return resolved;
+  const family = modelFamily(resolved.id);
+  return available.find((m) => modelFamily(m.id) === family) ?? resolved;
+}
 
 // ../../packages/executor-worktree/src/git-service.ts
 import { execFileSync } from "child_process";
@@ -1482,15 +1495,15 @@ function createGitService(opts = {}) {
   const withTokenUser = (gitUrl) => /^https:\/\/[^@/]+@/.test(gitUrl) ? gitUrl : gitUrl.replace(/^https:\/\//, "https://x-access-token@");
   const mirrorPathFor = (repoId) => join3(mirrorsDir, sanitizeBranchName(repoId));
   const listWorktrees = (mirror) => {
-    let out;
+    let out2;
     try {
-      out = git(mirror, ["worktree", "list", "--porcelain"]);
+      out2 = git(mirror, ["worktree", "list", "--porcelain"]);
     } catch {
       return [];
     }
     const entries = [];
     let path = "";
-    for (const line of out.split("\n")) {
+    for (const line of out2.split("\n")) {
       if (line.startsWith("worktree ")) path = line.slice(9).trim();
       else if (line.startsWith("branch ")) {
         const branch = line.slice(7).trim().replace(/^refs\/heads\//, "");
@@ -1848,13 +1861,13 @@ function lastUsedMs(worktreePath) {
   return newest;
 }
 function registeredWorktrees(mirror) {
-  let out;
+  let out2;
   try {
-    out = gitOut(mirror, ["worktree", "list", "--porcelain"]);
+    out2 = gitOut(mirror, ["worktree", "list", "--porcelain"]);
   } catch {
     return [];
   }
-  return out.split("\n").filter((l) => l.startsWith("worktree ")).map((l) => canonical(l.slice(9).trim())).filter((p) => p && p !== canonical(mirror));
+  return out2.split("\n").filter((l) => l.startsWith("worktree ")).map((l) => canonical(l.slice(9).trim())).filter((p) => p && p !== canonical(mirror));
 }
 function createWorktreeReaper(opts) {
   const log = opts.logger ?? noop;
@@ -2015,16 +2028,16 @@ import { createHash as createHash2 } from "crypto";
 import { cpSync, existsSync as existsSync3, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync2, readdirSync as readdirSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname2, join as join6, relative, sep } from "path";
 function readManifestFiles(dir) {
-  const out = [];
+  const out2 = [];
   const walk = (cur) => {
     for (const entry of readdirSync2(cur, { withFileTypes: true })) {
       const abs = join6(cur, entry.name);
       if (entry.isDirectory()) walk(abs);
-      else out.push(relative(dir, abs).split(sep).join("/"));
+      else out2.push(relative(dir, abs).split(sep).join("/"));
     }
   };
   walk(dir);
-  return out.sort();
+  return out2.sort();
 }
 
 // ../../packages/executor-worktree/src/overlay.ts
@@ -2195,11 +2208,11 @@ function fileJobLedger(file, warn = console.warn) {
   };
 }
 function announceableJobs(entries) {
-  const out = [];
+  const out2 = [];
   for (const e of entries) {
-    if (e.payloadVersion) out.push({ jobId: e.jobId, payloadVersion: e.payloadVersion });
+    if (e.payloadVersion) out2.push({ jobId: e.jobId, payloadVersion: e.payloadVersion });
   }
-  return out;
+  return out2;
 }
 function jobLedgerFile(stateDir2) {
   return join8(stateDir2, "jobs.json");
@@ -2357,18 +2370,18 @@ function scrubValue(value, depth = 0) {
   }
   if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return value;
   if (value instanceof Error) {
-    const out = new Error(scrubString(value.message));
-    out.name = value.name;
-    if (value.stack) out.stack = scrubString(value.stack);
-    return out;
+    const out2 = new Error(scrubString(value.message));
+    out2.name = value.name;
+    if (value.stack) out2.stack = scrubString(value.stack);
+    return out2;
   }
   if (Array.isArray(value)) return value.map((v) => scrubValue(v, depth + 1));
   if (typeof value === "object") {
-    const out = {};
+    const out2 = {};
     for (const [k, v] of Object.entries(value)) {
-      out[k] = isSensitiveKey(k) ? REDACTED : scrubValue(v, depth + 1);
+      out2[k] = isSensitiveKey(k) ? REDACTED : scrubValue(v, depth + 1);
     }
-    return out;
+    return out2;
   }
   return value;
 }
@@ -2602,11 +2615,11 @@ function withinRoots(raw, roots, need) {
 }
 function gitCommonDir(worktreePath) {
   try {
-    const out = execFileSync3("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+    const out2 = execFileSync3("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
       cwd: worktreePath,
       stdio: ["ignore", "pipe", "ignore"]
     }).toString().trim();
-    return out || void 0;
+    return out2 || void 0;
   } catch {
     return void 0;
   }
@@ -2615,8 +2628,8 @@ var pnpmStoreCache;
 function pnpmStore() {
   if (pnpmStoreCache) return pnpmStoreCache.path;
   try {
-    const out = execFileSync3("pnpm", ["store", "path"], { stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }).toString().trim();
-    pnpmStoreCache = { path: out || void 0 };
+    const out2 = execFileSync3("pnpm", ["store", "path"], { stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }).toString().trim();
+    pnpmStoreCache = { path: out2 || void 0 };
   } catch {
     pnpmStoreCache = { path: void 0 };
   }
@@ -2912,12 +2925,12 @@ function scanCommand(cmd, roots, cwd = roots.cwd) {
       }
       plain.push(t);
     }
-    const out = scanSimple(plain, roots, cwdNow);
-    if (out.kind === "cd") {
-      cwdNow = expandPath(out.to, cwdNow);
+    const out2 = scanSimple(plain, roots, cwdNow);
+    if (out2.kind === "cd") {
+      cwdNow = expandPath(out2.to, cwdNow);
       continue;
     }
-    if (out.kind !== "ok") return out;
+    if (out2.kind !== "ok") return out2;
   }
   return { kind: "ok" };
 }
@@ -2988,14 +3001,14 @@ var PATH_WRITE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit", "N
 function pathsIn(input) {
   if (!input || typeof input !== "object") return [];
   const o = input;
-  const out = [];
+  const out2 = [];
   for (const f of PATH_FIELDS) {
-    if (typeof o[f] === "string" && o[f]) out.push(o[f]);
+    if (typeof o[f] === "string" && o[f]) out2.push(o[f]);
   }
   if (o.changes && typeof o.changes === "object") {
-    out.push(...Object.keys(o.changes));
+    out2.push(...Object.keys(o.changes));
   }
-  return out;
+  return out2;
 }
 function fsConfineRule(roots) {
   return {
@@ -3587,10 +3600,10 @@ function createStageRunner(deps) {
             return `${tool3}\0`;
           }
         };
-        const policyReason = (verdict) => verdict.reason ?? `tool action denied by ${verdict.policy}`;
-        const recordDeny = (verdict, toolUseId) => {
+        const policyReason = (verdict2) => verdict2.reason ?? `tool action denied by ${verdict2.policy}`;
+        const recordDeny = (verdict2, toolUseId) => {
           denied = true;
-          const reason = policyReason(verdict);
+          const reason = policyReason(verdict2);
           if (toolUseId) {
             streamEvent(writer.append({ seq: 0, ts: nowIso2(), type: "observation", runtime, toolUseId, isError: true, output: { error: reason } }));
           }
@@ -3598,13 +3611,13 @@ function createStageRunner(deps) {
           deps.sendProgress({ jobId, kind: "error", ts: nowIso2(), text: reason });
         };
         const authorizeToolUse = (tool3, input) => {
-          const verdict = evaluatePolicies({ kind: "action", stageId, tool: tool3, input }, rules);
-          if (verdict.verdict === "deny") {
-            recordDeny(verdict);
+          const verdict2 = evaluatePolicies({ kind: "action", stageId, tool: tool3, input }, rules);
+          if (verdict2.verdict === "deny") {
+            recordDeny(verdict2);
           } else {
             authorisedActions.push(actionKey(tool3, input));
           }
-          return verdict;
+          return verdict2;
         };
         const onTrace = (event) => {
           if (event.type === "action") {
@@ -3613,14 +3626,14 @@ function createStageRunner(deps) {
             if (authorised >= 0) {
               authorisedActions.splice(authorised, 1);
             } else {
-              const verdict = evaluatePolicies(
+              const verdict2 = evaluatePolicies(
                 { kind: "action", stageId, tool: event.tool, input: event.input },
                 rules
               );
-              if (verdict.verdict === "deny") {
+              if (verdict2.verdict === "deny") {
                 streamEvent(writer.append(event));
-                recordDeny(verdict, event.toolUseId);
-                if (verdict.policy === "fs_confine" && runtime !== "claude-code") escapedUnblocked = true;
+                recordDeny(verdict2, event.toolUseId);
+                if (verdict2.policy === "fs_confine" && runtime !== "claude-code") escapedUnblocked = true;
                 return;
               }
             }
@@ -4486,6 +4499,10 @@ function parseCli(argv) {
         "hub-url": { type: "string" },
         ephemeral: { type: "boolean", default: false },
         foreground: { type: "boolean", default: false },
+        // `stop` / `restart`: take the node down even though it has work in flight.
+        force: { type: "boolean", default: false },
+        // `status`: machine-readable output.
+        json: { type: "boolean", default: false },
         help: { type: "boolean", default: false }
       },
       allowPositionals: false
@@ -4495,6 +4512,7 @@ function parseCli(argv) {
   }
   if (values.help) return { kind: "help", command };
   const ephemeral = values.ephemeral ?? false;
+  const force = values.force ?? false;
   const flags = {
     ...values.token ? { token: values.token } : {},
     ...values.name ? { name: values.name } : {},
@@ -4504,7 +4522,9 @@ function parseCli(argv) {
     // a supervisor that restarts it on boot. It is a foreground node by definition.
     foreground: (values.foreground ?? false) || ephemeral
   };
-  if (command === "stop") return { kind: "stop" };
+  if (command === "stop") return { kind: "stop", force };
+  if (command === "restart") return { kind: "restart", flags, force };
+  if (command === "status") return { kind: "status", flags: { ...flags, json: values.json ?? false } };
   return { kind: command, flags };
 }
 var LOG_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal"];
@@ -4639,6 +4659,7 @@ function parseUpdate(flagArgs) {
       args: flagArgs,
       options: {
         check: { type: "boolean", default: false },
+        verbose: { type: "boolean", default: false },
         help: { type: "boolean", default: false }
       },
       allowPositionals: false
@@ -4647,7 +4668,7 @@ function parseUpdate(flagArgs) {
     return { kind: "error", message: e.message };
   }
   if (values.help) return { kind: "help", command: "update" };
-  return { kind: "update", flags: { check: values.check ?? false } };
+  return { kind: "update", flags: { check: values.check ?? false, verbose: values.verbose ?? false } };
 }
 function usage(bin, command) {
   if (command === "start") {
@@ -4682,26 +4703,39 @@ function usage(bin, command) {
   }
   if (command === "stop") {
     return [
-      `Usage: ${bin} stop`,
+      `Usage: ${bin} stop [--force]`,
       "",
       "Stop the node. It stays stopped across reboots until you run `dahrk start` again - a stop that",
       "quietly undid itself at the next boot would not be a stop.",
       "",
+      "A node that is running a stage refuses to stop, because stopping it would kill work that costs real",
+      "agent time. It lists what is in flight and leaves the node up; --force stops it anyway.",
+      "",
       "The service stays installed, so starting it again is instant. To remove it entirely, use",
-      "`dahrk service uninstall`. To stop a node running in a terminal (--foreground), press Ctrl-C."
+      "`dahrk service uninstall`. To stop a node running in a terminal (--foreground), press Ctrl-C.",
+      "",
+      "Options:",
+      "  --force            Stop even if the node has stages in flight (this kills them)."
     ].join("\n");
   }
   if (command === "restart") {
     return [
       `Usage: ${bin} restart [options]`,
       "",
-      "Stop the node and start it again. Picks up a new client version, a rotated token, or a runtime you",
-      "have just installed (the node detects runtimes at boot, so a fresh `claude` on PATH needs a restart).",
+      "Stop the node and start it again, then report its status. Picks up a new client version, a rotated",
+      "token, or a runtime you have just installed (the node detects runtimes at boot, so a fresh `claude`",
+      "on PATH needs a restart).",
+      "",
+      "This is what picks up a `dahrk update`: a running node keeps executing the build it started with, so",
+      "`dahrk start` on it does nothing at all.",
+      "",
+      "Like `stop`, it refuses on a node with stages in flight rather than killing them; --force overrides.",
       "",
       "Options:",
       "  --token <token>    Re-enrol with a new token (or set DAHRK_ENROL_TOKEN).",
       "  --hub-url <url>    Hub WebSocket URL (or set DAHRK_HUB_URL).",
-      "  --name <name>      Display-name override (else the hub assigns one)."
+      "  --name <name>      Display-name override (else the hub assigns one).",
+      "  --force            Restart even if the node has stages in flight (this kills them)."
     ].join("\n");
   }
   if (command === "logs") {
@@ -4793,26 +4827,38 @@ function usage(bin, command) {
   }
   if (command === "status") {
     return [
-      `Usage: ${bin} status`,
+      `Usage: ${bin} status [--json]`,
+      "",
+      "Report this node's local state: whether it is running (and how), whether it is enrolled and as whom,",
+      "its node id, the runtimes it can serve with their versions, and what it is working on right now.",
+      "",
+      "Local only - it dials nothing, so it is instant and works offline. That is also why the hub line says",
+      "when the node was LAST known to be connected (from its log) rather than claiming it is connected now,",
+      "which this command cannot know without dialling. Use `doctor` for that: it checks the hub is",
+      "reachable and the token still valid.",
       "",
-      "Report this node's local state: whether it is enrolled (and as whom), its node id, the runtimes",
-      "it can serve, and whether the always-on service is installed and actually running.",
+      "Exits non-zero only when the node is installed but not running and nobody asked for that (i.e. it is",
+      "crash-looping), so it works as a health check in a script. A node you deliberately stopped is not a",
+      "failure.",
       "",
-      "Local only - it dials nothing, so it is instant and works offline. Use `doctor` to check the hub",
-      "is reachable and the token still valid. Exits non-zero only when the service is installed but",
-      "not running, so it works as a health check in a script."
+      "Options:",
+      "  --json     Print the facts as JSON (for a script) instead of the report."
     ].join("\n");
   }
   if (command === "update") {
     return [
-      `Usage: ${bin} update [--check]`,
+      `Usage: ${bin} update [--check] [--verbose]`,
       "",
       "Update this client in place to the latest published release. Detects how it was installed",
       "(npm / Homebrew / curl) and runs the right upgrade, or prints the exact command when it cannot.",
       "Reports current -> latest, and a no-op when already current.",
       "",
+      "A node that is already running keeps executing the OLD build until it is restarted, so if one is up",
+      "this offers to restart it for you (and tells you to run `dahrk restart` when there is nobody to ask).",
+      "",
       "Options:",
-      "  --check    Report whether an update is available without applying it (dry run)."
+      "  --check    Report whether an update is available without applying it (dry run).",
+      "  --verbose  Show the package manager's own output, which is hidden unless the upgrade fails."
     ].join("\n");
   }
   return [
@@ -4821,10 +4867,10 @@ function usage(bin, command) {
     "Commands:",
     "  start     Run the node, and keep it running (installs the service). --token to enrol, once.",
     "  stop      Stop the node. It stays stopped until the next `start`.",
-    "  restart   Stop it and start it again.",
+    "  restart   Stop it and start it again. This is what picks up a `dahrk update`.",
     "  logs      Show what the node is doing (-f to follow, --run <id> to narrow to one run).",
     "  diagnose  Write a support bundle you can read, and send on if you choose. Uploads nothing.",
-    "  status    Is this node enrolled, and is it up? (local, dials nothing)",
+    "  status    Is it up, is it enrolled, what is it working on? (local, dials nothing)",
     "  run       Run a workflow locally (engine-backed), e.g. `run preflight`.",
     "  doctor    Preflight checks: Node, runtimes, hub reachability, token validity.",
     "  service   Install/uninstall the always-on service by hand (`start` does this for you).",
@@ -4840,6 +4886,80 @@ function usage(bin, command) {
 // src/diagnose.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync8, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3, writeFileSync as writeFileSync7 } from "fs";
 import { join as join12 } from "path";
+
+// src/ui.ts
+import { styleText } from "util";
+function detectCapabilities(env = process.env, isTty = Boolean(process.stdout.isTTY)) {
+  const forced = env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "0";
+  const colour = forced || isTty && env.NO_COLOR === void 0 && env.TERM !== "dumb";
+  const locale = `${env.LC_ALL ?? ""}${env.LC_CTYPE ?? ""}${env.LANG ?? ""}`;
+  const unicode = process.platform !== "win32" && (locale === "" || /UTF-?8/i.test(locale));
+  return { colour, unicode };
+}
+var caps = detectCapabilities();
+var paint = (style, text) => (
+  // `validateStream: false` because our own gate above has already decided; the option is ignored by the
+  // Node 22.0-22.7 signature, which had no stream check at all, so this is correct on every supported Node.
+  caps.colour ? styleText(style, text, { validateStream: false }) : text
+);
+var dim = (s) => paint("dim", s);
+var bold = (s) => paint("bold", s);
+var green = (s) => paint("green", s);
+var red = (s) => paint("red", s);
+function amber(s) {
+  if (!caps.colour) return s;
+  const depth = process.stdout.getColorDepth?.() ?? 4;
+  return depth >= 24 ? `\x1B[38;2;245;165;36m${s}\x1B[39m` : paint("yellow", s);
+}
+var GLYPH = {
+  ok: { unicode: "\u2714", ascii: "OK" },
+  warn: { unicode: "\u25B2", ascii: "!" },
+  fail: { unicode: "\u2716", ascii: "x" },
+  info: { unicode: "\u2022", ascii: "-" }
+};
+var COLOUR = {
+  ok: green,
+  warn: amber,
+  fail: red,
+  info: dim
+};
+var symbol = (level) => COLOUR[level](caps.unicode ? GLYPH[level].unicode : GLYPH[level].ascii);
+var arrow = () => caps.unicode ? "\u2192" : "->";
+var verdict = (level, text) => `  ${symbol(level)} ${bold(text)}`;
+var LABEL_WIDTH = 11;
+function kv(label, value) {
+  const gutter = label ? dim(label.padEnd(LABEL_WIDTH)) : " ".repeat(LABEL_WIDTH);
+  return `  ${gutter}${value}`;
+}
+var hint = (text) => `  ${dim(text)}`;
+var hints = (pairs) => hint(pairs.map(([label, cmd]) => `${label}: ${cmd}`).join("   "));
+var out = (line) => void process.stdout.write(`${line}
+`);
+var stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+function humanDuration(ms) {
+  const s = Math.max(0, Math.round(ms / 1e3));
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return m % 60 === 0 ? `${h}h` : `${h}h ${m % 60}m`;
+  const d = Math.floor(h / 24);
+  return h % 24 === 0 ? `${d}d` : `${d}d ${h % 24}h`;
+}
+var ago = (ms) => ms < 5e3 ? "just now" : `${humanDuration(ms)} ago`;
+var isInteractive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+async function confirm(question) {
+  const { createInterface } = await import("readline/promises");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(`  ${question} ${dim("[Y/n]")} `)).trim().toLowerCase();
+    return answer === "" || answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+// src/diagnose.ts
 var BUNDLE_LOG_LINES = 2e3;
 function tailJsonl(raw, n) {
   const records = [];
@@ -4945,8 +5065,7 @@ var defaultDiagnoseDeps = (paths, clientVersion, doctor) => ({
     if (!existsSync8(dir)) mkdirSync8(dir, { recursive: true });
     writeFileSync7(p, content, { mode: 384 });
   },
-  out: (line) => void process.stdout.write(`${line}
-`)
+  out
 });
 function defaultBundlePath(cwd, now) {
   return join12(cwd, `dahrk-diagnose-${now.toISOString().replace(/[:.]/g, "-")}.json`);
@@ -4954,7 +5073,7 @@ function defaultBundlePath(cwd, now) {
 
 // src/doctor.ts
 var MIN_NODE_MAJOR = 22;
-var TAG = { pass: "[PASS]", warn: "[WARN]", fail: "[FAIL]" };
+var LEVEL = { pass: "ok", warn: "warn", fail: "fail" };
 function checkNode(nodeVersion) {
   const major = Number.parseInt(nodeVersion.replace(/^v/, "").split(".")[0] ?? "", 10);
   if (Number.isNaN(major)) {
@@ -5052,16 +5171,15 @@ function checkToken(tokenPresent, hubUrl, probe2) {
 function formatReport(checks) {
   const failed = checks.filter((c) => c.status === "fail").length;
   const warned = checks.filter((c) => c.status === "warn").length;
-  const lines = checks.map((c) => `${TAG[c.status]} ${c.label}${c.detail ? `: ${c.detail}` : ""}`);
-  const summary = failed > 0 ? `FAIL - ${failed} check${failed === 1 ? "" : "s"} failed${warned ? `, ${warned} warning${warned === 1 ? "" : "s"}` : ""}.` : warned > 0 ? `PASS with ${warned} warning${warned === 1 ? "" : "s"}.` : "PASS - all checks green.";
-  return ["dahrk doctor", "", ...lines, "", summary].join("\n");
+  const lines = checks.map((c) => `  ${symbol(LEVEL[c.status])} ${c.label}${c.detail ? `: ${dim(c.detail)}` : ""}`);
+  const summary = failed > 0 ? verdict("fail", `${failed} check${failed === 1 ? "" : "s"} failed${warned ? `, ${warned} warning${warned === 1 ? "" : "s"}` : ""}.`) : warned > 0 ? verdict("warn", `Passed with ${warned} warning${warned === 1 ? "" : "s"}.`) : verdict("ok", "All checks green.");
+  return ["", ...lines, "", summary].join("\n");
 }
 var defaultDeps = () => ({
   nodeVersion: process.versions.node,
   probeRuntimes: probeRuntimeStatuses,
   probeHub,
-  out: (line) => void process.stdout.write(`${line}
-`)
+  out
 });
 async function runDoctor(inputs, deps = {}) {
   const d = { ...defaultDeps(), ...deps };
@@ -5146,15 +5264,15 @@ function logsCommand(inputs) {
 var LEVEL_RANK = { trace: 10, debug: 20, info: 30, warn: 40, error: 50, fatal: 60 };
 var levelName = (n) => Object.entries(LEVEL_RANK).find(([, rank]) => rank === n)?.[0] ?? String(n);
 function parseRecords(raw) {
-  const out = [];
+  const out2 = [];
   for (const line of raw.split("\n")) {
     if (!line.trim()) continue;
     try {
-      out.push(JSON.parse(line));
+      out2.push(JSON.parse(line));
     } catch {
     }
   }
-  return out;
+  return out2;
 }
 function filterRecords(records, q) {
   const min = q.level ? LEVEL_RANK[q.level] ?? 0 : 0;
@@ -5230,8 +5348,7 @@ var defaultLogsDeps = (files, jsonlFile) => ({
     child.on("error", () => resolve3(1));
     child.on("close", (code) => resolve3(code ?? 0));
   }),
-  out: (line) => void process.stdout.write(`${line}
-`)
+  out
 });
 
 // src/process-safety.ts
@@ -5362,15 +5479,18 @@ function worst(checks) {
   if (checks.some((c) => c.status === "warn")) return "warn";
   return "pass";
 }
-function renderStage(index, total, verdict, out) {
-  const head = `[${index}/${total}] ${verdict.label}`;
-  const findings = verdict.checks.filter((c) => c.status !== "pass");
+function renderStage(index, total, stage, out2) {
+  const head = `  ${dim(`[${index}/${total}]`)} ${stage.label}`;
+  const findings = stage.checks.filter((c) => c.status !== "pass");
   if (findings.length === 0) {
-    out(`${head} \u2713`);
+    out2(`${head} ${symbol("ok")}`);
     return;
   }
-  out(head);
-  for (const f of findings) out(`      \u2022 ${f.label}: ${f.detail ?? f.status}`);
+  out2(head);
+  for (const f of findings) {
+    const level = f.status === "fail" ? "fail" : "warn";
+    out2(`      ${symbol(level)} ${f.label}: ${dim(f.detail ?? f.status)}`);
+  }
 }
 async function runPreflight(inputs, deps = {}) {
   const d = { ...defaultDeps2(), ...deps };
@@ -5422,8 +5542,7 @@ var defaultDeps2 = () => ({
   probeHub,
   gatherHost: gatherHostFacts,
   newRunId: () => randomUUID2(),
-  out: (line) => void process.stdout.write(`${line}
-`)
+  out
 });
 function commandPresent(cmd) {
   try {
@@ -5760,16 +5879,18 @@ function parseServiceStatus(manager, unitExists, probe2) {
   const running = active === "active";
   return running && pid > 0 ? { installed: true, running: true, pid } : { installed: true, running };
 }
-function printUnsupported(out) {
-  out("dahrk service is supported on macOS (launchd) and Linux (systemd) only.");
-  out("On other platforms, run the node under a process manager such as pm2 (see the README).");
+function printUnsupported(out2) {
+  out2(verdict("fail", "dahrk service is supported on macOS (launchd) and Linux (systemd) only."));
+  out2("");
+  out2(hint("On other platforms, run the node under a process manager such as pm2 (see the README)."));
   return 1;
 }
 function runCommands(commands, d) {
   for (const cmd of commands) {
-    const code = d.run(cmd.argv);
+    const { code, output } = d.run(cmd.argv);
     if (code !== 0 && !cmd.ignoreFailure) {
-      d.out(`  command failed (${code}): ${cmd.argv.join(" ")}`);
+      d.out(verdict("fail", `command failed (${code}): ${cmd.argv.join(" ")}`));
+      for (const line of output.split("\n")) if (line.trim()) d.out(`    ${dim(line)}`);
       return code;
     }
   }
@@ -5777,13 +5898,13 @@ function runCommands(commands, d) {
 }
 async function runServiceInstall(inputs, deps = {}) {
   const d = { ...defaultDeps3(), ...deps };
-  d.out("dahrk service install");
   d.out("");
   const manager = detectManager(d.platform);
   if (manager === "unsupported") return printUnsupported(d.out);
   if (!inputs.token) {
-    d.out("No enrolment token: pass --token <token> or set DAHRK_ENROL_TOKEN.");
-    d.out("Get one at https://app.dahrk.ai.");
+    d.out(verdict("fail", "No enrolment token."));
+    d.out("");
+    d.out(hint("Pass --token <token>, or set DAHRK_ENROL_TOKEN. Get one at https://app.dahrk.ai."));
     return 2;
   }
   const plan = buildPlan({
@@ -5802,26 +5923,41 @@ async function runServiceInstall(inputs, deps = {}) {
     d.mkdirp(dirOf(plan.filePath));
     d.writeFile(plan.filePath, plan.content);
   } catch (e) {
-    d.out(`Could not write the service file at ${plan.filePath}: ${e.message}`);
+    d.out(verdict("fail", `Could not write the service file at ${plan.filePath}`));
+    d.out("");
+    d.out(hint(e.message));
     return 1;
   }
-  d.out(`Wrote ${plan.manager} service: ${plan.filePath}`);
   const code = runCommands(plan.installCommands, d);
-  d.out("");
   if (code !== 0) {
-    d.out(`The service file is in place but registering it failed (exit ${code}).`);
-    d.out("Fix the reported error and re-run `dahrk service install`, or load it yourself.");
+    d.out("");
+    d.out(hint(`The service file is in place at ${plan.filePath}. Fix the error above and re-run.`));
     return code;
   }
-  d.out("Installed. The node will start on boot and restart on failure.");
-  d.out(`  logs:      ${plan.logHint}`);
-  d.out("  uninstall: dahrk service uninstall");
+  d.out(verdict("ok", "Installed. The node starts on boot and restarts on failure."));
+  d.out("");
+  d.out(kv("unit", plan.filePath));
+  d.out("");
+  d.out(hints([["logs", plan.logHint], ["uninstall", "dahrk service uninstall"]]));
   return 0;
 }
 function availabilityCommand(manager) {
   return manager === "systemd" ? ["systemctl", "--user", "show", "-p", "Version"] : void 0;
 }
-async function runNodeStart(inputs, deps = {}) {
+function liveNodePid(d) {
+  const manager = detectManager(d.platform);
+  if (manager !== "unsupported") {
+    const unit = unitPath(manager, d.homeDir);
+    if (d.fileExists(unit)) {
+      const status = parseServiceStatus(manager, true, d.capture(statusCommand(manager)));
+      if (status.running && status.pid) return status.pid;
+    }
+  }
+  const held = parseLock(d.readFile(d.lockFile));
+  return held !== void 0 && d.isAlive(held) ? held : void 0;
+}
+var nodeIsRunning = (deps = {}) => liveNodePid({ ...defaultDeps3(), ...deps }) !== void 0;
+async function runNodeStart(inputs, deps = {}, opts = {}) {
   const d = { ...defaultDeps3(), ...deps };
   const manager = detectManager(d.platform);
   if (manager === "unsupported") {
@@ -5834,8 +5970,9 @@ async function runNodeStart(inputs, deps = {}) {
   const filePath = unitPath(manager, d.homeDir);
   const unitExists = d.fileExists(filePath);
   if (!inputs.token && !unitExists) {
-    d.out("No enrolment token: pass --token <token> or set DAHRK_ENROL_TOKEN.");
-    d.out("Get one at https://app.dahrk.ai.");
+    d.out(verdict("fail", "No enrolment token."));
+    d.out("");
+    d.out(hint("Pass --token <token>, or set DAHRK_ENROL_TOKEN. Get one at https://app.dahrk.ai."));
     return { kind: "error", code: 2 };
   }
   const plan = buildPlan({
@@ -5851,12 +5988,10 @@ async function runNodeStart(inputs, deps = {}) {
   });
   const canRender = inputs.token !== void 0;
   const current = canRender && unitExists && unitIsCurrent(plan, d.readFile(filePath));
-  const probe2 = unitExists ? d.capture(statusCommand(manager)) : { code: 1, stdout: "" };
-  const status = parseServiceStatus(manager, unitExists, probe2);
-  if (current && status.running) {
-    d.out(`Node is already running${status.pid ? ` (pid ${status.pid})` : ""}.`);
-    d.out(`  logs: ${plan.logHint}`);
-    return { kind: "running", code: 0 };
+  if (!opts.alwaysLoad) {
+    const probe2 = unitExists ? d.capture(statusCommand(manager)) : { code: 1, stdout: "" };
+    const status = parseServiceStatus(manager, unitExists, probe2);
+    if (current && status.running) return { kind: "running", code: 0, already: true };
   }
   if (canRender && !current) {
     try {
@@ -5867,28 +6002,65 @@ async function runNodeStart(inputs, deps = {}) {
       d.out(`Could not write the service file at ${plan.filePath}: ${e.message}`);
       return { kind: "error", code: 1 };
     }
-    d.out(unitExists ? `Updated ${plan.manager} service: ${plan.filePath}` : `Installed ${plan.manager} service: ${plan.filePath}`);
+    d.out(hint(unitExists ? `Updated the ${plan.manager} service.` : `Installed the ${plan.manager} service.`));
   }
   const code = runCommands(plan.installCommands, d);
   if (code !== 0) {
-    d.out(`The service file is in place but starting it failed (exit ${code}).`);
+    d.out(hint(`The service file is in place at ${plan.filePath}, but starting it failed.`));
     return { kind: "error", code };
   }
-  d.out("Node is running. It will start on boot and restart on failure.");
-  d.out(`  logs:   ${plan.logHint}`);
-  d.out("  stop:   dahrk stop");
-  return { kind: "running", code: 0 };
+  return { kind: "running", code: 0, already: false };
+}
+async function runNodeRestart(inputs, deps = {}) {
+  const d = { ...defaultDeps3(), ...deps };
+  const manager = detectManager(d.platform);
+  if (manager === "unsupported") {
+    return { kind: "foreground", reason: "no supported supervisor on this platform (launchd / systemd)" };
+  }
+  const busy = guardBusy(d, inputs.force ?? false, "restart");
+  if (busy) return { kind: "error", code: busy };
+  const plan = buildPlan({
+    manager,
+    nodeBin: d.nodeBin,
+    scriptPath: d.scriptPath,
+    token: "-",
+    homeDir: d.homeDir,
+    logDir: d.logDir
+  });
+  if (d.fileExists(plan.filePath)) runCommands(plan.stopCommands, d);
+  return runNodeStart(inputs, deps, { alwaysLoad: true });
+}
+function guardBusy(d, force, verb) {
+  const live = liveNodePid(d);
+  const jobs = live === void 0 ? [] : d.inFlightJobs().filter((j) => j.nodePid === live);
+  if (jobs.length === 0) return void 0;
+  if (force) {
+    d.out(verdict("warn", `Forcing ${verb} with ${jobs.length} job(s) in flight.`));
+    return void 0;
+  }
+  d.out(verdict("warn", `This node is running ${jobs.length} job(s); \`${verb}\` would kill them.`));
+  d.out("");
+  for (const j of jobs) {
+    const where = j.stageId ? `${j.runId} / ${j.stageId}` : j.runId;
+    d.out(kv("", `${where}  ${dim(humanDuration(Date.now() - j.startedAt))}`));
+  }
+  d.out("");
+  d.out(hint(`Wait for them to finish, or \`dahrk ${verb} --force\` to interrupt them anyway.`));
+  return BUSY_NODE;
 }
+var BUSY_NODE = 4;
 var STOP_FOREIGN_NODE = 3;
 function foreignNodePid(lock, servicePid, isAlive2) {
   const held = parseLock(lock);
   if (held === void 0 || held === servicePid) return void 0;
   return isAlive2(held) ? held : void 0;
 }
-async function runNodeStop(deps = {}) {
+async function runNodeStop(inputs = {}, deps = {}) {
   const d = { ...defaultDeps3(), ...deps };
   const manager = detectManager(d.platform);
   if (manager === "unsupported") return printUnsupported(d.out);
+  const busy = guardBusy(d, inputs.force ?? false, "stop");
+  if (busy) return busy;
   const plan = buildPlan({
     manager,
     nodeBin: d.nodeBin,
@@ -5898,28 +6070,31 @@ async function runNodeStop(deps = {}) {
     logDir: d.logDir
   });
   if (!d.fileExists(plan.filePath)) {
-    d.out("No service installed, so there is nothing to stop.");
-    d.out("If you are running a node in a terminal (`dahrk start --foreground`), stop it with Ctrl-C.");
+    d.out(verdict("info", "No service installed, so there is nothing to stop."));
+    d.out("");
+    d.out(hint("A node running in a terminal (`dahrk start --foreground`) stops with Ctrl-C."));
     return reportForeignNode(d, void 0) ?? 0;
   }
   const servicePid = parseServiceStatus(manager, true, d.capture(statusCommand(manager))).pid;
   runCommands(plan.stopCommands, d);
-  d.out("Node stopped. It will stay stopped across reboots until you run `dahrk start`.");
+  d.out(verdict("ok", "Node stopped."));
+  d.out("");
+  d.out(hint("It stays stopped across reboots until you run `dahrk start`."));
   return reportForeignNode(d, servicePid) ?? 0;
 }
 function reportForeignNode(d, servicePid) {
   const pid = foreignNodePid(d.readFile(d.lockFile), servicePid, d.isAlive);
   if (pid === void 0) return void 0;
   d.out("");
-  d.out(`WARNING: a node is STILL RUNNING on this host (pid ${pid}). \`dahrk stop\` cannot stop it.`);
-  d.out("Something else is supervising it: pm2, a container, or `dahrk start --foreground` in a terminal.");
-  d.out("It is not a stray copy - it holds this node's identity, so it is still connected to the hub and");
-  d.out("still taking Jobs. Stop it where it was started (e.g. `pm2 delete dahrk-node`), or kill the pid.");
+  d.out(verdict("warn", `A node is STILL RUNNING on this host (pid ${pid}). \`dahrk stop\` cannot stop it.`));
+  d.out("");
+  d.out(hint("Something else supervises it: pm2, a container, or `dahrk start --foreground` in a terminal."));
+  d.out(hint("It is not a stray copy - it holds this node's identity, so it is still connected to the hub"));
+  d.out(hint("and still taking Jobs. Stop it where it was started, or kill the pid."));
   return STOP_FOREIGN_NODE;
 }
 async function runServiceUninstall(deps = {}) {
   const d = { ...defaultDeps3(), ...deps };
-  d.out("dahrk service uninstall");
   d.out("");
   const manager = detectManager(d.platform);
   if (manager === "unsupported") return printUnsupported(d.out);
@@ -5932,17 +6107,19 @@ async function runServiceUninstall(deps = {}) {
     logDir: d.logDir
   });
   if (!d.fileExists(plan.filePath)) {
-    d.out(`No service installed (${plan.filePath} not found). Nothing to do.`);
+    d.out(verdict("info", "No service installed. Nothing to do."));
     return 0;
   }
   runCommands(plan.uninstallCommands, d);
   try {
     d.removeFile(plan.filePath);
   } catch (e) {
-    d.out(`Deregistered, but could not delete ${plan.filePath}: ${e.message}`);
+    d.out(verdict("warn", `Deregistered, but could not delete ${plan.filePath}`));
+    d.out("");
+    d.out(hint(e.message));
     return 1;
   }
-  d.out(`Removed ${plan.filePath}. The node will no longer start on boot.`);
+  d.out(verdict("ok", "Removed. The node will no longer start on boot."));
   return 0;
 }
 function dirOf(path) {
@@ -5981,6 +6158,10 @@ var defaultDeps3 = () => ({
   logDir: logDir(process.env),
   lockFile: lockFile(process.env),
   isAlive,
+  // Read-only here, and best-effort by construction: a missing or corrupt ledger reads as "no jobs", which
+  // degrades the guard to today's behaviour rather than blocking a stop the operator needs.
+  inFlightJobs: () => fileJobLedger(jobLedgerFile(stateDir(process.env)), () => {
+  }).all(),
   // Snapshot the operator's PATH at install time so the daemon finds git + the runtime CLIs (Homebrew /
   // npm-global bins) that a supervisor's minimal PATH would otherwise hide.
   pathEnv: process.env.PATH,
@@ -6001,14 +6182,21 @@ var defaultDeps3 = () => ({
   },
   removeFile: (path) => rmSync7(path, { force: true }),
   fileExists: (path) => existsSync13(path),
+  // Captured, never inherited. A supervisor's stderr is ours to relay when it matters, not to leak
+  // unconditionally: `runCommands` decides who needs to read it.
   run: (argv) => {
     const [cmd, ...args] = argv;
     try {
-      execFileSync7(cmd, args, { stdio: "inherit" });
-      return 0;
+      const stdout = execFileSync7(cmd, args, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      return { code: 0, output: stdout };
     } catch (e) {
       const status = e.status;
-      return typeof status === "number" ? status : 1;
+      const { stdout, stderr } = e;
+      const output = `${stdout?.toString() ?? ""}${stderr?.toString() ?? ""}`;
+      return { code: typeof status === "number" ? status : 1, output };
     }
   },
   capture: (argv) => {
@@ -6024,8 +6212,7 @@ var defaultDeps3 = () => ({
       return { code: typeof status === "number" ? status : 1, stdout: "" };
     }
   },
-  out: (line) => void process.stdout.write(`${line}
-`)
+  out
 });
 
 // src/update.ts
@@ -6073,58 +6260,80 @@ function isNewer(latest, current) {
   }
   return false;
 }
-function printChannelCommands(out) {
-  out(`  npm:      ${CHANNEL_COMMANDS.npm}`);
-  out(`  Homebrew: ${CHANNEL_COMMANDS.homebrew}`);
-  out(`  curl:     ${CHANNEL_COMMANDS.curl}`);
+function printChannelCommands(out2) {
+  out2(kv("npm", CHANNEL_COMMANDS.npm));
+  out2(kv("Homebrew", CHANNEL_COMMANDS.homebrew));
+  out2(kv("curl", CHANNEL_COMMANDS.curl));
 }
 async function runUpdate(inputs, deps = {}) {
   const d = { ...defaultDeps4(), ...deps };
   const current = inputs.currentVersion;
-  d.out("dahrk update");
   d.out("");
   let latest;
   try {
     latest = await d.fetchLatest();
   } catch (e) {
-    d.out(`Could not determine the latest version: ${e.message}`);
-    d.out(`You are on ${current}. See https://www.npmjs.com/package/dahrk-node for releases.`);
+    d.out(verdict("fail", `Could not determine the latest version: ${e.message}`));
+    d.out("");
+    d.out(hint(`You are on ${current}. See https://www.npmjs.com/package/dahrk-node for releases.`));
     return 1;
   }
+  d.saveResult({ updateCheckedAt: new Date(d.now()).toISOString(), updateLatest: latest });
   if (!isNewer(latest, current)) {
-    d.out(`Already on the latest version (${current}).`);
+    d.out(verdict("ok", `Already on the latest version (${current}).`));
     return 0;
   }
-  d.out(`Update available: ${current} -> ${latest}`);
+  d.out(verdict("warn", `Update available: ${current} ${arrow()} ${latest}`));
   const channel = detectChannel(d.binPath);
   const cmd = upgradeCommand(channel);
   if (inputs.check) {
     d.out("");
     if (cmd) {
-      d.out(`Run \`dahrk update\` to upgrade (${channel}: ${cmd.display}).`);
+      d.out(hint(`Run \`dahrk update\` to upgrade (${channel}: ${cmd.display}).`));
     } else {
-      d.out("Run `dahrk update`, or upgrade with the command for your install channel:");
+      d.out(hint("Run `dahrk update`, or upgrade with the command for your install channel:"));
       printChannelCommands(d.out);
     }
     return 0;
   }
   if (!cmd) {
     d.out("");
-    d.out("Could not tell how this client was installed. Upgrade with the command for your channel:");
+    d.out(hint("Could not tell how this client was installed. Upgrade with the command for your channel:"));
     printChannelCommands(d.out);
     return 0;
   }
   d.out("");
-  d.out(`Upgrading via ${channel}: ${cmd.display}`);
+  d.out(hint(`Upgrading via ${channel}: ${cmd.display}`));
+  const { code, output } = d.runUpgrade(cmd.argv);
   d.out("");
-  const code = d.runUpgrade(cmd.argv);
+  if (code !== 0) {
+    d.out(verdict("fail", `Upgrade failed (exit ${code}).`));
+    for (const line of output.split("\n")) if (line.trim()) d.out(`    ${dim(line)}`);
+    d.out("");
+    d.out(hint(`Run it yourself to retry: ${cmd.display}`));
+    return code;
+  }
+  if (inputs.verbose) {
+    for (const line of output.split("\n")) if (line.trim()) d.out(`    ${dim(line)}`);
+  }
+  d.out(verdict("ok", `Upgraded to ${latest}.`));
+  await offerRestart(d);
+  return 0;
+}
+async function offerRestart(d) {
+  if (!d.nodeRunning()) return;
+  if (!d.interactive()) {
+    d.out(hint("A node is running on the old build. Run `dahrk restart` to pick this up."));
+    return;
+  }
   d.out("");
-  if (code === 0) {
-    d.out(`Upgraded to ${latest}. Restart a running node (\`dahrk start\`) to pick it up.`);
-  } else {
-    d.out(`Upgrade exited with code ${code}. Run it yourself to see the error: ${cmd.display}`);
+  if (!await d.confirm("A node is running on the old build. Restart it now?")) {
+    d.out(hint("Left running on the old build. Run `dahrk restart` when you are ready."));
+    return;
   }
-  return code;
+  const code = await d.restart();
+  if (code !== 0) d.out(hint("The node is still on the old build. Run `dahrk restart` once it is free."));
+  else d.out(verdict("ok", "Node restarted on the new build."));
 }
 async function fetchLatestVersion(signal) {
   const res = await fetch(LATEST_URL, {
@@ -6139,23 +6348,45 @@ async function fetchLatestVersion(signal) {
 function spawnUpgrade(argv) {
   const [cmd, ...args] = argv;
   try {
-    execFileSync8(cmd, args, { stdio: "inherit" });
-    return 0;
+    const stdout = execFileSync8(cmd, args, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { code: 0, output: stdout };
   } catch (e) {
     const status = e.status;
-    return typeof status === "number" ? status : 1;
+    const { stdout, stderr } = e;
+    return {
+      code: typeof status === "number" ? status : 1,
+      output: `${stdout?.toString() ?? ""}${stderr?.toString() ?? ""}`
+    };
   }
 }
 var defaultDeps4 = () => ({
   binPath: process.argv[1],
   fetchLatest: fetchLatestVersion,
   runUpgrade: spawnUpgrade,
-  out: (line) => void process.stdout.write(`${line}
-`)
+  // The same cache the daemon's periodic check writes (`updateCheckDeps` in main.ts), so both writers agree
+  // on where "what the registry last said" lives and `status` has one place to read it from.
+  saveResult: (patch) => writeState(process.env, patch),
+  now: () => Date.now(),
+  nodeRunning: nodeIsRunning,
+  interactive: isInteractive,
+  confirm,
+  // No inputs: the installed unit already carries this node's token and overrides in its env block, so a
+  // restart re-registers exactly what was there before, with the new client on disk behind it. `desired` is
+  // untouched on purpose - the node was running, and it still is.
+  restart: async () => {
+    const outcome = await runNodeRestart({});
+    if (outcome.kind === "running") return 0;
+    return outcome.kind === "error" ? outcome.code : 1;
+  },
+  out
 });
 
 // src/update-check.ts
-var DEFAULT_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+var STALE_AFTER_INTERVALS = 4;
 var FETCH_TIMEOUT_MS = 1500;
 function checkSuppressed(env) {
   return Boolean(env.DAHRK_NO_UPDATE_CHECK || env.NO_UPDATE_NOTIFIER || env.CI);
@@ -6188,7 +6419,8 @@ async function checkForUpdate(currentVersion, deps) {
   if (checkSuppressed(deps.env)) return void 0;
   const state = deps.readState();
   if (!shouldCheck(deps.now(), state.updateCheckedAt, checkIntervalMs(deps.env), deps.env)) {
-    return cachedUpdate(state, currentVersion, deps.binPath);
+    const cached = cachedUpdate(state, currentVersion, deps.binPath);
+    return cached.kind === "available" ? cached : void 0;
   }
   let latest;
   try {
@@ -6200,88 +6432,179 @@ async function checkForUpdate(currentVersion, deps) {
   if (!isNewer(latest, currentVersion)) return void 0;
   return { current: currentVersion, latest, channel: detectChannel(deps.binPath) };
 }
+var isStale = (checkedAt, now, intervalMs) => now - checkedAt >= intervalMs * STALE_AFTER_INTERVALS;
 function cachedUpdate(state, currentVersion, binPath) {
-  const latest = state.updateLatest;
-  if (!latest || !isNewer(latest, currentVersion)) return void 0;
-  return { current: currentVersion, latest, channel: detectChannel(binPath) };
+  const { updateLatest: latest, updateCheckedAt } = state;
+  const checkedAt = updateCheckedAt ? Date.parse(updateCheckedAt) : NaN;
+  if (!latest || !Number.isFinite(checkedAt)) return { kind: "unknown" };
+  return isNewer(latest, currentVersion) ? { kind: "available", checkedAt, current: currentVersion, latest, channel: detectChannel(binPath) } : { kind: "current", checkedAt };
 }
 
 // src/status.ts
-var bullet = (label, value) => `  ${label.padEnd(12)}${value}`;
+function presenceVerdict(f) {
+  switch (f.presence.kind) {
+    case "running": {
+      const pid = f.presence.pid ? ` (pid ${f.presence.pid})` : "";
+      return { level: "ok", text: `Node running${pid}` };
+    }
+    case "foreign":
+      return { level: "ok", text: `Node running under another supervisor (pid ${f.presence.pid})` };
+    case "stopped":
+      return { level: "warn", text: "Node stopped" };
+    case "not-installed":
+      return { level: "warn", text: "Node not installed" };
+    case "crashed":
+      return { level: "fail", text: "Node is installed but NOT running - it is failing to start or crash-looping" };
+    case "no-supervisor":
+      return { level: "warn", text: "No supervisor on this host" };
+  }
+}
+function presenceHints(f) {
+  switch (f.presence.kind) {
+    case "running":
+    case "foreign":
+      return [hints([["logs", "dahrk logs -f"], ["stop", "dahrk stop"]])];
+    case "stopped":
+      return [hints([["start", "dahrk start"]])];
+    case "not-installed":
+      return [hints([["start", "dahrk start"]])];
+    case "crashed":
+      return [hints([["logs", "dahrk logs -f"], ["check", "dahrk doctor"], ["report", "dahrk diagnose"]])];
+    case "no-supervisor":
+      return [hints([["run it here", "dahrk start --foreground"]])];
+  }
+}
 function renderStatus(f) {
-  const lines = ["dahrk status", ""];
+  const v = presenceVerdict(f);
+  const lines = ["", verdict(v.level, v.text)];
+  if (f.update?.kind === "available") {
+    lines.push(
+      verdict("warn", `Update available: ${f.clientVersion} ${arrow()} ${f.update.latest}`) + `    ${dim("run `dahrk update`")}`
+    );
+  }
+  lines.push("");
   const { nodeId, name, tenantId, enrolToken } = f.state;
   if (enrolToken) {
-    lines.push(bullet("Enrolled", name ? `yes, as ${name}` : "yes"));
-    if (tenantId) lines.push(bullet("Tenant", tenantId));
+    const who = name ? name : "yes";
+    lines.push(kv("Enrolled", tenantId ? `${who}  ${dim("\xB7")}  ${tenantId}` : who));
   } else if (f.envToken) {
-    lines.push(bullet("Enrolled", "yes, via DAHRK_ENROL_TOKEN (caches on the next successful start)"));
+    lines.push(kv("Enrolled", "via DAHRK_ENROL_TOKEN (caches on the next successful start)"));
   } else {
-    lines.push(bullet("Enrolled", "no - run `dahrk start --token <token>` once to enrol"));
+    lines.push(kv("Enrolled", `no  ${dim("run `dahrk start --token <token>` once to enrol")}`));
   }
-  lines.push(bullet("Node id", nodeId ?? "not yet minted (first `dahrk start` mints one)"));
-  lines.push(
-    bullet(
-      "Client",
-      f.update ? `${f.clientVersion} (update available: ${f.update.latest} - run \`dahrk update\`)` : f.clientVersion
-    )
-  );
-  lines.push(bullet("Hub", f.hubUrl));
+  lines.push(kv("Node id", nodeId ?? dim("not yet minted (first `dahrk start` mints one)")));
+  lines.push(kv("Client", `${f.clientVersion}${currency(f)}`));
+  const conn = f.connection ? `  ${dim(`(${f.connection.event} ${ago(f.now - f.connection.at)}${f.connection.detail ? `, ${f.connection.detail}` : ""})`)}` : "";
+  lines.push(kv("Hub", `${f.hubUrl}${conn}`));
+  const installed = f.runtimes.filter((r) => r.installed);
   lines.push(
-    bullet(
+    kv(
       "Runtimes",
-      f.runtimes.length > 0 ? f.runtimes.join(", ") : "none detected - this node will serve no Jobs (install claude / codex / pi)"
+      installed.length > 0 ? installed.map((r) => r.version ? `${r.runtime} ${dim(r.version)}` : r.runtime).join(", ") : `${dim("none detected - this node will serve no Jobs (install claude / codex / pi)")}`
     )
   );
-  if (!f.service) {
-    lines.push(bullet("Node", "no supervisor on this host - run `dahrk start --foreground` (or under pm2)"));
-  } else if (!f.service.installed) {
-    lines.push(bullet("Node", "not installed - run `dahrk start` to run it always-on"));
-  } else if (f.service.running) {
-    const pid = f.service.pid ? ` (pid ${f.service.pid})` : "";
-    lines.push(bullet("Node", `running${pid}`));
-  } else if (f.state.desired === "stopped") {
-    lines.push(bullet("Node", "stopped - run `dahrk start` to bring it back"));
+  if (f.jobs.length === 0) {
+    lines.push(kv("Work", dim("idle")));
   } else {
-    lines.push(bullet("Node", "INSTALLED BUT NOT RUNNING - it is failing to start or crash-looping"));
-    if (f.logHint) lines.push(bullet("", `check the logs: ${f.logHint}`));
+    const [first, ...rest] = f.jobs;
+    lines.push(kv("Work", jobLine(first, f.now)));
+    for (const j of rest) lines.push(kv("", jobLine(j, f.now)));
   }
-  lines.push("", `State file: ${f.stateFile}`);
+  lines.push(...presenceHints(f).flatMap((h) => ["", h]));
+  lines.push("", dim(`  State file: ${f.stateFile}`));
   return lines;
 }
+function currency(f) {
+  const u = f.update;
+  if (!u) return "";
+  if (u.kind === "unknown") {
+    return `  ${dim("update status unknown - run `dahrk update --check`")}`;
+  }
+  const age = ago(f.now - u.checkedAt);
+  if (isStale(u.checkedAt, f.now, f.updateIntervalMs)) {
+    return `  ${dim(`as of ${age} - run \`dahrk update --check\` to refresh`)}`;
+  }
+  if (u.kind === "available") return `  ${dim(`(checked ${age})`)}`;
+  return `  ${symbol("ok")} ${dim(`up to date (checked ${age})`)}`;
+}
+function jobLine(j, now) {
+  const where = j.stageId ? `${j.runId} ${dim("/")} ${j.stageId}` : `${j.runId} ${dim(`(${j.kind})`)}`;
+  return `${where}  ${dim(humanDuration(now - j.startedAt))}`;
+}
 function isUnhealthy(f) {
-  return Boolean(f.service?.installed && !f.service.running && f.state.desired !== "stopped");
+  return f.presence.kind === "crashed";
 }
-async function runStatus(inputs, deps) {
+function resolvePresence(service, lockedPid, desired) {
+  if (service?.running) return { kind: "running", ...service.pid ? { pid: service.pid } : {} };
+  if (lockedPid !== void 0) return { kind: "foreign", pid: lockedPid };
+  if (!service) return { kind: "no-supervisor" };
+  if (!service.installed) return { kind: "not-installed" };
+  return desired === "stopped" ? { kind: "stopped" } : { kind: "crashed" };
+}
+async function gatherFacts(inputs, deps) {
   const manager = detectManager(deps.platform);
   let service;
-  let logHint;
   if (manager !== "unsupported") {
     const unit = unitPath(manager, deps.homeDir);
     const exists = deps.fileExists(unit);
     const probe2 = exists ? deps.capture(statusCommand(manager)) : { code: 1, stdout: "" };
     service = parseServiceStatus(manager, exists, probe2);
-    logHint = "dahrk logs -f";
   }
   const state = readState(stateFile(deps.env));
+  const lockedPid = deps.lockedPid();
+  const presence = resolvePresence(service, lockedPid, state.desired);
+  const livePid = presence.kind === "running" || presence.kind === "foreign" ? presence.pid : void 0;
+  const jobs = livePid === void 0 ? [] : deps.jobs().filter((j) => j.nodePid === livePid);
   const update = checkSuppressed(deps.env) ? void 0 : cachedUpdate(state, inputs.clientVersion, deps.binPath);
-  const facts = {
+  const connection = deps.connection();
+  return {
     clientVersion: inputs.clientVersion,
     hubUrl: inputs.hubUrl,
     stateFile: stateFile(deps.env),
     state,
     envToken: Boolean(deps.env.DAHRK_ENROL_TOKEN),
-    runtimes: await deps.detectRuntimes(),
+    runtimes: await deps.probeRuntimes(),
+    presence,
+    jobs,
+    updateIntervalMs: checkIntervalMs(deps.env),
+    now: deps.now(),
     ...service ? { service } : {},
-    ...logHint ? { logHint } : {},
+    ...connection ? { connection } : {},
     ...update ? { update } : {}
   };
+}
+var CONNECTION_MARKERS = [
+  { prefix: "EDGE_WELCOMED", event: "welcomed", detail: false },
+  { prefix: "EDGE_CONNECTED", event: "connected", detail: false },
+  { prefix: "EDGE_DISCONNECTED", event: "disconnected", detail: true },
+  { prefix: "EDGE_STALE", event: "went stale", detail: false }
+];
+function lastConnection(records) {
+  for (let i = records.length - 1; i >= 0; i--) {
+    const r = records[i];
+    if (typeof r?.msg !== "string") continue;
+    const marker = CONNECTION_MARKERS.find((m) => r.msg === m.prefix || r.msg.startsWith(`${m.prefix}:`));
+    if (!marker) continue;
+    const at = typeof r.time === "string" ? Date.parse(r.time) : typeof r.time === "number" ? r.time : NaN;
+    if (Number.isNaN(at)) continue;
+    const detail = marker.detail ? r.msg.slice(marker.prefix.length + 1).split(/\s+/)[0] ?? "" : "";
+    return { event: marker.event, at, ...detail ? { detail } : {} };
+  }
+  return void 0;
+}
+async function runStatus(inputs, deps) {
+  const facts = await gatherFacts(inputs, deps);
+  if (inputs.json) {
+    const { enrolToken: _omitted, ...state } = facts.state;
+    deps.out(JSON.stringify({ ...facts, state, healthy: !isUnhealthy(facts) }, null, 2));
+    return isUnhealthy(facts) ? 1 : 0;
+  }
   for (const line of renderStatus(facts)) deps.out(line);
   return isUnhealthy(facts) ? 1 : 0;
 }
 
 // src/main.ts
-var CLIENT_VERSION = "0.1.14";
+var CLIENT_VERSION = "0.1.16";
 var DEFAULT_HUB_URL = "wss://api.dahrk.ai";
 var list = (v) => (v ?? "").split(",").map((s) => s.trim()).filter(Boolean);
 var RUNTIMES2 = ["claude-code", "codex", "pi"];
@@ -6367,20 +6690,40 @@ async function start(flags) {
   const env = envWithFlags(process.env, flags);
   if (wantsForeground(env, flags)) return startForeground(env, flags);
   await offerUpdate(env);
-  const outcome = await runNodeStart({
-    ...resolveEnrolToken(env) ? { token: resolveEnrolToken(env) } : {},
-    ...env.DAHRK_NODE_NAME ? { name: env.DAHRK_NODE_NAME } : {},
-    ...env.DAHRK_HUB_URL ? { hubUrl: env.DAHRK_HUB_URL } : {}
-  });
+  const outcome = await runNodeStart(serviceInputs(env));
   if (outcome.kind === "error") return outcome.code;
   if (outcome.kind === "running") {
     setDesired(env, "running");
+    await printStatus(env);
     return 0;
   }
-  console.warn(`${outcome.reason}; running the node in this terminal instead.`);
-  console.warn("Use `dahrk start --foreground` (or DAHRK_FOREGROUND=1) to ask for this explicitly.");
+  out("");
+  out(verdict("warn", `${outcome.reason}; running the node in this terminal instead.`));
+  out("");
+  out(hint("Use `dahrk start --foreground` (or DAHRK_FOREGROUND=1) to ask for this explicitly."));
   return startForeground(env, flags);
 }
+var serviceInputs = (env) => ({
+  ...resolveEnrolToken(env) ? { token: resolveEnrolToken(env) } : {},
+  ...env.DAHRK_NODE_NAME ? { name: env.DAHRK_NODE_NAME } : {},
+  ...env.DAHRK_HUB_URL ? { hubUrl: env.DAHRK_HUB_URL } : {}
+});
+async function restart(flags, force) {
+  const env = envWithFlags(process.env, flags);
+  out("");
+  out(hint("Restarting the node..."));
+  const outcome = await runNodeRestart({ ...serviceInputs(env), force });
+  if (outcome.kind === "error") return outcome.code;
+  if (outcome.kind === "foreground") {
+    out(verdict("warn", `${outcome.reason}; there is no service to restart.`));
+    out("");
+    out(hint("A node running in a terminal is restarted by stopping it (Ctrl-C) and starting it again."));
+    return 1;
+  }
+  setDesired(env, "running");
+  await printStatus(env);
+  return 0;
+}
 async function startForeground(env, flags) {
   if (!flags.ephemeral) {
     const lock = acquireLock(defaultLockDeps(lockFile(env)));
@@ -6446,11 +6789,14 @@ async function startForeground(env, flags) {
   });
   return 0;
 }
-async function stop(env) {
-  const code = await runNodeStop();
+async function stop(env, force) {
+  const code = await runNodeStop({ force });
   if (code === 0 || code === STOP_FOREIGN_NODE) setDesired(env, "stopped");
   return code;
 }
+var updateStateDeps = (env) => ({
+  saveResult: (patch) => writeState(env, patch)
+});
 function updateCheckDeps(env) {
   return {
     env,
@@ -6461,25 +6807,15 @@ function updateCheckDeps(env) {
     fetchLatest: fetchLatestVersion
   };
 }
-var isInteractive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
-async function confirm(question) {
-  const { createInterface } = await import("readline/promises");
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = (await rl.question(`${question} [Y/n] `)).trim().toLowerCase();
-    return answer === "" || answer === "y" || answer === "yes";
-  } finally {
-    rl.close();
-  }
-}
 async function offerUpdate(env) {
   const available = await checkForUpdate(CLIENT_VERSION, updateCheckDeps(env));
   if (!available) return;
-  console.log(renderUpdateNotice(available));
+  out("");
+  out(renderUpdateNotice(available));
   if (!isInteractive()) return;
-  if (!await confirm("update now?")) return;
-  const code = await runUpdate({ currentVersion: CLIENT_VERSION, check: false });
-  if (code !== 0) console.warn("Update failed; starting the node on the current version anyway.");
+  if (!await confirm("Update now?")) return;
+  const code = await runUpdate({ currentVersion: CLIENT_VERSION, check: false }, updateStateDeps(env));
+  if (code !== 0) out(hint("Update failed; starting the node on the current version anyway."));
 }
 function scheduleUpdateChecks(env) {
   if (checkSuppressed(env)) return;
@@ -6498,7 +6834,15 @@ function statusDeps(env) {
     homeDir: homedir7(),
     env,
     binPath: process.argv[1],
-    detectRuntimes: () => resolveRuntimes(env),
+    // The rich probe, with versions - the same one `doctor` runs. An explicit DAHRK_RUNTIMES override still
+    // wins, and is reported as installed-without-a-version, because a pinned runtime was never probed.
+    probeRuntimes: async () => {
+      const override = list(env.DAHRK_RUNTIMES).filter(isRuntime2);
+      if (override.length > 0) {
+        return RUNTIMES2.map((r) => ({ runtime: r, cmd: r, installed: override.includes(r) }));
+      }
+      return probeRuntimeStatuses();
+    },
     fileExists: (path) => existsSync14(path),
     capture: (argv) => {
       const [cmd, ...args] = argv;
@@ -6510,10 +6854,35 @@ function statusDeps(env) {
         return { code: typeof status === "number" ? status : 1, stdout: "" };
       }
     },
-    out: (line) => void process.stdout.write(`${line}
-`)
+    lockedPid: () => {
+      const held = parseLock(readFileOrUndefined(lockFile(env)));
+      return held !== void 0 && isAlive(held) ? held : void 0;
+    },
+    // Best-effort by construction: a missing or unreadable ledger reads as "no jobs in flight", which shows
+    // an idle node rather than failing the whole report over a file that only exists while work is running.
+    jobs: () => fileJobLedger(jobLedgerFile(stateDir(env)), () => {
+    }).all(),
+    connection: () => {
+      const raw = readFileOrUndefined(jsonlLogFile(env));
+      return raw ? lastConnection(parseRecords(raw)) : void 0;
+    },
+    now: () => Date.now(),
+    out
   };
 }
+function readFileOrUndefined(path) {
+  try {
+    return readFileSync11(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function printStatus(env) {
+  return runStatus(
+    { clientVersion: CLIENT_VERSION, hubUrl: env.DAHRK_HUB_URL ?? DEFAULT_HUB_URL },
+    statusDeps(env)
+  );
+}
 var KNOWN_WORKFLOWS = ["preflight"];
 async function runWorkflow(flags) {
   if (flags.workflow !== "preflight") {
@@ -6523,7 +6892,7 @@ async function runWorkflow(flags) {
     return 2;
   }
   const env = applyEnvAliases(process.env);
-  const hubUrl = flags.hubUrl ?? env.DAHRK_HUB_URL;
+  const hubUrl = flags.hubUrl ?? env.DAHRK_HUB_URL ?? DEFAULT_HUB_URL;
   const token = flags.token ?? resolveEnrolToken(env);
   return runPreflight({
     ...flags.repo ? { repoPath: flags.repo } : {},
@@ -6552,7 +6921,10 @@ async function main() {
     case "doctor": {
       const env = envWithFlags(process.env, parsed.flags);
       process.exitCode = await runDoctor({
-        hubUrl: env.DAHRK_HUB_URL,
+        // The same default the node itself dials. Without this, `dahrk doctor` on a stock install FAILED
+        // with "no hub URL configured" while the node was connected to that very hub - it was reporting
+        // that an env var was unset, not that anything was wrong.
+        hubUrl: env.DAHRK_HUB_URL ?? DEFAULT_HUB_URL,
         // Same resolution as `start`, so doctor checks the token the node would actually present:
         // the flag/env if given, else the one cached by the last successful enrolment.
         token: resolveEnrolToken(env),
@@ -6563,7 +6935,11 @@ async function main() {
     case "status": {
       const env = envWithFlags(process.env, parsed.flags);
       process.exitCode = await runStatus(
-        { clientVersion: CLIENT_VERSION, hubUrl: env.DAHRK_HUB_URL ?? DEFAULT_HUB_URL },
+        {
+          clientVersion: CLIENT_VERSION,
+          hubUrl: env.DAHRK_HUB_URL ?? DEFAULT_HUB_URL,
+          json: parsed.flags.json
+        },
         statusDeps(env)
       );
       break;
@@ -6588,24 +6964,24 @@ async function main() {
       break;
     }
     case "update":
-      process.exitCode = await runUpdate({ currentVersion: CLIENT_VERSION, check: parsed.flags.check });
+      process.exitCode = await runUpdate(
+        {
+          currentVersion: CLIENT_VERSION,
+          check: parsed.flags.check,
+          verbose: parsed.flags.verbose
+        },
+        updateStateDeps(applyEnvAliases(process.env))
+      );
       break;
     case "start":
       process.exitCode = await start(parsed.flags);
       break;
     case "stop":
-      process.exitCode = await stop(applyEnvAliases(process.env));
+      process.exitCode = await stop(applyEnvAliases(process.env), parsed.force);
       break;
-    case "restart": {
-      const env = envWithFlags(process.env, parsed.flags);
-      const code = await stop(env);
-      if (code !== 0) {
-        process.exitCode = code;
-        break;
-      }
-      process.exitCode = await start(parsed.flags);
+    case "restart":
+      process.exitCode = await restart(parsed.flags, parsed.force);
       break;
-    }
     case "logs": {
       const env = applyEnvAliases(process.env);
       process.exitCode = await runLogs(parsed.flags, defaultLogsDeps(logFiles(env), jsonlLogFile(env)));
@@ -6620,7 +6996,10 @@ async function main() {
             ...resolveEnrolToken(env) ? { token: resolveEnrolToken(env) } : {},
             hubUrl: env.DAHRK_HUB_URL ?? DEFAULT_HUB_URL
           },
-          { out: (line) => void doctorLines.push(line) }
+          // Stripped: stdout is a TTY here (the operator is watching), so the doctor correctly colours its
+          // report - but this copy is going into a JSON file that someone will open in an editor and paste
+          // into an issue, and escape codes have no business being in it.
+          { out: (line) => void doctorLines.push(stripAnsi(line)) }
         );
         return doctorLines;
       };