daemon stability wave 2: health you can see, someone else's Mac

commands/__tests__/home.test.ts

@@ -172,6 +172,16 @@ class FakeSeam implements ExecSeam {
  async run(cmd: string[]): Promise<ExecResult> {
  this.calls.push({ kind: "run", arg: cmd });
  if (this.opts.failRun?.(cmd)) return { code: 1, stdout: "", stderr: "boom" };
+ // commitInitialUserRepo probes identity before committing; default to
+ // "configured" so fixtures not exercising the no-identity path stay
+ // green, mirroring lib/daemon/__tests__/home-snapshot.test.ts's
+ // defaultResponders.
+ if (cmd[cmd.length - 2] === "config" && cmd[cmd.length - 1] === "user.name") {
+ return { code: 0, stdout: "rt test\n", stderr: "" };
+ }
+ if (cmd[cmd.length - 2] === "config" && cmd[cmd.length - 1] === "user.email") {
+ return { code: 0, stdout: "rt@example.test\n", stderr: "" };
+ }
  return { code: 0, stdout: "", stderr: "" };
  }
  async writeFile(path: string, content: string): Promise<void> {

commands/__tests__/log-level.test.ts

@@ -0,0 +1,9 @@
+import { test, expect } from "bun:test";
+import { formatLogLevelResult } from "../daemon.ts";
+
+test("formats a set result", () => {
+ expect(formatLogLevelResult({ ok: true, level: "debug" }, true)).toContain("debug");
+});
+test("formats a show result", () => {
+ expect(formatLogLevelResult({ ok: true, level: "info" }, false)).toContain("info");
+});

commands/__tests__/status-lines.test.ts

@@ -0,0 +1,33 @@
+import { test, expect } from "bun:test";
+import { statusLines } from "../daemon.ts";
+
+const strip = (s: string) => s.replace(/\[[0-9;]*m/g, "");
+
+test("degraded/unresponsive prints ping-carried maxLag, not 'likely mid-sync'", () => {
+ const lines = statusLines(
+ { state: "degraded", reason: "unresponsive", pid: 42, eventLoop: { maxLagMs: 1400, lastStallAt: 1, lastStallCmd: "mr:action", stalls: 2 } } as any,
+ 2000,
+ ).map(strip).join("\n");
+ expect(lines).not.toContain("likely mid-sync");
+ expect(lines).toContain("1400ms");
+ expect(lines).toContain("mr:action");
+});
+
+test("alive-not-serving 'stalled' prints stalled Ns ago", () => {
+ const lines = statusLines(
+ { state: "alive-not-serving", pid: 42, detail: "stalled", stalledForMs: 8000 } as any,
+ 0,
+ ).map(strip).join("\n");
+ expect(lines).toContain("event loop stalled");
+ expect(lines).toContain("8s");
+});
+
+test("running prints the health level and reasons when present", () => {
+ const lines = statusLines(
+ { state: "running", data: { pid: 42, uptime: 60000, watchedRepos: 3, cacheEntries: 10,
+ health: { level: "degraded", reasons: ["refresh: 3 repos failing (auth?)"] } } } as any,
+ 0,
+ ).map(strip).join("\n");
+ expect(lines).toContain("degraded");
+ expect(lines).toContain("refresh: 3 repos failing");
+});

commands/daemon.ts

@@ -33,11 +33,12 @@ import {
  LOG_DIR,
  LAUNCHD_PLIST_PATH,
 } from "../lib/daemon-config.ts";
-import { daemonQuery, isDaemonRunning, trayQuery } from "../lib/daemon-client.ts";
+import { daemonQuery, isDaemonRunning, pingDaemon, trayQuery } from "../lib/daemon-client.ts";
 import { classifyDaemonStatus, type DaemonStatusVerdict } from "../lib/daemon-status.ts";
 import { resolveIntendedMode, currentMode, type IntendedMode } from "../lib/dev-mode.ts";
 import { probeSocketHolder } from "../lib/daemon/park.ts";
 import { readBreadcrumb, readSupervisionState } from "../lib/daemon/supervision-state.ts";
+import { readHeartbeat } from "../lib/daemon/heartbeat-file.ts";
 import { runCapture } from "../lib/subprocess.ts";
 import { isGitLabRemote } from "../lib/enrich.ts";
 import type { CacheKind, RepoTrackingEntry } from "../lib/repo-tracking.ts";
@@ -403,22 +404,27 @@ export async function showStatus(args: string[] = []): Promise<void> {
  // A failed status query does NOT mean the daemon is down — it answers `ping`
  // in a fraction of the budget a loaded `status` needs. Establish liveness
  // before reporting, and only pay for the probe when nothing came back.
- const pingOk = classifyDaemonStatus.needsLivenessProbe(response) ? await isDaemonRunning() : false;
+ // pingDaemon (not isDaemonRunning) so the raw reply's eventLoop summary is
+ // still on hand to render, and so this probe never risks a restart.
+ const pingResp = classifyDaemonStatus.needsLivenessProbe(response) ? await pingDaemon() : null;
+ const pingOk = pingResp?.ok === true;
  const recordedPid = readDaemonPid() ?? null;
 
- // Ping ALSO failed: the only remaining ground is the pid/breadcrumb/kv
- // trail Task 9 left behind. Read it here, once, rather than on every status
+ // Ping ALSO failed: the only remaining ground is the pid/breadcrumb/kv/heartbeat
+ // trail Task 9/2 left behind. Read it here, once, rather than on every status
  // call, since it's the uncommon path.
  let pidAlive: boolean | undefined;
  let pid = recordedPid;
  let breadcrumb: ReturnType<typeof readBreadcrumb> | undefined;
  let supervision: ReturnType<typeof readSupervisionState> | undefined;
+ let heartbeat: ReturnType<typeof readHeartbeat> | undefined;
  if (classifyDaemonStatus.needsPidProbe(response, pingOk)) {
  breadcrumb = readBreadcrumb();
  // The kv tier can be legitimately empty (or reflect nothing useful) when
  // a failure happened before state.db ever opened (Ruling P1). The
  // breadcrumb read above is what classifyDaemonStatus falls back to then.
  supervision = readSupervisionState();
+ heartbeat = readHeartbeat(RT_DIR);
  const probed = await probePidAlive(recordedPid, breadcrumb?.pid);
  pidAlive = probed.alive;
  pid = probed.pid;
@@ -433,6 +439,8 @@ export async function showStatus(args: string[] = []): Promise<void> {
  intendedFlavor: resolveIntendedMode().mode,
  breadcrumb,
  supervision,
+ heartbeat,
+ pingEventLoop: (pingResp as any)?.eventLoop,
  });
 
  if (json) return void console.log(JSON.stringify({ ok: true, ...verdict }));
@@ -503,6 +511,15 @@ export function statusLines(verdict: DaemonStatusVerdict, now: number): string[]
  });
  lines.push(` ${dim}events: ${parts.join(" · ")}${reset}`);
  }
+
+ const health = verdict.data.health as { level: string; reasons: string[] } | undefined;
+ if (health && health.level !== "ok") {
+ const dot = health.level === "unhealthy" ? red : yellow;
+ lines.push(` ${dot}health: ${health.level}${reset}`);
+ for (const r of health.reasons) lines.push(` ${dim}- ${r}${reset}`);
+ }
+ const el = verdict.data.eventLoop as { maxLagMs: number } | undefined;
+ if (el && el.maxLagMs >= 500) lines.push(` ${dim}event loop: maxLag ${el.maxLagMs}ms${reset}`);
  return lines;
  }
 
@@ -511,11 +528,14 @@ export function statusLines(verdict: DaemonStatusVerdict, now: number): string[]
  // the operator to `rt daemon start` against a daemon that is already up.
  const lines = [` ${yellow}●${reset} running, but not reporting status`];
  if (verdict.pid) lines.push(` ${dim}pid: ${verdict.pid}${reset}`);
- lines.push(
- verdict.reason === "error"
- ? ` ${dim}status command failed: ${verdict.detail ?? "unknown error"}${reset}`
- : ` ${dim}answers ping, but status timed out — likely mid-sync${reset}`,
- );
+ if (verdict.reason === "error") {
+ lines.push(` ${dim}status command failed: ${verdict.detail ?? "unknown error"}${reset}`);
+ } else if (verdict.eventLoop && verdict.eventLoop.maxLagMs > 0) {
+ const el = verdict.eventLoop;
+ lines.push(` ${dim}answers ping, status timed out: event loop maxLag ${el.maxLagMs}ms${el.lastStallCmd ? ` (last stall in ${el.lastStallCmd})` : ""}${reset}`);
+ } else {
+ lines.push(` ${dim}answers ping, but status timed out — likely mid-sync${reset}`);
+ }
  lines.push(` ${dim}check: rt daemon logs${reset}`);
  return lines;
  }
@@ -536,6 +556,7 @@ export function statusLines(verdict: DaemonStatusVerdict, now: number): string[]
  booting: "still booting",
  wedged: "reached ready but stopped answering (likely deadlocked)",
  quarantined: "recovered from a corrupt db but still not answering",
+ stalled: `event loop stalled ${Math.round((verdict.stalledForMs ?? 0) / 1000)}s ago (no heartbeat)`,
  }[verdict.detail];
  return [
  ` ${yellow}●${reset} process ${verdict.pid} is running but not answering rt.sock`,
@@ -1145,3 +1166,19 @@ async function waitForPort(port: number, timeoutMs: number): Promise<void> {
  await new Promise(r => setTimeout(r, 100));
  }
 }
+
+/** Pure formatter for `daemon:log-level` results, shared by the CLI and its tests. */
+export function formatLogLevelResult(res: { ok: boolean; level?: string; error?: string }, wasSet: boolean): string {
+ if (!res.ok) return ` ${red}●${reset} ${res.error ?? "failed"}`;
+ return ` ${green}●${reset} daemon log level ${wasSet ? "set to" : "is"} ${res.level}`;
+}
+
+/** Show (no arg) or set (level arg) the running daemon's live pino log level. */
+export async function setLogLevel(args: string[] = []): Promise<void> {
+ const json = args.includes("--json");
+ const level = args.find((a) => !a.startsWith("--"));
+ const res = await daemonQuery("daemon:log-level", level ? { level } : {});
+ if (!res) { console.log(` ${red}●${reset} daemon not reachable`); return; }
+ if (json) { console.log(JSON.stringify(res)); return; }
+ console.log(formatLogLevelResult(res as any, Boolean(level)));
+}

commands/home.ts

@@ -38,6 +38,7 @@ import { join } from "path";
 import type { CommandContext } from "../lib/command-tree.ts";
 import { bold, dim, green, red, reset, yellow } from "../lib/ansi.ts";
 import { isSafeMachineKeySegment, machineKey, mattstackHome } from "../lib/rt-paths.ts";
+import { resolveInitialMachineKey } from "../lib/home/machine-id.ts";
 import {
  buildInitPlan,
  chooseMachineProfile,
@@ -549,7 +550,7 @@ export async function homeInit(args: string[], _ctx: CommandContext = {}, seams:
  const exec = seams.exec ?? createRealExecSeam(mattstackHome());
  const ageKeySeam = seams.ageKeySeam ?? createRealAgeKeySeam();
  const sopsYamlSeam = seams.sopsYamlSeam ?? defaultSopsYamlSeam();
- const key = seams.key ?? machineKey();
+ const key = seams.key ?? (await resolveInitialMachineKey(mattstackHome(), probes));
  const pickerSeam = seams.pickerSeam ?? createRealMachineProfilePickerSeam();
  const isInteractive = seams.isInteractive ?? (() => Boolean(process.stdin.isTTY));
  const materializeExec = seams.materializeExec ?? defaultMaterializeExec();

commands/settings.ts

@@ -16,7 +16,7 @@ import {
  TRAY_APP_NAME, DEV_TRAY_APP_NAME, TRAY_APP_BUNDLE,
  trayAppPath, devTrayAppPath,
 } from "../lib/rt-paths.ts";
-import { installRtBinary } from "../lib/dev-mode.ts";
+import { DEV_MODE_TAG, installRtBinary } from "../lib/dev-mode.ts";
 import { describeTuple, tupleWarning, type FlavorTuple } from "./daemon.ts";
 import { RT_BUNDLE_PATH } from "../lib/bundle-layout.ts";
 import { spawnSync } from "child_process";
@@ -511,6 +511,7 @@ export function renderDevModeWrapper(sourcePath: string, bunPath: string): strin
  const bunDir = dirname(bunPath);
  return [
  `#!/bin/zsh`,
+ `${DEV_MODE_TAG}`,
  `export PATH="${bunDir}:/opt/homebrew/bin:/usr/local/bin:$PATH"`,
  `export RT_LAUNCH_CWD="$PWD"`,
  `cd "${sourcePath}" || { echo "rt: dev-mode source checkout missing: ${sourcePath}" >&2; exit 1; }`,

commands/status/__tests__/status-fallback.test.ts

@@ -87,6 +87,30 @@ describe("rt status fallback (no daemon)", () => {
  expect(existsSync(rtDirPath) ? readdirSync(rtDirPath) : []).toEqual([]);
  });
 
+ test("S069/Task 10: two repos sharing a branch name display as a bare branch, not a composite key", async () => {
+ const dbPath = stateDbPath();
+ mkdirSync(join(home, ".mattstack", "rt"), { recursive: true });
+ const db = openStateDb(dbPath);
+ const store = getBranchCacheStore(db);
+ store.put("shared-branch", {
+ ticket: null, linearId: "", mr: null, fetchedAt: 1, repoName: "repo-a",
+ });
+ store.put("shared-branch", {
+ ticket: null, linearId: "", mr: null, fetchedAt: 2, repoName: "repo-b",
+ });
+ db.close();
+
+ const data = await fetchStatusData();
+
+ // Both rows are real, distinct composite-keyed rows in state.db...the
+ // dashboard's flat bare-branch dict can only show one, never a raw
+ // composite key, and never crashes reconciling the two.
+ expect(Object.keys(data.branches)).toEqual(["shared-branch"]);
+ const winner = data.branches["shared-branch"]!.repoName;
+ expect(winner).toBeDefined();
+ expect(["repo-a", "repo-b"]).toContain(winner!);
+ });
+
  test("an empty branch_cache table serves an empty dashboard", async () => {
  mkdirSync(join(home, ".mattstack", "rt"), { recursive: true });
  openStateDb(stateDbPath()).close();

commands/status/data.ts

@@ -10,6 +10,7 @@
 
 import type { CacheEntry, StatusData } from "./types.ts";
 import type { PortEntry } from "../../lib/port-scanner.ts";
+import { branchOf } from "../../lib/state/branch-cache.ts";
 
 interface BranchCacheRow {
  branch: string;
@@ -56,7 +57,7 @@ async function readBranchesFromStateDb(): Promise<Record<string, CacheEntry>> {
  // with looser optionality on the ticket fields (`stateName?: string`
  // vs `string | null`). Same data that used to arrive here as parsed
  // JSON out of branch-cache.json.
- branches[row.branch] = {
+ branches[branchOf(row.branch)] = {
  ticket: row.ticket !== null ? (JSON.parse(row.ticket) as CacheEntry["ticket"]) : null,
  linearId: row.linear_id,
  mr: row.mr !== null ? (JSON.parse(row.mr) as CacheEntry["mr"]) : null,