@bli-cockpit/cli 0.2.68 → 0.2.70

package/dist/autostart-darwin-plist.js

@@ -81,8 +81,22 @@ export async function writeDarwinAutostartPlist(options) {
  */
 export async function darwinAgentProblems(options, settings) {
     const homeDir = options.homeDir ?? os.homedir();
-    const nodeExecutable = (await schedulerNodeExecutable(options, "darwin")).path;
     const plist = await readFile(plistPathFor(homeDir), "utf8").catch(() => "");
+    if (!plist)
+        return ["plist could not be read"];
+    // A caller that named no roots gave us nothing to compare against:
+    // `resolveAutostartSettings` fills `work_dirs` from `process.cwd()`, so the
+    // comparison below would reject a perfectly good plist for naming a
+    // workspace nobody asked us to expect (BLI-3793 — that is how the setup
+    // receipt printed `autostart_not_loaded` beside a green doctor row). The
+    // Windows arm has refused this comparison since it was written
+    // (`syncScriptProblem`); macOS refuses it now too. Whether launchd HAS the
+    // agent is still answered — by `launchctl list`, in the sibling module.
+    if (!options.repoRoots || options.repoRoots.length === 0) {
+        console.error("[autostart] registration not compared against expectations", JSON.stringify({ reason: "no_roots_supplied", label: AUTOSTART_LABEL }));
+        return [];
+    }
+    const nodeExecutable = (await schedulerNodeExecutable(options, "darwin")).path;
     return darwinAgentRegistrationProblems(plist, {
         discoveryArgs: await savedDiscoveryLimitArgs(homeDir),
         workDirs: settings.work_dirs,

package/dist/commands/autostart-reading.js

@@ -0,0 +1,173 @@
+import { autostartStatus, registeredRuntimePathProblems, } from "../autostart.js";
+import { redactedHealthDetail } from "../health-detail.js";
+import { getCollectorRuntimePaths, readLocalCollectorConfig, } from "../local-state.js";
+import { normalizeCollectionRoots } from "../root-normalization.js";
+/**
+ * "Is background collection actually registered and running on this host?" —
+ * asked ONCE, here (BLI-3793).
+ *
+ * Two surfaces print that answer: doctor's `autostart-alive` row and the setup
+ * receipt's `collector autostart` word. Until this module they asked the same
+ * function DIFFERENTLY, and so printed opposite answers in one run:
+ *
+ *   ✅ autostart-alive      background sync is running
+ *   collector autostart ✗ (autostart_not_loaded) — Run `cockpit autostart install`.
+ *
+ * The doctor row handed `autostartStatus` the machine's saved collection
+ * roots; the receipt handed it `{homeDir, exec}` and nothing else. With no
+ * roots, `resolveAutostartSettings` fills `work_dirs` from `process.cwd()`,
+ * the launchd read-back compares the plist against a registration nobody ever
+ * asked for, the comparison fails, and a perfectly loaded agent reads
+ * `not_loaded`. The receipt therefore said "✓" only when the operator happened
+ * to be standing in their own collection root. Proven on the reference Mac:
+ * the same plist read `loaded` with roots passed and `not_loaded` without,
+ * flipping back to `loaded` when the process chdir'd into the saved root.
+ *
+ * So: one reader, one state, ONE reason label. `autostartDoctorRow` and
+ * `autostartSetupPiece` below only choose words for a state this file already
+ * decided — they never re-ask the host. Both host families go through the same
+ * `autostartStatus` front door, so the Windows probe keeps its own
+ * implementation behind this same contract.
+ */
+const TAG = "[autostart reading]";
+/**
+ * The machine's approved collection roots as the SCHEDULER should have them:
+ * an explicit `--workspace` when one was given, otherwise what the config on
+ * this host saved. Honours `homeDir` so a `--home` run reads the same machine
+ * its receipt reads.
+ */
+export async function autostartRegistrationRoots(homeDir, repoRoot) {
+    if (repoRoot)
+        return [repoRoot];
+    const config = await readLocalCollectorConfig(getCollectorRuntimePaths(homeDir)).catch(() => null);
+    return normalizeCollectionRoots(config?.default_repo_paths ?? []);
+}
+/** The ONE read of the host's scheduler. Never throws; an unaskable host is
+ * `unreadable` with a reason, never "absent" (BLI-2541: never report a state
+ * you did not observe). */
+export async function readAutostartRegistration(options) {
+    const exec = options.exec;
+    if (!exec) {
+        return {
+            state: "unreadable",
+            reason: "autostart_runner_unavailable",
+            message: "the operating-system scheduler could not be asked: no process runner on this run",
+            roots: [],
+        };
+    }
+    const roots = await autostartRegistrationRoots(options.homeDir, options.repoRoot).catch(() => []);
+    const result = await autostartStatus({
+        exec,
+        repoRoots: roots,
+        ...(roots[0] ? { repoRoot: roots[0] } : {}),
+        ...(options.homeDir ? { homeDir: options.homeDir } : {}),
+        ...(options.dashboardUrl ? { dashboardUrl: options.dashboardUrl } : {}),
+        ...(options.platform ? { platform: options.platform } : {}),
+    }).catch((error) => {
+        console.error(`${TAG} scheduler probe threw`, JSON.stringify({
+            reason: "autostart_probe_failed",
+            error_name: error instanceof Error ? error.name : typeof error,
+        }));
+        return null;
+    });
+    const reading = await stateFor(result, roots, options);
+    console.error(`${TAG} read back`, JSON.stringify({
+        reason: reading.reason,
+        state: reading.state,
+        root_count: reading.roots.length,
+        platform: options.platform ?? process.platform,
+    }));
+    return reading;
+}
+async function stateFor(result, roots, options) {
+    if (!result) {
+        return {
+            state: "unreadable",
+            reason: "autostart_probe_failed",
+            message: "the operating-system scheduler could not be read this run",
+            roots,
+        };
+    }
+    const detail = result.message
+        ? { detail: redactedHealthDetail(result.message) }
+        : {};
+    if (result.status === "unsupported") {
+        return {
+            state: "unsupported",
+            reason: "platform_unsupported",
+            message: result.message ?? "autostart is not supported on this host",
+            roots,
+        };
+    }
+    if (result.status === "absent" || result.status === "uninstalled") {
+        return {
+            state: "absent",
+            reason: "autostart_absent",
+            message: "background sync is not installed on this machine",
+            roots,
+            ...detail,
+        };
+    }
+    if (result.status === "not_loaded") {
+        return {
+            state: "not_loaded",
+            reason: "autostart_not_loaded",
+            message: "background sync is not running",
+            roots,
+            ...detail,
+        };
+    }
+    // BLI-3553: "loaded" only means the scheduler accepted the registration. It
+    // says nothing about whether the binary that registration names still exists
+    // — and `brew upgrade node` deletes exactly that. Ask the filesystem about
+    // the paths the PLATFORM holds, not the ones this process runs under.
+    const missing = options.exec
+        ? await registeredRuntimePathProblems({
+            exec: options.exec,
+            ...(options.homeDir ? { homeDir: options.homeDir } : {}),
+            ...(options.platform ? { platform: options.platform } : {}),
+        }).catch(() => [])
+        : [];
+    if (missing.length > 0) {
+        return {
+            state: "runtime_path_missing",
+            reason: "autostart_runtime_path_missing",
+            message: `background sync is registered but cannot run: ${missing.join("; ")}`,
+            roots,
+        };
+    }
+    return {
+        state: "loaded",
+        reason: "autostart_loaded",
+        message: "background sync is running",
+        roots,
+    };
+}
+/**
+ * The setup receipt's `collector autostart` word (BLI-3731).
+ *
+ * `ok` only when the host says it is registered AND loaded AND the runtime it
+ * names still exists. A plist nobody loaded runs nothing, which is exactly the
+ * failure that looks fine from the outside.
+ */
+export function autostartSetupPiece(reading) {
+    switch (reading.state) {
+        case "loaded":
+            return { status: "ok", reason: reading.reason };
+        case "unsupported":
+            return { status: "skipped", reason: reading.reason };
+        case "unreadable":
+            return { status: "unknown", reason: reading.reason };
+        default:
+            return { status: "missing", reason: reading.reason };
+    }
+}
+/** Doctor's `autostart-alive` row status for the same reading. The `code` a
+ * caller pairs with this is `reading.reason` — there is no second vocabulary. */
+export function autostartDoctorStatus(reading) {
+    if (reading.state === "loaded")
+        return "ok";
+    if (reading.state === "unsupported")
+        return "skipped";
+    return "needs_fix";
+}

package/dist/commands/doctor-registration.js

@@ -1,6 +1,6 @@
-import { autostartStatus, installAutostartAgent, registeredRuntimePathProblems, } from "../autostart.js";
+import { installAutostartAgent } from "../autostart.js";
 import { fail, needsFix, ok, skipped } from "./doctor-report.js";
-import { doctorRoots, savedRoots } from "./doctor-access.js";
+import { autostartDoctorStatus, autostartRegistrationRoots, readAutostartRegistration, } from "./autostart-reading.js";
 import { installMemoryIntegration, inspectMemoryIntegration, } from "./memory-install.js";
 /**
  * The `autostart-alive` and `memory-registered` check family: registrations
@@ -8,44 +8,40 @@ import { installMemoryIntegration, inspectMemoryIntegration, } from "./memory-in
  * background sync scheduler and BLI Memory's MCP/hook wiring. Both fixes
  * write host configuration only; neither installs software.
  */
+/**
+ * The row and the setup receipt's `collector autostart` word are the SAME
+ * reading now (BLI-3793) — `autostart-reading.ts` asks the host once and hands
+ * back one state and one reason label. This function only chooses the row
+ * status for it; it does not decide anything about the machine.
+ */
 export async function checkAutostartState(context) {
-    const exec = context.io.exec;
-    if (!exec) {
-        return needsFix("autostart-alive", "runner_unavailable", "autostart runner unavailable; would refresh autostart");
-    }
-    const roots = await doctorRoots(context);
-    const result = await autostartStatus({
-        repoRoot: roots[0],
-        repoRoots: roots,
+    const reading = await readAutostartRegistration({
+        exec: context.io.exec,
+        homeDir: context.command.homeDir,
         dashboardUrl: context.command.dashboardUrl,
-        exec,
+        repoRoot: context.command.repoRoot,
     });
-    if (result.status === "loaded") {
-        // BLI-3553: "loaded" only means the scheduler accepted the registration.
-        // It says nothing about whether the binary that registration names still
-        // exists — and `brew upgrade node` deletes exactly that. Ask the
-        // filesystem about the paths the PLATFORM holds, not the ones this process
-        // happens to be running under.
-        const missing = await registeredRuntimePathProblems({ exec });
-        if (missing.length > 0) {
-            return needsFix("autostart-alive", "runtime_path_missing", `background sync is registered but cannot run: ${missing.join("; ")}`);
-        }
-        return ok("autostart-alive", "already_installed", "background sync is running");
-    }
-    if (result.status === "unsupported") {
-        return skipped("autostart-alive", "unsupported", result.message ?? "unsupported");
+    const status = autostartDoctorStatus(reading);
+    if (status === "ok")
+        return ok("autostart-alive", reading.reason, reading.message);
+    if (status === "skipped") {
+        return skipped("autostart-alive", reading.reason, reading.message);
     }
-    return needsFix("autostart-alive", result.status === "not_loaded" ? "not_loaded" : "absent", "background sync is not running");
+    return needsFix("autostart-alive", reading.reason, reading.message);
 }
 export async function fixAutostartState(context) {
     const exec = context.io.exec;
     if (!exec) {
         return fail("autostart-alive", "runner_unavailable", "autostart runner unavailable");
     }
-    const roots = await savedRoots();
+    // The same roots the CHECK read against, resolved by the same function — a
+    // fix that registers a different boundary than the check inspected would
+    // leave the row red forever (BLI-3793).
+    const roots = await autostartRegistrationRoots(context.command.homeDir, context.command.repoRoot);
     const result = await installAutostartAgent({
-        repoRoot: context.command.repoRoot ?? roots[0],
-        repoRoots: context.command.repoRoot ? [context.command.repoRoot] : roots,
+        ...(roots[0] ? { repoRoot: roots[0] } : {}),
+        repoRoots: roots,
+        ...(context.command.homeDir ? { homeDir: context.command.homeDir } : {}),
         dashboardUrl: context.command.dashboardUrl,
         exec,
     });

package/dist/commands/heartbeat.js

@@ -29,6 +29,7 @@ import { describeError } from "../health-detail.js";
 import { shouldSuppressFleetReceipts, } from "../dev-build.js";
 import { getCollectorRuntimePaths, readLocalCollectorSessionFile, LOCAL_COLLECTOR_VERSION, } from "../local-state.js";
 import { readMemoryReceiptFile } from "./memory-install-receipt.js";
+import { readMemoryHookCounts } from "./memory-hook-counts.js";
 const HEARTBEAT_TIMEOUT_MS = 5_000;
 /**
  * The label form of one approved root.
@@ -123,6 +124,13 @@ export function buildCollectorHeartbeat(options) {
  * reads and a `--print-config` spawn every fifteen minutes to re-prove a state
  * that changes about once a month. The reason is returned rather than logged
  * here so the ONE heartbeat log line carries it.
+ *
+ * BLI-3788: the hook COUNTS are merged in here, on the tick, and deliberately
+ * not baked into the cached receipt. The five words change about monthly; how
+ * often the prompt hook lost its deadline changes every hour, and a number
+ * cached for a day would answer yesterday's question. An install receipt this
+ * machine could not read means no counts either — there is nowhere to put
+ * them — and that case keeps the receipt's own reason.
  */
 export async function readHeartbeatMemoryReceipt(options) {
     const paths = getCollectorRuntimePaths(options.homeDir);
@@ -142,7 +150,20 @@ export async function readHeartbeatMemoryReceipt(options) {
             return parsed.success ? parsed.data : null;
         },
     });
-    return { receipt: result.receipt, reason: result.reason };
+    if (!result.receipt)
+        return { receipt: null, reason: result.reason };
+    const hooks = readMemoryHookCounts({
+        homeDir: options.homeDir ?? os.homedir(),
+        ...(options.now ? { now: options.now } : {}),
+    });
+    return {
+        receipt: {
+            ...result.receipt,
+            ...(hooks.counts ?? {}),
+            hook_stats_reason: hooks.reason,
+        },
+        reason: result.reason,
+    };
 }
 /**
  * Sends the heartbeat. Returns whether it landed; never throws.
@@ -248,6 +269,13 @@ export async function sendCollectorHeartbeatBestEffort(options) {
             // sync.err.log alone.
             memory_receipt: memory.reason,
             memory_gaps: memory.receipt ? memoryInstallGaps(memory.receipt) : null,
+            // BLI-3788. The hooks are registered (above) AND they either worked or
+            // did not (here). A prompt hook that misses its deadline prints
+            // nothing to the person, so these counts are the only trace one leaves
+            // on this machine; `null` means no counter file, never zero misses.
+            memory_hook_runs_24h: memory.receipt?.hook_runs_24h ?? null,
+            memory_hook_timeouts_24h: memory.receipt?.hook_timeouts_24h ?? null,
+            memory_hook_stats: memory.receipt?.hook_stats_reason ?? null,
         }));
         return true;
     }

package/dist/commands/memory-hook-counts.js

@@ -0,0 +1,61 @@
+/**
+ * HOW OFTEN DID THE HOOKS MISS? — the reading half (BLI-3788).
+ *
+ * `bli-memory-mcp` counts every hook run into a counts-only file in this
+ * machine's state directory. This module reads it once a sync tick and hands
+ * the last 24 hours to the heartbeat, where it rides the memory receipt into
+ * `ambient_collector_devices.metadata.memory_install` and out onto `cockpit
+ * ops --memory`.
+ *
+ * Nothing here knows the file's shape: the path, the schema and the windowing
+ * rule are `@bli-cockpit/telemetry-core`'s `memory-hook-stats.ts`, which the
+ * writing package spends too. That is the whole point of putting them there.
+ *
+ * ## Which event, and why only one
+ *
+ * The PROMPT hook. It is the one a person waits on with their sentence typed,
+ * the one whose budget QA tick 18 caught it losing, and the one that runs on
+ * every turn — so it is the only one whose miss rate means anything as a
+ * daily number. The file holds all three; a future gauge that wants
+ * SessionStart or Stop reads the same rows with the same function.
+ *
+ * ## Absent is not zero
+ *
+ * A machine with no file has no counts and says `hook_stats_absent`. A machine
+ * whose file will not parse says `hook_stats_unparseable`. Neither reports
+ * zeroes, because a zero here would read as "the hooks ran and never missed",
+ * which is the exact false green this ticket exists to remove.
+ */
+import fs from "node:fs";
+import { memoryHookStatsFilePath, parseMemoryHookStats, summariseMemoryHookWindow, } from "@bli-cockpit/telemetry-core";
+export function readMemoryHookCounts(options) {
+    const readText = options.readText ?? defaultReadText;
+    const file = memoryHookStatsFilePath(options.homeDir);
+    const raw = readText(file);
+    if (raw === null)
+        return { counts: null, reason: "hook_stats_absent" };
+    const parsed = parseMemoryHookStats(raw);
+    if (!parsed.ok)
+        return { counts: null, reason: parsed.reason };
+    const window = summariseMemoryHookWindow(parsed.file, "prompt", {
+        now: options.now ?? new Date(),
+        hours: 24,
+    });
+    return {
+        counts: {
+            hook_runs_24h: window.runs,
+            hook_timeouts_24h: window.timeouts,
+            hook_printed_24h: window.printed,
+            hook_failed_24h: window.failed,
+        },
+        reason: "ok",
+    };
+}
+function defaultReadText(file) {
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return null;
+    }
+}

package/dist/commands/ops-render-memory.js

@@ -70,6 +70,40 @@ export function renderMemoryUsage(memory, dim) {
     }
     return lines;
 }
+/**
+ * The hook half: one line per machine, the server's own words.
+ *
+ * A machine that reports NO counts is printed too, dimmed and named. It is the
+ * whole point: "no measurement" and "no misses" are different facts, and the
+ * only reason this section exists is that they used to be indistinguishable.
+ */
+export function renderMemoryHooks(hooks, dim) {
+    const lines = ["", `HOOKS   ${hooks.summary ?? "(no summary)"}`];
+    if (hooks.readError) {
+        lines.push(`  the devices could not be read (${hooks.readError}); nothing is known about whether recalls are arriving`);
+        return lines;
+    }
+    const devices = hooks.devices ?? [];
+    if (devices.length === 0) {
+        lines.push(dim("  no live collector device to report on"));
+        return lines;
+    }
+    // Worst first: the machine losing recalls is the one somebody acts on, and a
+    // machine that reports nothing sinks below both — it is a rollout gap, not a
+    // failure.
+    const ranked = [...devices].sort((left, right) => {
+        const leftKnown = typeof left.runs === "number" ? 0 : 1;
+        const rightKnown = typeof right.runs === "number" ? 0 : 1;
+        if (leftKnown !== rightKnown)
+            return leftKnown - rightKnown;
+        return (right.timeouts ?? 0) - (left.timeouts ?? 0);
+    });
+    for (const device of ranked) {
+        const line = `  ${device.line ?? `${device.displayName ?? "?"}: (no line)`}`;
+        lines.push((device.timeouts ?? 0) > 0 ? line : dim(line));
+    }
+    return lines;
+}
 /** The two sources that mean a PERSON's agent used memory. Never the import. */
 function agentSaves(counts) {
     return (counts?.mcp ?? 0) + (counts?.stop_hook ?? 0);

package/dist/commands/ops-render.js

@@ -12,7 +12,7 @@
  * artifact does and does not prove — because that is exactly the moment
  * somebody is about to conclude something from it.
  */
-export { renderMemoryUsage } from "./ops-render-memory.js";
+export { renderMemoryHooks, renderMemoryUsage } from "./ops-render-memory.js";
 /** The word a person reads. Short, fixed width, and never a bare colour. */
 export function verdictWord(verdict) {
     switch (verdict) {

package/dist/commands/ops.js

@@ -25,7 +25,7 @@
  */
 import { colorEnabled, dim, writeLine } from "./cli-io.js";
 import { renderOpsStatus } from "./ops-render.js";
-import { renderMemoryUsage, } from "./ops-render-memory.js";
+import { renderMemoryHooks, renderMemoryUsage, } from "./ops-render-memory.js";
 import { asRecord, callTower, openTower, writeCommandFailure } from "./tower-command.js";
 /**
  * A whole compile, plus a little. `maxDuration` on `/api/ops/recompile` is 800
@@ -79,7 +79,7 @@ async function runOpsStatus(command, io, tower) {
         // BLI-3762: a job that ran and wrote less than it owed is not healthy.
         row.verdict === "degraded");
     if (command.json) {
-        writeLine(io.stdout, JSON.stringify(memory ? { ...payload, memory: memory.section } : payload));
+        writeLine(io.stdout, JSON.stringify(memory ? { ...payload, memory: memory.section, hooks: memory.hooks } : payload));
     }
     else {
         const styled = colorEnabled(io);
@@ -91,7 +91,16 @@ async function runOpsStatus(command, io, tower) {
                 writeLine(io.stdout, line);
             }
         }
-        else if (memory) {
+        // BLI-3788. Printed whenever the door sent it, including when the usage
+        // half could not be read: "are the recalls arriving" and "is anybody
+        // saving" are two questions, and one being unreadable does not silence
+        // the other.
+        if (memory?.hooks) {
+            for (const line of renderMemoryHooks(memory.hooks, (text) => dim(text, styled))) {
+                writeLine(io.stdout, line);
+            }
+        }
+        if (memory && !memory.section) {
             // Never a silent gap where a section was asked for: the reason the gauge
             // could not be read is printed where the gauge would have been.
             writeLine(io.stdout, "");
@@ -119,6 +128,12 @@ async function runOpsStatus(command, io, tower) {
         memory_agent_saves: memory?.section
             ? (memory.section.counts?.mcp ?? 0) + (memory.section.counts?.stop_hook ?? 0)
             : null,
+        // BLI-3788: whether the per-turn recalls arrived, on the same line. A
+        // null here is "this dashboard does not report it yet", never zero
+        // misses.
+        memory_hook_runs_24h: memory?.hooks?.totals?.runs ?? null,
+        memory_hook_timeouts_24h: memory?.hooks?.totals?.timeouts ?? null,
+        memory_hook_devices_reporting: memory?.hooks?.reporting ?? null,
     })}`);
     return unhealthy.length > 0 ? 1 : 0;
 }
@@ -144,12 +159,15 @@ async function readMemoryUsage(command, io, tower) {
             reason: result.reason,
             http_status: result.httpStatus ?? null,
         })}`);
-        return { section: null, reason: result.reason };
+        return { section: null, hooks: null, reason: result.reason };
     }
     const body = asRecord(result.body);
+    // BLI-3788: the hook counts ride the same answer, and their absence is a
+    // fact about the SERVER's version rather than about this fleet — an older
+    // dashboard sends no `hooks` key, and printing nothing is right there.
     if (!body.memory)
-        return { section: null, reason: "memory_section_absent" };
-    return { section: body.memory, reason: "ok" };
+        return { section: null, hooks: body.hooks ?? null, reason: "memory_section_absent" };
+    return { section: body.memory, hooks: body.hooks ?? null, reason: "ok" };
 }
 async function runOpsRecompile(command, io, tower) {
     const person = command.person ?? "";

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.68");
+    writeLine(io?.stdout ?? process.stdout, "0.2.70");
     return 0;
   }
 

package/dist/commands/setup-receipt.js

@@ -15,8 +15,13 @@
  *                        in, so the session file is the evidence — there is no
  *                        second thing to ask.
  *   device               that same session, still unexpired.
- *   collector.autostart  `autostartStatus`, which asks launchd or Task
- *                        Scheduler what it actually has registered.
+ *   collector.autostart  `readAutostartRegistration`, which asks launchd or
+ *                        Task Scheduler what it actually has registered. That
+ *                        reader is SHARED with doctor's `autostart-alive` row
+ *                        (BLI-3793) — this module used to ask the scheduler
+ *                        itself, without the machine's saved roots, and so
+ *                        printed `autostart_not_loaded` under a doctor row
+ *                        that said the same agent was running.
  *
  * The five AGENT-HOST words in the printed block are NOT computed here. They
  * are BLI-3729's `MemoryInstallReceipt`, already read back off
@@ -36,7 +41,7 @@
 import os from "node:os";
 import { SETUP_RECEIPT_SCHEMA_VERSION, setupReceiptGaps, setupReceiptLine, } from "@bli-cockpit/telemetry-core";
 import { readHeartbeatMemoryReceipt } from "./heartbeat.js";
-import { autostartStatus } from "../autostart.js";
+import { autostartSetupPiece, readAutostartRegistration, } from "./autostart-reading.js";
 import { readLocalSessionReference } from "../local-state.js";
 import { getCollectorRuntimePaths } from "../local-state-paths.js";
 import { readJsonFile, writeJsonFile } from "../local-state-files.js";
@@ -63,14 +68,19 @@ export async function buildSetupReceipt(io, options = {}) {
     });
     const autostart = await probes.autostart().catch((error) => {
         console.error(`${TAG} scheduler could not be read`, JSON.stringify({ reason: "autostart_probe_failed", error_name: errorName(error) }));
-        return { status: "unreadable" };
+        return {
+            state: "unreadable",
+            reason: "autostart_probe_failed",
+            message: "the operating-system scheduler could not be read this run",
+            roots: [],
+        };
     });
     const receipt = {
         schema_version: SETUP_RECEIPT_SCHEMA_VERSION,
         checked_at: checkedAt,
         browser: browserPiece(session),
         device: devicePiece(session),
-        collector: { autostart: autostartPiece(autostart) },
+        collector: { autostart: autostartSetupPiece(autostart) },
     };
     const gaps = setupReceiptGaps(receipt, memory);
     console.error(`${TAG} read back`, JSON.stringify({
@@ -97,19 +107,16 @@ function withDefaultProbes(io, homeDir, options) {
                 };
             }),
         autostart: options.probes?.autostart ??
-            (async () => {
-                // The scheduler can only be READ through a process runner; a machine
-                // whose io carries none is unknown, never "absent" (BLI-2541: never
-                // report a state you did not observe).
-                const exec = io.exec;
-                if (!exec)
-                    return { status: "unreadable", message: "runner_unavailable" };
-                const result = await autostartStatus({ homeDir, exec });
-                return {
-                    status: result.status,
-                    ...(result.message ? { message: result.message } : {}),
-                };
-            }),
+            // The one shared reader. It handles the no-process-runner host itself
+            // (`unreadable`, never "absent" — BLI-2541: never report a state you did
+            // not observe) and it hands the scheduler this machine's saved roots,
+            // which is what stopped this word from contradicting doctor's row
+            // (BLI-3793).
+            (async () => readAutostartRegistration({
+                exec: io.exec,
+                homeDir,
+                ...(options.dashboardUrl ? { dashboardUrl: options.dashboardUrl } : {}),
+            })),
     };
 }
 /**
@@ -139,32 +146,6 @@ function devicePiece(session) {
     }
     return { status: "missing", reason: `session_${session.state}` };
 }
-/**
- * The scheduler is `ok` only when the host says it is registered AND loaded.
- * `installed` on macOS means the plist is on disk; `loaded` means launchd has
- * it. A plist nobody loaded runs nothing, which is exactly the failure that
- * looks fine from the outside.
- */
-function autostartPiece(result) {
-    if (result.status === "loaded" || result.status === "installed") {
-        return { status: "ok", reason: `autostart_${result.status}` };
-    }
-    if (result.status === "not_loaded") {
-        return { status: "missing", reason: "autostart_not_loaded" };
-    }
-    if (result.status === "absent" || result.status === "uninstalled") {
-        return { status: "missing", reason: "autostart_absent" };
-    }
-    if (result.status === "unsupported") {
-        return { status: "skipped", reason: "platform_unsupported" };
-    }
-    return { status: "unknown", reason: normalizeReason(result.status) };
-}
-/** Reason labels are `[a-z0-9_:.-]` by schema; anything else becomes one word. */
-function normalizeReason(value) {
-    const cleaned = value.trim().toLowerCase().replace(/[^a-z0-9_:.-]+/gu, "_");
-    return cleaned.slice(0, 120) || "unlabelled";
-}
 function errorName(error) {
     return error instanceof Error ? error.name : typeof error;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.68",
+  "version": "0.2.70",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,8 +27,8 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.9",
-    "@bli-cockpit/mcp": "0.1.10",
-    "@bli-cockpit/telemetry-core": "0.1.30"
+    "@bli-cockpit/memory-mcp": "0.1.10",
+    "@bli-cockpit/mcp": "0.1.11",
+    "@bli-cockpit/telemetry-core": "0.1.31"
   }
 }