@bli-cockpit/cli 0.2.84 → 0.2.85

package/dist/commands/doctor-memory-daemon.js

@@ -0,0 +1,36 @@
+/**
+ * The `memory-daemon` row (BLI-3884): is the resident local answerer running?
+ *
+ * **This row is NEVER red, and it has no fix.** A machine with no daemon is a
+ * machine whose recalls take the path they took before the daemon existed —
+ * slower by a process start, a TLS handshake and a token check, and completely
+ * correct. Colouring that red would train people to ignore doctor, the way an
+ * amber "you could be faster" line trains them to ignore everything under it.
+ *
+ * So there are exactly two outcomes:
+ *
+ *   ok       something answered a `ping` on this user's endpoint.
+ *   skipped  nothing did, and the reason is named — `daemon_absent` (the
+ *            ordinary state on a machine that has not prompted in two hours),
+ *            `socket_path_too_long`, or whatever the socket said.
+ *
+ * Starting one is not doctor's job either: the PROMPT HOOK is the daemon's
+ * supervisor and spawns one at most once an hour (`memory-mcp`'s
+ * `daemon/spawn.ts`). A doctor that started a daemon would be a second
+ * supervisor with different rules.
+ */
+import { ok, skipped } from "./doctor-report.js";
+import { memoryDaemonLine, probeMemoryDaemon } from "./memory-daemon-probe.js";
+export async function checkMemoryDaemonState(context, deps = {}) {
+    const probe = deps.probe ?? probeMemoryDaemon;
+    const reading = await probe({
+        ...(context.command.homeDir ? { homeDir: context.command.homeDir } : {}),
+    });
+    return memoryDaemonRow(reading);
+}
+export function memoryDaemonRow(reading) {
+    const sentence = memoryDaemonLine(reading);
+    return reading.answering
+        ? ok("memory-daemon", "answering", sentence)
+        : skipped("memory-daemon", reading.reason, sentence);
+}

package/dist/commands/doctor.js

@@ -1,6 +1,7 @@
 import { checkSingleInstallState, fixAuthState, fixRootState, readAuthState, readRootState, } from "./doctor-access.js";
 import { backfillCompletionStepState, checkBackfillState, checkDiskState, checkGcState, checkSyncState, fixBackfillState, fixDiskState, fixGcState, fixSyncState, syncBacklogDrainingVerdict, } from "./doctor-pipeline.js";
 import { checkMcpAnswersState } from "./doctor-mcp.js";
+import { checkMemoryDaemonState } from "./doctor-memory-daemon.js";
 import { checkAutostartState, checkMemoryState, fixAutostartState, fixMemoryState, } from "./doctor-registration.js";
 import { dryRunPreview, isInteractiveDoctorFix, maybeReportDoctorEvents, writeDoctorOutput, } from "./doctor-report.js";
 import { refreshSetupReceipt } from "./setup-receipt.js";
@@ -104,6 +105,14 @@ function doctorInvariants() {
             id: "mcp-answers",
             check: (context) => context.deps.checkMcpAnswers(context),
         },
+        // BLI-3884. Beside the two rows above because it is the same family — what
+        // this machine's agents can reach — and, like `mcp-answers`, it has NO fix:
+        // the prompt hook is the daemon's supervisor and starts one itself. It is
+        // never red; a machine without one recalls exactly as it did before.
+        {
+            id: "memory-daemon",
+            check: (context) => context.deps.checkMemoryDaemon(context),
+        },
         {
             id: "backfill-complete",
             check: (context) => context.deps.checkBackfill(context),
@@ -146,6 +155,7 @@ function defaultDoctorDeps(hooks) {
         checkMemory: checkMemoryState,
         fixMemory: fixMemoryState,
         checkMcpAnswers: (context) => checkMcpAnswersState(context),
+        checkMemoryDaemon: (context) => checkMemoryDaemonState(context),
         checkBackfill: checkBackfillState,
         fixBackfill: fixBackfillState,
         checkGc: checkGcState,

package/dist/commands/heartbeat.js

@@ -317,6 +317,11 @@ export async function sendCollectorHeartbeatBestEffort(options) {
             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,
+            // BLI-3884. Which route answered those recalls. `null` on a machine
+            // whose memory-mcp does not name one yet — never zero, which would
+            // read as "the daemon answered none".
+            memory_hook_via_daemon_24h: memory.receipt?.hook_via_daemon_24h ?? null,
+            memory_hook_via_direct_24h: memory.receipt?.hook_via_direct_24h ?? null,
         }));
         return true;
     }

package/dist/commands/memory-daemon-probe.js

@@ -0,0 +1,118 @@
+/**
+ * IS THE RESIDENT MEMORY DAEMON ANSWERING? (BLI-3884)
+ *
+ * `bli-memory-mcp daemon` holds a warm connection, credential and scope so a
+ * prompt hook stops paying for a process, a TLS handshake and the device-token
+ * gate on every turn. Two collector surfaces need to know whether it is there:
+ * `cockpit doctor`'s `memory-daemon` row and `cockpit memory status`.
+ *
+ * The probe is written HERE, in twenty lines of `node:net`, rather than by
+ * importing the memory-mcp client: that package is a devDependency of this one
+ * and is not copied into the packed CLI, so an import would be green in the
+ * repo and missing on every fleet machine (the `runtimeFiles` trap this repo
+ * has paid for more than once). What IS shared is the CONTRACT — the address,
+ * the protocol version and the line limit come from
+ * `@bli-cockpit/telemetry-core`'s `memory-daemon-endpoint.ts`, which both
+ * packages depend on.
+ *
+ * **It never fixes anything and never fails anything.** A machine with no
+ * daemon is a machine whose hooks work exactly as they did before the daemon
+ * existed; this reports presence, absence and the reason, and that is all.
+ */
+import net from "node:net";
+import os from "node:os";
+import { MEMORY_DAEMON_MAX_LINE_BYTES, MEMORY_DAEMON_PROTOCOL_VERSION, memoryDaemonEndpoint, } from "@bli-cockpit/telemetry-core";
+/** A probe waits this long in total. A live local socket answers in ~1 ms. */
+export const DAEMON_PROBE_TIMEOUT_MS = 400;
+export function probeMemoryDaemon(options = {}) {
+    const now = options.now ?? Date.now;
+    const started = now();
+    const endpoint = memoryDaemonEndpoint({
+        homeDir: options.homeDir ?? os.homedir(),
+        ...(options.platform ? { platform: options.platform } : {}),
+        username: options.username ?? safeUsername(),
+    });
+    const base = { kind: endpoint.kind, pid: null, startedAt: null };
+    if (endpoint.kind === "unix" && endpoint.addressTooLong) {
+        return Promise.resolve({
+            ...base,
+            answering: false,
+            reason: "socket_path_too_long",
+            elapsedMs: 0,
+        });
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        let buffered = "";
+        const finish = (answering, reason, extra = {}) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            resolve({ ...base, ...extra, answering, reason, elapsedMs: now() - started });
+        };
+        const timer = setTimeout(() => finish(false, "probe_timeout"), options.timeoutMs ?? DAEMON_PROBE_TIMEOUT_MS);
+        timer.unref?.();
+        const socket = (options.connectImpl ?? ((address) => net.createConnection({ path: address })))(endpoint.address);
+        socket.on("error", (error) => {
+            const code = error.code;
+            finish(false, code === "ENOENT" || code === "ECONNREFUSED"
+                ? "daemon_absent"
+                : `daemon_socket_${(code ?? "error").toLowerCase()}`);
+        });
+        socket.on("connect", () => {
+            socket.write(`${JSON.stringify({ v: MEMORY_DAEMON_PROTOCOL_VERSION, event: "ping" })}\n`);
+        });
+        socket.on("data", (chunk) => {
+            buffered += chunk.toString("utf8");
+            if (buffered.length > MEMORY_DAEMON_MAX_LINE_BYTES) {
+                finish(false, "daemon_answer_too_large");
+                return;
+            }
+            const newline = buffered.indexOf("\n");
+            if (newline === -1)
+                return;
+            let parsed;
+            try {
+                parsed = JSON.parse(buffered.slice(0, newline));
+            }
+            catch {
+                finish(false, "daemon_answer_unparseable");
+                return;
+            }
+            const record = (parsed ?? {});
+            if (record["ok"] !== true) {
+                finish(false, typeof record["reason"] === "string" ? record["reason"] : "daemon_refused");
+                return;
+            }
+            finish(true, "answering", {
+                pid: typeof record["pid"] === "number" ? record["pid"] : null,
+                startedAt: typeof record["startedAt"] === "string" ? record["startedAt"] : null,
+            });
+        });
+        socket.on("close", () => finish(false, "daemon_closed_without_answer"));
+    });
+}
+/** One sentence a person reads, on either branch. Never a path. */
+export function memoryDaemonLine(reading) {
+    if (reading.answering) {
+        return (`the memory daemon is answering on this machine's ${reading.kind === "pipe" ? "named pipe" : "local socket"}` +
+            `${reading.pid === null ? "" : ` (pid ${reading.pid})`}` +
+            ` — prompt recalls skip a process start, a fresh connection and the token check`);
+    }
+    if (reading.reason === "socket_path_too_long") {
+        return ("the memory daemon cannot run here: this machine's home directory is deep enough that its socket path" +
+            " exceeds the operating system's limit. Recall still works — every prompt takes the direct path.");
+    }
+    return (`no memory daemon is answering (${reading.reason}); every prompt recall takes the direct path,` +
+        " which is how it worked before the daemon existed. The next prompt hook starts one.");
+}
+function safeUsername() {
+    try {
+        return os.userInfo().username;
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -47,6 +47,12 @@ export function readMemoryHookCounts(options) {
             hook_timeouts_24h: window.timeouts,
             hook_printed_24h: window.printed,
             hook_failed_24h: window.failed,
+            ...(window.viaMeasured
+                ? {
+                    hook_via_daemon_24h: window.viaDaemon,
+                    hook_via_direct_24h: window.viaDirect,
+                }
+                : {}),
             hook_skipped_trivial_24h: window.skippedTrivial,
         },
         reason: "ok",

package/dist/commands/memory-install-report.js

@@ -4,6 +4,7 @@
  * Sibling of `memory-install.ts`, named in its header.
  */
 import { memoryInstallGaps } from "@bli-cockpit/telemetry-core";
+import { memoryDaemonLine } from "./memory-daemon-probe.js";
 import { memoryReceiptLine } from "./memory-install-receipt.js";
 import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, readLocalCollectorConfig, } from "../local-state.js";
 export async function resolveDashboardUrl(command, deps) {
@@ -94,6 +95,10 @@ export function memoryOutcomeLines(outcome) {
                         ? "BLI Memory was not registered and nothing was written: the bli-memory-mcp server is not on this machine yet."
                         : `BLI Memory is not fully registered: ${outcome.reason}.`;
     const lines = [headline, `  ${memoryReceiptLine(outcome.receipt)}`];
+    // BLI-3884. Only `status` asks; an absent reading is not printed as "no
+    // daemon", because nothing looked.
+    if (outcome.daemon)
+        lines.push(`  ${memoryDaemonLine(outcome.daemon)}`);
     // The trust step is the one thing a person has to do by hand, so it is said
     // here in words rather than left as a status word they have to look up.
     if (outcome.receipt.codex.hooks === "needs_trust") {

package/dist/commands/memory-install.js

@@ -48,6 +48,7 @@ import { defaultMemoryFileIo, } from "./memory-install-files.js";
 import { installClaudeMemoryIntegration, inspectClaudeMemoryIntegration, } from "./memory-install-claude.js";
 import { installCodexMemoryIntegration, inspectCodexMemoryIntegration, } from "./memory-install-codex.js";
 import { resolveMemoryConfig } from "./memory-install-config.js";
+import { probeMemoryDaemon } from "./memory-daemon-probe.js";
 import { expectedCodexTrustRows, readCodexHookTrustFromDisk, } from "./memory-install-codex-hooks.js";
 import { buildMemoryInstallReceipt, writeMemoryReceiptFile, } from "./memory-install-receipt.js";
 import { getCollectorRuntimePaths } from "../local-state.js";
@@ -208,6 +209,10 @@ export async function inspectMemoryIntegration(command, io, deps = {}) {
     })));
     const outcome = {
         action: "status",
+        // The one live question on this surface: is the daemon answering? It is
+        // bounded, it opens nothing but a local socket, and a machine without one
+        // is reported as exactly that rather than as a problem.
+        daemon: await probeMemoryDaemon({ ...(homeDir ? { homeDir } : {}) }),
         ...aggregate(targets),
         config_source: resolved.source,
         bin_found: resolved.config !== null,

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

@@ -103,6 +103,10 @@ export function renderMemoryHooks(hooks, dim) {
         lines.push((device.timeouts ?? 0) > 0 ? line : dim(line));
         if (device.performanceLine)
             lines.push(`    ${device.performanceLine}`);
+        // BLI-3884. Written on the server (`lib/ops/memory-hook-misses.ts`) and
+        // printed verbatim, like every other sentence in this section.
+        if (device.viaLine)
+            lines.push(dim(`    ${device.viaLine}`));
     }
     return lines;
 }

package/dist/commands/ops.js

@@ -148,6 +148,10 @@ async function runOpsStatus(command, io, tower) {
         // `runs - skipped_trivial` is how many turns actually asked the door.
         memory_hook_skipped_trivial_24h: memory?.hooks?.totals?.skippedTrivial ?? null,
         memory_hook_devices_reporting: memory?.hooks?.reporting ?? null,
+        // BLI-3884: which route answered them, fleet-wide. Null while no machine
+        // names one — a rollout fact, not a count of zero.
+        memory_hook_via_daemon_24h: memory?.hooks?.via?.daemon ?? null,
+        memory_hook_via_direct_24h: memory?.hooks?.via?.direct ?? null,
     })}`);
     return unhealthy.length > 0 ? 1 : 0;
 }

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.84");
+    writeLine(io?.stdout ?? process.stdout, "0.2.85");
     return 0;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.84",
+  "version": "0.2.85",
   "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-verb-help.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.16",
-    "@bli-cockpit/mcp": "0.1.18",
-    "@bli-cockpit/telemetry-core": "0.1.34"
+    "@bli-cockpit/memory-mcp": "0.1.17",
+    "@bli-cockpit/mcp": "0.1.19",
+    "@bli-cockpit/telemetry-core": "0.1.35"
   }
 }