@primitive.ai/prim 0.1.0-alpha.40 → 0.1.0-alpha.42

package/dist/index.js

@@ -4,34 +4,40 @@ import {
   color,
   colorForArea,
   dim,
+  requireDurableIngestAcknowledgement,
   stripAnsi,
   stripControlChars
-} from "./chunk-AAGJFO7C.js";
+} from "./chunk-QY75BQMF.js";
 import {
   checkAffectedDecisions,
   daemonOrDirectGet,
   formatDecisionsWarning
-} from "./chunk-UWAJCF7P.js";
+} from "./chunk-BSZGI5RL.js";
 import {
   JOURNAL_DIR,
   SESSIONS_DIR,
   bucketStats,
   listBuckets,
   listFlushing,
+  pendingJournalStats,
   readMovesFromPath
-} from "./chunk-H4OR42TJ.js";
+} from "./chunk-OKUXEBPT.js";
 import {
-  activateRepoBestEffort,
-  gitToplevel,
-  setRepoActive
-} from "./chunk-LUPD2JSH.js";
+  fetchFeedbackCapability
+} from "./chunk-NDIK4FBF.js";
+import {
+  inspectWorkspaceId
+} from "./chunk-IMAIBPUC.js";
 import {
+  activateRepoBestEffort,
   binFile,
   commandMatchesBin,
   detachedHookShimCommand,
+  gitToplevel,
   hookShimCommand,
+  setRepoActive,
   warmBinCache
-} from "./chunk-HSZPTVKU.js";
+} from "./chunk-F7O7V6ZM.js";
 import {
   HttpError,
   REFRESH_TOKEN_PATH,
@@ -42,15 +48,15 @@ import {
   getSiteUrl,
   getTokenExpiresAt,
   saveTokenExpiry
-} from "./chunk-26VA3ADF.js";
+} from "./chunk-W6PAKEDO.js";
 import {
   daemonIsLive,
   daemonRequest
 } from "./chunk-UTKQTZHL.js";
 
 // src/index.ts
-import { readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname8, resolve as resolve5 } from "path";
+import { readFileSync as readFileSync12 } from "fs";
+import { dirname as dirname9, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { Command } from "commander";
 import updateNotifier from "update-notifier";
@@ -344,8 +350,8 @@ function registerAuthCommands(program2) {
     const state = base64url(randomBytes(16));
     const redirectUri = `http://${LOCALHOST}:${CALLBACK_PORT}/callback`;
     let settle;
-    const outcome = new Promise((resolve6) => {
-      settle = resolve6;
+    const outcome = new Promise((resolve7) => {
+      settle = resolve7;
     });
     const server = createServer((req, res) => {
       const url = new URL(req.url ?? "/", `http://${LOCALHOST}`);
@@ -359,12 +365,12 @@ function registerAuthCommands(program2) {
       res.end(page.html, () => settle(page.result));
     });
     try {
-      await new Promise((resolve6, reject) => {
+      await new Promise((resolve7, reject) => {
         const onError = (err) => reject(err);
         server.once("error", onError);
         server.listen(CALLBACK_PORT, LOCALHOST, () => {
           server.removeListener("error", onError);
-          resolve6();
+          resolve7();
         });
       });
     } catch (err) {
@@ -536,16 +542,546 @@ async function exchangeCode(siteUrl, code, codeVerifier, redirectUri) {
 // src/commands/claude-install.ts
 import {
   closeSync,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   fsyncSync,
-  mkdirSync as mkdirSync2,
+  mkdirSync as mkdirSync3,
   openSync,
+  readFileSync as readFileSync3,
+  renameSync as renameSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname3, join as join2 } from "path";
+
+// src/daemon/launchd.ts
+import { spawnSync } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  mkdtempSync,
   readFileSync as readFileSync2,
   renameSync,
+  rmSync as rmSync2,
+  statSync,
+  symlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
 import { homedir } from "os";
-import { dirname as dirname2, join } from "path";
+import { dirname as dirname2, isAbsolute, join, resolve } from "path";
+var LAUNCHD_LABEL = "ai.getprimitive.prim-daemon";
+var RUNTIME_SCHEMA_VERSION = 1;
+var RUNTIME_DIR_MODE = 448;
+var RUNTIME_FILE_MODE = 384;
+var RUNTIME_LAUNCHER_MODE = 448;
+var PLIST_FILE_MODE = 384;
+var READY_TIMEOUT_MS = 15e3;
+var READY_POLL_MS = 100;
+var READY_PROBE_TIMEOUT_MS = 250;
+var LIFECYCLE_LOCK_TIMEOUT_MS = 3e4;
+var LIFECYCLE_LOCK_POLL_MS = 50;
+var LIFECYCLE_LOCK_INIT_GRACE_MS = 2e3;
+function xdgDataHome(options) {
+  const home = options.homeDir ?? homedir();
+  const configured = (options.env ?? process.env).XDG_DATA_HOME;
+  return configured && isAbsolute(configured) ? configured : join(home, ".local", "share");
+}
+function runtimePaths(options = {}) {
+  const dataDir = join(xdgDataHome(options), "prim");
+  const runtimeDir = join(dataDir, "runtime");
+  const currentLink = join(runtimeDir, "current");
+  return {
+    dataDir,
+    runtimeDir,
+    releasesDir: join(runtimeDir, "releases"),
+    currentLink,
+    daemonEntry: join(currentLink, "prim-daemon-server"),
+    statuslineEntry: join(currentLink, "prim-statusline"),
+    statuslineLauncher: join(runtimeDir, "prim-statusline"),
+    manifestPath: join(currentLink, "manifest.json"),
+    disabledMarker: join(dataDir, "daemon.disabled"),
+    lifecycleLockDir: join(dataDir, "daemon.lifecycle.lock")
+  };
+}
+function findPackageVersion(entryFile) {
+  let dir = dirname2(resolve(entryFile));
+  for (let depth = 0; depth < 6; depth++) {
+    const packagePath = join(dir, "package.json");
+    if (existsSync2(packagePath)) {
+      try {
+        const manifest = JSON.parse(readFileSync2(packagePath, "utf8"));
+        if (manifest.name === "@primitive.ai/prim" && manifest.version) {
+          return manifest.version;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(`cannot determine @primitive.ai/prim version from ${entryFile}`);
+}
+function readRuntimeManifest(path) {
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (parsed.schemaVersion !== RUNTIME_SCHEMA_VERSION || typeof parsed.version !== "string" || typeof parsed.nodePath !== "string" || parsed.daemonFile !== "prim-daemon-server") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function sameRuntime(current, desired, paths) {
+  return Boolean(
+    current && current.version === desired.version && current.nodePath === desired.nodePath && current.statuslineFile === desired.statuslineFile && existsSync2(paths.daemonEntry) && (desired.statuslineFile === void 0 || existsSync2(paths.statuslineEntry))
+  );
+}
+function atomicSymlink(target, linkPath) {
+  const tempLink = `${linkPath}.tmp-${process.pid}-${createHash2("sha256").update(`${target}\0${Date.now()}\0${Math.random()}`).digest("hex").slice(0, 12)}`;
+  symlinkSync(target, tempLink);
+  try {
+    renameSync(tempLink, linkPath);
+  } catch (error) {
+    rmSync2(tempLink, { force: true });
+    throw error;
+  }
+}
+function stageRuntime(options = {}) {
+  const paths = runtimePaths(options);
+  const daemonSource = options.daemonSource ?? binFile("prim-daemon-server");
+  if (!daemonSource || !existsSync2(daemonSource)) {
+    throw new Error("cannot stage runtime: prim-daemon-server bundle is unavailable");
+  }
+  const configuredStatusline = options.statuslineSource === void 0 ? binFile("prim-statusline") : options.statuslineSource;
+  const statuslineSource = configuredStatusline && existsSync2(configuredStatusline) ? configuredStatusline : null;
+  const nodePath = resolve(options.nodePath ?? process.execPath);
+  const version = options.version ?? findPackageVersion(daemonSource);
+  const desired = {
+    schemaVersion: RUNTIME_SCHEMA_VERSION,
+    version,
+    nodePath,
+    daemonFile: "prim-daemon-server",
+    ...statuslineSource ? { statuslineFile: "prim-statusline" } : {},
+    stagedAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
+  };
+  const current = readRuntimeManifest(paths.manifestPath);
+  if (sameRuntime(current, desired, paths)) {
+    if (current?.statuslineFile) {
+      atomicWrite(
+        paths.statuslineLauncher,
+        statuslineLauncherContent(paths, current.nodePath),
+        RUNTIME_LAUNCHER_MODE
+      );
+    } else {
+      rmSync2(paths.statuslineLauncher, { force: true });
+    }
+    return { changed: false, manifest: current, paths };
+  }
+  mkdirSync2(paths.releasesDir, { recursive: true, mode: RUNTIME_DIR_MODE });
+  chmodSync(paths.runtimeDir, RUNTIME_DIR_MODE);
+  chmodSync(paths.releasesDir, RUNTIME_DIR_MODE);
+  const stagingDir = mkdtempSync(join(paths.releasesDir, ".stage-"));
+  chmodSync(stagingDir, RUNTIME_DIR_MODE);
+  try {
+    const daemonTarget = join(stagingDir, desired.daemonFile);
+    copyFileSync(daemonSource, daemonTarget);
+    chmodSync(daemonTarget, RUNTIME_FILE_MODE);
+    if (statuslineSource && desired.statuslineFile) {
+      const statuslineTarget = join(stagingDir, desired.statuslineFile);
+      copyFileSync(statuslineSource, statuslineTarget);
+      chmodSync(statuslineTarget, RUNTIME_FILE_MODE);
+    }
+    const manifestTarget = join(stagingDir, "manifest.json");
+    writeFileSync2(manifestTarget, `${JSON.stringify(desired, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: RUNTIME_FILE_MODE,
+      flag: "wx"
+    });
+    const releaseName = `release-${createHash2("sha256").update(
+      `${version}\0${nodePath}\0${desired.statuslineFile ?? ""}\0${desired.stagedAt}\0${process.pid}\0${Math.random()}`
+    ).digest("hex").slice(0, 16)}`;
+    const releaseDir = join(paths.releasesDir, releaseName);
+    renameSync(stagingDir, releaseDir);
+    atomicSymlink(join("releases", releaseName), paths.currentLink);
+    if (desired.statuslineFile) {
+      atomicWrite(
+        paths.statuslineLauncher,
+        statuslineLauncherContent(paths, desired.nodePath),
+        RUNTIME_LAUNCHER_MODE
+      );
+    } else {
+      rmSync2(paths.statuslineLauncher, { force: true });
+    }
+  } catch (error) {
+    rmSync2(stagingDir, { recursive: true, force: true });
+    throw error;
+  }
+  return { changed: true, manifest: desired, paths };
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function statuslineLauncherContent(paths, nodePath) {
+  return `#!/bin/sh
+exec ${shellQuote(nodePath)} ${shellQuote(paths.statuslineEntry)}
+`;
+}
+function runtimeStatuslineCommand(options = {}) {
+  return shellQuote(runtimePaths(options).statuslineLauncher);
+}
+function xmlEscape(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function generateLaunchAgentPlist(config) {
+  const apiUrl = config.apiUrl ? `
+      <key>PRIM_API_URL</key>
+      <string>${xmlEscape(config.apiUrl)}</string>` : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xmlEscape(config.nodePath)}</string>
+    <string>${xmlEscape(config.daemonPath)}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>ProcessType</key>
+  <string>Background</string>
+  <key>Umask</key>
+  <integer>63</integer>
+  <key>WorkingDirectory</key>
+  <string>${xmlEscape(config.workingDirectory)}</string>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(config.logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(config.logPath)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PRIM_RUNTIME_VERSION</key>
+    <string>${xmlEscape(config.runtimeVersion)}</string>${apiUrl}
+  </dict>
+</dict>
+</plist>
+`;
+}
+function launchdPaths(options = {}) {
+  const home = options.homeDir ?? homedir();
+  const uid = options.uid ?? process.getuid?.();
+  if (uid === void 0) throw new Error("cannot determine uid for launchd user domain");
+  return {
+    domainTarget: `gui/${uid}`,
+    serviceTarget: `gui/${uid}/${LAUNCHD_LABEL}`,
+    plistPath: join(home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`),
+    logPath: join(home, ".config", "prim", "daemon.log")
+  };
+}
+var runLaunchctl = (args) => {
+  const result = spawnSync("/bin/launchctl", args, { encoding: "utf8" });
+  return {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.error?.message ?? result.stderr ?? ""
+  };
+};
+function parseLaunchdService(result) {
+  if (result.status !== 0) return { loaded: false };
+  const state = /^\s*state = (.+?)\s*$/m.exec(result.stdout)?.[1];
+  const rawPid = /^\s*pid = (\d+)\s*$/m.exec(result.stdout)?.[1];
+  const pid = rawPid ? Number(rawPid) : void 0;
+  return { loaded: true, state, pid, raw: result.stdout };
+}
+function getLaunchdService(options = {}) {
+  const paths = launchdPaths(options);
+  return parseLaunchdService((options.runner ?? runLaunchctl)(["print", paths.serviceTarget]));
+}
+function atomicWrite(path, content, mode) {
+  try {
+    if (readFileSync2(path, "utf8") === content) {
+      chmodSync(path, mode);
+      return false;
+    }
+  } catch {
+  }
+  mkdirSync2(dirname2(path), { recursive: true });
+  const temp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  writeFileSync2(temp, content, { encoding: "utf8", mode, flag: "wx" });
+  try {
+    renameSync(temp, path);
+  } catch (error) {
+    rmSync2(temp, { force: true });
+    throw error;
+  }
+  return true;
+}
+function launchctlOrThrow(runner, args, operation) {
+  const result = runner(args);
+  if (result.status !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim() || `exit ${String(result.status)}`;
+    throw new Error(`launchctl ${operation} failed: ${detail}`);
+  }
+  return result;
+}
+function defaultSleep(ms) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+async function identifyDaemon(timeoutMs) {
+  const snapshot = await daemonRequest("status_snapshot", {}, { timeoutMs });
+  return typeof snapshot?.pid === "number" ? snapshot.pid : null;
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function lifecycleOwnerPath(lockDir) {
+  return join(lockDir, "owner.json");
+}
+function readLifecycleOwner(lockDir) {
+  try {
+    const owner = JSON.parse(
+      readFileSync2(lifecycleOwnerPath(lockDir), "utf8")
+    );
+    if (!Number.isInteger(owner.pid) || owner.pid <= 0 || typeof owner.nonce !== "string" || typeof owner.createdAt !== "number") {
+      return null;
+    }
+    return owner;
+  } catch {
+    return null;
+  }
+}
+function sameLifecycleOwner(a, b) {
+  return a?.pid === b.pid && a.nonce === b.nonce && a.createdAt === b.createdAt;
+}
+function tryTakeLifecycleLock(lockDir, now) {
+  try {
+    mkdirSync2(lockDir, { mode: RUNTIME_DIR_MODE });
+  } catch (error) {
+    if (error.code === "EEXIST") return null;
+    throw error;
+  }
+  const owner = {
+    pid: process.pid,
+    nonce: createHash2("sha256").update(`${process.pid}\0${now}\0${Math.random()}`).digest("hex"),
+    createdAt: now
+  };
+  try {
+    writeFileSync2(lifecycleOwnerPath(lockDir), `${JSON.stringify(owner)}
+`, {
+      encoding: "utf8",
+      mode: RUNTIME_FILE_MODE,
+      flag: "wx"
+    });
+    return owner;
+  } catch (error) {
+    rmSync2(lockDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+function recoverStaleLifecycleLock(lockDir, now, alive) {
+  const owner = readLifecycleOwner(lockDir);
+  if (owner) {
+    if (alive(owner.pid)) return false;
+    if (!sameLifecycleOwner(readLifecycleOwner(lockDir), owner)) return false;
+    rmSync2(lockDir, { recursive: true, force: true });
+    return true;
+  }
+  try {
+    const before = statSync(lockDir).mtimeMs;
+    if (now - before < LIFECYCLE_LOCK_INIT_GRACE_MS) return false;
+    if (readLifecycleOwner(lockDir)) return false;
+    if (statSync(lockDir).mtimeMs !== before) return false;
+    rmSync2(lockDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    return true;
+  }
+}
+async function withDaemonLifecycleLock(operation, options = {}) {
+  const lockDir = runtimePaths(options).lifecycleLockDir;
+  mkdirSync2(dirname2(lockDir), { recursive: true, mode: RUNTIME_DIR_MODE });
+  const control = options.lifecycleLock;
+  const nowMs = control?.nowMs ?? Date.now;
+  const sleepFor = control?.sleep ?? defaultSleep;
+  const alive = control?.processAlive ?? processIsAlive;
+  const deadline = nowMs() + (control?.timeoutMs ?? LIFECYCLE_LOCK_TIMEOUT_MS);
+  let owner = null;
+  while (!owner) {
+    const now = nowMs();
+    owner = tryTakeLifecycleLock(lockDir, now);
+    if (owner) break;
+    recoverStaleLifecycleLock(lockDir, now, alive);
+    if (now >= deadline) {
+      throw new Error(`timed out waiting for daemon lifecycle lock ${lockDir}`);
+    }
+    await sleepFor(control?.pollMs ?? LIFECYCLE_LOCK_POLL_MS);
+  }
+  try {
+    return await operation();
+  } finally {
+    if (sameLifecycleOwner(readLifecycleOwner(lockDir), owner)) {
+      rmSync2(lockDir, { recursive: true, force: true });
+    }
+  }
+}
+async function stopVerifiedLegacyDaemon(homeDir) {
+  const pidPath = join(homeDir, ".config", "prim", "daemon.pid");
+  let pid;
+  try {
+    pid = Number(readFileSync2(pidPath, "utf8").trim());
+  } catch {
+    throw new Error("an unsupervised daemon answered, but it has no verifiable pidfile");
+  }
+  const snapshot = await daemonRequest("status_snapshot", {}, { timeoutMs: 500 });
+  if (!Number.isInteger(pid) || pid <= 0 || !processIsAlive(pid) || snapshot?.pid !== pid) {
+    throw new Error("refusing to signal an unsupervised daemon whose pid cannot be verified");
+  }
+  process.kill(pid, "SIGTERM");
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline && processIsAlive(pid)) {
+    await defaultSleep(100);
+  }
+  if (processIsAlive(pid)) {
+    throw new Error(`verified legacy daemon pid=${pid} did not stop within 5000ms`);
+  }
+  return true;
+}
+async function waitForReady(probe, sleep2) {
+  const deadline = Date.now() + READY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (await probe(READY_PROBE_TIMEOUT_MS)) return true;
+    await sleep2(READY_POLL_MS);
+  }
+  return probe(READY_PROBE_TIMEOUT_MS);
+}
+function daemonExplicitlyDisabled(options = {}) {
+  return existsSync2(runtimePaths(options).disabledMarker);
+}
+function setDaemonExplicitlyDisabled(disabled, options = {}) {
+  const marker = runtimePaths(options).disabledMarker;
+  if (!disabled) {
+    rmSync2(marker, { force: true });
+    return;
+  }
+  mkdirSync2(dirname2(marker), { recursive: true, mode: RUNTIME_DIR_MODE });
+  writeFileSync2(marker, "disabled by `prim daemon stop`\n", {
+    encoding: "utf8",
+    mode: RUNTIME_FILE_MODE
+  });
+  chmodSync(marker, RUNTIME_FILE_MODE);
+}
+async function ensureMacDaemon(options = {}) {
+  return withDaemonLifecycleLock(() => ensureMacDaemonLocked(options), options);
+}
+async function ensureMacDaemonLocked(options) {
+  if (!options.explicitlyStarted && daemonExplicitlyDisabled(options)) {
+    return {
+      state: "disabled",
+      action: "none",
+      runtimeChanged: false,
+      plistChanged: false,
+      responding: false,
+      service: getLaunchdService(options)
+    };
+  }
+  if (options.explicitlyStarted) setDaemonExplicitlyDisabled(false, options);
+  const runtime = stageRuntime(options);
+  const servicePaths = launchdPaths(options);
+  mkdirSync2(dirname2(servicePaths.logPath), { recursive: true, mode: RUNTIME_DIR_MODE });
+  writeFileSync2(servicePaths.logPath, "", { mode: RUNTIME_FILE_MODE, flag: "a" });
+  chmodSync(servicePaths.logPath, RUNTIME_FILE_MODE);
+  const plist = generateLaunchAgentPlist({
+    nodePath: runtime.manifest.nodePath,
+    daemonPath: runtime.paths.daemonEntry,
+    runtimeVersion: runtime.manifest.version,
+    logPath: servicePaths.logPath,
+    workingDirectory: options.homeDir ?? homedir(),
+    apiUrl: (options.env ?? process.env).PRIM_API_URL
+  });
+  const plistChanged = atomicWrite(servicePaths.plistPath, plist, PLIST_FILE_MODE);
+  const runner = options.runner ?? runLaunchctl;
+  let service = getLaunchdService({ ...options, runner });
+  let action = "none";
+  if (service.loaded && plistChanged) {
+    launchctlOrThrow(runner, ["bootout", servicePaths.serviceTarget], "bootout");
+    launchctlOrThrow(
+      runner,
+      ["bootstrap", servicePaths.domainTarget, servicePaths.plistPath],
+      "bootstrap"
+    );
+    action = "reload";
+  } else if (!service.loaded) {
+    if (await (options.probe ?? daemonIsLive)(READY_PROBE_TIMEOUT_MS)) {
+      await (options.migrateLegacy ?? (() => stopVerifiedLegacyDaemon(options.homeDir ?? homedir())))();
+    }
+    launchctlOrThrow(
+      runner,
+      ["bootstrap", servicePaths.domainTarget, servicePaths.plistPath],
+      "bootstrap"
+    );
+    action = "bootstrap";
+  } else {
+    const healthy = await (options.probe ?? daemonIsLive)(READY_PROBE_TIMEOUT_MS);
+    const socketPid2 = healthy ? await (options.identify ?? identifyDaemon)(READY_PROBE_TIMEOUT_MS) : null;
+    const ownsSocket = service.pid !== void 0 && socketPid2 !== null && service.pid === socketPid2;
+    if (healthy && socketPid2 !== null && !ownsSocket) {
+      await (options.migrateLegacy ?? (() => stopVerifiedLegacyDaemon(options.homeDir ?? homedir())))();
+    }
+    if (runtime.changed || options.forceRestart || !healthy || !ownsSocket) {
+      launchctlOrThrow(runner, ["kickstart", "-k", servicePaths.serviceTarget], "kickstart");
+      action = "kickstart";
+    }
+  }
+  const responding = await waitForReady(
+    options.probe ?? daemonIsLive,
+    options.sleep ?? defaultSleep
+  );
+  service = getLaunchdService({ ...options, runner });
+  const socketPid = responding ? await (options.identify ?? identifyDaemon)(READY_PROBE_TIMEOUT_MS) : null;
+  const running = responding && service.loaded && service.pid !== void 0 && socketPid !== null && service.pid === socketPid;
+  return {
+    state: running ? "running" : "unhealthy",
+    action,
+    runtimeChanged: runtime.changed,
+    plistChanged,
+    responding,
+    ...socketPid === null ? {} : { socketPid },
+    service,
+    runtime
+  };
+}
+async function bootoutMacDaemon(options = {}) {
+  return withDaemonLifecycleLock(() => bootoutMacDaemonLocked(options), options);
+}
+async function bootoutMacDaemonLocked(options) {
+  setDaemonExplicitlyDisabled(true, options);
+  const runner = options.runner ?? runLaunchctl;
+  const paths = launchdPaths(options);
+  const service = getLaunchdService({ ...options, runner });
+  if (service.loaded) {
+    launchctlOrThrow(runner, ["bootout", paths.serviceTarget], "bootout");
+    return { wasLoaded: true, legacyStopped: false, service };
+  }
+  const legacyStopped = await (options.probe ?? daemonIsLive)(READY_PROBE_TIMEOUT_MS) ? await (options.migrateLegacy ?? (() => stopVerifiedLegacyDaemon(options.homeDir ?? homedir())))() : false;
+  return { wasLoaded: false, legacyStopped, service };
+}
+
+// src/commands/claude-install.ts
 var CAPTURE_BIN = "prim-hook";
 var GATE_BIN = "prim-pre-tool-use";
 var POST_TOOL_USE_BIN = "prim-post-tool-use";
@@ -563,11 +1099,11 @@ var PRIM_BINS = [
   SESSION_END_BIN
 ];
 var JSON_INDENT = 2;
-var USER_SCOPE_PATH = join(homedir(), ".claude", "settings.json");
+var USER_SCOPE_PATH = join2(homedir2(), ".claude", "settings.json");
 function projectRoot() {
   return gitToplevel() ?? process.cwd();
 }
-var projectScopePath = () => join(projectRoot(), ".claude", "settings.json");
+var projectScopePath = () => join2(projectRoot(), ".claude", "settings.json");
 var CAPTURE_EVENTS = [
   "SessionStart",
   "UserPromptSubmit",
@@ -609,10 +1145,10 @@ function settingsPathFor(scope) {
   return scope === "user" ? USER_SCOPE_PATH : projectScopePath();
 }
 function readSettings(path) {
-  if (!existsSync2(path)) {
+  if (!existsSync3(path)) {
     return {};
   }
-  const raw = readFileSync2(path, "utf-8");
+  const raw = readFileSync3(path, "utf-8");
   try {
     return JSON.parse(raw);
   } catch (err) {
@@ -645,15 +1181,24 @@ function ensureRegistration(list, reg, force) {
   return [...stripCommand(list, reg.bin), canonicalEntry(reg)];
 }
 var LEGACY_STATUSLINE_COMMAND = "prim statusline";
+var RUNTIME_STATUSLINE_SUFFIXES = [
+  "/prim/runtime/prim-statusline",
+  // One pre-launcher build persisted the JS entry directly. Keep recognizing
+  // it so reinstall migrates and uninstall removes that older staged form.
+  "/prim/runtime/current/prim-statusline"
+];
 function isPrimStatusLine(settings) {
   const s = settings.statusLine;
   if (s?.type !== "command") {
     return false;
   }
   const c = (s.command ?? "").trim();
-  return c === LEGACY_STATUSLINE_COMMAND || c.includes("@primitive.ai/prim") && c.includes("statusline");
+  return c === LEGACY_STATUSLINE_COMMAND || c.includes("@primitive.ai/prim") && c.includes("statusline") || RUNTIME_STATUSLINE_SUFFIXES.some((suffix) => c.includes(suffix));
 }
-function applyStatusLine(settings) {
+function applyStatusLine(settings, command = STATUSLINE_COMMAND) {
+  if (command === false) {
+    return isPrimStatusLine(settings) ? { ...settings, statusLine: void 0 } : settings;
+  }
   if (settings.statusLine && !isPrimStatusLine(settings)) {
     return settings;
   }
@@ -661,7 +1206,7 @@ function applyStatusLine(settings) {
     ...settings,
     statusLine: {
       type: "command",
-      command: STATUSLINE_COMMAND,
+      command,
       refreshInterval: STATUSLINE_REFRESH_SECONDS
     }
   };
@@ -721,7 +1266,12 @@ function applyInstall(settings, options = {}) {
   for (const reg of REGISTRATIONS) {
     hooks[reg.event] = ensureRegistration(hooks[reg.event] ?? [], reg, options.force ?? false);
   }
-  return applyPermissions(applyStatusLine({ ...settings, hooks }));
+  return applyPermissions(
+    applyStatusLine(
+      { ...settings, hooks },
+      options.installStatusline === false ? false : options.statuslineCommand ?? STATUSLINE_COMMAND
+    )
+  );
 }
 function applyUninstall(settings) {
   const source = settings.hooks ?? {};
@@ -746,19 +1296,34 @@ function captureInstalled(settings) {
     (event) => (settings.hooks?.[event] ?? []).some((e) => entryHasCommand(e, CAPTURE_BIN))
   );
 }
+function feedbackInstalled(settings) {
+  const stopCapture = (settings.hooks?.Stop ?? []).some(
+    (entry) => entryHasCommand(entry, CAPTURE_BIN)
+  );
+  const sessionStart = (settings.hooks?.SessionStart ?? []).some(
+    (entry) => entryHasCommand(entry, SESSION_START_BIN)
+  );
+  return stopCapture && sessionStart;
+}
 function statuslineInstalled(settings) {
   return isPrimStatusLine(settings);
 }
+function statuslineState(settings) {
+  if (isPrimStatusLine(settings)) {
+    return "primitive";
+  }
+  return settings.statusLine ? "custom" : "empty";
+}
 function isGateInstalled(settings) {
   return (settings.hooks?.PreToolUse ?? []).some((e) => entryHasCommand(e, GATE_BIN));
 }
-function atomicWrite(path, content) {
-  const dir = dirname2(path);
-  if (!existsSync2(dir)) {
-    mkdirSync2(dir, { recursive: true });
+function atomicWrite2(path, content) {
+  const dir = dirname3(path);
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true });
   }
   const tmp = `${path}.tmp.${String(Date.now())}`;
-  writeFileSync2(tmp, `${JSON.stringify(content, null, JSON_INDENT)}
+  writeFileSync3(tmp, `${JSON.stringify(content, null, JSON_INDENT)}
 `, "utf-8");
   const fd = openSync(tmp, "r+");
   try {
@@ -766,15 +1331,42 @@ function atomicWrite(path, content) {
   } finally {
     closeSync(fd);
   }
-  renameSync(tmp, path);
+  renameSync2(tmp, path);
+}
+function userStatuslineBlocksProjectInstall(scope, userSettings) {
+  return scope === "project" && statuslineState(userSettings) === "custom";
 }
 function performInstall(scope, force) {
   const path = settingsPathFor(scope);
   const before = readSettings(path);
-  const after = applyInstall(before, { force });
+  const blockedByUserStatusline = userStatuslineBlocksProjectInstall(
+    scope,
+    scope === "project" ? readSettings(USER_SCOPE_PATH) : {}
+  );
+  let statuslineCommand = STATUSLINE_COMMAND;
+  if (!blockedByUserStatusline && process.platform === "darwin" && (!before.statusLine || isPrimStatusLine(before))) {
+    try {
+      const runtime = stageRuntime();
+      if (!runtime.manifest.statuslineFile) {
+        throw new Error("standalone prim-statusline entry is unavailable");
+      }
+      statuslineCommand = runtimeStatuslineCommand();
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      process.stderr.write(
+        `[prim] \u26A0 could not stage the durable statusline runtime (${detail}); using the package resolver
+`
+      );
+    }
+  }
+  const after = applyInstall(before, {
+    force,
+    statuslineCommand,
+    installStatusline: !blockedByUserStatusline
+  });
   const changed = JSON.stringify(before) !== JSON.stringify(after);
   if (changed) {
-    atomicWrite(path, after);
+    atomicWrite2(path, after);
   }
   if (scope === "project") {
     activateRepoBestEffort(process.cwd());
@@ -784,7 +1376,9 @@ function performInstall(scope, force) {
     path,
     gate: isGateInstalled(after),
     capture: captureInstalled(after),
+    feedback: feedbackInstalled(after),
     statusline: statuslineInstalled(after),
+    statuslineState: statuslineState(after),
     changed
   };
 }
@@ -794,14 +1388,16 @@ function performUninstall(scope) {
   const after = applyUninstall(before);
   const changed = JSON.stringify(before) !== JSON.stringify(after);
   if (changed) {
-    atomicWrite(path, after);
+    atomicWrite2(path, after);
   }
   return {
     scope,
     path,
     gate: isGateInstalled(after),
     capture: captureInstalled(after),
+    feedback: feedbackInstalled(after),
     statusline: statuslineInstalled(after),
+    statuslineState: statuslineState(after),
     changed
   };
 }
@@ -811,7 +1407,7 @@ function performPermissionInstall(scope) {
   const after = applyAutoModeTrust(applyPermissions(before));
   const changed = JSON.stringify(before) !== JSON.stringify(after);
   if (changed) {
-    atomicWrite(path, after);
+    atomicWrite2(path, after);
   }
   return {
     scope,
@@ -828,7 +1424,9 @@ function performStatus() {
       path,
       gate: isGateInstalled(settings),
       capture: captureInstalled(settings),
-      statusline: statuslineInstalled(settings)
+      feedback: feedbackInstalled(settings),
+      statusline: statuslineInstalled(settings),
+      statuslineState: statuslineState(settings)
     };
   };
   return { user: statusFor(USER_SCOPE_PATH), project: statusFor(projectScopePath()) };
@@ -860,6 +1458,14 @@ function registerClaudeCommands(program2) {
         `[prim] Claude Code integration already present at ${result.path} (no changes)`
       );
     }
+    const projectState = scope === "user" ? performStatus().project.statuslineState : void 0;
+    const userState = scope === "project" ? performStatus().user.statuslineState : void 0;
+    if (result.statuslineState === "custom" || projectState === "custom" || userState === "custom") {
+      const owner = result.statuslineState === "custom" ? result.path : projectState === "custom" ? projectScopePath() : USER_SCOPE_PATH;
+      console.error(
+        `[prim] \u26A0 statusline skipped: an existing custom statusLine is preserved at ${owner}; run \`prim daemon status\` for Primitive health`
+      );
+    }
     console.log(JSON.stringify(result, null, JSON_INDENT));
   });
   claude.command("preauth").description(
@@ -889,11 +1495,11 @@ function registerClaudeCommands(program2) {
     console.log(JSON.stringify(result, null, JSON_INDENT));
   });
   claude.command("status").description(
-    "Report whether each prim surface (gate, capture, statusline) is installed per scope"
+    "Report whether each prim surface (gate, capture, feedback, statusline) is installed per scope"
   ).action(() => {
     const result = performStatus();
     const mark = (b) => b ? "\u2713" : "\u2717";
-    const line = (label, s) => `[prim] ${label}: gate ${mark(s.gate)} \xB7 capture ${mark(s.capture)} \xB7 statusline ${mark(s.statusline)} (${s.path})`;
+    const line = (label, s) => `[prim] ${label}: gate ${mark(s.gate)} \xB7 capture ${mark(s.capture)} \xB7 feedback ${mark(s.feedback)} \xB7 statusline ${s.statuslineState} (${s.path})`;
     console.error(`${line("user", result.user)}
 ${line("project", result.project)}`);
     console.log(JSON.stringify(result, null, JSON_INDENT));
@@ -901,8 +1507,8 @@ ${line("project", result.project)}`);
 }
 
 // src/commands/codex-install.ts
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
 var CAPTURE_BIN2 = "prim-hook";
 var GATE_BIN2 = "prim-pre-tool-use";
 var POST_TOOL_USE_BIN2 = "prim-post-tool-use";
@@ -926,8 +1532,8 @@ var CODEX_REGISTRATIONS = [
   // refresh the bin cache the other hooks read. See lib/bin-cache.ts.
   makeRegistration("SessionStart", "*", SESSION_START_BIN2, CODEX_ARGS, { cacheRead: false })
 ];
-var USER_SCOPE_PATH2 = join2(homedir2(), ".codex", "hooks.json");
-var projectScopePath2 = () => join2(projectRoot(), ".codex", "hooks.json");
+var USER_SCOPE_PATH2 = join3(homedir3(), ".codex", "hooks.json");
+var projectScopePath2 = () => join3(projectRoot(), ".codex", "hooks.json");
 function settingsPathFor2(scope) {
   return scope === "user" ? USER_SCOPE_PATH2 : projectScopePath2();
 }
@@ -975,7 +1581,7 @@ function performInstall2(scope, force) {
   const after = applyInstall2(before, { force });
   const changed = JSON.stringify(before) !== JSON.stringify(after);
   if (changed) {
-    atomicWrite(path, after);
+    atomicWrite2(path, after);
   }
   if (scope === "project") {
     activateRepoBestEffort(process.cwd());
@@ -988,7 +1594,7 @@ function performUninstall2(scope) {
   const after = applyUninstall2(before);
   const changed = JSON.stringify(before) !== JSON.stringify(after);
   if (changed) {
-    atomicWrite(path, after);
+    atomicWrite2(path, after);
   }
   return resultFor(scope, path, after, changed);
 }
@@ -1051,9 +1657,9 @@ ${line("project", result.project)}`);
 
 // src/commands/daemon.ts
 import { spawn } from "child_process";
-import { closeSync as closeSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, openSync as openSync2, readFileSync as readFileSync3, unlinkSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
+import { closeSync as closeSync2, existsSync as existsSync4, mkdirSync as mkdirSync4, openSync as openSync2, readFileSync as readFileSync4, unlinkSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
 
 // src/lib/presence.ts
 function formatLabeled(labels, cap) {
@@ -1083,33 +1689,35 @@ function formatTeammatesWithArea(teammates, cap) {
 
 // src/commands/daemon.ts
 var DAEMON_BIN = "prim-daemon-server";
-var CONFIG_DIR = join3(homedir3(), ".config", "prim");
-var PID_PATH = join3(CONFIG_DIR, "daemon.pid");
-var SOCK_PATH = join3(CONFIG_DIR, "sock");
-var LOG_PATH = join3(CONFIG_DIR, "daemon.log");
+var CONFIG_DIR = join4(homedir4(), ".config", "prim");
+var PID_PATH = join4(CONFIG_DIR, "daemon.pid");
+var SOCK_PATH = join4(CONFIG_DIR, "sock");
+var LOG_PATH = join4(CONFIG_DIR, "daemon.log");
 var CONFIG_DIR_MODE = 448;
 var LOG_FILE_MODE = 384;
 var STOP_TIMEOUT_MS = 5e3;
 var STOP_POLL_MS = 100;
 var STATUS_PROBE_TIMEOUT_MS = 500;
-var READY_TIMEOUT_MS = 5e3;
-var READY_POLL_MS = 100;
-var READY_PROBE_TIMEOUT_MS = 250;
+var READY_TIMEOUT_MS2 = 5e3;
+var READY_POLL_MS2 = 100;
+var READY_PROBE_TIMEOUT_MS2 = 250;
+var HEALTHY_TIMEOUT_MS = 3e4;
+var HEALTHY_POLL_MS = 250;
 var EXIT_OK2 = 0;
 var EXIT_NOT_RUNNING = 2;
 var EXIT_BOOTING = 3;
 function readPidfile() {
-  if (!existsSync3(PID_PATH)) {
+  if (!existsSync4(PID_PATH)) {
     return null;
   }
-  const raw = readFileSync3(PID_PATH, "utf-8").trim();
+  const raw = readFileSync4(PID_PATH, "utf-8").trim();
   const pid = Number(raw);
   if (!Number.isInteger(pid) || pid <= 0) {
     return null;
   }
-  return { pid, alive: processIsAlive(pid) };
+  return { pid, alive: processIsAlive2(pid) };
 }
-function processIsAlive(pid) {
+function processIsAlive2(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -1128,40 +1736,89 @@ function clearStaleArtifacts() {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve6) => {
-    const timer = setTimeout(resolve6, ms);
-    timer.unref();
-  });
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 function spawnDaemon(options) {
   const file = binFile(DAEMON_BIN);
   return file ? spawn(process.execPath, [file], options) : spawn(DAEMON_BIN, [], options);
 }
 function openDaemonLog(configDir = CONFIG_DIR) {
-  if (!existsSync3(configDir)) {
-    mkdirSync3(configDir, { recursive: true, mode: CONFIG_DIR_MODE });
+  if (!existsSync4(configDir)) {
+    mkdirSync4(configDir, { recursive: true, mode: CONFIG_DIR_MODE });
   }
-  return openSync2(join3(configDir, "daemon.log"), "a", LOG_FILE_MODE);
+  return openSync2(join4(configDir, "daemon.log"), "a", LOG_FILE_MODE);
 }
-async function waitForReady() {
-  const deadline = Date.now() + READY_TIMEOUT_MS;
+async function waitForReady2() {
+  const deadline = Date.now() + READY_TIMEOUT_MS2;
   while (Date.now() < deadline) {
-    if (await daemonIsLive(READY_PROBE_TIMEOUT_MS)) {
+    if (await daemonIsLive(READY_PROBE_TIMEOUT_MS2)) {
       return true;
     }
-    await sleep(READY_POLL_MS);
+    await sleep(READY_POLL_MS2);
   }
-  return daemonIsLive(READY_PROBE_TIMEOUT_MS);
+  return daemonIsLive(READY_PROBE_TIMEOUT_MS2);
 }
-async function daemonStart(opts) {
+async function waitForHealthySnapshot(expectedVersion) {
+  const deadline = Date.now() + HEALTHY_TIMEOUT_MS;
+  let snapshot = null;
+  while (Date.now() < deadline) {
+    snapshot = await daemonRequest(
+      "status_snapshot",
+      {},
+      { timeoutMs: STATUS_PROBE_TIMEOUT_MS }
+    );
+    if (snapshot?.healthy === true && snapshot.version === expectedVersion) return snapshot;
+    await sleep(HEALTHY_POLL_MS);
+  }
+  return snapshot;
+}
+async function verifiedPid(existing) {
+  if (!existing.alive) return null;
+  const snapshot = await daemonRequest(
+    "status_snapshot",
+    {},
+    { timeoutMs: STATUS_PROBE_TIMEOUT_MS }
+  );
+  return snapshot?.pid === existing.pid ? snapshot : null;
+}
+function daemonStartIsHealthy(serviceReady, snapshot, expectedVersion) {
+  return serviceReady && snapshot?.healthy === true && expectedVersion !== void 0 && snapshot.version === expectedVersion;
+}
+async function detachedDaemonStart(opts) {
   const existing = readPidfile();
   if (existing?.alive) {
-    process.stderr.write(`[prim] daemon already running (pid=${existing.pid})
+    const snapshot = await verifiedPid(existing);
+    if (snapshot) {
+      process.stderr.write(`[prim] daemon already running (pid=${existing.pid})
 `);
-    console.log(JSON.stringify({ started: false, pid: existing.pid }, null, 2));
+      console.log(JSON.stringify({ started: false, pid: existing.pid }, null, 2));
+      return;
+    }
+    process.stderr.write(
+      `[prim] refusing to replace live pid=${existing.pid}: daemon ownership could not be verified over ${SOCK_PATH}
+`
+    );
+    console.log(JSON.stringify({ started: false, pid: existing.pid, verified: false }, null, 2));
+    if (!process.exitCode) process.exitCode = EXIT_BOOTING;
     return;
   }
   if (existing && !existing.alive) {
+    const socketOwner = await daemonRequest(
+      "status_snapshot",
+      {},
+      { timeoutMs: STATUS_PROBE_TIMEOUT_MS }
+    );
+    if (socketOwner) {
+      process.stderr.write(
+        `[prim] refusing to clear stale pidfile: socket is owned by pid=${socketOwner.pid}
+`
+      );
+      console.log(
+        JSON.stringify({ started: false, pid: socketOwner.pid, verified: false }, null, 2)
+      );
+      if (!process.exitCode) process.exitCode = EXIT_BOOTING;
+      return;
+    }
     clearStaleArtifacts();
   }
   if (opts.foreground) {
@@ -1185,7 +1842,7 @@ async function daemonStart(opts) {
   if (logFd !== void 0) {
     closeSync2(logFd);
   }
-  const live = await waitForReady();
+  const live = await waitForReady2();
   if (live) {
     const after = readPidfile();
     process.stderr.write(
@@ -1196,7 +1853,7 @@ async function daemonStart(opts) {
     return;
   }
   process.stderr.write(
-    `[prim] \u2717 daemon start: spawned but the socket did not respond within ${READY_TIMEOUT_MS}ms (check that \`${DAEMON_BIN}\` resolves, and see ${LOG_PATH})
+    `[prim] \u2717 daemon start: spawned but the socket did not respond within ${READY_TIMEOUT_MS2}ms (check that \`${DAEMON_BIN}\` resolves, and see ${LOG_PATH})
 `
   );
   console.log(JSON.stringify({ started: false }, null, 2));
@@ -1204,7 +1861,7 @@ async function daemonStart(opts) {
     process.exitCode = EXIT_NOT_RUNNING;
   }
 }
-async function daemonStop() {
+async function detachedDaemonStop() {
   const existing = readPidfile();
   if (!existing) {
     process.stderr.write("[prim] daemon not running (no pidfile)\n");
@@ -1212,11 +1869,36 @@ async function daemonStop() {
     return;
   }
   if (!existing.alive) {
+    const socketOwner = await daemonRequest(
+      "status_snapshot",
+      {},
+      { timeoutMs: STATUS_PROBE_TIMEOUT_MS }
+    );
+    if (socketOwner) {
+      process.stderr.write(
+        `[prim] refusing to clear stale pidfile: socket is owned by pid=${socketOwner.pid}
+`
+      );
+      console.log(
+        JSON.stringify({ stopped: false, pid: socketOwner.pid, verified: false }, null, 2)
+      );
+      return;
+    }
     clearStaleArtifacts();
     process.stderr.write("[prim] daemon not running (cleared stale pidfile)\n");
     console.log(JSON.stringify({ stopped: false, wasRunning: false }, null, 2));
     return;
   }
+  const snapshot = await verifiedPid(existing);
+  if (!snapshot) {
+    process.stderr.write(
+      `[prim] refusing to signal live pid=${existing.pid}: daemon ownership could not be verified over ${SOCK_PATH}
+`
+    );
+    console.log(JSON.stringify({ stopped: false, pid: existing.pid, verified: false }, null, 2));
+    if (!process.exitCode) process.exitCode = EXIT_BOOTING;
+    return;
+  }
   try {
     process.kill(existing.pid, "SIGTERM");
   } catch (err) {
@@ -1229,7 +1911,7 @@ async function daemonStop() {
   }
   const deadline = Date.now() + STOP_TIMEOUT_MS;
   while (Date.now() < deadline) {
-    if (!processIsAlive(existing.pid)) {
+    if (!processIsAlive2(existing.pid)) {
       clearStaleArtifacts();
       process.stderr.write(`[prim] daemon stopped (pid=${existing.pid})
 `);
@@ -1243,23 +1925,212 @@ async function daemonStop() {
 `
   );
   console.log(JSON.stringify({ stopped: false, pid: existing.pid }, null, 2));
+  if (!process.exitCode) process.exitCode = EXIT_BOOTING;
+}
+async function macDaemonStart(forceRestart = false) {
+  const result = await ensureMacDaemon({ explicitlyStarted: true, forceRestart });
+  const serviceReady = result.state === "running";
+  const expectedVersion = result.runtime?.manifest.version;
+  const snapshot = serviceReady && expectedVersion ? await waitForHealthySnapshot(expectedVersion) : null;
+  const healthy = daemonStartIsHealthy(serviceReady, snapshot, expectedVersion);
+  if (healthy) {
+    const verb = result.action === "none" ? "already running" : "started";
+    process.stderr.write(
+      `[prim] \u2713 daemon ${verb} under launchd (pid=${snapshot?.pid ?? result.service.pid ?? "?"})
+`
+    );
+  } else {
+    process.stderr.write(
+      `[prim] \u2717 launchd daemon did not reach healthy heartbeat + ingestion state (see ${LOG_PATH})
+`
+    );
+    if (!process.exitCode) process.exitCode = EXIT_NOT_RUNNING;
+  }
+  console.log(
+    JSON.stringify(
+      {
+        started: healthy,
+        supervised: true,
+        action: result.action,
+        pid: snapshot?.pid ?? result.service.pid,
+        loaded: result.service.loaded,
+        responding: result.responding,
+        healthy,
+        version: snapshot?.version,
+        expectedVersion
+      },
+      null,
+      2
+    )
+  );
+}
+async function daemonStart(opts) {
+  if (process.platform === "darwin") {
+    if (!opts.foreground) {
+      await macDaemonStart(false);
+      return;
+    }
+  }
+  await withDaemonLifecycleLock(async () => {
+    setDaemonExplicitlyDisabled(false);
+    await detachedDaemonStart(opts);
+  });
+}
+async function daemonStop() {
+  if (process.platform !== "darwin") {
+    await withDaemonLifecycleLock(async () => {
+      setDaemonExplicitlyDisabled(true);
+      await detachedDaemonStop();
+    });
+    return;
+  }
+  const result = await bootoutMacDaemon();
+  process.stderr.write(
+    result.wasLoaded ? "[prim] daemon stopped and explicitly disabled\n" : result.legacyStopped ? "[prim] legacy daemon stopped and explicitly disabled\n" : "[prim] daemon was not loaded; explicitly disabled\n"
+  );
+  console.log(
+    JSON.stringify(
+      {
+        stopped: result.wasLoaded || result.legacyStopped,
+        wasRunning: result.wasLoaded || result.legacyStopped,
+        supervised: true,
+        disabled: true
+      },
+      null,
+      2
+    )
+  );
 }
 function classifyStatus(pidAlive, responding, snapshot, pid) {
   if (!pidAlive) {
     return { json: { running: false }, exitCode: EXIT_NOT_RUNNING };
   }
-  if (!responding) {
+  if (!responding) {
+    return {
+      json: { running: true, responding: false, state: "starting", pid },
+      exitCode: EXIT_BOOTING
+    };
+  }
+  if (!snapshot) {
+    return { json: { running: true, responding: true }, exitCode: EXIT_OK2 };
+  }
+  if (snapshot.healthy === false) {
+    return {
+      json: { running: true, responding: true, state: "degraded", ...snapshot },
+      exitCode: EXIT_BOOTING
+    };
+  }
+  return { json: { running: true, responding: true, ...snapshot }, exitCode: EXIT_OK2 };
+}
+function classifyLaunchdStatus(service, responding, snapshot, disabled) {
+  if (!service.loaded) {
+    if (responding) {
+      return {
+        json: {
+          running: true,
+          responding: true,
+          supervised: false,
+          state: "unsupervised",
+          disabled,
+          ...snapshot
+        },
+        exitCode: EXIT_BOOTING
+      };
+    }
+    return {
+      json: { running: false, supervised: true, loaded: false, disabled },
+      exitCode: EXIT_NOT_RUNNING
+    };
+  }
+  if (!responding) {
+    return {
+      json: {
+        running: true,
+        responding: false,
+        supervised: true,
+        state: service.state ?? "starting",
+        pid: service.pid,
+        disabled
+      },
+      exitCode: EXIT_BOOTING
+    };
+  }
+  if (!snapshot || service.pid === void 0) {
+    return {
+      json: {
+        running: true,
+        responding: true,
+        supervised: true,
+        state: "ownership_unverified",
+        pid: service.pid,
+        socketPid: snapshot?.pid,
+        disabled
+      },
+      exitCode: EXIT_BOOTING
+    };
+  }
+  if (service.pid !== snapshot.pid) {
     return {
-      json: { running: true, responding: false, state: "starting", pid },
+      json: {
+        running: true,
+        responding: true,
+        supervised: true,
+        state: "pid_mismatch",
+        pid: service.pid,
+        socketPid: snapshot.pid,
+        disabled
+      },
+      exitCode: EXIT_BOOTING
+    };
+  }
+  if (snapshot?.healthy === false) {
+    return {
+      json: {
+        running: true,
+        responding: true,
+        supervised: true,
+        state: "degraded",
+        disabled,
+        ...snapshot
+      },
       exitCode: EXIT_BOOTING
     };
   }
+  return {
+    json: {
+      running: true,
+      responding: true,
+      supervised: true,
+      state: service.state ?? "running",
+      disabled,
+      ...snapshot
+    },
+    exitCode: EXIT_OK2
+  };
+}
+function writeLiveSnapshot(snapshot, supervised = false) {
   if (!snapshot) {
-    return { json: { running: true, responding: true }, exitCode: EXIT_OK2 };
+    process.stderr.write(
+      supervised ? "[prim] \u2713 daemon live under launchd (no snapshot)\n" : "[prim] \u2713 daemon live\n"
+    );
+    return;
   }
-  return { json: { running: true, responding: true, ...snapshot }, exitCode: EXIT_OK2 };
+  const team = snapshot.onlineNames !== void 0 ? ` \xB7 team: ${formatTeammates(snapshot.onlineNames, Number.POSITIVE_INFINITY)}` : "";
+  if (snapshot.healthy === false) {
+    process.stderr.write(
+      `[prim] \u2717 daemon unhealthy${supervised ? " under launchd" : ""} \xB7 pid=${snapshot.pid}${team}
+`
+    );
+    return;
+  }
+  process.stderr.write(
+    `[prim] \u2713 daemon live${supervised ? " under launchd" : ""} \xB7 pid=${snapshot.pid} \xB7 uptime=${Math.round(
+      snapshot.uptimeMs / 1e3
+    )}s \xB7 session=${snapshot.sessionId}${team}
+`
+  );
 }
-async function daemonStatus() {
+async function detachedDaemonStatus() {
   const pid = readPidfile();
   const pidAlive = pid?.alive ?? false;
   const responding = pidAlive ? await daemonIsLive(STATUS_PROBE_TIMEOUT_MS) : false;
@@ -1274,38 +2145,127 @@ async function daemonStatus() {
   } else if (!responding) {
     process.stderr.write(`[prim] \u25CC daemon pid=${pid?.pid} starting (socket not responding yet)
 `);
-  } else if (!snapshot) {
-    process.stderr.write("[prim] \u2713 daemon live (no snapshot)\n");
   } else {
-    const team = snapshot.onlineNames !== void 0 ? ` \xB7 team: ${formatTeammates(snapshot.onlineNames, Number.POSITIVE_INFINITY)}` : "";
+    writeLiveSnapshot(snapshot);
+  }
+  console.log(JSON.stringify(json, null, 2));
+  if (exitCode !== EXIT_OK2 && !process.exitCode) {
+    process.exitCode = exitCode;
+  }
+}
+async function macDaemonStatus() {
+  const service = getLaunchdService();
+  const responding = await daemonIsLive(STATUS_PROBE_TIMEOUT_MS);
+  const snapshot = responding ? await daemonRequest(
+    "status_snapshot",
+    {},
+    { timeoutMs: STATUS_PROBE_TIMEOUT_MS }
+  ) : null;
+  const disabled = daemonExplicitlyDisabled();
+  const { json, exitCode } = classifyLaunchdStatus(service, responding, snapshot, disabled);
+  if (!service.loaded && responding) {
+    process.stderr.write(
+      `[prim] \u25CC daemon pid=${snapshot?.pid ?? "?"} is live but not supervised by launchd
+`
+    );
+  } else if (!service.loaded) {
+    process.stderr.write(`[prim] \u2717 daemon down${disabled ? " (explicitly disabled)" : ""}
+`);
+  } else if (!responding) {
+    process.stderr.write(
+      `[prim] \u25CC launchd service ${service.state ?? "loaded"}; socket is not responding yet
+`
+    );
+  } else if (!snapshot || service.pid === void 0) {
+    process.stderr.write("[prim] \u2717 launchd daemon socket ownership could not be verified\n");
+  } else if (service.pid !== snapshot.pid) {
     process.stderr.write(
-      `[prim] \u2713 daemon live \xB7 pid=${snapshot.pid} \xB7 uptime=${Math.round(snapshot.uptimeMs / 1e3)}s \xB7 session=${snapshot.sessionId}${team}
+      `[prim] \u2717 launchd pid=${service.pid} does not own the daemon socket (pid=${snapshot.pid})
 `
     );
+  } else {
+    writeLiveSnapshot(snapshot, true);
   }
   console.log(JSON.stringify(json, null, 2));
-  if (exitCode !== EXIT_OK2 && !process.exitCode) {
-    process.exitCode = exitCode;
+  if (exitCode !== EXIT_OK2 && !process.exitCode) process.exitCode = exitCode;
+}
+async function daemonStatus() {
+  if (process.platform === "darwin") {
+    await macDaemonStatus();
+    return;
   }
+  await detachedDaemonStatus();
 }
 async function daemonRestart(opts) {
+  if (process.platform === "darwin" && !opts.foreground) {
+    await macDaemonStart(true);
+    return;
+  }
+  if (process.platform !== "darwin") {
+    await withDaemonLifecycleLock(async () => {
+      setDaemonExplicitlyDisabled(false);
+      await detachedDaemonStop();
+      await detachedDaemonStart(opts);
+    });
+    return;
+  }
   await daemonStop();
   await daemonStart(opts);
 }
+async function daemonEnsure() {
+  if (process.platform !== "darwin") {
+    const disabled = await withDaemonLifecycleLock(async () => {
+      if (daemonExplicitlyDisabled()) return true;
+      await detachedDaemonStart({});
+      return false;
+    });
+    if (disabled) {
+      process.stderr.write("[prim] daemon remains explicitly disabled\n");
+      console.log(JSON.stringify({ ensured: false, disabled: true, supervised: false }, null, 2));
+    }
+    return;
+  }
+  const result = await ensureMacDaemon();
+  if (result.state === "disabled") {
+    process.stderr.write("[prim] daemon remains explicitly disabled\n");
+  } else if (result.state === "running") {
+    process.stderr.write(`[prim] \u2713 daemon ensured under launchd (${result.action})
+`);
+  } else {
+    process.stderr.write(`[prim] \u2717 daemon ensure failed; see ${LOG_PATH}
+`);
+    if (!process.exitCode) process.exitCode = EXIT_NOT_RUNNING;
+  }
+  console.log(
+    JSON.stringify(
+      {
+        ensured: result.state === "running",
+        disabled: result.state === "disabled",
+        supervised: true,
+        action: result.action
+      },
+      null,
+      2
+    )
+  );
+}
 function registerDaemonCommands(program2) {
   const daemon = program2.command("daemon").description("Manage the prim companion daemon (latency unlock + presence + broadcast)");
-  daemon.command("start").description("Spawn the prim-daemon-server in the background").option("--foreground", "Run in the foreground (inherit stdio); use under launchd / systemd").action(async (opts) => {
+  daemon.command("start").description("Start the daemon (installs a supervised LaunchAgent on macOS)").option("--foreground", "Run in the foreground (inherit stdio); use under launchd / systemd").action(async (opts) => {
     await daemonStart(opts);
   });
-  daemon.command("stop").description("Send SIGTERM to the running daemon and clean up the socket").action(async () => {
+  daemon.command("stop").description("Stop and explicitly disable the daemon").action(async () => {
     await daemonStop();
   });
   daemon.command("status").description("Report daemon liveness + a snapshot if responding").action(async () => {
     await daemonStatus();
   });
-  daemon.command("restart").description("Stop, then start (preserves no state today)").option("--foreground", "Restart in the foreground").action(async (opts) => {
+  daemon.command("restart").description("Restart the daemon and clear any explicit disable marker").option("--foreground", "Restart in the foreground").action(async (opts) => {
     await daemonRestart(opts);
   });
+  daemon.command("ensure").description("Idempotently install, upgrade, and heal the daemon unless explicitly disabled").action(async () => {
+    await daemonEnsure();
+  });
 }
 
 // src/decisions/cascade-renderer.ts
@@ -1576,6 +2536,12 @@ async function fetchRecent(args, deps = defaultDeps2) {
     if (res.authorHasDecisions !== void 0) {
       result.authorHasDecisions = res.authorHasDecisions;
     }
+    if (res.windowTotal !== void 0) {
+      result.windowTotal = res.windowTotal;
+    }
+    if (res.windowTotalCapped !== void 0) {
+      result.windowTotalCapped = res.windowTotalCapped;
+    }
     if (res.unavailable !== void 0) {
       result.unavailable = res.unavailable;
     }
@@ -1628,6 +2594,19 @@ function formatRecentRow(row) {
   const areaCol = row.area ? areaPlain.replace("\u2022", color("\u2022", colorForArea(row.area))) : areaPlain;
   return `  ${clock}  ${author}${areaCol}${row.intent}`;
 }
+var RECENT_LIMIT_CEILING = 100;
+function remainingHint(result) {
+  const { windowTotal } = result;
+  if (windowTotal === void 0 || windowTotal <= result.decisions.length) {
+    return;
+  }
+  const remaining = windowTotal - result.decisions.length;
+  const remainingText = result.windowTotalCapped === true ? `${remaining}+` : String(remaining);
+  if (windowTotal <= RECENT_LIMIT_CEILING) {
+    return `${remainingText} more not shown \u2014 re-run with --limit ${windowTotal} to see all`;
+  }
+  return `${remainingText} more not shown \u2014 re-run with --limit ${RECENT_LIMIT_CEILING} for the newest ${RECENT_LIMIT_CEILING} (the full set exceeds the feed cap)`;
+}
 function formatRecentHuman(result) {
   if (result.unavailable !== void 0) {
     return `[prim] recent \xB7 feed not verified \u2014 ${result.unavailable}`;
@@ -1645,7 +2624,9 @@ function formatRecentHuman(result) {
   if (result.decisions.length === 0) {
     return "[prim] recent \xB7 0 decisions";
   }
-  const lines = [`[prim] ${label} \xB7 ${String(result.decisions.length)} decision(s)`];
+  const header = `[prim] ${label} \xB7 ${String(result.decisions.length)} decision(s)`;
+  const hint = remainingHint(result);
+  const lines = [hint === void 0 ? header : `${header} \xB7 ${hint}`];
   for (const row of result.decisions) {
     lines.push(formatRecentRow(row));
   }
@@ -2132,11 +3113,11 @@ function registerDecisionsCommands(program2) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 var DAEMON_PROBE_TIMEOUT_MS = 500;
 var CONNECTIVITY_TIMEOUT_MS = 3e3;
 var MS_PER_SECOND = 1e3;
-var STALE_PENDING_MS = 6e4;
+var STALE_PENDING_MS = 3e4;
 var EXIT_UNHEALTHY = 1;
 function classifyDoctor(checks) {
   const status = checks.some((c) => c.status === "fail") ? "fail" : checks.some((c) => c.status === "warn") ? "warn" : "ok";
@@ -2150,7 +3131,7 @@ function checkAuth() {
     return { name: "auth", status: "fail", detail: "no token \u2014 run `prim auth login`" };
   }
   const expiresAt = getTokenExpiresAt();
-  const hasRefresh = existsSync4(REFRESH_TOKEN_PATH);
+  const hasRefresh = existsSync5(REFRESH_TOKEN_PATH);
   if (expiresAt !== void 0 && Date.now() >= expiresAt) {
     return hasRefresh ? { name: "auth", status: "warn", detail: "access token expired (refresh available)" } : {
       name: "auth",
@@ -2164,62 +3145,269 @@ function checkAuth() {
   const detail = expiresAt !== void 0 ? `valid (${String(Math.round((expiresAt - Date.now()) / MS_PER_SECOND))}s left)` : "valid";
   return { name: "auth", status: "ok", detail };
 }
-async function checkDaemon() {
-  const live = await daemonIsLive(DAEMON_PROBE_TIMEOUT_MS);
-  return live ? { name: "daemon", status: "ok", detail: "live" } : {
+function classifyDaemonHealth(snapshot, options = {}) {
+  if (options.disabled) {
+    return {
+      name: "daemon",
+      status: "fail",
+      detail: "explicitly stopped \u2014 run `prim daemon start`"
+    };
+  }
+  if (options.service && !options.service.loaded) {
+    return {
+      name: "daemon",
+      status: "fail",
+      detail: "launchd service is not loaded \u2014 run `prim daemon start`"
+    };
+  }
+  if (!snapshot) {
+    return {
+      name: "daemon",
+      status: "fail",
+      detail: "socket unavailable \u2014 run `prim daemon start`"
+    };
+  }
+  if (options.service && (!Number.isInteger(options.service.pid) || (options.service.pid ?? 0) <= 0 || !Number.isInteger(snapshot.pid) || (snapshot.pid ?? 0) <= 0 || options.service.pid !== snapshot.pid)) {
+    return {
+      name: "daemon",
+      status: "fail",
+      detail: `launchd does not own the daemon socket (launchd ${String(options.service.pid ?? "none")} \xB7 socket ${String(snapshot.pid ?? "none")})`
+    };
+  }
+  if (!snapshot.heartbeat?.healthy) {
+    return {
+      name: "daemon",
+      status: "fail",
+      detail: `heartbeat unhealthy${snapshot.heartbeat?.lastError ? ` \u2014 ${snapshot.heartbeat.lastError}` : ""}`
+    };
+  }
+  if (!snapshot.ingestion?.healthy) {
+    const pending = snapshot.ingestion?.pendingCount ?? 0;
+    const pendingLabel = snapshot.ingestion?.pendingSampled ? `at least ${String(pending)}` : String(pending);
+    return {
+      name: "daemon",
+      status: "fail",
+      detail: `ingestion unhealthy \xB7 ${pendingLabel} pending${snapshot.ingestion?.lastError ? ` \u2014 ${snapshot.ingestion.lastError}` : ""}`
+    };
+  }
+  if (snapshot.healthy !== true) {
+    return { name: "daemon", status: "fail", detail: "health state is not ready" };
+  }
+  return {
     name: "daemon",
-    status: "warn",
-    detail: "down \u2014 capture still journals; drains on next `prim` invocation"
+    status: "ok",
+    detail: `supervised and healthy${snapshot.version ? ` \xB7 v${snapshot.version}` : ""}`
   };
 }
+async function checkDaemon() {
+  let service;
+  if (process.platform === "darwin") {
+    try {
+      service = getLaunchdService();
+    } catch {
+      service = { loaded: false };
+    }
+  }
+  const snapshot = await daemonRequest(
+    "status_snapshot",
+    {},
+    { timeoutMs: DAEMON_PROBE_TIMEOUT_MS }
+  );
+  return classifyDaemonHealth(snapshot, {
+    disabled: daemonExplicitlyDisabled(),
+    service
+  });
+}
 function checkJournal() {
-  const stats = bucketStats();
-  const pending = stats.reduce((n, s) => n + s.lineCount, 0);
+  const stats = pendingJournalStats();
+  const pending = stats.pendingCount;
+  const pendingLabel = stats.sampled ? `at least ${String(pending)}` : String(pending);
   if (pending === 0) {
+    if (stats.sampled) {
+      return {
+        name: "journal",
+        status: "fail",
+        detail: "bounded journal sample could not prove the queue is empty"
+      };
+    }
     return { name: "journal", status: "ok", detail: "no pending moves" };
   }
-  const oldestMs = Math.max(...stats.map((s) => Date.now() - s.mtimeMs));
+  if (stats.oldestPendingAt === void 0) {
+    return {
+      name: "journal",
+      status: "fail",
+      detail: `${pendingLabel} pending with no readable capture timestamp`
+    };
+  }
+  const oldestMs = Date.now() - stats.oldestPendingAt;
   const oldestS = Math.round(oldestMs / MS_PER_SECOND);
   if (oldestMs > STALE_PENDING_MS) {
     return {
       name: "journal",
-      status: "warn",
-      detail: `${String(pending)} pending, oldest ${String(oldestS)}s \u2014 drain may be stalled`
+      status: "fail",
+      detail: `${pendingLabel} pending, oldest observed ${String(oldestS)}s \u2014 30s delivery SLA missed`
+    };
+  }
+  if (stats.sampled) {
+    return {
+      name: "journal",
+      status: "fail",
+      detail: `${pendingLabel} pending in bounded sample; 30s delivery SLA cannot be proven`
     };
   }
   return { name: "journal", status: "ok", detail: `${String(pending)} pending, draining` };
 }
 function checkStranded() {
-  const stranded = listFlushing();
-  if (stranded.length === 0) {
+  const stats = pendingJournalStats();
+  if (stats.strandedFileCount === 0 && !stats.strandedSampled) {
     return { name: "stranded", status: "ok", detail: "none" };
   }
-  const moves = stranded.reduce((n, f) => n + f.lineCount, 0);
+  const qualifier = stats.strandedSampled ? "at least " : "";
   return {
     name: "stranded",
     status: "warn",
-    detail: `${String(moves)} move(s) in ${String(stranded.length)} file(s) \u2014 run \`prim moves flush\``
+    detail: `${qualifier}${String(stats.strandedCount)} move(s) in ${qualifier}${String(stats.strandedFileCount)} file(s) \u2014 run \`prim moves flush\``
+  };
+}
+function checkWorkspaceIdentity() {
+  const identity = inspectWorkspaceId();
+  switch (identity.status) {
+    case "ready":
+      return { name: "feedback-id", status: "ok", detail: "stable worktree identity ready" };
+    case "missing":
+      return {
+        name: "feedback-id",
+        status: "warn",
+        detail: "not initialized \u2014 the next active hook will create it"
+      };
+    case "not_git":
+      return {
+        name: "feedback-id",
+        status: "warn",
+        detail: "not in a Git worktree \u2014 capture falls back to legacy V1"
+      };
+    case "corrupt":
+      return {
+        name: "feedback-id",
+        status: "warn",
+        detail: "identity is corrupt \u2014 not rotated; capture falls back to legacy V1"
+      };
+    case "unavailable":
+      return {
+        name: "feedback-id",
+        status: "warn",
+        detail: `identity unavailable during ${identity.operation} \u2014 capture falls back to legacy V1`
+      };
+  }
+}
+function checkFeedbackHooks() {
+  try {
+    const status = performStatus();
+    if (status.project.feedback || status.user.feedback) {
+      return {
+        name: "feedback-hooks",
+        status: "ok",
+        detail: status.project.feedback ? "project handlers ready" : "user handlers ready"
+      };
+    }
+    return {
+      name: "feedback-hooks",
+      status: "warn",
+      detail: "Stop + SessionStart handlers missing \u2014 run `prim claude install`"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { name: "feedback-hooks", status: "warn", detail: message.slice(0, 80) };
+  }
+}
+function parseMovesStatus(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("moves status returned a non-object response");
+  }
+  const status = value;
+  const nullableNumber = (candidate) => candidate === null || typeof candidate === "number" && Number.isFinite(candidate);
+  if (status.captureState !== "enabled" && status.captureState !== "disabled" || !nullableNumber(status.latestIngestAt) || !nullableNumber(status.latestClassificationAt) || !nullableNumber(status.highWaterMark) || typeof status.pendingSessionCount !== "number" || !Number.isInteger(status.pendingSessionCount) || status.pendingSessionCount < 0 || typeof status.sampled !== "boolean") {
+    throw new Error("moves status returned an invalid response");
+  }
+  return status;
+}
+function classifyMovesStatus(status) {
+  const capture = status.captureState === "enabled" ? { name: "capture", status: "ok", detail: "enabled; ingest endpoint durable" } : {
+    name: "capture",
+    status: "fail",
+    detail: "disabled for the current organization; local Moves are retained"
   };
+  let classification;
+  if (status.pendingSessionCount > 0) {
+    classification = {
+      name: "classification",
+      status: "warn",
+      detail: `${String(status.pendingSessionCount)} session(s) pending${status.sampled ? " in a bounded sample" : ""}`
+    };
+  } else if (status.sampled) {
+    classification = {
+      name: "classification",
+      status: "warn",
+      detail: "caught up in the bounded sample; older sessions were not inspected"
+    };
+  } else {
+    classification = {
+      name: "classification",
+      status: "ok",
+      detail: status.latestClassificationAt === null ? "no sessions awaiting classification" : `caught up \xB7 last ${new Date(status.latestClassificationAt).toISOString()}`
+    };
+  }
+  return [capture, classification];
 }
-async function checkConnectivity() {
+async function checkBackend() {
   try {
-    await getClient().get("/api/cli/decisions/recent?limit=1", {
+    const response = await getClient().get("/api/cli/moves/status", {
       signal: AbortSignal.timeout(CONNECTIVITY_TIMEOUT_MS)
     });
-    return { name: "connectivity", status: "ok", detail: "server reachable" };
+    const status = parseMovesStatus(response);
+    return [
+      { name: "connectivity", status: "ok", detail: "server reachable and authenticated" },
+      ...classifyMovesStatus(status)
+    ];
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    const status = message.includes("Authentication") ? "fail" : "warn";
-    return { name: "connectivity", status, detail: message.slice(0, 80) };
+    return [{ name: "connectivity", status: "fail", detail: message.slice(0, 120) }];
+  }
+}
+async function checkFeedbackCapability() {
+  try {
+    const capability = await fetchFeedbackCapability(AbortSignal.timeout(CONNECTIVITY_TIMEOUT_MS));
+    return capability.status === "available" ? { name: "feedback-api", status: "ok", detail: "server supports decision feedback" } : {
+      name: "feedback-api",
+      status: "warn",
+      detail: "available after binding this CLI to an organization"
+    };
+  } catch (error) {
+    if (error instanceof HttpError && error.status === 404) {
+      return {
+        name: "feedback-api",
+        status: "warn",
+        detail: "server does not support decision feedback yet"
+      };
+    }
+    if (error instanceof HttpError && error.status === 401) {
+      return { name: "feedback-api", status: "fail", detail: error.message.slice(0, 80) };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return { name: "feedback-api", status: "warn", detail: message.slice(0, 80) };
   }
 }
 async function collectChecks() {
+  const backend = await checkBackend();
   return [
     checkAuth(),
     await checkDaemon(),
     checkJournal(),
     checkStranded(),
-    await checkConnectivity()
+    checkFeedbackHooks(),
+    checkWorkspaceIdentity(),
+    ...backend,
+    await checkFeedbackCapability()
   ];
 }
 function icon(status) {
@@ -2241,26 +3429,28 @@ async function runDoctor() {
   }
 }
 function registerDoctorCommands(program2) {
-  program2.command("doctor").description("Check capture-pipeline health end to end (auth, daemon, journal, server)").action(async () => {
+  program2.command("doctor").description(
+    "Check capture and feedback health end to end (auth, supervisor, delivery, worktree, server)"
+  ).action(async () => {
     await runDoctor();
   });
 }
 
 // src/commands/hermes-install.ts
 import {
-  chmodSync,
+  chmodSync as chmodSync2,
   closeSync as closeSync3,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   fsyncSync as fsyncSync2,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   openSync as openSync3,
-  readFileSync as readFileSync4,
-  renameSync as renameSync2,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync3
+  readFileSync as readFileSync5,
+  renameSync as renameSync3,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname3, join as join4 } from "path";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname4, join as join5 } from "path";
 import { Document, parseDocument, stringify } from "yaml";
 var CAPTURE_BIN3 = "prim-hook";
 var GATE_BIN3 = "prim-pre-tool-use";
@@ -2279,13 +3469,13 @@ var PRIM_BINS3 = [
   SESSION_END_BIN2
 ];
 function hermesHome() {
-  return process.env.HERMES_HOME ?? join4(homedir4(), ".hermes");
+  return process.env.HERMES_HOME ?? join5(homedir5(), ".hermes");
 }
 function configPath() {
-  return join4(hermesHome(), "config.yaml");
+  return join5(hermesHome(), "config.yaml");
 }
 function shimPath() {
-  return join4(hermesHome(), "agent-hooks", "prim-shim.sh");
+  return join5(hermesHome(), "agent-hooks", "prim-shim.sh");
 }
 var SHIM_SCRIPT = `#!/bin/sh
 # prim Hermes hook shim \u2014 managed by \`prim hermes install\`. Hermes runs hooks
@@ -2374,10 +3564,10 @@ function isCaptureInstalled(hooks) {
   );
 }
 function readDoc(path) {
-  if (!existsSync5(path)) {
+  if (!existsSync6(path)) {
     return new Document();
   }
-  const raw = readFileSync4(path, "utf-8");
+  const raw = readFileSync5(path, "utf-8");
   return raw.trim().length === 0 ? new Document() : parseDocument(raw);
 }
 function readHooks(doc) {
@@ -2449,19 +3639,19 @@ function setAutoAccept(raw) {
 `;
 }
 function atomicWriteFile(path, content) {
-  const dir = dirname3(path);
-  if (!existsSync5(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  const dir = dirname4(path);
+  if (!existsSync6(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
   const tmp = `${path}.tmp.${String(process.pid)}`;
-  writeFileSync3(tmp, content, "utf-8");
+  writeFileSync4(tmp, content, "utf-8");
   const fd = openSync3(tmp, "r+");
   try {
     fsyncSync2(fd);
   } finally {
     closeSync3(fd);
   }
-  renameSync2(tmp, path);
+  renameSync3(tmp, path);
 }
 function mergeKeepsYamlValid(before, after) {
   return parseDocument(after).errors.length <= parseDocument(before).errors.length;
@@ -2474,15 +3664,15 @@ function assertMergeValid(before, after) {
 }
 function writeShim() {
   const path = shimPath();
-  const dir = dirname3(path);
-  if (!existsSync5(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  const dir = dirname4(path);
+  if (!existsSync6(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
-  writeFileSync3(path, SHIM_SCRIPT, "utf-8");
-  chmodSync(path, SHIM_MODE);
+  writeFileSync4(path, SHIM_SCRIPT, "utf-8");
+  chmodSync2(path, SHIM_MODE);
 }
 function removeShim() {
-  rmSync2(shimPath(), { force: true });
+  rmSync3(shimPath(), { force: true });
 }
 function autoAcceptOf(raw) {
   if (raw.trim().length === 0) {
@@ -2495,7 +3685,7 @@ function readHooksFromRaw(raw) {
 }
 function performInstall3(opts) {
   const path = configPath();
-  const raw = existsSync5(path) ? readFileSync4(path, "utf-8") : "";
+  const raw = existsSync6(path) ? readFileSync5(path, "utf-8") : "";
   const existing = readHooksFromRaw(raw);
   const desired = applyInstall3(existing, opts.force);
   let next = raw;
@@ -2521,11 +3711,11 @@ function performInstall3(opts) {
 }
 function performUninstall3() {
   const path = configPath();
-  if (!existsSync5(path)) {
+  if (!existsSync6(path)) {
     removeShim();
     return { path, gate: false, capture: false, autoAccept: false, changed: false };
   }
-  const raw = readFileSync4(path, "utf-8");
+  const raw = readFileSync5(path, "utf-8");
   const existing = readHooksFromRaw(raw);
   const remaining = applyUninstall3(existing);
   const next = JSON.stringify(existing) === JSON.stringify(remaining) ? raw : spliceHooks(raw, remaining);
@@ -2545,7 +3735,7 @@ function performUninstall3() {
 }
 function performStatus3() {
   const path = configPath();
-  const hooks = existsSync5(path) ? readHooks(readDoc(path)) : {};
+  const hooks = existsSync6(path) ? readHooks(readDoc(path)) : {};
   return { path, gate: isGateInstalled3(hooks), capture: isCaptureInstalled(hooks) };
 }
 var TRUST_NOTICE2 = "[prim] Hermes requires hook consent: it prompts once per (event, command) on a TTY and records approval in ~/.hermes/shell-hooks-allowlist.json. To pre-approve non-interactively, re-run with --auto-accept (sets hooks_auto_accept: true), export HERMES_ACCEPT_HOOKS=1, or start Hermes with `hermes --accept-hooks chat`. Until approved, the hooks will not fire.";
@@ -2590,9 +3780,9 @@ function registerHermesCommands(program2) {
 
 // src/commands/hooks.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname4, join as join5, resolve } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname5, join as join6, resolve as resolve2 } from "path";
 import { Option } from "commander";
 var PRE_COMMIT = { hookName: "pre-commit", binName: "prim-pre-commit" };
 var POST_COMMIT = { hookName: "post-commit", binName: "prim-post-commit" };
@@ -2641,16 +3831,16 @@ ${gatedShim(spec.binName)}
 ${end}`;
 }
 function mergePrimBlock(hookPath, block, binName) {
-  if (existsSync6(hookPath)) {
-    const existing = readFileSync5(hookPath, "utf-8");
+  if (existsSync7(hookPath)) {
+    const existing = readFileSync6(hookPath, "utf-8");
     if (containsPrimHook(existing, binName)) return false;
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    writeFileSync4(hookPath, `${existing}${separator}${block}
+    writeFileSync5(hookPath, `${existing}${separator}${block}
 `, { mode: 493 });
     return true;
   }
-  mkdirSync5(dirname4(hookPath), { recursive: true });
-  writeFileSync4(hookPath, `#!/bin/sh
+  mkdirSync6(dirname5(hookPath), { recursive: true });
+  writeFileSync5(hookPath, `#!/bin/sh
 # ${PRIM_CREATED_MARK}
 
 ${block}
@@ -2665,14 +3855,14 @@ function getGitRoot() {
   return root;
 }
 function detectHusky(gitRoot) {
-  const huskyDir = resolve(gitRoot, ".husky");
-  if (!existsSync6(huskyDir)) return false;
-  if (existsSync6(resolve(huskyDir, "_"))) return true;
-  if (existsSync6(resolve(huskyDir, "pre-commit"))) return true;
-  const pkgPath = resolve(gitRoot, "package.json");
-  if (existsSync6(pkgPath)) {
+  const huskyDir = resolve2(gitRoot, ".husky");
+  if (!existsSync7(huskyDir)) return false;
+  if (existsSync7(resolve2(huskyDir, "_"))) return true;
+  if (existsSync7(resolve2(huskyDir, "pre-commit"))) return true;
+  const pkgPath = resolve2(gitRoot, "package.json");
+  if (existsSync7(pkgPath)) {
     try {
-      const pkg2 = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+      const pkg2 = JSON.parse(readFileSync6(pkgPath, "utf-8"));
       const scripts = pkg2.scripts ?? {};
       if (/husky/i.test(scripts.prepare ?? "") || /husky/i.test(scripts.postinstall ?? "")) {
         return true;
@@ -2687,8 +3877,8 @@ function containsPrimHook(content, binName = PRE_COMMIT.binName) {
 }
 async function askConfirmation(question) {
   if (!process.stdin.isTTY) return false;
-  const { createInterface } = await import("readline/promises");
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const { createInterface: createInterface2 } = await import("readline/promises");
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   try {
     const answer = await rl.question(`${question} [y/N] `);
     const normalized = answer.trim().toLowerCase();
@@ -2698,8 +3888,8 @@ async function askConfirmation(question) {
   }
 }
 function installToHusky(gitRoot, spec = PRE_COMMIT) {
-  const hookPath = resolve(gitRoot, ".husky", spec.hookName);
-  const existed = existsSync6(hookPath);
+  const hookPath = resolve2(gitRoot, ".husky", spec.hookName);
+  const existed = existsSync7(hookPath);
   const wrote = mergePrimBlock(hookPath, huskyBlock(spec), spec.binName);
   if (!wrote) {
     console.log(`Prim ${spec.hookName} hook is already installed in .husky/${spec.hookName}.`);
@@ -2710,13 +3900,13 @@ function installToHusky(gitRoot, spec = PRE_COMMIT) {
   }
 }
 function installToDotGit(gitRoot, spec = PRE_COMMIT) {
-  const hooksDir = resolve(gitRoot, ".git", "hooks");
-  const hookPath = resolve(hooksDir, spec.hookName);
-  if (!existsSync6(hooksDir)) {
-    mkdirSync5(hooksDir, { recursive: true });
+  const hooksDir = resolve2(gitRoot, ".git", "hooks");
+  const hookPath = resolve2(hooksDir, spec.hookName);
+  if (!existsSync7(hooksDir)) {
+    mkdirSync6(hooksDir, { recursive: true });
   }
-  if (existsSync6(hookPath)) {
-    const existing = readFileSync5(hookPath, "utf-8");
+  if (existsSync7(hookPath)) {
+    const existing = readFileSync6(hookPath, "utf-8");
     if (containsPrimHook(existing, spec.binName)) {
       console.log(`Prim ${spec.hookName} hook is already installed at ${hookPath}.`);
       return;
@@ -2725,12 +3915,12 @@ function installToDotGit(gitRoot, spec = PRE_COMMIT) {
     console.log("To replace it, run: prim hooks uninstall && prim hooks install");
     return;
   }
-  writeFileSync4(hookPath, dotGitScript(spec), { mode: 493 });
+  writeFileSync5(hookPath, dotGitScript(spec), { mode: 493 });
   console.log(`Installed ${spec.hookName} hook at ${hookPath}`);
 }
-var PRIM_GIT_HOOKS_DIR = join5(homedir5(), ".config", "prim", "git-hooks");
+var PRIM_GIT_HOOKS_DIR = join6(homedir6(), ".config", "prim", "git-hooks");
 function expandTilde(p) {
-  return p.startsWith("~/") ? join5(homedir5(), p.slice(2)) : p;
+  return p.startsWith("~/") ? join6(homedir6(), p.slice(2)) : p;
 }
 function isOurHooksDir(value) {
   return value !== "" && expandTilde(value) === PRIM_GIT_HOOKS_DIR;
@@ -2795,24 +3985,24 @@ function ownedHookNames() {
   return [...HOOKS.map((s) => s.hookName), ...PASSTHROUGH_HOOKS];
 }
 function writeOwnHooks() {
-  if (!existsSync6(PRIM_GIT_HOOKS_DIR)) {
-    mkdirSync5(PRIM_GIT_HOOKS_DIR, { recursive: true });
+  if (!existsSync7(PRIM_GIT_HOOKS_DIR)) {
+    mkdirSync6(PRIM_GIT_HOOKS_DIR, { recursive: true });
   }
   for (const spec of HOOKS) {
-    writeFileSync4(resolve(PRIM_GIT_HOOKS_DIR, spec.hookName), globalHookScript(spec), {
+    writeFileSync5(resolve2(PRIM_GIT_HOOKS_DIR, spec.hookName), globalHookScript(spec), {
       mode: 493
     });
   }
   for (const name of PASSTHROUGH_HOOKS) {
-    writeFileSync4(resolve(PRIM_GIT_HOOKS_DIR, name), passThroughScript(name), { mode: 493 });
+    writeFileSync5(resolve2(PRIM_GIT_HOOKS_DIR, name), passThroughScript(name), { mode: 493 });
   }
 }
 function appendPrimBlock(hookPath, spec) {
   mergePrimBlock(hookPath, gatedBlock(spec), spec.binName);
 }
 function stripPrimBlock(hookPath, spec) {
-  if (!existsSync6(hookPath)) return;
-  const existing = readFileSync5(hookPath, "utf-8");
+  if (!existsSync7(hookPath)) return;
+  const existing = readFileSync6(hookPath, "utf-8");
   const primCreated = existing.includes(PRIM_CREATED_MARK);
   const { start, end } = blockMarkers(spec);
   const s = existing.indexOf(start);
@@ -2824,7 +4014,7 @@ function stripPrimBlock(hookPath, spec) {
     unlinkSync2(hookPath);
     return;
   }
-  writeFileSync4(hookPath, out, { mode: 493 });
+  writeFileSync5(hookPath, out, { mode: 493 });
 }
 function installGlobalHooks(opts = {}) {
   const global = gitConfigGet("--global");
@@ -2855,7 +4045,7 @@ function installGlobalHooks(opts = {}) {
   }
   const dir = expandTilde(global);
   for (const spec of HOOKS) {
-    appendPrimBlock(resolve(dir, spec.hookName), spec);
+    appendPrimBlock(resolve2(dir, spec.hookName), spec);
   }
   console.log(
     `Appended prim hooks into existing core.hooksPath dir ${global} (pointer unchanged).`
@@ -2866,8 +4056,8 @@ function uninstallGlobalHooks() {
   const global = gitConfigGet("--global");
   if (isOurHooksDir(global)) {
     for (const name of ownedHookNames()) {
-      const p = resolve(PRIM_GIT_HOOKS_DIR, name);
-      if (existsSync6(p)) unlinkSync2(p);
+      const p = resolve2(PRIM_GIT_HOOKS_DIR, name);
+      if (existsSync7(p)) unlinkSync2(p);
     }
     execFileSync("git", ["config", "--global", "--unset", "core.hooksPath"]);
     console.log("Removed prim global git hooks and unset core.hooksPath.");
@@ -2876,7 +4066,7 @@ function uninstallGlobalHooks() {
   if (global !== "") {
     const dir = expandTilde(global);
     for (const spec of HOOKS) {
-      stripPrimBlock(resolve(dir, spec.hookName), spec);
+      stripPrimBlock(resolve2(dir, spec.hookName), spec);
     }
     console.log(`Removed the prim block from ${global} (left the dir and core.hooksPath intact).`);
     return;
@@ -2956,12 +4146,12 @@ function registerHooksCommands(program2) {
     }
     const gitRoot = getGitRoot();
     for (const spec of HOOKS) {
-      const hookPath = resolve(gitRoot, ".git", "hooks", spec.hookName);
-      if (!existsSync6(hookPath)) {
+      const hookPath = resolve2(gitRoot, ".git", "hooks", spec.hookName);
+      if (!existsSync7(hookPath)) {
         console.log(`No ${spec.hookName} hook found.`);
         continue;
       }
-      if (containsPrimHook(readFileSync5(hookPath, "utf-8"), spec.binName)) {
+      if (containsPrimHook(readFileSync6(hookPath, "utf-8"), spec.binName)) {
         unlinkSync2(hookPath);
         console.log(`Removed ${spec.hookName} hook at ${hookPath}`);
       } else {
@@ -2972,43 +4162,60 @@ function registerHooksCommands(program2) {
 }
 
 // src/commands/moves.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync6, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync7, unlinkSync as unlinkSync4, writeFileSync as writeFileSync6 } from "fs";
+import { join as join7 } from "path";
 
 // src/flusher.ts
-import { renameSync as renameSync3, unlinkSync as unlinkSync3 } from "fs";
+import { createReadStream, renameSync as renameSync4, unlinkSync as unlinkSync3 } from "fs";
+import { createInterface } from "readline";
 var BATCH_SIZE = 500;
 var HTTP_TIMEOUT_MS = 1e4;
 var OPPORTUNISTIC_FLUSH_AFTER_MS = 6e4;
 var ORPHAN_QUARANTINE_MS = 6e4;
-function batchMoves(moves, size = BATCH_SIZE) {
-  const batches = [];
-  for (let i = 0; i < moves.length; i += size) {
-    batches.push(moves.slice(i, i + size));
-  }
-  return batches;
-}
-async function drainFlushingPath(flushingPath) {
-  const moves = readMovesFromPath(flushingPath);
-  if (moves.length === 0) {
-    unlinkSync3(flushingPath);
-    return 0;
-  }
-  const client = getClient();
-  for (const batch of batchMoves(moves)) {
-    await client.post(
+async function drainFlushingPath(flushingPath, client = getClient()) {
+  const postBatch = async (batch2) => {
+    const response = await client.post(
       "/api/cli/moves/ingest",
-      { batch },
+      { batch: batch2 },
       { signal: AbortSignal.timeout(HTTP_TIMEOUT_MS) }
     );
+    requireDurableIngestAcknowledgement(response, batch2.length);
+  };
+  const input = createReadStream(flushingPath, { encoding: "utf-8" });
+  const lines = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
+  let batch = [];
+  let total = 0;
+  try {
+    for await (const line of lines) {
+      if (line.length === 0) {
+        continue;
+      }
+      try {
+        batch.push(JSON.parse(line));
+      } catch {
+        continue;
+      }
+      if (batch.length === BATCH_SIZE) {
+        await postBatch(batch);
+        total += batch.length;
+        batch = [];
+      }
+    }
+    if (batch.length > 0) {
+      await postBatch(batch);
+      total += batch.length;
+    }
+  } finally {
+    lines.close();
+    input.destroy();
   }
   unlinkSync3(flushingPath);
-  return moves.length;
+  return total;
 }
 async function drainPath(path) {
   const tmpPath = `${path}.flushing.${String(Date.now())}.${String(process.pid)}`;
   try {
-    renameSync3(path, tmpPath);
+    renameSync4(path, tmpPath);
   } catch (err) {
     if (err.code === "ENOENT") {
       return 0;
@@ -3017,7 +4224,7 @@ async function drainPath(path) {
   }
   return drainFlushingPath(tmpPath);
 }
-function processIsAlive2(pid) {
+function processIsAlive3(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -3027,36 +4234,84 @@ function processIsAlive2(pid) {
 }
 function selectRecoverable(files, now, opts = {}) {
   const quarantineMs = opts.quarantineMs ?? ORPHAN_QUARANTINE_MS;
-  const isAlive = opts.isAlive ?? processIsAlive2;
-  return files.filter(
-    (f) => f.pid === void 0 ? now - f.mtimeMs > quarantineMs : !isAlive(f.pid)
-  );
+  const isAlive = opts.isAlive ?? processIsAlive3;
+  return files.filter((f) => {
+    if (f.pid === void 0) {
+      return now - f.mtimeMs > quarantineMs;
+    }
+    return f.pid === opts.ownerPid || !isAlive(f.pid);
+  });
 }
-async function recoverOrphans() {
-  let total = 0;
-  for (const file of selectRecoverable(listFlushing(), Date.now())) {
+async function recoverOrphans(candidates = listFlushing({ sampleBytes: 0 }), options = {}) {
+  const summary = { flushed: 0, errors: [], failedBuckets: /* @__PURE__ */ new Set() };
+  const recoverable = selectRecoverable(candidates, options.now ?? Date.now(), {
+    ownerPid: options.ownerPid ?? process.pid,
+    isAlive: options.isAlive
+  }).sort((a, b) => a.mtimeMs - b.mtimeMs || a.path.localeCompare(b.path));
+  const drain = options.drain ?? drainFlushingPath;
+  for (const file of recoverable) {
+    if (summary.failedBuckets.has(file.bucket)) {
+      continue;
+    }
     try {
-      total += await drainFlushingPath(file.path);
-    } catch {
+      summary.flushed += await drain(file.path);
+    } catch (err) {
+      summary.errors.push(err);
+      summary.failedBuckets.add(file.bucket);
     }
   }
-  return total;
+  return summary;
 }
-async function flush() {
-  let total = await recoverOrphans();
-  for (const { path } of listBuckets()) {
-    total += await drainPath(path);
+var FlushError = class extends Error {
+  flushed;
+  constructor(cause, flushed) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.name = "FlushError";
+    this.flushed = flushed;
+  }
+};
+async function flushOnce() {
+  const recovered = await recoverOrphans();
+  let total = recovered.flushed;
+  const errors = recovered.errors;
+  for (const { bucket, path } of listBuckets()) {
+    if (recovered.failedBuckets.has(bucket)) {
+      continue;
+    }
+    try {
+      total += await drainPath(path);
+    } catch (err) {
+      errors.push(err);
+    }
+  }
+  if (errors.length > 0) {
+    throw new FlushError(errors[0], total);
   }
   return { flushed: total };
 }
+var flushInFlight;
+function flush() {
+  if (flushInFlight) {
+    return flushInFlight;
+  }
+  const attempt = flushOnce().finally(() => {
+    if (flushInFlight === attempt) {
+      flushInFlight = void 0;
+    }
+  });
+  flushInFlight = attempt;
+  return attempt;
+}
+function shouldFlushPending(stats, now, thresholdMs = OPPORTUNISTIC_FLUSH_AFTER_MS) {
+  if (stats.sampled) {
+    return true;
+  }
+  return stats.pendingCount > 0 && (stats.oldestPendingAt === void 0 || now - stats.oldestPendingAt > thresholdMs);
+}
 async function flushIfNeeded() {
   try {
-    const stats = bucketStats();
-    if (stats.length === 0) {
-      return;
-    }
-    const oldest = stats.reduce((min, s) => s.mtimeMs < min ? s.mtimeMs : min, stats[0].mtimeMs);
-    if (Date.now() - oldest > OPPORTUNISTIC_FLUSH_AFTER_MS) {
+    const stats = pendingJournalStats();
+    if (shouldFlushPending(stats, Date.now())) {
       await flush();
     }
   } catch {
@@ -3090,21 +4345,25 @@ function registerMovesCommands(program2) {
     console.log(`[prim] root: ${JOURNAL_DIR}`);
     for (const s of stats) {
       const ageS = Math.round((Date.now() - s.mtimeMs) / MS_PER_SECOND2);
+      const count = `${String(s.lineCount)}${s.sampled ? "+" : ""}`;
       console.log(
-        `  ${s.bucket.padEnd(BUCKET_COL_WIDTH)} ${String(s.lineCount).padStart(5)} pending, ${String(s.sizeBytes).padStart(8)} bytes, last write ${String(ageS)}s ago`
+        `  ${s.bucket.padEnd(BUCKET_COL_WIDTH)} ${count.padStart(5)} pending, ${String(s.sizeBytes).padStart(8)} bytes, last write ${String(ageS)}s ago`
       );
     }
     if (stranded.length > 0) {
       const moveCount = stranded.reduce((n, f) => n + f.lineCount, 0);
       const byteCount = stranded.reduce((n, f) => n + f.sizeBytes, 0);
+      const sampled = stranded.some((file) => file.sampled);
+      const qualifier = sampled ? "at least " : "";
       console.log(
-        `[prim] \u26A0 ${String(stranded.length)} stranded flush file(s): ${String(moveCount)} move(s), ${String(byteCount)} bytes \u2014 recover with \`prim moves flush\``
+        `[prim] \u26A0 ${String(stranded.length)} stranded flush file(s): ${qualifier}${String(moveCount)} move(s), ${String(byteCount)} bytes \u2014 recover with \`prim moves flush\``
       );
       for (const f of stranded) {
         const ageS = Math.round((Date.now() - f.mtimeMs) / MS_PER_SECOND2);
         const owner = f.pid === void 0 ? "no pid" : `pid ${String(f.pid)}`;
+        const count = `${String(f.lineCount)}${f.sampled ? "+" : ""}`;
         console.log(
-          `  ${f.bucket.padEnd(BUCKET_COL_WIDTH)} ${String(f.lineCount).padStart(5)} stranded, ${String(f.sizeBytes).padStart(8)} bytes, ${String(ageS)}s ago (${owner})`
+          `  ${f.bucket.padEnd(BUCKET_COL_WIDTH)} ${count.padStart(5)} stranded, ${String(f.sizeBytes).padStart(8)} bytes, ${String(ageS)}s ago (${owner})`
         );
       }
     }
@@ -3132,19 +4391,19 @@ function registerMovesCommands(program2) {
     }
   });
   moves.command("bind").description("Pin the current directory to an org via .prim/workspace.json").requiredOption("--orgId <orgId>", "Convex organization id").action((opts) => {
-    const dir = join6(process.cwd(), ".prim");
-    if (!existsSync7(dir)) {
-      mkdirSync6(dir, { recursive: true, mode: DIR_MODE });
+    const dir = join7(process.cwd(), ".prim");
+    if (!existsSync8(dir)) {
+      mkdirSync7(dir, { recursive: true, mode: DIR_MODE });
     }
-    const file = join6(process.cwd(), WORKSPACE_FILE);
-    writeFileSync5(file, JSON.stringify({ orgId: opts.orgId, boundAt: Date.now() }, null, 2), {
+    const file = join7(process.cwd(), WORKSPACE_FILE);
+    writeFileSync6(file, JSON.stringify({ orgId: opts.orgId, boundAt: Date.now() }, null, 2), {
       mode: FILE_MODE2
     });
     console.log(`[prim] bound ${process.cwd()} to org ${opts.orgId}`);
   });
   moves.command("drop").description("Remove the .prim/workspace.json binding from the cwd").action(() => {
-    const file = join6(process.cwd(), WORKSPACE_FILE);
-    if (!existsSync7(file)) {
+    const file = join7(process.cwd(), WORKSPACE_FILE);
+    if (!existsSync8(file)) {
       console.log("[prim] no workspace binding in cwd");
       return;
     }
@@ -3237,23 +4496,23 @@ function registerReconcileCommands(program2) {
 
 // src/commands/session.ts
 import {
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync6,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync7,
   readdirSync,
   unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var DIR_MODE2 = 448;
 var FILE_MODE3 = 384;
 function ensureDir() {
-  if (!existsSync8(SESSIONS_DIR)) {
-    mkdirSync7(SESSIONS_DIR, { recursive: true, mode: DIR_MODE2 });
+  if (!existsSync9(SESSIONS_DIR)) {
+    mkdirSync8(SESSIONS_DIR, { recursive: true, mode: DIR_MODE2 });
   }
 }
 function markerPath(sessionId) {
-  return join7(SESSIONS_DIR, `${sessionId}.json`);
+  return join8(SESSIONS_DIR, `${sessionId}.json`);
 }
 function registerSessionCommands(program2) {
   const session = program2.command("session").description("Decision Event Pipeline \u2014 session binding markers");
@@ -3263,13 +4522,13 @@ function registerSessionCommands(program2) {
       orgId: opts.orgId,
       startedAt: Date.now()
     };
-    writeFileSync6(markerPath(sessionId), JSON.stringify(marker, null, 2), {
+    writeFileSync7(markerPath(sessionId), JSON.stringify(marker, null, 2), {
       mode: FILE_MODE3
     });
     console.log(`[prim] session ${sessionId} bound to org ${opts.orgId}`);
   });
   session.command("list").description("List active session markers").action(() => {
-    if (!existsSync8(SESSIONS_DIR)) {
+    if (!existsSync9(SESSIONS_DIR)) {
       console.log("[prim] no session markers");
       return;
     }
@@ -3281,7 +4540,7 @@ function registerSessionCommands(program2) {
     for (const f of files) {
       const sessionId = f.replace(/\.json$/, "");
       try {
-        const m = JSON.parse(readFileSync6(join7(SESSIONS_DIR, f), "utf-8"));
+        const m = JSON.parse(readFileSync7(join8(SESSIONS_DIR, f), "utf-8"));
         console.log(`${sessionId}  org=${m.orgId}`);
       } catch {
       }
@@ -3289,7 +4548,7 @@ function registerSessionCommands(program2) {
   });
   session.command("drop <sessionId>").description("Remove a session marker").action((sessionId) => {
     const p = markerPath(sessionId);
-    if (!existsSync8(p)) {
+    if (!existsSync9(p)) {
       console.log(`[prim] no marker for session ${sessionId}`);
       return;
     }
@@ -3299,9 +4558,9 @@ function registerSessionCommands(program2) {
 }
 
 // src/commands/setup.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { join as join8 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { join as join9 } from "path";
 var EXIT_INCOMPLETE = 1;
 var EXIT_USAGE3 = 2;
 var SESSION_LABELS = {
@@ -3325,7 +4584,20 @@ function planSetupSteps(opts) {
       key: "daemon",
       label: "Companion daemon",
       args: ["daemon", "start"],
-      required: false
+      required: true
+    });
+    steps.push({
+      key: "health",
+      label: "Capture health",
+      args: ["doctor"],
+      required: true
+    });
+  } else {
+    steps.push({
+      key: "daemon-opt-out",
+      label: "Daemon opt-out",
+      args: ["daemon", "stop"],
+      required: true
     });
   }
   steps.push({
@@ -3364,8 +4636,8 @@ function detectProjectConflicts(agent, run) {
   }
   try {
     const root = gitToplevel();
-    const preCommit = root && join8(root, ".git", "hooks", "pre-commit");
-    if (preCommit && existsSync9(preCommit) && readFileSync7(preCommit, "utf-8").includes("prim-pre-commit")) {
+    const preCommit = root && join9(root, ".git", "hooks", "pre-commit");
+    if (preCommit && existsSync10(preCommit) && readFileSync8(preCommit, "utf-8").includes("prim-pre-commit")) {
       conflicts.push(CONFLICT_HOOKS);
     }
   } catch {
@@ -3401,7 +4673,7 @@ function registerSetupCommand(program2) {
   ).option(
     "--migrate",
     "with the default user scope, remove any project-scoped prim config in this repo (else just warn)"
-  ).option("--no-daemon", "skip starting the companion daemon").action((opts) => {
+  ).option("--no-daemon", "stop and disable the companion daemon").action((opts) => {
     const { agent: agentInput, detected } = resolveAgent(opts.agent, process.env);
     if (agentInput !== "claude" && agentInput !== "codex" && agentInput !== "hermes") {
       process.stderr.write(
@@ -3419,7 +4691,7 @@ function registerSetupCommand(program2) {
     const scope = opts.scope;
     const self = process.argv[1];
     const run = (args, capture = false) => {
-      const r = spawnSync(process.execPath, [self, ...args], {
+      const r = spawnSync2(process.execPath, [self, ...args], {
         stdio: capture ? ["inherit", "pipe", "ignore"] : "inherit",
         encoding: "utf-8"
       });
@@ -3483,39 +4755,39 @@ function registerSetupCommand(program2) {
 // src/commands/skill.ts
 import {
   closeSync as closeSync4,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   fsyncSync as fsyncSync3,
   openSync as openSync4,
-  readFileSync as readFileSync9,
-  renameSync as renameSync4,
-  writeFileSync as writeFileSync7
+  readFileSync as readFileSync10,
+  renameSync as renameSync5,
+  writeFileSync as writeFileSync8
 } from "fs";
-import { homedir as homedir7 } from "os";
-import { dirname as dirname6, join as join10, resolve as resolve3 } from "path";
+import { homedir as homedir8 } from "os";
+import { dirname as dirname7, join as join11, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createPatch } from "diff";
 
 // src/commands/claude-plugin.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync8, readdirSync as readdirSync2, rmSync as rmSync3, rmdirSync } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname as dirname5, join as join9, resolve as resolve2 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync9, readdirSync as readdirSync2, rmSync as rmSync4, rmdirSync } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname6, join as join10, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
-var __dirname = dirname5(fileURLToPath(import.meta.url));
+var __dirname = dirname6(fileURLToPath(import.meta.url));
 var PLUGIN_DESCRIPTION = "Primitive decision-graph guidance for the prim CLI \u2014 a model-invoked skill installed by prim skill install.";
 function resolvePluginDir(cwd, scope) {
   if (scope && scope !== "user" && scope !== "project") {
     console.error(`Unknown --scope "${scope}" (expected user or project)`);
     return null;
   }
-  const base = scope === "user" ? join9(homedir6(), ".claude") : join9(gitToplevel(cwd) ?? cwd, ".claude");
-  return join9(base, "skills", "prim");
+  const base = scope === "user" ? join10(homedir7(), ".claude") : join10(gitToplevel(cwd) ?? cwd, ".claude");
+  return join10(base, "skills", "prim");
 }
 function packageVersion() {
   let dir = __dirname;
-  while (dir !== dirname5(dir)) {
-    const p = resolve2(dir, "package.json");
-    if (existsSync10(p)) return JSON.parse(readFileSync8(p, "utf-8")).version;
-    dir = dirname5(dir);
+  while (dir !== dirname6(dir)) {
+    const p = resolve3(dir, "package.json");
+    if (existsSync11(p)) return JSON.parse(readFileSync9(p, "utf-8")).version;
+    dir = dirname6(dir);
   }
   return "0.0.0";
 }
@@ -3525,12 +4797,12 @@ function pluginManifest() {
 `;
 }
 function removeDirIfEmpty(dir) {
-  if (existsSync10(dir) && readdirSync2(dir).length === 0) rmdirSync(dir);
+  if (existsSync11(dir) && readdirSync2(dir).length === 0) rmdirSync(dir);
 }
 function pluginPaths(dir) {
   return {
-    manifestPath: join9(dir, ".claude-plugin", "plugin.json"),
-    skillPath: join9(dir, "SKILL.md")
+    manifestPath: join10(dir, ".claude-plugin", "plugin.json"),
+    skillPath: join10(dir, "SKILL.md")
   };
 }
 function installClaudePlugin(cwd, opts) {
@@ -3539,8 +4811,8 @@ function installClaudePlugin(cwd, opts) {
   const { manifestPath, skillPath } = pluginPaths(dir);
   const manifest = pluginManifest();
   const skill = loadSkill();
-  const manifestCurrent = existsSync10(manifestPath) ? readFileSync8(manifestPath, "utf-8") : null;
-  const skillCurrent = existsSync10(skillPath) ? readFileSync8(skillPath, "utf-8") : null;
+  const manifestCurrent = existsSync11(manifestPath) ? readFileSync9(manifestPath, "utf-8") : null;
+  const skillCurrent = existsSync11(skillPath) ? readFileSync9(skillPath, "utf-8") : null;
   if (manifestCurrent === manifest && skillCurrent === skill) {
     console.log("No changes \u2014 prim skill plugin already up to date.");
     return 0;
@@ -3549,9 +4821,9 @@ function installClaudePlugin(cwd, opts) {
     console.log(`Would write plugin to ${dir} (.claude-plugin/plugin.json + SKILL.md)`);
     return 0;
   }
-  mkdirSync8(join9(dir, ".claude-plugin"), { recursive: true });
-  atomicWrite2(manifestPath, manifest);
-  atomicWrite2(skillPath, skill);
+  mkdirSync9(join10(dir, ".claude-plugin"), { recursive: true });
+  atomicWrite3(manifestPath, manifest);
+  atomicWrite3(skillPath, skill);
   console.log(`Installed prim skill plugin at ${dir}`);
   console.log("Restart Claude Code or run /reload-plugins to load it.");
   if (opts.scope !== "user") {
@@ -3563,13 +4835,13 @@ function uninstallClaudePlugin(cwd, opts) {
   const dir = resolvePluginDir(cwd, opts.scope);
   if (dir === null) return 1;
   const { manifestPath, skillPath } = pluginPaths(dir);
-  if (!existsSync10(manifestPath) && !existsSync10(skillPath)) {
+  if (!existsSync11(manifestPath) && !existsSync11(skillPath)) {
     console.log(`prim skill plugin not present at ${dir}`);
     return 0;
   }
-  rmSync3(manifestPath, { force: true });
-  rmSync3(skillPath, { force: true });
-  removeDirIfEmpty(join9(dir, ".claude-plugin"));
+  rmSync4(manifestPath, { force: true });
+  rmSync4(skillPath, { force: true });
+  removeDirIfEmpty(join10(dir, ".claude-plugin"));
   removeDirIfEmpty(dir);
   console.log(`Removed prim skill plugin from ${dir}`);
   return 0;
@@ -3578,7 +4850,7 @@ function statusClaudePlugin(cwd, opts) {
   const dir = resolvePluginDir(cwd, opts.scope);
   if (dir === null) return 1;
   const { skillPath } = pluginPaths(dir);
-  const installed = existsSync10(skillPath);
+  const installed = existsSync11(skillPath);
   if (opts.json) {
     printJson({ installed, target: dir });
     return installed ? 0 : 1;
@@ -3592,7 +4864,7 @@ function statusClaudePlugin(cwd, opts) {
 }
 
 // src/commands/skill.ts
-var __dirname2 = dirname6(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname7(fileURLToPath2(import.meta.url));
 var SKILL_BEGIN = "<!-- BEGIN PRIM SKILL v1 -->";
 var SKILL_END = "<!-- END PRIM SKILL v1 -->";
 var TARGET_CANDIDATES = [
@@ -3610,24 +4882,24 @@ var AGENT_TARGET = {
   hermes: ".hermes.md"
 };
 function userTargetFor(agent) {
-  if (agent === "claude") return join10(homedir7(), ".claude", "CLAUDE.md");
-  if (agent === "codex") return join10(homedir7(), ".codex", "AGENTS.md");
+  if (agent === "claude") return join11(homedir8(), ".claude", "CLAUDE.md");
+  if (agent === "codex") return join11(homedir8(), ".codex", "AGENTS.md");
   if (agent === "hermes") {
-    return join10(process.env.HERMES_HOME ?? join10(homedir7(), ".hermes"), ".hermes.md");
+    return join11(process.env.HERMES_HOME ?? join11(homedir8(), ".hermes"), ".hermes.md");
   }
   return null;
 }
 function loadSkill() {
   let dir = __dirname2;
-  while (dir !== dirname6(dir)) {
-    const p = resolve3(dir, "SKILL.md");
-    if (existsSync11(p)) return readFileSync9(p, "utf-8");
-    dir = dirname6(dir);
+  while (dir !== dirname7(dir)) {
+    const p = resolve4(dir, "SKILL.md");
+    if (existsSync12(p)) return readFileSync10(p, "utf-8");
+    dir = dirname7(dir);
   }
   throw new Error("SKILL.md not found in package");
 }
 function detectTargets(cwd) {
-  return TARGET_CANDIDATES.filter((p) => existsSync11(resolve3(cwd, p)));
+  return TARGET_CANDIDATES.filter((p) => existsSync12(resolve4(cwd, p)));
 }
 function detectNewline(content) {
   return content.includes("\r\n") ? "\r\n" : "\n";
@@ -3653,23 +4925,23 @@ function removeBlock(existing) {
   const out = existing.slice(0, b) + existing.slice(e + SKILL_END.length);
   return out.replace(/(\r?\n){2,}$/, "$1");
 }
-function atomicWrite2(target, content) {
+function atomicWrite3(target, content) {
   const tmp = `${target}.tmp`;
-  writeFileSync7(tmp, content);
+  writeFileSync8(tmp, content);
   const fd = openSync4(tmp, "r+");
   try {
     fsyncSync3(fd);
   } finally {
     closeSync4(fd);
   }
-  renameSync4(tmp, target);
+  renameSync5(tmp, target);
 }
 function resolveTarget(cwd, opts) {
   if (opts.scope && opts.scope !== "user" && opts.scope !== "project") {
     console.error(`Unknown --scope "${opts.scope}" (expected user or project)`);
     return null;
   }
-  if (opts.target) return resolve3(cwd, opts.target);
+  if (opts.target) return resolve4(cwd, opts.target);
   if (opts.scope === "user") {
     if (!opts.agent) {
       console.error("--scope user requires --agent (claude, codex, or hermes)");
@@ -3682,13 +4954,13 @@ function resolveTarget(cwd, opts) {
   }
   if (opts.agent) {
     const mapped = AGENT_TARGET[opts.agent];
-    if (typeof mapped === "string") return resolve3(cwd, mapped);
+    if (typeof mapped === "string") return resolve4(cwd, mapped);
     console.error(`Unknown --agent "${opts.agent}" (expected claude, codex, or hermes)`);
     return null;
   }
   const matches = detectTargets(cwd);
-  if (matches.length === 0) return resolve3(cwd, DEFAULT_TARGET);
-  if (matches.length === 1) return resolve3(cwd, matches[0]);
+  if (matches.length === 0) return resolve4(cwd, DEFAULT_TARGET);
+  if (matches.length === 1) return resolve4(cwd, matches[0]);
   console.error("Multiple rules files detected. Use --target to disambiguate:");
   for (const m of matches) console.error(`  ${m}`);
   return null;
@@ -3697,7 +4969,7 @@ function runInstall(cwd, opts) {
   if (opts.agent === "claude" && !opts.target) return installClaudePlugin(cwd, opts);
   const target = resolveTarget(cwd, opts);
   if (target === null) return 1;
-  const existing = existsSync11(target) ? readFileSync9(target, "utf-8") : "";
+  const existing = existsSync12(target) ? readFileSync10(target, "utf-8") : "";
   const eol = existing ? detectNewline(existing) : "\n";
   const block = composeBlock(loadSkill(), eol);
   const next = applyBlock(existing, block, eol);
@@ -3709,7 +4981,7 @@ function runInstall(cwd, opts) {
     process.stdout.write(createPatch(target, existing, next, "current", "proposed"));
     return 0;
   }
-  atomicWrite2(target, next);
+  atomicWrite3(target, next);
   console.log(`Wrote ${Buffer.byteLength(next)} bytes to ${target}`);
   return 0;
 }
@@ -3717,17 +4989,17 @@ function runUninstall(cwd, opts) {
   if (opts.agent === "claude" && !opts.target) return uninstallClaudePlugin(cwd, opts);
   const target = resolveTarget(cwd, opts);
   if (target === null) return 1;
-  if (!existsSync11(target)) {
+  if (!existsSync12(target)) {
     console.log(`Skill block not present at ${target}`);
     return 0;
   }
-  const existing = readFileSync9(target, "utf-8");
+  const existing = readFileSync10(target, "utf-8");
   const next = removeBlock(existing);
   if (next === null) {
     console.log(`Skill block not present at ${target}`);
     return 0;
   }
-  atomicWrite2(target, next);
+  atomicWrite3(target, next);
   console.log(`Removed skill block from ${target}`);
   return 0;
 }
@@ -3735,10 +5007,10 @@ function runStatus(cwd, opts) {
   if (opts.agent === "claude" && !opts.target) return statusClaudePlugin(cwd, opts);
   const target = resolveTarget(cwd, opts);
   if (target === null) return 1;
-  const fileExists = existsSync11(target);
+  const fileExists = existsSync12(target);
   let installed = false;
   if (fileExists) {
-    const content = readFileSync9(target, "utf-8");
+    const content = readFileSync10(target, "utf-8");
     installed = content.includes(SKILL_BEGIN) && content.includes(SKILL_END);
   }
   if (opts.json) {
@@ -3775,18 +5047,24 @@ function registerSkillCommands(program2) {
 }
 
 // src/commands/statusline.ts
-import { readFileSync as readFileSync10 } from "fs";
-import { dirname as dirname7, resolve as resolve4 } from "path";
+import { readFileSync as readFileSync11 } from "fs";
+import { dirname as dirname8, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var STATUSLINE_TIMEOUT_MS = 200;
 var STATUSLINE_NAME_CAP = 3;
 function readPackageVersion() {
   try {
-    const here = dirname7(fileURLToPath3(import.meta.url));
-    const candidates = [resolve4(here, "../../package.json"), resolve4(here, "../package.json")];
+    const here = dirname8(fileURLToPath3(import.meta.url));
+    const candidates = [
+      // The supervised runtime stages a tiny manifest beside the standalone
+      // statusline bundle, so it remains versioned without loading the package.
+      resolve5(here, "manifest.json"),
+      resolve5(here, "../../package.json"),
+      resolve5(here, "../package.json")
+    ];
     for (const path of candidates) {
       try {
-        const pkg2 = JSON.parse(readFileSync10(path, "utf-8"));
+        const pkg2 = JSON.parse(readFileSync11(path, "utf-8"));
         if (pkg2.version) {
           return pkg2.version;
         }
@@ -3816,6 +5094,17 @@ async function renderStatusline() {
     debug("daemon snapshot missing");
     return `primitive ${version} (daemon: down)`;
   }
+  if (snapshot.healthy === false) {
+    if (snapshot.ingestion?.healthy === false) {
+      const pending = snapshot.ingestion.pendingCount;
+      const qualifier = snapshot.ingestion.pendingSampled ? "at least " : "";
+      return `primitive ${version} (daemon: degraded \xB7 delivery: stalled${typeof pending === "number" ? ` \xB7 ${qualifier}${String(pending)} pending` : ""})`;
+    }
+    if (snapshot.heartbeat?.healthy === false) {
+      return `primitive ${version} (daemon: degraded \xB7 presence: unavailable)`;
+    }
+    return `primitive ${version} (daemon: starting)`;
+  }
   if (snapshot.envMismatch) {
     return `primitive ${version} (daemon: live \xB7 presence: other env)`;
   }
@@ -3841,6 +5130,7 @@ function registerStatuslineCommands(program2) {
       const line = await renderStatusline();
       process.stdout.write(line);
     } catch {
+      process.stdout.write(`primitive ${readPackageVersion()} (daemon: unavailable)`);
     }
   });
 }
@@ -3957,8 +5247,8 @@ function registerWelcomeCommand(program2, deps = { getClient }) {
 }
 
 // src/index.ts
-var __dirname3 = dirname8(fileURLToPath4(import.meta.url));
-var pkg = JSON.parse(readFileSync11(resolve5(__dirname3, "../package.json"), "utf-8"));
+var __dirname3 = dirname9(fileURLToPath4(import.meta.url));
+var pkg = JSON.parse(readFileSync12(resolve6(__dirname3, "../package.json"), "utf-8"));
 updateNotifier({ pkg }).notify();
 var program = new Command();
 program.name("prim").description("CLI for Primitive's decision graph").version(pkg.version).option("-y, --yes", "auto-confirm prompts").option(