dahrk-node 0.1.13 → 0.1.15

package/dist/main.js

@@ -2,10 +2,10 @@
 
 // src/main.ts
 import { execFileSync as execFileSync9 } from "child_process";
-import { existsSync as existsSync13, 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 join16 } from "path";
+import { basename as basename2, join as join17 } from "path";
 import { pathToFileURL } from "url";
 
 // ../../packages/edge/src/ws-client.ts
@@ -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 {
@@ -1482,15 +1482,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\//, "");
@@ -1590,6 +1590,7 @@ function createGitService(opts = {}) {
     gitUrl: spec.gitUrl,
     repo: spec.repo ?? spec.repoId,
     baseBranch: spec.baseBranch,
+    branch: sanitizeBranchName(spec.branch ?? `dahrk/${spec.runId}`),
     worktreePath,
     scratchPath: join3(worktreePath, ".skakel", "scratch")
   });
@@ -1730,6 +1731,31 @@ function createGitService(opts = {}) {
       }
       return { headSha, pushed: true, nothingToCommit: !dirty, wipRef };
     },
+    async reconcileInterrupted(ref, opts2) {
+      const { worktreePath } = ref;
+      if (!existsSync(worktreePath) || !gitOk2(worktreePath, ["rev-parse", "--git-dir"])) {
+        throw new Error(`worktree missing for reconcile: ${worktreePath}`);
+      }
+      const headSha = git(worktreePath, ["rev-parse", "HEAD"]).trim();
+      const wipRef = sanitizeBranchName(opts2.branch);
+      const { headSha: tailSha, dirty } = commitPending(worktreePath, opts2.message);
+      if (!dirty) return { dirty: false, headSha, pushed: false };
+      git(worktreePath, ["branch", "--force", wipRef, tailSha]);
+      let pushed = false;
+      const auth = opts2.credentialToken ? setupAuth(opts2.credentialToken) : void 0;
+      const remote = opts2.credentialToken ? withTokenUser(ref.gitUrl) : ref.gitUrl;
+      try {
+        git(worktreePath, ["push", "--force", remote, `${tailSha}:refs/heads/${wipRef}`], netEnv(auth?.env));
+        pushed = true;
+      } catch (e) {
+        log.warn(`could not push the preserved tail to ${wipRef}: ${e.message}`);
+      } finally {
+        auth?.cleanup();
+      }
+      git(worktreePath, ["reset", "--hard", headSha]);
+      git(worktreePath, ["clean", "-fd", "--exclude", SCRATCH_DIR]);
+      return { dirty: true, headSha, tailSha, wipRef, pushed };
+    },
     async openPrAmbient(ref, opts2) {
       const ownerRepo = parseOwnerRepo(ref.gitUrl);
       if (!ownerRepo) return { prError: `cannot derive owner/repo from ${ref.gitUrl}` };
@@ -1822,13 +1848,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;
@@ -1989,16 +2015,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
@@ -2110,6 +2136,75 @@ function collectHealth(inputs) {
   };
 }
 
+// ../../packages/edge/src/job-ledger.ts
+import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4, renameSync, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname4, join as join8 } from "path";
+var FILE_MODE = 384;
+var DIR_MODE = 448;
+function nullJobLedger() {
+  return { all: () => [], stale: () => [], upsert: () => {
+  }, remove: () => {
+  }, clear: () => {
+  } };
+}
+var isEntry = (v) => {
+  if (typeof v !== "object" || v === null) return false;
+  const e = v;
+  return typeof e["jobId"] === "string" && !!e["jobId"] && typeof e["runId"] === "string" && (e["kind"] === "stage" || e["kind"] === "push") && typeof e["startedAt"] === "number" && typeof e["nodePid"] === "number";
+};
+function fileJobLedger(file, warn = console.warn) {
+  const read = () => {
+    if (!existsSync5(file)) return [];
+    try {
+      const parsed = JSON.parse(readFileSync4(file, "utf8"));
+      if (!Array.isArray(parsed)) return [];
+      return parsed.filter(isEntry);
+    } catch {
+      return [];
+    }
+  };
+  const write = (entries) => {
+    const tmp = `${file}.${process.pid}.tmp`;
+    try {
+      mkdirSync5(dirname4(file), { recursive: true, mode: DIR_MODE });
+      writeFileSync5(tmp, `${JSON.stringify(entries, null, 2)}
+`, { mode: FILE_MODE });
+      chmodSync(tmp, FILE_MODE);
+      renameSync(tmp, file);
+    } catch (e) {
+      warn(`could not persist the job ledger to ${file}: ${e.message}`);
+      try {
+        if (existsSync5(tmp)) unlinkSync(tmp);
+      } catch {
+      }
+    }
+  };
+  return {
+    all: read,
+    stale: (currentPid) => read().filter((e) => e.nodePid !== currentPid),
+    upsert(entry) {
+      write([...read().filter((e) => e.jobId !== entry.jobId), entry]);
+    },
+    remove(jobId) {
+      const next = read().filter((e) => e.jobId !== jobId);
+      write(next);
+    },
+    clear() {
+      write([]);
+    }
+  };
+}
+function announceableJobs(entries) {
+  const out2 = [];
+  for (const e of entries) {
+    if (e.payloadVersion) out2.push({ jobId: e.jobId, payloadVersion: e.payloadVersion });
+  }
+  return out2;
+}
+function jobLedgerFile(stateDir2) {
+  return join8(stateDir2, "jobs.json");
+}
+
 // ../../packages/edge/src/log-shipper.ts
 import { shouldShip } from "@dahrk/contracts";
 var SHIP_BUFFER_MAX = 500;
@@ -2210,8 +2305,8 @@ function ceilingFromEnv(env) {
 }
 
 // ../../packages/edge/src/logger.ts
-import { closeSync, existsSync as existsSync5, mkdirSync as mkdirSync5, openSync, renameSync, rmSync as rmSync4, statSync as statSync2, writeSync } from "fs";
-import { join as join8 } from "path";
+import { closeSync, existsSync as existsSync6, mkdirSync as mkdirSync6, openSync, renameSync as renameSync2, rmSync as rmSync4, statSync as statSync2, writeSync } from "fs";
+import { join as join9 } from "path";
 import pino from "pino";
 
 // ../../packages/edge/src/redact.ts
@@ -2262,18 +2357,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;
 }
@@ -2307,7 +2402,7 @@ var RotatingFile = class {
   open() {
     try {
       this.fd = openSync(this.path, "a");
-      this.size = existsSync5(this.path) ? statSync2(this.path).size : 0;
+      this.size = existsSync6(this.path) ? statSync2(this.path).size : 0;
     } catch (e) {
       this.disable(e);
     }
@@ -2335,12 +2430,12 @@ var RotatingFile = class {
       closeSync(this.fd);
       this.fd = void 0;
       const oldest = `${this.path}.${this.maxFiles}`;
-      if (existsSync5(oldest)) rmSync4(oldest, { force: true });
+      if (existsSync6(oldest)) rmSync4(oldest, { force: true });
       for (let i = this.maxFiles - 1; i >= 1; i--) {
         const from = `${this.path}.${i}`;
-        if (existsSync5(from)) renameSync(from, `${this.path}.${i + 1}`);
+        if (existsSync6(from)) renameSync2(from, `${this.path}.${i + 1}`);
       }
-      if (existsSync5(this.path)) renameSync(this.path, `${this.path}.1`);
+      if (existsSync6(this.path)) renameSync2(this.path, `${this.path}.1`);
       this.open();
     } catch (e) {
       this.disable(e);
@@ -2400,8 +2495,8 @@ function createNodeLogger(opts = {}) {
   if (level !== "silent") streams.push({ level, stream: humanSink });
   if (opts.dir && fileLevel !== "silent") {
     try {
-      mkdirSync5(opts.dir, { recursive: true, mode: 448 });
-      const file = new RotatingFile(join8(opts.dir, "node.jsonl"), opts.maxBytes ?? 10 * 1024 * 1024, opts.maxFiles ?? 5);
+      mkdirSync6(opts.dir, { recursive: true, mode: 448 });
+      const file = new RotatingFile(join9(opts.dir, "node.jsonl"), opts.maxBytes ?? 10 * 1024 * 1024, opts.maxFiles ?? 5);
       streams.push({ level: fileLevel, stream: file });
     } catch (e) {
       process.stderr.write(`dahrk: file logging disabled (${e.message})
@@ -2459,9 +2554,9 @@ function denyToolRule(tool3) {
 // ../../packages/edge/src/stage-runner.ts
 import { execFileSync as execFileSync5 } from "child_process";
 import { createHash as createHash3 } from "crypto";
-import { mkdirSync as mkdirSync6, readdirSync as readdirSync3, readFileSync as readFileSync4, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
+import { mkdirSync as mkdirSync7, readdirSync as readdirSync3, readFileSync as readFileSync5, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { isAbsolute as isAbsolute3, join as join10, relative as relative3, resolve as resolve2, sep as sep3 } from "path";
+import { isAbsolute as isAbsolute3, join as join11, relative as relative3, resolve as resolve2, sep as sep3 } from "path";
 import { attachedDocBasename as attachedDocBasename2 } from "@dahrk/contracts";
 
 // ../../packages/edge/src/builtins.ts
@@ -2469,9 +2564,9 @@ import { execFileSync as execFileSync4 } from "child_process";
 
 // ../../packages/edge/src/fs-roots.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync6, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync7, realpathSync as realpathSync2 } from "fs";
 import { homedir as homedir3, tmpdir as tmpdir3 } from "os";
-import { dirname as dirname4, isAbsolute as isAbsolute2, join as join9, relative as relative2, resolve, sep as sep2 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute2, join as join10, relative as relative2, resolve, sep as sep2 } from "path";
 function isUnder(root, target) {
   const rel = relative2(resolve(root), resolve(target));
   return rel === "" || !rel.startsWith(`..${sep2}`) && rel !== ".." && !isAbsolute2(rel);
@@ -2484,16 +2579,16 @@ function expandPath(raw, cwd) {
 function realish(p) {
   let head = p;
   const tail = [];
-  while (head !== dirname4(head)) {
-    if (existsSync6(head)) {
+  while (head !== dirname5(head)) {
+    if (existsSync7(head)) {
       try {
-        return join9(realpathSync2.native(head), ...tail.reverse());
+        return join10(realpathSync2.native(head), ...tail.reverse());
       } catch {
         return p;
       }
     }
-    tail.push(head.slice(dirname4(head).length + 1));
-    head = dirname4(head);
+    tail.push(head.slice(dirname5(head).length + 1));
+    head = dirname5(head);
   }
   return p;
 }
@@ -2507,11 +2602,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;
   }
@@ -2520,8 +2615,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 };
   }
@@ -2556,26 +2651,26 @@ function computeFsRoots(opts) {
     "/System",
     "/proc",
     "/sys",
-    join9(home, ".gitconfig"),
-    join9(home, ".config"),
-    join9(home, ".npmrc"),
-    join9(home, ".cache"),
-    join9(home, "Library", "Caches"),
-    join9(home, "Library", "pnpm"),
-    join9(home, ".local", "share"),
-    join9(home, ".nvm"),
-    join9(home, ".volta"),
-    join9(home, ".asdf"),
-    join9(home, ".cargo"),
-    join9(home, ".rustup"),
+    join10(home, ".gitconfig"),
+    join10(home, ".config"),
+    join10(home, ".npmrc"),
+    join10(home, ".cache"),
+    join10(home, "Library", "Caches"),
+    join10(home, "Library", "pnpm"),
+    join10(home, ".local", "share"),
+    join10(home, ".nvm"),
+    join10(home, ".volta"),
+    join10(home, ".asdf"),
+    join10(home, ".cargo"),
+    join10(home, ".rustup"),
     ...splitRoots(process.env.DAHRK_FS_EXTRA_READ_ROOTS).map((p) => realish(resolve(p)))
   ].map(realish);
   const deny = [
-    join9(home, ".ssh"),
-    join9(home, ".aws"),
-    join9(home, ".gnupg"),
-    join9(home, ".config", "gcloud"),
-    join9(home, "Library", "Keychains"),
+    join10(home, ".ssh"),
+    join10(home, ".aws"),
+    join10(home, ".gnupg"),
+    join10(home, ".config", "gcloud"),
+    join10(home, "Library", "Keychains"),
     "/Volumes",
     "/etc/shadow",
     "/etc/sudoers"
@@ -2817,12 +2912,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" };
 }
@@ -2893,14 +2988,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 {
@@ -3097,32 +3192,32 @@ var attemptOf = (jobId) => {
 };
 var digest = (value) => `sha256:${createHash3("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 16)}`;
 function writeScratchState(ref, job, attempt, status) {
-  const statePath = join10(ref.scratchPath, "state.json");
+  const statePath = join11(ref.scratchPath, "state.json");
   let state;
   try {
-    state = JSON.parse(readFileSync4(statePath, "utf8"));
+    state = JSON.parse(readFileSync5(statePath, "utf8"));
   } catch {
     state = { runId: job.runId, tenantId: job.tenantId, stages: {} };
   }
   state.stages[job.stageId] = { currentAttempt: attempt, status };
-  mkdirSync6(ref.scratchPath, { recursive: true });
-  writeFileSync5(statePath, JSON.stringify(state, null, 2));
+  mkdirSync7(ref.scratchPath, { recursive: true });
+  writeFileSync6(statePath, JSON.stringify(state, null, 2));
 }
 function writeIssueContext(ref, issueContext) {
   if (issueContext === void 0) return;
   try {
-    mkdirSync6(ref.scratchPath, { recursive: true });
-    writeFileSync5(join10(ref.scratchPath, "issue.md"), issueContext);
+    mkdirSync7(ref.scratchPath, { recursive: true });
+    writeFileSync6(join11(ref.scratchPath, "issue.md"), issueContext);
   } catch {
   }
 }
 function writeAttachedDocuments(ref, docs) {
   if (!docs || docs.length === 0) return;
   try {
-    const dir = join10(ref.scratchPath, "docs");
-    mkdirSync6(dir, { recursive: true });
+    const dir = join11(ref.scratchPath, "docs");
+    mkdirSync7(dir, { recursive: true });
     for (const doc of docs) {
-      writeFileSync5(join10(dir, `${attachedDocBasename2(doc)}.md`), doc.content);
+      writeFileSync6(join11(dir, `${attachedDocBasename2(doc)}.md`), doc.content);
     }
   } catch {
   }
@@ -3140,8 +3235,8 @@ ${lines.join("\n")}
 function writeGuidance(ref, guidance) {
   if (!guidance || guidance.length === 0) return;
   try {
-    mkdirSync6(ref.scratchPath, { recursive: true });
-    writeFileSync5(join10(ref.scratchPath, "guidance.md"), renderGuidanceMarkdown(guidance));
+    mkdirSync7(ref.scratchPath, { recursive: true });
+    writeFileSync6(join11(ref.scratchPath, "guidance.md"), renderGuidanceMarkdown(guidance));
   } catch {
   }
 }
@@ -3167,7 +3262,7 @@ function readEmittedArtifact(ref, relPath) {
   const path = resolveWorktreeRelativePath(ref, relPath);
   if (!path) return void 0;
   try {
-    const raw = readFileSync4(path, "utf8");
+    const raw = readFileSync5(path, "utf8");
     return { path: relPath, content: capContent(raw) };
   } catch {
     return void 0;
@@ -3175,13 +3270,13 @@ function readEmittedArtifact(ref, relPath) {
 }
 function scanScratchOutput(ref, preferRel) {
   try {
-    const names = readdirSync3(join10(ref.worktreePath, SCRATCH_OUTPUT_DIR)).filter(
+    const names = readdirSync3(join11(ref.worktreePath, SCRATCH_OUTPUT_DIR)).filter(
       (n) => n.toLowerCase().endsWith(".md")
     );
     if (names.length === 0) return void 0;
     const preferBase = preferRel?.split("/").pop();
     const pick = preferBase && names.includes(preferBase) ? preferBase : names[0];
-    const raw = readFileSync4(join10(ref.worktreePath, SCRATCH_OUTPUT_DIR, pick), "utf8");
+    const raw = readFileSync5(join11(ref.worktreePath, SCRATCH_OUTPUT_DIR, pick), "utf8");
     if (raw.trim().length === 0) return void 0;
     return { path: `${SCRATCH_OUTPUT_DIR}/${pick}`, content: capContent(raw) };
   } catch {
@@ -3201,7 +3296,7 @@ function scanChangedMarkdown(ref) {
   );
   for (const rel of rels) {
     try {
-      const raw = readFileSync4(join10(ref.worktreePath, rel), "utf8");
+      const raw = readFileSync5(join11(ref.worktreePath, rel), "utf8");
       if (raw.trim().length > 0) return { path: rel, content: capContent(raw) };
     } catch {
     }
@@ -3324,10 +3419,10 @@ function createStageRunner(deps) {
               ...job.workspaceRef.credentialToken ? { credentialToken: job.workspaceRef.credentialToken } : {}
             });
           } else {
-            const base = deps.scratchRoot ?? join10(tmpdir4(), "dahrk", "scratch");
-            const worktreePath = join10(base, runId);
-            const scratchPath = join10(worktreePath, ".skakel", "scratch");
-            mkdirSync6(scratchPath, { recursive: true });
+            const base = deps.scratchRoot ?? join11(tmpdir4(), "dahrk", "scratch");
+            const worktreePath = join11(base, runId);
+            const scratchPath = join11(worktreePath, ".skakel", "scratch");
+            mkdirSync7(scratchPath, { recursive: true });
             ref = { repoId: "", gitUrl: "", repo: "", baseBranch: "", worktreePath, scratchPath };
             scratchOnly.add(runId);
           }
@@ -3342,7 +3437,7 @@ function createStageRunner(deps) {
           const slash = job.agentConfig.emitArtifact.lastIndexOf("/");
           if (artifactDir && slash > 0) {
             try {
-              mkdirSync6(join10(ref.worktreePath, job.agentConfig.emitArtifact.slice(0, slash)), { recursive: true });
+              mkdirSync7(join11(ref.worktreePath, job.agentConfig.emitArtifact.slice(0, slash)), { recursive: true });
             } catch {
             }
           }
@@ -3370,8 +3465,8 @@ function createStageRunner(deps) {
           if (!sink) return;
           const base = { tenantId: job.tenantId, runId, stageId, attempt };
           try {
-            for (const name of readdirSync3(join10(writer.dir, "blobs"))) {
-              const bytes = readFileSync4(join10(writer.dir, "blobs", name));
+            for (const name of readdirSync3(join11(writer.dir, "blobs"))) {
+              const bytes = readFileSync5(join11(writer.dir, "blobs", name));
               const { url } = await sink.requestBlobUrl({
                 ...base,
                 sha256: name,
@@ -3385,7 +3480,7 @@ function createStageRunner(deps) {
           }
           let archiveKey;
           try {
-            const bytes = readFileSync4(join10(writer.dir, "trace.jsonl"));
+            const bytes = readFileSync5(join11(writer.dir, "trace.jsonl"));
             const sha = createHash3("sha256").update(bytes).digest("hex");
             const { key, url } = await sink.requestBlobUrl({
               ...base,
@@ -3492,10 +3587,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 } }));
           }
@@ -3503,13 +3598,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") {
@@ -3518,14 +3613,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;
               }
             }
@@ -3771,6 +3866,7 @@ async function startEdgeNode(opts) {
   const log = opts.logger ?? createNodeLogger({ level: levelFromEnv(process.env) });
   const rules = opts.denyTool ? [denyToolRule(opts.denyTool)] : [];
   const counters = new HealthCounters();
+  const ledger = opts.jobLedger ?? nullJobLedger();
   const shipper = opts.shipper;
   const telemetryCeiling = ceilingFromEnv(process.env);
   let currentRuntimes = opts.runtimes;
@@ -3869,6 +3965,39 @@ async function startEdgeNode(opts) {
   };
   const stageRunner = createStageRunner(stageDeps);
   stageRunnerRef = stageRunner;
+  const reconcileInterruptedJobs = async () => {
+    const stale = ledger.stale(process.pid);
+    if (!stale.length) return;
+    log.warn({ count: stale.length }, `EDGE_INTERRUPTED:${stale.length} jobs died with the previous process`);
+    for (const entry of stale) {
+      const entryLog = log.child({ runId: entry.runId, jobId: entry.jobId, ...entry.stageId ? { stageId: entry.stageId } : {} });
+      if (!entry.worktreePath || !entry.gitUrl) {
+        entryLog.warn({}, `EDGE_INTERRUPTED_ABANDONED:${entry.jobId} no worktree recorded`);
+        continue;
+      }
+      try {
+        const r = await gitService.reconcileInterrupted(
+          { worktreePath: entry.worktreePath, gitUrl: entry.gitUrl },
+          {
+            message: `wip: work in progress when the node was interrupted (run ${entry.runId})`,
+            branch: `dahrk/wip/${entry.runId}`
+          }
+        );
+        if (r.dirty) {
+          entryLog.warn(
+            { wipRef: r.wipRef, tailSha: r.tailSha, headSha: r.headSha, pushed: r.pushed },
+            `EDGE_INTERRUPTED_RESET:${entry.jobId} preserved the uncommitted tail on ${r.wipRef}${r.pushed ? "" : " (locally only)"} and reset to ${r.headSha.slice(0, 8)}`
+          );
+        } else {
+          entryLog.info({ headSha: r.headSha }, `EDGE_INTERRUPTED_CLEAN:${entry.jobId} worktree was already clean`);
+        }
+      } catch (e) {
+        entryLog.warn({ err: e }, `EDGE_INTERRUPTED_ERROR:${entry.jobId} ${e.message}`);
+      }
+    }
+    ledger.clear();
+  };
+  await reconcileInterruptedJobs();
   void stageRunner.reapWorktrees().then((r) => {
     counters.worktreeCount = Math.max(r.scanned - r.reaped.length, 0);
     if (r.reaped.length) {
@@ -3895,7 +4024,22 @@ async function startEdgeNode(opts) {
       // Advertise the resolved worktree base so the hub records each run's real worktree location in
       // the projection instead of an advisory placeholder. Single-sourced from the git service so it
       // always matches where worktrees actually land.
-      worktreesDir: gitService.worktreesDir
+      worktreesDir: gitService.worktreesDir,
+      // What we are running RIGHT NOW (DHK-416), which is what lets a new hub build ADOPT an in-flight
+      // stage rather than duplicate it (DHK-415). Without this the hub cannot tell "this node is midway
+      // through the stage you are about to re-dispatch" from "this node is idle", so a hub roll or a
+      // reconnect re-ran the stage from scratch.
+      //
+      // Always sent, even empty. Per the wire contract an ABSENT list means "unknown" (a node too old to
+      // answer, for which the hub must keep its old re-dispatch behaviour), while an EMPTY list means "I
+      // have nothing in flight" - a positive statement the hub can act on. We always know, so we always
+      // say, and the two must not be conflated.
+      //
+      // Only genuinely-running jobs are in `running`: boot reconciliation has already dropped the entries
+      // whose runner died with the previous process, so we never claim to be running something we are not.
+      // `announceableJobs` drops what we cannot version-stamp - announcing such a job would make the hub
+      // KILL it, not adopt it. See there.
+      inFlightJobs: announceableJobs(running.values())
     });
   };
   let reprobeTimer;
@@ -3915,7 +4059,15 @@ async function startEdgeNode(opts) {
     }, opts.runtimeRecheckMs ?? 6e4);
     reprobeTimer.unref?.();
   }
-  const running = /* @__PURE__ */ new Set();
+  const running = /* @__PURE__ */ new Map();
+  const trackJob = (entry) => {
+    running.set(entry.jobId, entry);
+    ledger.upsert(entry);
+  };
+  const untrackJob = (jobId) => {
+    running.delete(jobId);
+    ledger.remove(jobId);
+  };
   const onMessage = async (raw) => {
     const msg = decode(raw);
     if (msg.type === "welcome") {
@@ -3984,8 +4136,20 @@ async function startEdgeNode(opts) {
         pushLog.info({}, `PUSH_REPLAY:${job2.runId} ${job2.jobId}`);
         return;
       }
-      running.add(job2.jobId);
       const pushStartedAt = Date.now();
+      trackJob({
+        jobId: job2.jobId,
+        runId: job2.runId,
+        kind: "push",
+        // No `payloadVersion`: `PushJob` does not carry one (DHK-415 added the field to `JobRequest`
+        // only). It is ledgered anyway - boot reconciliation still has to clean its worktree - but it is
+        // deliberately never announced. See `sendHello`.
+        ...job2.workspaceRef?.worktreePath ? { worktreePath: job2.workspaceRef.worktreePath } : {},
+        ...job2.branch ? { branch: job2.branch } : {},
+        ...job2.workspaceRef?.gitUrl ? { gitUrl: job2.workspaceRef.gitUrl } : {},
+        startedAt: pushStartedAt,
+        nodePid: process.pid
+      });
       pushLog.info({}, `PUSH_STARTED:${job2.runId} ${job2.branch}`);
       try {
         const result = await stageRunner.runPush(job2);
@@ -4006,7 +4170,7 @@ async function startEdgeNode(opts) {
         send(frame);
         pushLog.error({ err: e, durationMs: Date.now() - pushStartedAt }, `PUSH_ERROR:${job2.runId} ${e.message}`);
       } finally {
-        running.delete(job2.jobId);
+        untrackJob(job2.jobId);
       }
       return;
     }
@@ -4030,9 +4194,23 @@ async function startEdgeNode(opts) {
       jobLog.info({}, `JOB_REPLAY:${job.stageId} ${job.jobId}`);
       return;
     }
-    running.add(job.jobId);
-    counters.activeJobs = running.size;
     const startedAt = Date.now();
+    trackJob({
+      jobId: job.jobId,
+      runId: job.runId,
+      kind: "stage",
+      stageId: job.stageId,
+      // The hub stamped this on dispatch. Persisting it is what lets a reconnecting node prove, after a
+      // restart, that the job it is announcing was dispatched under a contract the adopting build can
+      // still read. Announced without it, the hub's gate version-rejects the job rather than adopting it.
+      ...job.payloadVersion ? { payloadVersion: job.payloadVersion } : {},
+      ...job.workspaceRef?.worktreePath ? { worktreePath: job.workspaceRef.worktreePath } : {},
+      ...job.workspaceRef?.branch ? { branch: job.workspaceRef.branch } : {},
+      ...job.workspaceRef?.gitUrl ? { gitUrl: job.workspaceRef.gitUrl } : {},
+      startedAt,
+      nodePid: process.pid
+    });
+    counters.activeJobs = running.size;
     jobLog.info({}, `JOB_STARTED:${job.stageId} ${job.jobId}`);
     try {
       const result = await stageRunner.runJob(job);
@@ -4054,7 +4232,7 @@ async function startEdgeNode(opts) {
       counters.recordError(classifyError(e));
       jobLog.error({ err: e, durationMs: Date.now() - startedAt }, `JOB_ERROR:${job.stageId} ${e.message}`);
     } finally {
-      running.delete(job.jobId);
+      untrackJob(job.jobId);
       counters.activeJobs = running.size;
     }
   };
@@ -4308,6 +4486,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
@@ -4317,6 +4499,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 } : {},
@@ -4326,7 +4509,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"];
@@ -4461,6 +4646,7 @@ function parseUpdate(flagArgs) {
       args: flagArgs,
       options: {
         check: { type: "boolean", default: false },
+        verbose: { type: "boolean", default: false },
         help: { type: "boolean", default: false }
       },
       allowPositionals: false
@@ -4469,7 +4655,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") {
@@ -4504,26 +4690,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") {
@@ -4615,26 +4814,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.",
       "",
-      "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.",
+      "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.",
       "",
-      "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."
+      "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.",
+      "",
+      "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 [
@@ -4643,10 +4854,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).",
@@ -4660,8 +4871,82 @@ function usage(bin, command) {
 }
 
 // src/diagnose.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync7, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
-import { join as join11 } from "path";
+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 = [];
@@ -4702,7 +4987,7 @@ async function buildBundle(deps) {
   if (deps.exists(deps.crashDir)) {
     for (const name of deps.listDir(deps.crashDir).filter((f) => f.endsWith(".json")).sort()) {
       try {
-        crashes.push(JSON.parse(deps.readFile(join11(deps.crashDir, name))));
+        crashes.push(JSON.parse(deps.readFile(join12(deps.crashDir, name))));
       } catch (e) {
         warnings.push(`could not read crash record ${name} (${e.message})`);
       }
@@ -4759,24 +5044,23 @@ var defaultDiagnoseDeps = (paths, clientVersion, doctor) => ({
   ...paths,
   clientVersion,
   ...doctor ? { doctor } : {},
-  readFile: (p) => readFileSync5(p, "utf8"),
+  readFile: (p) => readFileSync6(p, "utf8"),
   listDir: (p) => readdirSync4(p),
-  exists: (p) => existsSync7(p),
+  exists: (p) => existsSync8(p),
   writeFile: (p, content) => {
-    const dir = join11(p, "..");
-    if (!existsSync7(dir)) mkdirSync7(dir, { recursive: true });
-    writeFileSync6(p, content, { mode: 384 });
+    const dir = join12(p, "..");
+    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 join11(cwd, `dahrk-diagnose-${now.toISOString().replace(/[:.]/g, "-")}.json`);
+  return join12(cwd, `dahrk-diagnose-${now.toISOString().replace(/[:.]/g, "-")}.json`);
 }
 
 // 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)) {
@@ -4874,16 +5158,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 };
@@ -4906,8 +5189,8 @@ async function runDoctor(inputs, deps = {}) {
 }
 
 // src/lock.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync6, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname5 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync7, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname6 } from "path";
 function parseLock(content) {
   if (!content) return void 0;
   const pid = Number(content.trim());
@@ -4939,14 +5222,14 @@ var defaultLockDeps = (file) => ({
   pid: process.pid,
   readFile: (path) => {
     try {
-      return readFileSync6(path, "utf8");
+      return readFileSync7(path, "utf8");
     } catch {
       return void 0;
     }
   },
   writeFile: (path, content) => {
-    if (!existsSync8(dirname5(path))) mkdirSync8(dirname5(path), { recursive: true, mode: 448 });
-    writeFileSync7(path, content);
+    if (!existsSync9(dirname6(path))) mkdirSync9(dirname6(path), { recursive: true, mode: 448 });
+    writeFileSync8(path, content);
   },
   removeFile: (path) => rmSync6(path, { force: true }),
   isAlive
@@ -4954,7 +5237,7 @@ var defaultLockDeps = (file) => ({
 
 // src/logs.ts
 import { spawn } from "child_process";
-import { copyFileSync, existsSync as existsSync9, readFileSync as readFileSync7, statSync as statSync4, truncateSync } from "fs";
+import { copyFileSync, existsSync as existsSync10, readFileSync as readFileSync8, statSync as statSync4, truncateSync } from "fs";
 var MAX_LOG_BYTES = 10 * 1024 * 1024;
 function logsCommand(inputs) {
   return [
@@ -4968,15 +5251,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;
@@ -5035,7 +5318,7 @@ async function runStructuredLogs(inputs, deps) {
 }
 function rotateIfLarge(file, maxBytes = MAX_LOG_BYTES) {
   try {
-    if (!existsSync9(file) || statSync4(file).size <= maxBytes) return;
+    if (!existsSync10(file) || statSync4(file).size <= maxBytes) return;
     copyFileSync(file, `${file}.1`);
     truncateSync(file, 0);
   } catch {
@@ -5044,26 +5327,25 @@ function rotateIfLarge(file, maxBytes = MAX_LOG_BYTES) {
 var defaultLogsDeps = (files, jsonlFile) => ({
   files,
   jsonlFile,
-  fileExists: (path) => existsSync9(path),
-  readFile: (path) => readFileSync7(path, "utf8"),
+  fileExists: (path) => existsSync10(path),
+  readFile: (path) => readFileSync8(path, "utf8"),
   run: (argv) => new Promise((resolve3) => {
     const [cmd, ...args] = argv;
     const child = spawn(cmd, args, { stdio: "inherit" });
     child.on("error", () => resolve3(1));
     child.on("close", (code) => resolve3(code ?? 0));
   }),
-  out: (line) => void process.stdout.write(`${line}
-`)
+  out
 });
 
 // src/process-safety.ts
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync8 } from "fs";
-import { join as join12 } from "path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
+import { join as join13 } from "path";
 function writeCrashRecord(dir, record) {
   try {
-    mkdirSync9(dir, { recursive: true, mode: 448 });
-    const file = join12(dir, `${record.at.replace(/[:.]/g, "-")}.json`);
-    writeFileSync8(file, `${JSON.stringify(record, null, 2)}
+    mkdirSync10(dir, { recursive: true, mode: 448 });
+    const file = join13(dir, `${record.at.replace(/[:.]/g, "-")}.json`);
+    writeFileSync9(file, `${JSON.stringify(record, null, 2)}
 `, { mode: 384 });
     return file;
   } catch {
@@ -5118,9 +5400,9 @@ function installProcessSafetyNet(opts) {
 // src/preflight.ts
 import { execFileSync as execFileSync6 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { accessSync, constants as fsConstants, existsSync as existsSync10, readdirSync as readdirSync5, statfsSync as statfsSync2 } from "fs";
+import { accessSync, constants as fsConstants, existsSync as existsSync11, readdirSync as readdirSync5, statfsSync as statfsSync2 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 var REPORT_BASE_URL = "https://app.dahrk.ai/r";
 var LOW_DISK_BYTES = 512 * 1024 * 1024;
 var PREFLIGHT_STAGES = [
@@ -5184,15 +5466,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 };
@@ -5244,8 +5529,7 @@ var defaultDeps2 = () => ({
   probeHub,
   gatherHost: gatherHostFacts,
   newRunId: () => randomUUID2(),
-  out: (line) => void process.stdout.write(`${line}
-`)
+  out
 });
 function commandPresent(cmd) {
   try {
@@ -5257,8 +5541,8 @@ function commandPresent(cmd) {
 }
 function sshKeyPresent() {
   try {
-    const dir = join13(homedir4(), ".ssh");
-    if (existsSync10(dir) && readdirSync5(dir).some((f) => f.endsWith(".pub"))) return true;
+    const dir = join14(homedir4(), ".ssh");
+    if (existsSync11(dir) && readdirSync5(dir).some((f) => f.endsWith(".pub"))) return true;
   } catch {
   }
   try {
@@ -5277,12 +5561,12 @@ function writable(dir) {
   }
 }
 function worktreeRoot(env) {
-  return env.DAHRK_WORKTREES_DIR ?? join13(env.DAHRK_STATE_DIR ?? join13(homedir4(), ".dahrk"), "worktrees");
+  return env.DAHRK_WORKTREES_DIR ?? join14(env.DAHRK_STATE_DIR ?? join14(homedir4(), ".dahrk"), "worktrees");
 }
 function nearestExisting(dir) {
   let cur = dir;
-  while (!existsSync10(cur)) {
-    const parent = join13(cur, "..");
+  while (!existsSync11(cur)) {
+    const parent = join14(cur, "..");
     if (parent === cur) break;
     cur = parent;
   }
@@ -5333,52 +5617,52 @@ function gatherHostFacts(repoPath) {
 
 // src/service.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { chmodSync as chmodSync2, existsSync as existsSync12, mkdirSync as mkdirSync11, readFileSync as readFileSync9, realpathSync as realpathSync3, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "fs";
+import { chmodSync as chmodSync3, existsSync as existsSync13, mkdirSync as mkdirSync12, readFileSync as readFileSync10, realpathSync as realpathSync3, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir6, platform as osPlatform3, userInfo } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/state.ts
-import { chmodSync, existsSync as existsSync11, mkdirSync as mkdirSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync12, mkdirSync as mkdirSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var RUNTIMES = ["claude-code", "codex", "pi"];
 var isRuntime = (v) => RUNTIMES.includes(v);
 var STRING_FIELDS = ["nodeId", "enrolToken", "name", "tenantId", "updateCheckedAt", "updateLatest"];
 var isDesired = (v) => v === "running" || v === "stopped";
-var FILE_MODE = 384;
-var DIR_MODE = 448;
+var FILE_MODE2 = 384;
+var DIR_MODE2 = 448;
 function stateDir(env) {
-  return env.DAHRK_STATE_DIR ?? join14(homedir5(), ".dahrk");
+  return env.DAHRK_STATE_DIR ?? join15(homedir5(), ".dahrk");
 }
 function legacyStateDir(env) {
-  return env.DAHRK_STATE_DIR ? void 0 : join14(homedir5(), ".skakel");
+  return env.DAHRK_STATE_DIR ? void 0 : join15(homedir5(), ".skakel");
 }
 function stateFile(env) {
-  return join14(stateDir(env), "node.json");
+  return join15(stateDir(env), "node.json");
 }
 function logDir(env) {
-  return join14(stateDir(env), "logs");
+  return join15(stateDir(env), "logs");
 }
 function logFiles(env) {
   const dir = logDir(env);
-  return { out: join14(dir, "node.out.log"), err: join14(dir, "node.err.log") };
+  return { out: join15(dir, "node.out.log"), err: join15(dir, "node.err.log") };
 }
 function jsonlLogFile(env) {
-  return join14(logDir(env), "node.jsonl");
+  return join15(logDir(env), "node.jsonl");
 }
 function crashDir(env) {
-  return join14(logDir(env), "crashes");
+  return join15(logDir(env), "crashes");
 }
 function lockFile(env) {
-  return join14(stateDir(env), "node.pid");
+  return join15(stateDir(env), "node.pid");
 }
 function setDesired(env, desired) {
   writeState(env, { desired });
 }
 function readState(file) {
-  if (!existsSync11(file)) return {};
+  if (!existsSync12(file)) return {};
   try {
-    const parsed = JSON.parse(readFileSync8(file, "utf8"));
+    const parsed = JSON.parse(readFileSync9(file, "utf8"));
     const state = {};
     for (const key of STRING_FIELDS) {
       const value = parsed[key];
@@ -5398,11 +5682,11 @@ function writeState(env, patch) {
   const dir = stateDir(env);
   const file = stateFile(env);
   try {
-    mkdirSync10(dir, { recursive: true, mode: DIR_MODE });
+    mkdirSync11(dir, { recursive: true, mode: DIR_MODE2 });
     const next = { ...readState(file), ...patch };
-    writeFileSync9(file, `${JSON.stringify(next, null, 2)}
-`, { mode: FILE_MODE });
-    chmodSync(file, FILE_MODE);
+    writeFileSync10(file, `${JSON.stringify(next, null, 2)}
+`, { mode: FILE_MODE2 });
+    chmodSync2(file, FILE_MODE2);
   } catch (e) {
     console.warn(`could not persist node state to ${file}: ${e.message}`);
   }
@@ -5481,9 +5765,9 @@ ${envEntries}
   <key>ThrottleInterval</key>
   <integer>10</integer>
   <key>StandardOutPath</key>
-  <string>${xmlEscape(join15(inputs.logDir, "node.out.log"))}</string>
+  <string>${xmlEscape(join16(inputs.logDir, "node.out.log"))}</string>
   <key>StandardErrorPath</key>
-  <string>${xmlEscape(join15(inputs.logDir, "node.err.log"))}</string>
+  <string>${xmlEscape(join16(inputs.logDir, "node.err.log"))}</string>
 </dict>
 </plist>
 `;
@@ -5506,8 +5790,8 @@ Type=simple
 ExecStart=${exec}
 ${envLines}
 WorkingDirectory=${inputs.homeDir}
-StandardOutput=append:${join15(inputs.logDir, "node.out.log")}
-StandardError=append:${join15(inputs.logDir, "node.err.log")}
+StandardOutput=append:${join16(inputs.logDir, "node.out.log")}
+StandardError=append:${join16(inputs.logDir, "node.err.log")}
 Restart=on-failure
 RestartSec=3
 RestartPreventExitStatus=78
@@ -5518,7 +5802,7 @@ WantedBy=default.target
 }
 function buildPlan(inputs) {
   if (inputs.manager === "launchd") {
-    const filePath2 = join15(inputs.homeDir, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+    const filePath2 = join16(inputs.homeDir, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
     return {
       manager: "launchd",
       label: LAUNCHD_LABEL,
@@ -5535,7 +5819,7 @@ function buildPlan(inputs) {
       logHint: "dahrk logs -f"
     };
   }
-  const filePath = join15(inputs.homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
+  const filePath = join16(inputs.homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
   const user = userInfo().username;
   return {
     manager: "systemd",
@@ -5565,7 +5849,7 @@ function unitIsCurrent(plan, onDisk) {
   return onDisk === plan.content;
 }
 function unitPath(manager, homeDir) {
-  return manager === "launchd" ? join15(homeDir, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`) : join15(homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
+  return manager === "launchd" ? join16(homeDir, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`) : join16(homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
 }
 function statusCommand(manager) {
   return manager === "launchd" ? ["launchctl", "list", LAUNCHD_LABEL] : ["systemctl", "--user", "show", SYSTEMD_UNIT, "-p", "ActiveState", "-p", "MainPID"];
@@ -5582,16 +5866,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;
     }
   }
@@ -5599,13 +5885,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({
@@ -5624,26 +5910,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") {
@@ -5656,8 +5957,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({
@@ -5673,12 +5975,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 {
@@ -5689,28 +5989,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,
@@ -5720,28 +6057,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);
@@ -5754,17 +6094,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) {
@@ -5803,34 +6145,45 @@ 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,
-  mkdirp: (dir) => void mkdirSync11(dir, { recursive: true }),
+  mkdirp: (dir) => void mkdirSync12(dir, { recursive: true }),
   // The unit's environment block carries the enrolment token, so the file is a secret: write it
   // owner-only. `writeFileSync`'s `mode` applies only when it CREATES the file, so chmod explicitly
   // too - re-installing over a unit an older client left at 0644 must tighten it, not keep it.
   writeFile: (path, content) => {
-    writeFileSync10(path, content, { mode: UNIT_FILE_MODE });
-    chmodSync2(path, UNIT_FILE_MODE);
+    writeFileSync11(path, content, { mode: UNIT_FILE_MODE });
+    chmodSync3(path, UNIT_FILE_MODE);
   },
   readFile: (path) => {
     try {
-      return readFileSync9(path, "utf8");
+      return readFileSync10(path, "utf8");
     } catch {
       return void 0;
     }
   },
   removeFile: (path) => rmSync7(path, { force: true }),
-  fileExists: (path) => existsSync12(path),
+  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) => {
@@ -5846,8 +6199,7 @@ var defaultDeps3 = () => ({
       return { code: typeof status === "number" ? status : 1, stdout: "" };
     }
   },
-  out: (line) => void process.stdout.write(`${line}
-`)
+  out
 });
 
 // src/update.ts
@@ -5895,58 +6247,79 @@ 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;
   }
   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, {
@@ -5961,19 +6334,36 @@ 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}
-`)
+  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
@@ -6029,81 +6419,155 @@ function cachedUpdate(state, currentVersion, binPath) {
 }
 
 // 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), ""];
   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(kv("Node id", nodeId ?? dim("not yet minted (first `dahrk start` mints one)")));
   lines.push(
-    bullet(
+    kv(
       "Client",
-      f.update ? `${f.clientVersion} (update available: ${f.update.latest} - run \`dahrk update\`)` : f.clientVersion
+      f.update ? `${f.clientVersion}  ${dim(`(update available: ${f.update.latest} - run \`dahrk update\`)`)}` : f.clientVersion
     )
   );
-  lines.push(bullet("Hub", f.hubUrl));
+  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 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,
+    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.13";
+var CLIENT_VERSION = "0.1.15";
 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"];
@@ -6115,7 +6579,7 @@ function resolveNodeId(env, opts = {}) {
   if (existing) return existing;
   const legacy = legacyStateDir(env);
   if (legacy) {
-    const legacyId = readState(join16(legacy, "node.json")).nodeId;
+    const legacyId = readState(join17(legacy, "node.json")).nodeId;
     if (legacyId) return legacyId;
   }
   const nodeId = randomUUID3();
@@ -6189,20 +6653,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)));
@@ -6258,14 +6742,18 @@ async function startForeground(env, flags) {
     // (a pinned override never re-probes to something else) and the mock runner path stays stable.
     reprobeRuntimes: () => resolveRuntimes(env),
     ...env.DAHRK_RUNTIME_RECHECK_MS ? { runtimeRecheckMs: Number(env.DAHRK_RUNTIME_RECHECK_MS) } : {},
+    // What this node is running, on disk, so a crash mid-stage does not silently re-run the stage from
+    // scratch (DHK-416). Skipped for an ephemeral node for the same reason it never caches a token: a
+    // one-shot CI node touches no state dir, and has no next boot to recover into.
+    ...flags.ephemeral ? {} : { jobLedger: fileJobLedger(jobLedgerFile(stateDir(env))) },
     ...persist ? {
       onEnrolled: (welcome) => persistEnrolment(env, { token, name: welcome.name, tenantId: welcome.tenantId })
     } : {}
   });
   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;
 }
@@ -6279,25 +6767,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;
+  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 (code !== 0) out(hint("Update failed; starting the node on the current version anyway."));
 }
 function scheduleUpdateChecks(env) {
   if (checkSuppressed(env)) return;
@@ -6316,8 +6794,16 @@ function statusDeps(env) {
     homeDir: homedir7(),
     env,
     binPath: process.argv[1],
-    detectRuntimes: () => resolveRuntimes(env),
-    fileExists: (path) => existsSync13(path),
+    // 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;
       try {
@@ -6328,10 +6814,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") {
@@ -6341,7 +6852,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 } : {},
@@ -6370,7 +6881,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),
@@ -6381,7 +6895,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;
@@ -6406,24 +6924,21 @@ 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
+      });
       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)));
@@ -6438,7 +6953,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;
       };