@primitive.ai/prim 0.1.0-alpha.91 → 0.1.0-alpha.93

package/dist/hook-runtime/index.js

@@ -3035,7 +3035,7 @@ var require_commander = __commonJS({
 var require_polyfills = __commonJS({
   "node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module) {
     "use strict";
-    var constants8 = __require("constants");
+    var constants9 = __require("constants");
     var origCwd = process.cwd;
     var cwd = null;
     var platform2 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
@@ -3059,7 +3059,7 @@ var require_polyfills = __commonJS({
     var chdir;
     module.exports = patch;
     function patch(fs5) {
-      if (constants8.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+      if (constants9.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
         patchLchmod(fs5);
       }
       if (!fs5.lutimes) {
@@ -3161,7 +3161,7 @@ var require_polyfills = __commonJS({
         fs6.lchmod = function(path9, mode, callback) {
           fs6.open(
             path9,
-            constants8.O_WRONLY | constants8.O_SYMLINK,
+            constants9.O_WRONLY | constants9.O_SYMLINK,
             mode,
             function(err, fd) {
               if (err) {
@@ -3177,7 +3177,7 @@ var require_polyfills = __commonJS({
           );
         };
         fs6.lchmodSync = function(path9, mode) {
-          var fd = fs6.openSync(path9, constants8.O_WRONLY | constants8.O_SYMLINK, mode);
+          var fd = fs6.openSync(path9, constants9.O_WRONLY | constants9.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
@@ -3197,9 +3197,9 @@ var require_polyfills = __commonJS({
         };
       }
       function patchLutimes(fs6) {
-        if (constants8.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
+        if (constants9.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
           fs6.lutimes = function(path9, at, mt, cb) {
-            fs6.open(path9, constants8.O_SYMLINK, function(er, fd) {
+            fs6.open(path9, constants9.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
@@ -3212,7 +3212,7 @@ var require_polyfills = __commonJS({
             });
           };
           fs6.lutimesSync = function(path9, at, mt) {
-            var fd = fs6.openSync(path9, constants8.O_SYMLINK);
+            var fd = fs6.openSync(path9, constants9.O_SYMLINK);
             var ret;
             var threw = true;
             try {
@@ -3495,14 +3495,14 @@ var require_graceful_fs = __commonJS({
         return close;
       })(fs5.close);
       fs5.closeSync = (function(fs$closeSync) {
-        function closeSync8(fd) {
+        function closeSync9(fd) {
           fs$closeSync.apply(fs5, arguments);
           resetQueue();
         }
-        Object.defineProperty(closeSync8, previousSymbol, {
+        Object.defineProperty(closeSync9, previousSymbol, {
           value: fs$closeSync
         });
-        return closeSync8;
+        return closeSync9;
       })(fs5.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
@@ -4963,7 +4963,7 @@ var require_rc = __commonJS({
   "node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js"(exports, module) {
     "use strict";
     var cc = require_utils();
-    var join28 = __require("path").join;
+    var join30 = __require("path").join;
     var deepExtend = require_deep_extend();
     var etc = "/etc";
     var win = process.platform === "win32";
@@ -4988,15 +4988,15 @@ var require_rc = __commonJS({
       }
       if (!win)
         [
-          join28(etc, name, "config"),
-          join28(etc, name + "rc")
+          join30(etc, name, "config"),
+          join30(etc, name + "rc")
         ].forEach(addConfigFile);
       if (home)
         [
-          join28(home, ".config", name, "config"),
-          join28(home, ".config", name),
-          join28(home, "." + name, "config"),
-          join28(home, "." + name + "rc")
+          join30(home, ".config", name, "config"),
+          join30(home, ".config", name),
+          join30(home, "." + name, "config"),
+          join30(home, "." + name + "rc")
         ].forEach(addConfigFile);
       addConfigFile(cc.find("." + name + "rc"));
       if (env4.config) addConfigFile(env4.config);
@@ -5014,7 +5014,7 @@ var require_rc = __commonJS({
 var require_polyfills2 = __commonJS({
   "node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/polyfills.js"(exports, module) {
     "use strict";
-    var constants8 = __require("constants");
+    var constants9 = __require("constants");
     var origCwd = process.cwd;
     var cwd = null;
     var platform2 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
@@ -5038,7 +5038,7 @@ var require_polyfills2 = __commonJS({
     var chdir;
     module.exports = patch;
     function patch(fs5) {
-      if (constants8.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+      if (constants9.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
         patchLchmod(fs5);
       }
       if (!fs5.lutimes) {
@@ -5140,7 +5140,7 @@ var require_polyfills2 = __commonJS({
         fs6.lchmod = function(path9, mode, callback) {
           fs6.open(
             path9,
-            constants8.O_WRONLY | constants8.O_SYMLINK,
+            constants9.O_WRONLY | constants9.O_SYMLINK,
             mode,
             function(err, fd) {
               if (err) {
@@ -5156,7 +5156,7 @@ var require_polyfills2 = __commonJS({
           );
         };
         fs6.lchmodSync = function(path9, mode) {
-          var fd = fs6.openSync(path9, constants8.O_WRONLY | constants8.O_SYMLINK, mode);
+          var fd = fs6.openSync(path9, constants9.O_WRONLY | constants9.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
@@ -5176,9 +5176,9 @@ var require_polyfills2 = __commonJS({
         };
       }
       function patchLutimes(fs6) {
-        if (constants8.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
+        if (constants9.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
           fs6.lutimes = function(path9, at, mt, cb) {
-            fs6.open(path9, constants8.O_SYMLINK, function(er, fd) {
+            fs6.open(path9, constants9.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
@@ -5191,7 +5191,7 @@ var require_polyfills2 = __commonJS({
             });
           };
           fs6.lutimesSync = function(path9, at, mt) {
-            var fd = fs6.openSync(path9, constants8.O_SYMLINK);
+            var fd = fs6.openSync(path9, constants9.O_SYMLINK);
             var ret;
             var threw = true;
             try {
@@ -5474,14 +5474,14 @@ var require_graceful_fs2 = __commonJS({
         return close;
       })(fs5.close);
       fs5.closeSync = (function(fs$closeSync) {
-        function closeSync8(fd) {
+        function closeSync9(fd) {
           fs$closeSync.apply(fs5, arguments);
           resetQueue();
         }
-        Object.defineProperty(closeSync8, previousSymbol, {
+        Object.defineProperty(closeSync9, previousSymbol, {
           value: fs$closeSync
         });
-        return closeSync8;
+        return closeSync9;
       })(fs5.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
@@ -6340,11 +6340,11 @@ var require_util = __commonJS({
           if (files.includes("node_modules") || files.includes("package.json") || files.includes("package.json5") || files.includes("package.yaml") || files.includes("pnpm-workspace.yaml")) {
             return name2;
           }
-          const dirname19 = path9.dirname(name2);
-          if (dirname19 === name2) {
+          const dirname21 = path9.dirname(name2);
+          if (dirname21 === name2) {
             return original;
           }
-          return find(dirname19, original);
+          return find(dirname21, original);
         } catch (error) {
           if (name2 === original) {
             if (error.code === "ENOENT") {
@@ -8313,7 +8313,7 @@ var require_semver2 = __commonJS({
   "node_modules/.pnpm/semver@7.7.4/node_modules/semver/index.js"(exports, module) {
     "use strict";
     var internalRe = require_re();
-    var constants8 = require_constants();
+    var constants9 = require_constants();
     var SemVer = require_semver();
     var identifiers = require_identifiers();
     var parse2 = require_parse();
@@ -8395,8 +8395,8 @@ var require_semver2 = __commonJS({
       re: internalRe.re,
       src: internalRe.src,
       tokens: internalRe.t,
-      SEMVER_SPEC_VERSION: constants8.SEMVER_SPEC_VERSION,
-      RELEASE_TYPES: constants8.RELEASE_TYPES,
+      SEMVER_SPEC_VERSION: constants9.SEMVER_SPEC_VERSION,
+      RELEASE_TYPES: constants9.RELEASE_TYPES,
       compareIdentifiers: identifiers.compareIdentifiers,
       rcompareIdentifiers: identifiers.rcompareIdentifiers
     };
@@ -8896,8 +8896,8 @@ var require_ucs2length = __commonJS({
 });
 
 // src/index.ts
-import { readFileSync as readFileSync22 } from "fs";
-import { dirname as dirname18, resolve as resolve10 } from "path";
+import { readFileSync as readFileSync24 } from "fs";
+import { dirname as dirname20, resolve as resolve10 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // node_modules/.pnpm/commander@12.1.0/node_modules/commander/esm.mjs
@@ -9257,14 +9257,14 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename4 = path2.basename(filePath);
-    if (basename4.length <= LIMIT_BASENAME_LENGTH)
+    const basename5 = path2.basename(filePath);
+    if (basename5.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
-    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename4);
+    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename5);
     if (!truncable)
       return filePath;
-    const truncationLength = basename4.length - LIMIT_BASENAME_LENGTH;
-    return `${filePath.slice(0, -basename4.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
+    const truncationLength = basename5.length - LIMIT_BASENAME_LENGTH;
+    return `${filePath.slice(0, -basename5.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
   }
 };
 node_default(Temp.purgeSyncAll);
@@ -12398,13 +12398,13 @@ function sameIssuerUrl(value, field, issuer) {
   return parsed.toString();
 }
 function parseWorkosConnectConfiguration(value) {
-  const record2 = recordFrom(value, "Connect discovery");
+  const record3 = recordFrom(value, "Connect discovery");
   const expectedKeys = ["protocol_version", "issuer", "client_id", "default_scopes"];
-  if (record2.protocol_version !== 1 || Object.keys(record2).length !== expectedKeys.length || expectedKeys.some((key) => !Object.hasOwn(record2, key)) || !Array.isArray(record2.default_scopes) || record2.default_scopes.length !== WORKOS_CONNECT_DEFAULT_SCOPES.length || record2.default_scopes.some((scope, index) => scope !== WORKOS_CONNECT_DEFAULT_SCOPES[index])) {
+  if (record3.protocol_version !== 1 || Object.keys(record3).length !== expectedKeys.length || expectedKeys.some((key) => !Object.hasOwn(record3, key)) || !Array.isArray(record3.default_scopes) || record3.default_scopes.length !== WORKOS_CONNECT_DEFAULT_SCOPES.length || record3.default_scopes.some((scope, index) => scope !== WORKOS_CONNECT_DEFAULT_SCOPES[index])) {
     throw new WorkosConnectProtocolError("invalid_response", "Connect discovery is invalid");
   }
-  const issuer = canonicalIssuer(record2.issuer);
-  const clientId = exactString(record2.client_id, "client_id", MAX_CLIENT_ID_LENGTH);
+  const issuer = canonicalIssuer(record3.issuer);
+  const clientId = exactString(record3.client_id, "client_id", MAX_CLIENT_ID_LENGTH);
   if (!CONNECT_CLIENT_ID_PATTERN.test(clientId)) {
     throw new WorkosConnectProtocolError("invalid_response", "Connect discovery is invalid");
   }
@@ -12415,14 +12415,14 @@ function parseWorkosConnectConfiguration(value) {
   };
 }
 function parseWorkosConnectCredentialMetadata(value) {
-  const record2 = recordFrom(value, "credential metadata");
-  if (record2.version !== 1 || record2.family !== "workos_connect") {
+  const record3 = recordFrom(value, "credential metadata");
+  if (record3.version !== 1 || record3.family !== "workos_connect") {
     throw new WorkosConnectProtocolError("invalid_metadata", "credential metadata is invalid");
   }
-  const issuer = canonicalIssuer(record2.issuer);
-  const clientId = exactString(record2.clientId, "clientId", MAX_CLIENT_ID_LENGTH);
-  const accessTokenHash = exactString(record2.accessTokenHash, "accessTokenHash", 64);
-  const refreshTokenHash = exactString(record2.refreshTokenHash, "refreshTokenHash", 64);
+  const issuer = canonicalIssuer(record3.issuer);
+  const clientId = exactString(record3.clientId, "clientId", MAX_CLIENT_ID_LENGTH);
+  const accessTokenHash = exactString(record3.accessTokenHash, "accessTokenHash", 64);
+  const refreshTokenHash = exactString(record3.refreshTokenHash, "refreshTokenHash", 64);
   if (!CONNECT_CLIENT_ID_PATTERN.test(clientId)) {
     throw new WorkosConnectProtocolError("invalid_metadata", "credential clientId is invalid");
   }
@@ -12526,37 +12526,37 @@ async function requestWorkosDeviceAuthorization(configuration, fetchImpl = fetch
       `Device authorization returned HTTP ${response.status}`
     );
   }
-  const record2 = recordFrom(value, "device authorization");
+  const record3 = recordFrom(value, "device authorization");
   const verificationUri = sameIssuerUrl(
-    record2.verification_uri,
+    record3.verification_uri,
     "verification_uri",
     configuration.issuer
   );
   return {
-    deviceCode: exactString(record2.device_code, "device_code", MAX_DEVICE_CODE_LENGTH),
-    userCode: exactString(record2.user_code, "user_code", MAX_USER_CODE_LENGTH),
+    deviceCode: exactString(record3.device_code, "device_code", MAX_DEVICE_CODE_LENGTH),
+    userCode: exactString(record3.user_code, "user_code", MAX_USER_CODE_LENGTH),
     verificationUri,
-    verificationUriComplete: record2.verification_uri_complete === void 0 ? void 0 : sameIssuerUrl(
-      record2.verification_uri_complete,
+    verificationUriComplete: record3.verification_uri_complete === void 0 ? void 0 : sameIssuerUrl(
+      record3.verification_uri_complete,
       "verification_uri_complete",
       configuration.issuer
     ),
-    expiresIn: safeInteger(record2.expires_in, "expires_in", 1, MAX_DEVICE_LIFETIME_SECONDS),
-    interval: safeInteger(record2.interval ?? 5, "interval", 1, MAX_INTERVAL_SECONDS)
+    expiresIn: safeInteger(record3.expires_in, "expires_in", 1, MAX_DEVICE_LIFETIME_SECONDS),
+    interval: safeInteger(record3.interval ?? 5, "interval", 1, MAX_INTERVAL_SECONDS)
   };
 }
 function parseWorkosConnectTokens(value, options = {}) {
-  const record2 = recordFrom(value, "token response");
+  const record3 = recordFrom(value, "token response");
   const accessToken = exactString(
-    record2.access_token,
+    record3.access_token,
     "access_token",
     WORKOS_CONNECT_RESPONSE_MAX_BYTES
   );
-  const refreshToken2 = record2.refresh_token === void 0 && options.fallbackRefreshToken !== void 0 ? options.fallbackRefreshToken : exactString(record2.refresh_token, "refresh_token", WORKOS_CONNECT_RESPONSE_MAX_BYTES);
+  const refreshToken2 = record3.refresh_token === void 0 && options.fallbackRefreshToken !== void 0 ? options.fallbackRefreshToken : exactString(record3.refresh_token, "refresh_token", WORKOS_CONNECT_RESPONSE_MAX_BYTES);
   return {
     accessToken,
     refreshToken: refreshToken2,
-    expiresIn: record2.expires_in === void 0 ? void 0 : safeInteger(record2.expires_in, "expires_in", 1, MAX_TOKEN_LIFETIME_SECONDS)
+    expiresIn: record3.expires_in === void 0 ? void 0 : safeInteger(record3.expires_in, "expires_in", 1, MAX_TOKEN_LIFETIME_SECONDS)
   };
 }
 function providerError(value) {
@@ -12678,15 +12678,15 @@ function parseLegacyBrokerCredentialMetadata(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new Error("credential family is invalid");
   }
-  const record2 = value;
-  if (record2.version !== 1 || record2.family !== "legacy_broker" || typeof record2.accessTokenHash !== "string" || typeof record2.refreshTokenHash !== "string" || !/^[a-f0-9]{64}$/u.test(record2.accessTokenHash) || !/^[a-f0-9]{64}$/u.test(record2.refreshTokenHash)) {
+  const record3 = value;
+  if (record3.version !== 1 || record3.family !== "legacy_broker" || typeof record3.accessTokenHash !== "string" || typeof record3.refreshTokenHash !== "string" || !/^[a-f0-9]{64}$/u.test(record3.accessTokenHash) || !/^[a-f0-9]{64}$/u.test(record3.refreshTokenHash)) {
     throw new Error("credential family is invalid");
   }
   return {
     version: 1,
     family: "legacy_broker",
-    accessTokenHash: record2.accessTokenHash,
-    refreshTokenHash: record2.refreshTokenHash
+    accessTokenHash: record3.accessTokenHash,
+    refreshTokenHash: record3.refreshTokenHash
   };
 }
 function readBoundedCredentialJson(path9) {
@@ -12721,9 +12721,9 @@ function readCredentialFamily(path9) {
 }
 function isCredentialMigrationSentinel(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-  const record2 = value;
-  const keys = Object.keys(record2).sort();
-  return keys.length === 2 && keys[0] === "state" && keys[1] === "version" && record2.version === CREDENTIAL_MIGRATION_VERSION && record2.state === CREDENTIAL_MIGRATION_STATE;
+  const record3 = value;
+  const keys = Object.keys(record3).sort();
+  return keys.length === 2 && keys[0] === "state" && keys[1] === "version" && record3.version === CREDENTIAL_MIGRATION_VERSION && record3.state === CREDENTIAL_MIGRATION_STATE;
 }
 function readCredentialMigrationState(path9 = CREDENTIAL_MIGRATION_PATH) {
   const parsed = readBoundedCredentialJson(path9);
@@ -13837,10 +13837,10 @@ async function performTokenRefresh(options = {}) {
           }
           return void 0;
         }
-        const record2 = typeof data === "object" && data !== null && !Array.isArray(data) ? data : void 0;
-        accessToken = typeof record2?.access_token === "string" ? record2.access_token.trim() : "";
-        replacementRefreshToken = typeof record2?.refresh_token === "string" ? record2.refresh_token.trim() : "";
-        expiresIn = typeof record2?.expires_in === "number" && Number.isFinite(record2.expires_in) ? record2.expires_in : void 0;
+        const record3 = typeof data === "object" && data !== null && !Array.isArray(data) ? data : void 0;
+        accessToken = typeof record3?.access_token === "string" ? record3.access_token.trim() : "";
+        replacementRefreshToken = typeof record3?.refresh_token === "string" ? record3.refresh_token.trim() : "";
+        expiresIn = typeof record3?.expires_in === "number" && Number.isFinite(record3.expires_in) ? record3.expires_in : void 0;
         if (!(accessToken && replacementRefreshToken)) {
           if (readTrimmed2(REFRESH_TOKEN_PATH) === currentGeneration) {
             writeTerminalFingerprint(currentGeneration);
@@ -31856,19 +31856,19 @@ var defaultDependencies = {
 function isSafeVersion(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
-function optionalStringArray(record2, key) {
-  const value = record2[key];
+function optionalStringArray(record3, key) {
+  const value = record3[key];
   if (value === void 0) return void 0;
   if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) return void 0;
   return [...value];
 }
-function optionalSafeInteger(record2, key) {
-  const value = record2[key];
+function optionalSafeInteger(record3, key) {
+  const value = record3[key];
   if (value === void 0) return void 0;
   return typeof value === "number" && Number.isSafeInteger(value) ? value : void 0;
 }
-function optionalUserScopeMembers(record2) {
-  const value = record2.users;
+function optionalUserScopeMembers(record3) {
+  const value = record3.users;
   if (value === void 0) return void 0;
   if (!Array.isArray(value)) return void 0;
   const members = [];
@@ -31897,27 +31897,27 @@ function optionalUserScopeMembers(record2) {
 }
 function policyFromUnknown(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-  const record2 = value;
-  if (!isSafeVersion(record2.updatedAt)) return void 0;
+  const record3 = value;
+  if (!isSafeVersion(record3.updatedAt)) return void 0;
   const fields = {
-    repositories: optionalStringArray(record2, "repositories"),
-    directories: optionalStringArray(record2, "directories"),
-    globs: optionalStringArray(record2, "globs"),
-    branches: optionalStringArray(record2, "branches"),
-    effectiveFrom: optionalSafeInteger(record2, "effectiveFrom"),
-    effectiveUntil: optionalSafeInteger(record2, "effectiveUntil"),
-    users: optionalUserScopeMembers(record2)
+    repositories: optionalStringArray(record3, "repositories"),
+    directories: optionalStringArray(record3, "directories"),
+    globs: optionalStringArray(record3, "globs"),
+    branches: optionalStringArray(record3, "branches"),
+    effectiveFrom: optionalSafeInteger(record3, "effectiveFrom"),
+    effectiveUntil: optionalSafeInteger(record3, "effectiveUntil"),
+    users: optionalUserScopeMembers(record3)
   };
   if (Object.entries(fields).some(
-    ([key, parsed]) => record2[key] !== void 0 && parsed === void 0
+    ([key, parsed]) => record3[key] !== void 0 && parsed === void 0
   )) {
     return void 0;
   }
-  if (record2.effectiveFrom !== void 0 && fields.effectiveFrom === void 0 || record2.effectiveUntil !== void 0 && fields.effectiveUntil === void 0 || fields.effectiveFrom !== void 0 && fields.effectiveUntil !== void 0 && fields.effectiveFrom >= fields.effectiveUntil) {
+  if (record3.effectiveFrom !== void 0 && fields.effectiveFrom === void 0 || record3.effectiveUntil !== void 0 && fields.effectiveUntil === void 0 || fields.effectiveFrom !== void 0 && fields.effectiveUntil !== void 0 && fields.effectiveFrom >= fields.effectiveUntil) {
     return void 0;
   }
   return {
-    updatedAt: record2.updatedAt,
+    updatedAt: record3.updatedAt,
     ...fields.repositories === void 0 ? {} : { repositories: fields.repositories },
     ...fields.directories === void 0 ? {} : { directories: fields.directories },
     ...fields.globs === void 0 ? {} : { globs: fields.globs },
@@ -33697,18 +33697,18 @@ function parseAuthBrokerConfig(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new Error("broker config must be an object");
   }
-  const record2 = value;
-  if (typeof record2.authorization_server !== "string" || !record2.authorization_server.trim()) {
+  const record3 = value;
+  if (typeof record3.authorization_server !== "string" || !record3.authorization_server.trim()) {
     throw new Error("authorization_server is required");
   }
-  if (typeof record2.client_id !== "string" || !record2.client_id.trim()) {
+  if (typeof record3.client_id !== "string" || !record3.client_id.trim()) {
     throw new Error("client_id is required");
   }
-  if (!Array.isArray(record2.default_scopes) || !record2.default_scopes.every((scope) => typeof scope === "string" && scope.length > 0)) {
+  if (!Array.isArray(record3.default_scopes) || !record3.default_scopes.every((scope) => typeof scope === "string" && scope.length > 0)) {
     throw new Error("default_scopes must be a string array");
   }
-  const authorizationServer = parseHttpUrl(record2.authorization_server, "authorization_server");
-  const rawEndpoint = record2.authorization_endpoint === void 0 ? DEFAULT_WORKOS_AUTHORIZE_URL : record2.authorization_endpoint;
+  const authorizationServer = parseHttpUrl(record3.authorization_server, "authorization_server");
+  const rawEndpoint = record3.authorization_endpoint === void 0 ? DEFAULT_WORKOS_AUTHORIZE_URL : record3.authorization_endpoint;
   if (typeof rawEndpoint !== "string" || !rawEndpoint.trim()) {
     throw new Error("authorization_endpoint must be a URL");
   }
@@ -33719,8 +33719,8 @@ function parseAuthBrokerConfig(value) {
   return {
     authorization_server: authorizationServer.toString(),
     authorization_endpoint: authorizationEndpoint.toString(),
-    client_id: record2.client_id.trim(),
-    default_scopes: [...record2.default_scopes]
+    client_id: record3.client_id.trim(),
+    default_scopes: [...record3.default_scopes]
   };
 }
 async function fetchAuthBrokerConfig(siteUrl, fetchImpl = fetch) {
@@ -34963,7 +34963,7 @@ import {
   utimesSync,
   writeFileSync as writeFileSync6
 } from "fs";
-import { dirname as dirname8, isAbsolute as isAbsolute5, join as join10, resolve as resolve5 } from "path";
+import { delimiter, dirname as dirname8, isAbsolute as isAbsolute5, join as join10, resolve as resolve5 } from "path";
 var HOOK_RUNTIME_SCHEMA_VERSION = 1;
 var DIRECTORY_MODE2 = 448;
 var DATA_FILE_MODE = 384;
@@ -35313,11 +35313,28 @@ function writeRelease(sourceDir, releaseDir, manifest, releasesDir) {
     rmSync4(stagingDir, { recursive: true, force: true });
   }
 }
+function stableNodePath(execPath = process.execPath, searchPath = process.env.PATH ?? "") {
+  let target;
+  try {
+    target = realpathSync2(execPath);
+  } catch {
+    return execPath;
+  }
+  for (const directory of searchPath.split(delimiter)) {
+    if (!isAbsolute5(directory)) continue;
+    const candidate = join10(directory, "node");
+    try {
+      if (realpathSync2(candidate) === target) return candidate;
+    } catch {
+    }
+  }
+  return execPath;
+}
 function stageHookRuntime(options = {}) {
   const root = packageRoot();
   const sourceDir = options.sourceDir ?? (root ? join10(root, "dist", "hook-runtime") : null);
   const version = options.version ?? packageVersion();
-  const nodePath = resolve5(options.nodePath ?? process.execPath);
+  const nodePath = resolve5(options.nodePath ?? stableNodePath());
   if (!sourceDir || !version || compareSemver(version, version) !== 0 || !isAbsolute5(nodePath) || /[\r\n]/u.test(nodePath)) {
     throw new Error("cannot stage hook runtime: package identity is unavailable");
   }
@@ -36369,7 +36386,7 @@ function registerCursorCommands(program3) {
 
 // src/commands/daemon.ts
 import { spawn as spawn3 } from "child_process";
-import { closeSync as closeSync3, existsSync as existsSync12, mkdirSync as mkdirSync9, openSync as openSync3, readFileSync as readFileSync13, unlinkSync as unlinkSync3 } from "fs";
+import { closeSync as closeSync4, existsSync as existsSync12, mkdirSync as mkdirSync9, openSync as openSync4, readFileSync as readFileSync13, unlinkSync as unlinkSync3 } from "fs";
 import { join as join16 } from "path";
 
 // src/daemon/latest-bootstrap.ts
@@ -36441,12 +36458,12 @@ async function runLatestDaemonBootstrap(ensureCurrent, options = {}) {
 import { spawnSync } from "child_process";
 import { createHash as createHash8, randomBytes as randomBytes5 } from "crypto";
 import {
-  constants as constants4,
+  constants as constants5,
   accessSync as accessSync2,
   chmodSync as chmodSync4,
   copyFileSync as copyFileSync2,
   existsSync as existsSync11,
-  lstatSync as lstatSync5,
+  lstatSync as lstatSync6,
   mkdirSync as mkdirSync8,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync12,
@@ -36455,16 +36472,53 @@ import {
   realpathSync as realpathSync3,
   renameSync as renameSync4,
   rmSync as rmSync5,
+  statSync as statSync3,
   symlinkSync,
   writeFileSync as writeFileSync7
 } from "fs";
 import { homedir as homedir8 } from "os";
 import { basename as basename3, dirname as dirname10, isAbsolute as isAbsolute7, join as join15, resolve as resolve6 } from "path";
 
+// src/lib/bounded-file.ts
+import { constants as constants4, closeSync as closeSync3, fstatSync, lstatSync as lstatSync5, openSync as openSync3, readSync } from "fs";
+function readBoundedRegularFile(path9, maxBytes) {
+  let fd;
+  try {
+    const linked = lstatSync5(path9);
+    if (!linked.isFile() || linked.size > maxBytes) return void 0;
+    fd = openSync3(path9, constants4.O_RDONLY | constants4.O_NOFOLLOW | constants4.O_NONBLOCK);
+    const opened = fstatSync(fd);
+    if (!opened.isFile() || opened.dev !== linked.dev || opened.ino !== linked.ino || opened.size > maxBytes) {
+      return void 0;
+    }
+    const buffer = Buffer.allocUnsafe(opened.size + 1);
+    let length = 0;
+    while (length < buffer.length) {
+      const count = readSync(fd, buffer, length, buffer.length - length, length);
+      if (count === 0) break;
+      length += count;
+    }
+    if (length > opened.size) return void 0;
+    return { text: buffer.subarray(0, length).toString("utf8"), ownerUid: opened.uid };
+  } catch {
+    return void 0;
+  } finally {
+    if (fd !== void 0) {
+      try {
+        closeSync3(fd);
+      } catch {
+      }
+    }
+  }
+}
+
 // src/daemon/env-binding.ts
 function normalizeApiUrl(url) {
   return url.trim().replace(/\/+$/, "");
 }
+function apiUrlsMatch(a, b) {
+  return normalizeApiUrl(a) === normalizeApiUrl(b);
+}
 
 // src/daemon/launchd.ts
 var LAUNCHD_LABEL = "ai.getprimitive.prim-daemon";
@@ -36483,6 +36537,11 @@ var SERVICE_NOT_FOUND = 113;
 var TRANSITION_IN_PROGRESS = 5;
 var OUTPUT_LIMIT = 4096;
 var DAEMON_DISABLED_CONTENT = "disabled by `prim daemon stop`\n";
+var LAUNCHER_MAX_BYTES = 64 * 1024;
+var PLIST_MAX_BYTES = 64 * 1024;
+var DRIFT_HEAL_MARKER = "daemon-drift-heal.json";
+var DRIFT_HEAL_MARKER_TEMPORARY_RE = /^daemon-drift-heal\.json\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.tmp$/u;
+var DRIFT_HEAL_CLAIM_OWNER = "owner.json";
 var LaunchctlError = class extends Error {
   status;
   timedOut;
@@ -36522,6 +36581,8 @@ function daemonControlPaths(options = {}) {
   return {
     launcher: join15(configDir, `prim-daemon-launcher-v${LAUNCHER_SCHEMA_VERSION}`),
     disabledMarker: join15(configDir, "daemon.disabled"),
+    driftHealMarker: join15(configDir, DRIFT_HEAL_MARKER),
+    driftHealClaim: join15(configDir, "daemon-drift-heal.lock"),
     lifecycleLockDir: join15(configDir, "daemon.lifecycle.lock"),
     legacyDisabledMarker: legacy.disabledMarker,
     legacyLifecycleLockDir: legacy.lifecycleLockDir
@@ -36582,7 +36643,7 @@ function readOwnedRuntimeManifest(releaseDir) {
     }
     const manifest = parsed;
     if (manifest.schemaVersion !== RUNTIME_SCHEMA_VERSION || compareSemver(manifest.version, manifest.version) !== 0 || !isAbsolute7(manifest.nodePath) || /[\r\n]/u.test(manifest.nodePath) || manifest.daemonFile !== "prim-daemon-server" || !/^[0-9a-f]{64}$/u.test(manifest.daemonSha256) || new Date(manifest.stagedAt).toISOString() !== manifest.stagedAt || raw !== `${JSON.stringify(manifest, null, 2)}
-` || !lstatSync5(daemonPath).isFile() || sha256File(daemonPath) !== manifest.daemonSha256) {
+` || !lstatSync6(daemonPath).isFile() || sha256File(daemonPath) !== manifest.daemonSha256) {
       return null;
     }
     const entries = readdirSync3(releaseDir).sort();
@@ -36591,8 +36652,17 @@ function readOwnedRuntimeManifest(releaseDir) {
     return null;
   }
 }
+function sameNode(recorded, desired) {
+  if (recorded === desired) return true;
+  try {
+    const target = realpathSync3(desired);
+    return recorded !== target && realpathSync3(recorded) === target;
+  } catch {
+    return false;
+  }
+}
 function sameRuntime(current, desired, daemonPath) {
-  if (!current || current.version !== desired.version || current.nodePath !== desired.nodePath || current.daemonSha256 !== desired.daemonSha256) {
+  if (!current || current.version !== desired.version || !sameNode(current.nodePath, desired.nodePath) || current.daemonSha256 !== desired.daemonSha256) {
     return false;
   }
   try {
@@ -36620,7 +36690,7 @@ function stageRuntime(options = {}) {
   if (!daemonSource || !existsSync11(daemonSource)) {
     throw new Error("cannot stage runtime: prim-daemon-server bundle is unavailable");
   }
-  const nodePath = resolve6(options.nodePath ?? process.execPath);
+  const nodePath = resolve6(options.nodePath ?? stableNodePath());
   const version = options.version ?? findPackageVersion(daemonSource);
   const desired = {
     schemaVersion: RUNTIME_SCHEMA_VERSION,
@@ -36719,13 +36789,30 @@ function assertRegularFile(path9, label) {
 }
 function lstatIfPresent3(path9) {
   try {
-    return lstatSync5(path9);
+    return lstatSync6(path9);
   } catch (error) {
     const code = error.code;
     if (code === "ENOENT" || code === "ENOTDIR") return void 0;
     throw error;
   }
 }
+function driftHealMarkerTemporaries(configDir) {
+  try {
+    return readdirSync3(configDir).filter((entry) => DRIFT_HEAL_MARKER_TEMPORARY_RE.test(entry)).map((entry) => join15(configDir, entry));
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return [];
+    throw error;
+  }
+}
+function assertDriftHealClaim(path9) {
+  const claim = lstatIfPresent3(path9);
+  if (!claim) return;
+  if (!claim.isDirectory() || readdirSync3(path9).some((entry) => entry !== DRIFT_HEAL_CLAIM_OWNER)) {
+    throw new Error(`refusing to remove unrecognized daemon drift-heal claim at ${path9}`);
+  }
+  assertRegularFile(join15(path9, DRIFT_HEAL_CLAIM_OWNER), "daemon drift-heal claim owner");
+}
 function assertExactFile(path9, expected, label) {
   if (!lstatIfPresent3(path9)) return;
   assertRegularFile(path9, label);
@@ -36764,17 +36851,16 @@ function assertOwnedDaemonRuntime(options) {
     );
   }
   assertRegularFile(logPath, "daemon log");
+  assertRegularFile(control.driftHealMarker, "daemon drift-heal marker");
+  for (const temporary of driftHealMarkerTemporaries(configDir)) {
+    assertRegularFile(temporary, "daemon drift-heal marker temporary");
+  }
+  assertDriftHealClaim(control.driftHealClaim);
   assertRegularFile(join15(configDir, "daemon-health.json"), "daemon health snapshot");
   assertRegularFile(join15(configDir, "client_instance_id"), "daemon client instance id");
   if (service && lstatIfPresent3(service.plistPath)) {
     assertRegularFile(service.plistPath, "launchd property list");
-    const expected = generateLaunchAgentPlist({
-      launcherPath: control.launcher,
-      logPath,
-      workingDirectory: options.homeDir ?? homedir8(),
-      label: options.label
-    });
-    if (readFileSync12(service.plistPath, "utf8") !== expected) {
+    if (readFileSync12(service.plistPath, "utf8") !== ownedLaunchAgentPlist(options, logPath)) {
       throw new Error(
         `refusing to remove unrecognized launchd property list at ${service.plistPath}`
       );
@@ -36851,6 +36937,9 @@ async function removeDaemonRuntime(options = {}) {
     control.launcher,
     control.disabledMarker,
     control.legacyDisabledMarker,
+    control.driftHealMarker,
+    ...driftHealMarkerTemporaries(configDir),
+    control.driftHealClaim,
     ...service ? [service.plistPath] : [],
     logPath,
     join15(configDir, "daemon-health.json"),
@@ -36862,7 +36951,7 @@ async function removeDaemonRuntime(options = {}) {
   return withDaemonLifecycleLock(async () => {
     assertOwnedDaemonRuntime(options);
     for (const path9 of ownedArtifacts.filter((candidate) => candidate !== runtime.runtimeDir)) {
-      rmSync5(path9, { force: true });
+      rmSync5(path9, { force: true, recursive: path9 === control.driftHealClaim });
     }
     if (lstatIfPresent3(runtime.runtimeDir)) {
       const quarantined = `${runtime.runtimeDir}.uninstall-${String(process.pid)}-${randomBytes5(8).toString("hex")}`;
@@ -36896,9 +36985,22 @@ ${config.configDir ? `export PRIM_CONFIG_DIR=${shellQuote2(config.configDir)}
 `
   };
 }
+function ownedLaunchAgentPlist(options, logPath) {
+  return generateLaunchAgentPlist({
+    launcherPath: daemonControlPaths(options).launcher,
+    logPath,
+    workingDirectory: options.homeDir ?? homedir8(),
+    label: options.label
+  });
+}
 function readDaemonLauncher(path9) {
+  return readDaemonLauncherFile(path9)?.config ?? null;
+}
+function readDaemonLauncherFile(path9) {
   try {
-    const content = readFileSync12(path9, "utf8");
+    const file = readBoundedRegularFile(path9, LAUNCHER_MAX_BYTES);
+    if (!file) return null;
+    const content = file.text;
     const encoded = /^# prim-daemon-launcher: ([A-Za-z0-9_-]+)$/mu.exec(content)?.[1];
     if (!encoded) return null;
     const value = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
@@ -36913,7 +37015,7 @@ function readDaemonLauncher(path9) {
       ...typeof value.configDir === "string" ? { configDir: value.configDir } : {}
     };
     const expected = generateDaemonLauncher(config);
-    return expected.revision === value.revision && expected.content === content ? config : null;
+    return expected.revision === value.revision && expected.content === content ? { config, ownerUid: file.ownerUid } : null;
   } catch {
     return null;
   }
@@ -36923,7 +37025,7 @@ function readUsableDaemonConfig(path9) {
   if (!config) return null;
   const manifest = readRuntimeManifest(join15(dirname10(config.daemonPath), "manifest.json"));
   try {
-    accessSync2(config.nodePath, constants4.X_OK);
+    accessSync2(config.nodePath, constants5.X_OK);
     return manifest?.version === config.runtimeVersion && manifest.nodePath === config.nodePath && manifest.daemonSha256 === sha256File(config.daemonPath) ? config : null;
   } catch {
     return null;
@@ -37267,6 +37369,68 @@ function setDaemonExplicitlyDisabled(disabled, options = {}) {
   }
   atomicWrite3(paths.disabledMarker, content, RUNTIME_FILE_MODE);
 }
+function launcherRunnable(config) {
+  try {
+    accessSync2(config.nodePath, constants5.X_OK);
+    return statSync3(config.daemonPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function selectedDaemonLauncher(options = {}) {
+  const file = readDaemonLauncherFile(daemonControlPaths(options).launcher);
+  if (!file) return null;
+  const { config, ownerUid } = file;
+  return {
+    runtimeVersion: config.runtimeVersion,
+    ...config.apiUrl ? { apiUrl: config.apiUrl } : {},
+    ownerUid,
+    runnable: launcherRunnable(config)
+  };
+}
+var XML_ENTITIES = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&apos;": "'"
+};
+var XML_ENTITY_RE = /&(?:amp|lt|gt|quot|apos);/gu;
+var PLIST_LABEL_KEY = "<key>Label</key>";
+var PLIST_PROGRAM_KEY = "<key>ProgramArguments</key>";
+var PLIST_LABEL_RE = /<key>Label<\/key>\s*<string>([^<]*)<\/string>/u;
+var PLIST_PROGRAM_RE = /<key>ProgramArguments<\/key>\s*<array>\s*<string>([^<]*)<\/string>/u;
+function xmlUnescape(value) {
+  if (value.replace(XML_ENTITY_RE, "").includes("&")) return void 0;
+  return value.replace(XML_ENTITY_RE, (entity) => XML_ENTITIES[entity] ?? entity);
+}
+function launchAgentProgram(plist) {
+  if (plist.split(PLIST_LABEL_KEY).length !== 2 || plist.split(PLIST_PROGRAM_KEY).length !== 2) {
+    return void 0;
+  }
+  const label = PLIST_LABEL_RE.exec(plist)?.[1];
+  const program3 = PLIST_PROGRAM_RE.exec(plist)?.[1];
+  if (label === void 0 || program3 === void 0) return void 0;
+  const decodedLabel = xmlUnescape(label);
+  const decodedProgram = xmlUnescape(program3);
+  return decodedLabel === void 0 || decodedProgram === void 0 ? void 0 : { label: decodedLabel, program: decodedProgram };
+}
+function launchAgentRunsConfigRoot(options = {}) {
+  try {
+    const service = launchdPaths(options);
+    const plist = readBoundedRegularFile(service.plistPath, PLIST_MAX_BYTES);
+    const agent = plist ? launchAgentProgram(plist.text) : void 0;
+    return agent?.label === (options.label ?? LAUNCHD_LABEL) && agent.program === daemonControlPaths(options).launcher;
+  } catch {
+    return false;
+  }
+}
+function daemonDriftHealMarkerPath(options = {}) {
+  return daemonControlPaths(options).driftHealMarker;
+}
+function daemonDriftHealClaimPath(options = {}) {
+  return daemonControlPaths(options).driftHealClaim;
+}
 async function ensureMacDaemon(options = {}) {
   return withDaemonLifecycleLock(() => ensureMacDaemonLocked(options), options);
 }
@@ -37454,6 +37618,54 @@ async function bootoutMacDaemonLocked(options) {
   return { wasLoaded, legacyStopped, service };
 }
 
+// src/lib/delivery-backlog.ts
+var MS_PER_SECOND = 1e3;
+var MS_PER_MINUTE = 60 * MS_PER_SECOND;
+var MS_PER_HOUR = 60 * MS_PER_MINUTE;
+var MS_PER_DAY = 24 * MS_PER_HOUR;
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+  return isNonNegativeInteger(value) && value > 0;
+}
+function deliveryBacklogState(ingestion) {
+  if (ingestion?.healthy !== false) return void 0;
+  const failures = ingestion.consecutiveFailures;
+  const failedWithoutProgress = failures !== 0 && !(isPositiveInteger(failures) && isPositiveInteger(ingestion.lastFailedDrainAcknowledgedCount));
+  if (failedWithoutProgress) return "failing";
+  const retained = ingestion.lastRetainedBucketCount;
+  if (!isNonNegativeInteger(retained)) return "failing";
+  return retained > 0 ? "retained" : "draining";
+}
+function formatBacklogAge(ageMs) {
+  if (ageMs >= MS_PER_DAY) return `${String(Math.floor(ageMs / MS_PER_DAY))}d`;
+  if (ageMs >= MS_PER_HOUR) return `${String(Math.floor(ageMs / MS_PER_HOUR))}h`;
+  if (ageMs >= MS_PER_MINUTE) return `${String(Math.floor(ageMs / MS_PER_MINUTE))}m`;
+  return `${String(Math.max(0, Math.floor(ageMs / MS_PER_SECOND)))}s`;
+}
+function formatPendingBacklog(backlog, now = Date.now()) {
+  const count = backlog.pendingCount;
+  const moves = typeof count === "number" && count > 0 ? `${backlog.pendingSampled ? "at least " : ""}${String(count)} pending move${count === 1 ? "" : "s"}` : "an unknown number of pending moves";
+  const age = backlog.oldestPendingAt === void 0 ? "" : ` (oldest ${backlog.pendingSampled ? "\u2265 " : ""}${formatBacklogAge(now - backlog.oldestPendingAt)})`;
+  return `${moves}${age}`;
+}
+function deliveryBacklogSummary(ingestion, now = Date.now(), backlog = ingestion) {
+  const state = deliveryBacklogState(ingestion);
+  if (!(state && ingestion && backlog)) return void 0;
+  const pending = formatPendingBacklog(backlog, now);
+  if (state === "draining") return `draining ${pending} in the background`;
+  if (state === "retained") {
+    const buckets = ingestion.lastRetainedBucketCount ?? 0;
+    const reasons = boundedHealthError(ingestion.lastRetainedReasons);
+    return `delivery held back: ${String(buckets)} journal bucket${buckets === 1 ? "" : "s"} retained${reasons ? ` (${reasons})` : ""} \xB7 holding ${pending} \u2014 run \`prim doctor\``;
+  }
+  const failures = ingestion.consecutiveFailures;
+  const count = isPositiveInteger(failures) ? ` (${String(failures)} consecutive failure${failures === 1 ? "" : "s"})` : "";
+  const error = boundedHealthError(ingestion.lastError);
+  return `delivery failing${count}${error ? `: ${error}` : ""} \xB7 retrying ${pending} in the background`;
+}
+
 // src/lib/presence.ts
 var DECISION_ORIGIN = "https://app.getprimitive.ai";
 function validDecisionUrl(value) {
@@ -37528,7 +37740,8 @@ function formatStatusline(version, snapshot, resolveIngestionStatus, options = {
     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` : ""}${repositorySuffix}${ingestionSuffix(ingestionStatus)})`;
+      const delivery = deliveryBacklogState(snapshot.ingestion) === "draining" && snapshot.heartbeat?.healthy === true ? "draining" : "stalled";
+      return `primitive ${version} (daemon: degraded \xB7 delivery: ${delivery}${typeof pending === "number" ? ` \xB7 ${qualifier}${String(pending)} pending` : ""}${repositorySuffix}${ingestionSuffix(ingestionStatus)})`;
     }
     if (snapshot.heartbeat?.healthy === false) {
       return `primitive ${version} (daemon: degraded \xB7 presence: unavailable${repositorySuffix}${ingestionSuffix(ingestionStatus)})`;
@@ -37571,16 +37784,20 @@ var STATUS_PROBE_TIMEOUT_MS = 500;
 var READY_TIMEOUT_MS = 5e3;
 var READY_POLL_MS2 = 100;
 var READY_PROBE_TIMEOUT_MS2 = 250;
-var HEALTHY_TIMEOUT_MS = 3e4;
-var HEALTHY_POLL_MS = 250;
+var READY_SNAPSHOT_TIMEOUT_MS = 3e4;
+var READY_SNAPSHOT_POLL_MS = 250;
 var EXIT_OK3 = 0;
 var EXIT_NOT_RUNNING = 2;
 var EXIT_BOOTING = 3;
-function formatDaemonLifecycleMessage(message, decisionIngestion) {
-  return `${message} \xB7 Decision ingestion ${decisionIngestion}`;
+var VERIFIED_PREFIX = "[prim] \u2713 ";
+function formatDaemonLifecycleMessage(message, decisionIngestion, snapshot, now = Date.now()) {
+  const backlog = deliveryBacklogSummary(snapshot?.ingestion, now);
+  const state = deliveryBacklogState(snapshot?.ingestion);
+  const verdict = (state === "failing" || state === "retained") && message.startsWith(VERIFIED_PREFIX) ? `[prim] \u26A0 ${message.slice(VERIFIED_PREFIX.length)}` : message;
+  return `${verdict} \xB7 Decision ingestion ${decisionIngestion}${backlog ? ` \xB7 ${backlog}` : ""}`;
 }
-function formatCurrentDaemonLifecycleMessage(message) {
-  return formatDaemonLifecycleMessage(message, decisionIngestionStatus(process.cwd()));
+function formatCurrentDaemonLifecycleMessage(message, snapshot) {
+  return formatDaemonLifecycleMessage(message, decisionIngestionStatus(process.cwd()), snapshot);
 }
 function daemonDegradedReason(snapshot) {
   if (!snapshot || snapshot.healthy !== false) return void 0;
@@ -37631,7 +37848,7 @@ function openDaemonLog(configDir = CONFIG_DIR) {
   if (!existsSync12(configDir)) {
     mkdirSync9(configDir, { recursive: true, mode: CONFIG_DIR_MODE2 });
   }
-  return openSync3(join16(configDir, "daemon.log"), "a", LOG_FILE_MODE);
+  return openSync4(join16(configDir, "daemon.log"), "a", LOG_FILE_MODE);
 }
 async function waitForReady() {
   const deadline = Date.now() + READY_TIMEOUT_MS;
@@ -37643,17 +37860,23 @@ async function waitForReady() {
   }
   return daemonIsLive(READY_PROBE_TIMEOUT_MS2);
 }
-async function waitForHealthySnapshot(expectedVersion) {
-  const deadline = Date.now() + HEALTHY_TIMEOUT_MS;
+function requestStatusSnapshot() {
+  return daemonRequest(
+    "status_snapshot",
+    {},
+    { timeoutMs: STATUS_PROBE_TIMEOUT_MS }
+  );
+}
+async function waitForReadySnapshot(expectedVersion, options = {}) {
+  const request2 = options.requestSnapshot ?? requestStatusSnapshot;
+  const wait = options.sleep ?? sleep;
+  const nowMs = options.nowMs ?? Date.now;
+  const deadline = nowMs() + READY_SNAPSHOT_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);
+  while (nowMs() < deadline) {
+    snapshot = await request2();
+    if (daemonStartIsReady(true, snapshot, expectedVersion)) return snapshot;
+    await wait(READY_SNAPSHOT_POLL_MS);
   }
   return snapshot;
 }
@@ -37666,11 +37889,20 @@ async function verifiedPid(existing) {
   );
   return snapshot?.pid === existing.pid ? snapshot : null;
 }
-function daemonStartIsHealthy(serviceReady, snapshot, expectedVersion) {
-  return serviceReady && snapshot?.healthy === true && expectedVersion !== void 0 && snapshot.version === expectedVersion;
+function daemonStartIsReady(serviceReady, snapshot, expectedVersion) {
+  if (!serviceReady || !snapshot || expectedVersion === void 0) return false;
+  if (snapshot.version !== expectedVersion || snapshot.needsReauth === true) return false;
+  if (snapshot.healthy === true) return true;
+  return snapshot.heartbeat?.healthy === true && snapshot.ingestion?.healthy === false;
 }
-function daemonStartHealthFields(healthy, snapshot) {
-  if (healthy) return {};
+function daemonBacklogFields(snapshot) {
+  const state = deliveryBacklogState(snapshot?.ingestion);
+  if (!state) return {};
+  if (state === "draining") return { draining: true, ingestion: snapshot?.ingestion };
+  return state === "retained" ? { draining: false, deliveryRetained: true, ingestion: snapshot?.ingestion } : { draining: false, deliveryFailing: true, ingestion: snapshot?.ingestion };
+}
+function daemonStartHealthFields(ready, snapshot) {
+  if (ready) return daemonBacklogFields(snapshot);
   return {
     state: "degraded",
     needsReauth: snapshot?.needsReauth === true,
@@ -37678,16 +37910,28 @@ function daemonStartHealthFields(healthy, snapshot) {
     ingestion: snapshot?.ingestion ?? null
   };
 }
+function daemonStartFailureReason(snapshot, expectedVersion) {
+  if (snapshot && !snapshot.needsReauth && expectedVersion !== void 0 && snapshot.version !== expectedVersion) {
+    return `daemon reports ${snapshot.version ? `v${snapshot.version}` : "no version"}, expected v${expectedVersion}`;
+  }
+  return daemonDegradedReason(snapshot);
+}
 async function detachedDaemonStart(opts) {
   const existing = readPidfile();
   if (existing?.alive) {
     const snapshot = await verifiedPid(existing);
     if (snapshot) {
       process.stderr.write(
-        `${formatCurrentDaemonLifecycleMessage(`[prim] daemon already running (pid=${existing.pid})`)}
+        `${formatCurrentDaemonLifecycleMessage(`[prim] daemon already running (pid=${existing.pid})`, snapshot)}
 `
       );
-      console.log(JSON.stringify({ started: false, pid: existing.pid }, null, 2));
+      console.log(
+        JSON.stringify(
+          { started: false, pid: existing.pid, ...daemonBacklogFields(snapshot) },
+          null,
+          2
+        )
+      );
       return;
     }
     process.stderr.write(
@@ -37736,16 +37980,19 @@ async function detachedDaemonStart(opts) {
   });
   child.unref();
   if (logFd !== void 0) {
-    closeSync3(logFd);
+    closeSync4(logFd);
   }
   const live = await waitForReady();
   if (live) {
     const after = readPidfile();
+    const snapshot = await requestStatusSnapshot();
     process.stderr.write(
-      `${formatCurrentDaemonLifecycleMessage(`[prim] \u2713 daemon started (pid=${after?.pid ?? "?"}, socket=${SOCK_PATH2})`)}
+      `${formatCurrentDaemonLifecycleMessage(`[prim] \u2713 daemon started (pid=${after?.pid ?? "?"}, socket=${SOCK_PATH2})`, snapshot)}
 `
     );
-    console.log(JSON.stringify({ started: true, pid: after?.pid }, null, 2));
+    console.log(
+      JSON.stringify({ started: true, pid: after?.pid, ...daemonBacklogFields(snapshot) }, null, 2)
+    );
     return;
   }
   process.stderr.write(
@@ -37868,19 +38115,25 @@ 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 snapshot = serviceReady && expectedVersion ? await waitForReadySnapshot(expectedVersion) : null;
+  const ready = daemonStartIsReady(serviceReady, snapshot, expectedVersion);
+  if (ready) {
     const verb = result.action === "none" ? "already running" : "started";
     const servicePid = result.service.loaded ? result.service.pid : void 0;
     process.stderr.write(
-      `${formatCurrentDaemonLifecycleMessage(`[prim] \u2713 daemon ${verb} under launchd (pid=${snapshot?.pid ?? servicePid ?? "?"})`)}
+      `${formatCurrentDaemonLifecycleMessage(`[prim] \u2713 daemon ${verb} under launchd (pid=${snapshot?.pid ?? servicePid ?? "?"})`, snapshot)}
 `
     );
+  } else if (!(serviceReady && expectedVersion)) {
+    process.stderr.write(
+      `[prim] \u2717 launchd did not converge on the desired daemon (${result.action}) (see ${LOG_PATH})
+`
+    );
+    if (!process.exitCode) process.exitCode = EXIT_NOT_RUNNING;
   } else {
-    const reason = daemonDegradedReason(snapshot);
+    const reason = daemonStartFailureReason(snapshot, expectedVersion);
     process.stderr.write(
-      `[prim] \u2717 launchd daemon did not reach healthy heartbeat + ingestion state${reason ? ` \xB7 ${reason}` : ""} (see ${LOG_PATH})
+      `[prim] \u2717 launchd daemon did not reach a healthy heartbeat on the expected version${reason ? ` \xB7 ${reason}` : ""} (see ${LOG_PATH})
 `
     );
     if (!process.exitCode) process.exitCode = EXIT_NOT_RUNNING;
@@ -37888,14 +38141,20 @@ async function macDaemonStart(forceRestart = false) {
   console.log(
     JSON.stringify(
       {
-        started: healthy,
+        started: ready,
         supervised: true,
         action: result.action,
         pid: snapshot?.pid ?? (result.service.loaded ? result.service.pid : void 0),
         loaded: result.service.loaded,
         responding: result.responding,
-        healthy,
-        ...daemonStartHealthFields(healthy, snapshot),
+        // `healthy` keeps meaning "start succeeded" (always equal to `started`
+        // and the exit code) so existing consumers stay correct. It is not the
+        // daemon's own health: `daemon status --json` stays degraded while a
+        // backlog drains, is held back, or fails to deliver, which start
+        // reports additively via `draining`, `deliveryRetained`,
+        // `deliveryFailing`, and `ingestion`.
+        healthy: ready,
+        ...daemonStartHealthFields(ready, snapshot),
         version: snapshot?.version,
         expectedVersion
       },
@@ -38199,11 +38458,12 @@ async function daemonEnsure() {
     return { disabled };
   }
   const result = await ensureMacDaemon();
+  const snapshot = result.state === "running" ? await requestStatusSnapshot() : null;
   if (result.state === "disabled") {
     process.stderr.write("[prim] daemon remains explicitly disabled\n");
   } else if (result.state === "running") {
     process.stderr.write(
-      `${formatCurrentDaemonLifecycleMessage(`[prim] \u2713 daemon ensured under launchd (${result.action})`)}
+      `${formatCurrentDaemonLifecycleMessage(`[prim] \u2713 daemon ensured under launchd (${result.action})`, snapshot)}
 `
     );
   } else {
@@ -38217,7 +38477,8 @@ async function daemonEnsure() {
         ensured: result.state === "running",
         disabled: result.state === "disabled",
         supervised: true,
-        action: result.action
+        action: result.action,
+        ...daemonBacklogFields(snapshot)
       },
       null,
       2
@@ -39273,11 +39534,11 @@ function asRecord(value, path9) {
   }
   return value;
 }
-function assertKeys(record2, path9, required, optional = []) {
+function assertKeys(record3, path9, required, optional = []) {
   const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
-  const missing = required.find((key) => !Object.hasOwn(record2, key));
+  const missing = required.find((key) => !Object.hasOwn(record3, key));
   if (missing !== void 0) contractError(path9, `is missing ${missing}`);
-  const extra = Object.keys(record2).find((key) => !allowed.has(key));
+  const extra = Object.keys(record3).find((key) => !allowed.has(key));
   if (extra !== void 0) contractError(path9, `contains unexpected field ${extra}`);
 }
 function asString(value, path9, options) {
@@ -39307,97 +39568,97 @@ function asSha(value, path9) {
   if (!SHA_RE.test(sha)) contractError(path9, "must be a canonical lowercase Git commit SHA");
   return sha;
 }
-function optionalString(record2, key, path9, max) {
-  if (!Object.hasOwn(record2, key)) return void 0;
-  return asString(record2[key], `${path9}.${key}`, { max, nonempty: true });
+function optionalString(record3, key, path9, max) {
+  if (!Object.hasOwn(record3, key)) return void 0;
+  return asString(record3[key], `${path9}.${key}`, { max, nonempty: true });
 }
 function parseProposal(value, path9) {
-  const record2 = asRecord(value, path9);
+  const record3 = asRecord(value, path9);
   assertKeys(
-    record2,
+    record3,
     path9,
     ["_id", "repoFullName", "deadCommitSha", "status", "signals", "lastEvaluatedAt"],
     ["proposedSha", "proposedTier", "nextEvaluateAt"]
   );
-  const repoFullName = asString(record2.repoFullName, `${path9}.repoFullName`, {
+  const repoFullName = asString(record3.repoFullName, `${path9}.repoFullName`, {
     max: 200,
     nonempty: true
   });
   if (!REPO_FULL_NAME_RE.test(repoFullName)) {
     contractError(`${path9}.repoFullName`, "must be canonical owner/repository syntax");
   }
-  const status = record2.status;
+  const status = record3.status;
   if (status !== "proposed" && status !== "confirmed" && status !== "verification_failed") {
     contractError(`${path9}.status`, "is not a review-visible proposal status");
   }
-  if (!Array.isArray(record2.signals) || record2.signals.length > MAX_SIGNALS) {
+  if (!Array.isArray(record3.signals) || record3.signals.length > MAX_SIGNALS) {
     contractError(`${path9}.signals`, "must be a bounded array");
   }
-  const signals = record2.signals.map(
+  const signals = record3.signals.map(
     (signal, index) => asString(signal, `${path9}.signals[${String(index)}]`, {
       max: MAX_SIGNAL_LENGTH,
       nonempty: true
     })
   );
-  const proposedSha = Object.hasOwn(record2, "proposedSha") ? asSha(record2.proposedSha, `${path9}.proposedSha`) : void 0;
+  const proposedSha = Object.hasOwn(record3, "proposedSha") ? asSha(record3.proposedSha, `${path9}.proposedSha`) : void 0;
   let proposedTier;
-  if (Object.hasOwn(record2, "proposedTier")) {
-    if (record2.proposedTier !== "exact_patch_body" && record2.proposedTier !== "exact_file_set") {
+  if (Object.hasOwn(record3, "proposedTier")) {
+    if (record3.proposedTier !== "exact_patch_body" && record3.proposedTier !== "exact_file_set") {
       contractError(`${path9}.proposedTier`, "is not a supported match tier");
     }
-    proposedTier = record2.proposedTier;
+    proposedTier = record3.proposedTier;
   }
-  const nextEvaluateAt = Object.hasOwn(record2, "nextEvaluateAt") ? asTimestamp(record2.nextEvaluateAt, `${path9}.nextEvaluateAt`) : void 0;
+  const nextEvaluateAt = Object.hasOwn(record3, "nextEvaluateAt") ? asTimestamp(record3.nextEvaluateAt, `${path9}.nextEvaluateAt`) : void 0;
   return {
-    _id: asString(record2._id, `${path9}._id`, { max: 256, nonempty: true }),
+    _id: asString(record3._id, `${path9}._id`, { max: 256, nonempty: true }),
     repoFullName,
-    deadCommitSha: asSha(record2.deadCommitSha, `${path9}.deadCommitSha`),
+    deadCommitSha: asSha(record3.deadCommitSha, `${path9}.deadCommitSha`),
     status,
     proposedSha,
     proposedTier,
     signals,
-    lastEvaluatedAt: asTimestamp(record2.lastEvaluatedAt, `${path9}.lastEvaluatedAt`),
+    lastEvaluatedAt: asTimestamp(record3.lastEvaluatedAt, `${path9}.lastEvaluatedAt`),
     nextEvaluateAt
   };
 }
 function parseDecision(value, path9) {
-  const record2 = asRecord(value, path9);
-  assertKeys(record2, path9, ["_id", "intent", "status", "intentTruncated"], ["shortId"]);
-  const status = record2.status;
+  const record3 = asRecord(value, path9);
+  assertKeys(record3, path9, ["_id", "intent", "status", "intentTruncated"], ["shortId"]);
+  const status = record3.status;
   if (status !== "provisional" && status !== "abandoned") {
     contractError(`${path9}.status`, "is not a repairable decision status");
   }
   return {
-    _id: asString(record2._id, `${path9}._id`, { max: 256, nonempty: true }),
-    shortId: optionalString(record2, "shortId", path9, 128),
-    intent: asString(record2.intent, `${path9}.intent`, { max: MAX_INTENT_LENGTH }),
+    _id: asString(record3._id, `${path9}._id`, { max: 256, nonempty: true }),
+    shortId: optionalString(record3, "shortId", path9, 128),
+    intent: asString(record3.intent, `${path9}.intent`, { max: MAX_INTENT_LENGTH }),
     status,
-    intentTruncated: asBoolean(record2.intentTruncated, `${path9}.intentTruncated`)
+    intentTruncated: asBoolean(record3.intentTruncated, `${path9}.intentTruncated`)
   };
 }
 function parseListItem(value, path9) {
-  const record2 = asRecord(value, path9);
-  assertKeys(record2, path9, [
+  const record3 = asRecord(value, path9);
+  assertKeys(record3, path9, [
     "proposal",
     "decisions",
     "affectedDecisionCount",
     "decisionsTruncated",
     "reviewToken"
   ]);
-  if (!Array.isArray(record2.decisions) || record2.decisions.length > MAX_REPAIR_DECISIONS_FOR_CONFIRM) {
+  if (!Array.isArray(record3.decisions) || record3.decisions.length > MAX_REPAIR_DECISIONS_FOR_CONFIRM) {
     contractError(`${path9}.decisions`, "must be a bounded array");
   }
-  const decisions = record2.decisions.map(
+  const decisions = record3.decisions.map(
     (decision, index) => parseDecision(decision, `${path9}.decisions[${String(index)}]`)
   );
-  const proposal = parseProposal(record2.proposal, `${path9}.proposal`);
-  const decisionsTruncated = asBoolean(record2.decisionsTruncated, `${path9}.decisionsTruncated`);
-  const affectedDecisionCount = record2.affectedDecisionCount === null ? null : asCount(record2.affectedDecisionCount, `${path9}.affectedDecisionCount`);
+  const proposal = parseProposal(record3.proposal, `${path9}.proposal`);
+  const decisionsTruncated = asBoolean(record3.decisionsTruncated, `${path9}.decisionsTruncated`);
+  const affectedDecisionCount = record3.affectedDecisionCount === null ? null : asCount(record3.affectedDecisionCount, `${path9}.affectedDecisionCount`);
   let reviewToken;
-  if (record2.reviewToken === null) {
+  if (record3.reviewToken === null) {
     reviewToken = null;
   } else {
-    reviewToken = asString(record2.reviewToken, `${path9}.reviewToken`, {
+    reviewToken = asString(record3.reviewToken, `${path9}.reviewToken`, {
       max: 64,
       nonempty: true
     });
@@ -39430,19 +39691,19 @@ function parseListItem(value, path9) {
 }
 function parseListPage(value, pageNumber) {
   const path9 = `page ${String(pageNumber)}`;
-  const record2 = asRecord(value, path9);
-  assertKeys(record2, path9, ["repairs", "isDone", "nextCursor", "truncated"]);
-  if (!Array.isArray(record2.repairs) || record2.repairs.length > MAX_REPAIRS_PER_PAGE) {
+  const record3 = asRecord(value, path9);
+  assertKeys(record3, path9, ["repairs", "isDone", "nextCursor", "truncated"]);
+  if (!Array.isArray(record3.repairs) || record3.repairs.length > MAX_REPAIRS_PER_PAGE) {
     contractError(`${path9}.repairs`, "must be a bounded array");
   }
-  const isDone = asBoolean(record2.isDone, `${path9}.isDone`);
-  const truncated = asBoolean(record2.truncated, `${path9}.truncated`);
+  const isDone = asBoolean(record3.isDone, `${path9}.isDone`);
+  const truncated = asBoolean(record3.truncated, `${path9}.truncated`);
   if (truncated === isDone) contractError(path9, "has inconsistent isDone/truncated flags");
   let nextCursor;
-  if (record2.nextCursor === null) {
+  if (record3.nextCursor === null) {
     nextCursor = null;
   } else {
-    nextCursor = asString(record2.nextCursor, `${path9}.nextCursor`, {
+    nextCursor = asString(record3.nextCursor, `${path9}.nextCursor`, {
       max: MAX_CURSOR_LENGTH,
       nonempty: true
     });
@@ -39450,7 +39711,7 @@ function parseListPage(value, pageNumber) {
   if (isDone && nextCursor !== null) contractError(path9, "is done but includes a next cursor");
   if (!isDone && nextCursor === null) contractError(path9, "is incomplete without a next cursor");
   return {
-    repairs: record2.repairs.map(
+    repairs: record3.repairs.map(
       (item, index) => parseListItem(item, `${path9}.repairs[${String(index)}]`)
     ),
     isDone,
@@ -39528,23 +39789,23 @@ function normalizedResolutionInput(proposalId, expectedProposedSha) {
   return { proposalId, expectedProposedSha: expectedProposedSha.toLowerCase() };
 }
 function parseResolutionOutcome(value, action) {
-  const record2 = asRecord(value, "resolution response");
+  const record3 = asRecord(value, "resolution response");
   const allowed = action === "confirm" ? ["confirmed", "already_applied", "disabled", "no_op", "stale"] : ["rejected", "already_applied", "no_op", "stale"];
-  if (record2.status === "backoff") {
-    assertKeys(record2, "resolution response", ["status", "retryAt"]);
+  if (record3.status === "backoff") {
+    assertKeys(record3, "resolution response", ["status", "retryAt"]);
     if (action !== "confirm") {
       contractError("resolution response.status", "backoff is impossible for reject");
     }
     return {
       status: "backoff",
-      retryAt: asTimestamp(record2.retryAt, "resolution response.retryAt")
+      retryAt: asTimestamp(record3.retryAt, "resolution response.retryAt")
     };
   }
-  assertKeys(record2, "resolution response", ["status"]);
-  if (typeof record2.status !== "string" || !allowed.includes(record2.status)) {
+  assertKeys(record3, "resolution response", ["status"]);
+  if (typeof record3.status !== "string" || !allowed.includes(record3.status)) {
     contractError("resolution response.status", "is not a supported outcome");
   }
-  return { status: record2.status };
+  return { status: record3.status };
 }
 function normalizedReviewToken(value) {
   if (value === void 0 || !REVIEW_TOKEN_INPUT_RE.test(value)) {
@@ -39555,18 +39816,18 @@ function normalizedReviewToken(value) {
   return value.toLowerCase();
 }
 function parseConflictOutcome(value, action) {
-  const record2 = asRecord(value, "resolution conflict response");
-  assertKeys(record2, "resolution conflict response", ["status"]);
+  const record3 = asRecord(value, "resolution conflict response");
+  assertKeys(record3, "resolution conflict response", ["status"]);
   if (action !== "confirm") {
     contractError(
       "resolution conflict response.status",
       "a review conflict is impossible for reject"
     );
   }
-  if (record2.status !== "review_too_large" && record2.status !== "stale_review") {
+  if (record3.status !== "review_too_large" && record3.status !== "stale_review") {
     contractError("resolution conflict response.status", "is not a supported 409 outcome");
   }
-  return { status: record2.status };
+  return { status: record3.status };
 }
 async function resolveRepair(proposalId, expectedProposedSha, action, expectedReviewToken, deps = defaultDeps6) {
   const normalized = normalizedResolutionInput(proposalId, expectedProposedSha);
@@ -40708,7 +40969,7 @@ function registerDecisionsCommands(program3) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 
 // src/decisions/feedback.ts
 var FEEDBACK_PROTOCOL_VERSION = 2;
@@ -40757,28 +41018,35 @@ function parseOrganizationBinding(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return { state: "server_contract_unavailable" };
   }
-  const record2 = value;
-  if (record2.authenticated !== true || record2.organizationBindingVersion !== ORGANIZATION_BINDING_VERSION || !isCaptureAuthorityKind(record2.captureAuthorityKind)) {
+  const record3 = value;
+  if (record3.authenticated !== true || record3.organizationBindingVersion !== ORGANIZATION_BINDING_VERSION || !isCaptureAuthorityKind(record3.captureAuthorityKind)) {
     return { state: "server_contract_unavailable" };
   }
-  if (record2.organizationId === null && record2.workosOrganizationId === null) {
+  if (record3.organizationId === null && record3.workosOrganizationId === null) {
     return { state: "no_current_organization" };
   }
-  if (safeOrganizationId(record2.organizationId) && record2.workosOrganizationId === null) {
+  if (safeOrganizationId(record3.organizationId) && record3.workosOrganizationId === null) {
     return { state: "organization_identity_unreconciled" };
   }
-  if (!safeOrganizationId(record2.organizationId) || !safeOrganizationId(record2.workosOrganizationId)) {
+  if (!safeOrganizationId(record3.organizationId) || !safeOrganizationId(record3.workosOrganizationId)) {
     return { state: "server_contract_unavailable" };
   }
   return {
     state: "current",
     binding: {
-      captureAuthorityKind: record2.captureAuthorityKind,
-      organizationId: record2.organizationId,
-      workosOrganizationId: record2.workosOrganizationId
+      captureAuthorityKind: record3.captureAuthorityKind,
+      organizationId: record3.organizationId,
+      workosOrganizationId: record3.workosOrganizationId
     }
   };
 }
+function summarizeRetainedBuckets(retained) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of retained) {
+    counts.set(item.reason, (counts.get(item.reason) ?? 0) + 1);
+  }
+  return [...counts].sort(([left], [right]) => left.localeCompare(right)).map(([reason, count]) => `${reason}:${String(count)}`).join(", ");
+}
 function classifyJournalBuckets(buckets, binding) {
   const deliverableBuckets = /* @__PURE__ */ new Set();
   const retainedBuckets = [];
@@ -40852,18 +41120,109 @@ async function inspectJournalDelivery(buckets, options = {}) {
 // src/journal.ts
 import {
   appendFileSync,
-  closeSync as closeSync4,
-  existsSync as existsSync13,
-  fstatSync,
+  closeSync as closeSync5,
+  existsSync as existsSync14,
+  fstatSync as fstatSync2,
   mkdirSync as mkdirSync10,
-  openSync as openSync4,
+  openSync as openSync5,
   opendirSync,
+  readFileSync as readFileSync15,
+  readSync as readSync2,
+  readdirSync as readdirSync5
+} from "fs";
+import { dirname as dirname12, join as join18 } from "path";
+
+// src/drain-progress.ts
+import {
+  chmodSync as chmodSync5,
+  existsSync as existsSync13,
   readFileSync as readFileSync14,
-  readSync,
-  readdirSync as readdirSync4
+  readdirSync as readdirSync4,
+  rmSync as rmSync6,
+  rmdirSync
 } from "fs";
-import { dirname as dirname11, join as join17 } from "path";
-var JOURNAL_DIR = join17(primConfigDirectory(), "moves");
+import { basename as basename4, dirname as dirname11, join as join17 } from "path";
+var DIRECTORY_MODE3 = 448;
+var FILE_MODE2 = 384;
+var DRAIN_PROGRESS_DIRNAME = "drain-progress";
+var CHECKPOINT_NAME = /^(.+)\.json(?:\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.tmp)?$/;
+function rotationIdentity(stat) {
+  return { size: stat.size, ino: stat.ino, dev: stat.dev };
+}
+function drainProgressDirectory(flushingPath) {
+  return join17(dirname11(flushingPath), DRAIN_PROGRESS_DIRNAME);
+}
+function drainProgressPath(flushingPath) {
+  return join17(drainProgressDirectory(flushingPath), `${basename4(flushingPath)}.json`);
+}
+function isByteCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function drainResumeOffset(flushingPath, rotation) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync14(drainProgressPath(flushingPath), "utf8"));
+  } catch {
+    return 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return 0;
+  }
+  const { v, offset, size, ino, dev } = parsed;
+  if (v !== 2 || ino !== rotation.ino || dev !== rotation.dev || size !== rotation.size || !isByteCount(offset) || offset > rotation.size) {
+    return 0;
+  }
+  return offset;
+}
+function writeDrainCheckpoint(flushingPath, checkpoint) {
+  const directory = drainProgressDirectory(flushingPath);
+  ensureDurableDirectory(directory, DIRECTORY_MODE3);
+  chmodSync5(directory, DIRECTORY_MODE3);
+  atomicWriteFile(drainProgressPath(flushingPath), `${JSON.stringify(checkpoint)}
+`, {
+    mode: FILE_MODE2
+  });
+}
+function removeEmptyDirectory(directory) {
+  try {
+    rmdirSync(directory);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+function removeDrainCheckpoint(flushingPath) {
+  rmSync6(drainProgressPath(flushingPath), { force: true });
+  removeEmptyDirectory(drainProgressDirectory(flushingPath));
+}
+function sweepOrphanedDrainCheckpoints(bucketDirectory) {
+  const directory = join17(bucketDirectory, DRAIN_PROGRESS_DIRNAME);
+  let names;
+  try {
+    names = readdirSync4(directory);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const rotation = CHECKPOINT_NAME.exec(name)?.[1];
+    if (rotation === void 0 || existsSync13(join17(bucketDirectory, rotation))) {
+      continue;
+    }
+    try {
+      rmSync6(join17(directory, name), { force: true });
+    } catch {
+    }
+  }
+  try {
+    removeEmptyDirectory(directory);
+  } catch {
+  }
+}
+
+// src/journal.ts
+var JOURNAL_DIR = join18(primConfigDirectory(), "moves");
 var JOURNAL_BASENAME = "journal.ndjson";
 var JOURNAL_STATS_SAMPLE_BYTES = 64 * 1024;
 var PENDING_STATS_MAX_FILES = 128;
@@ -40875,7 +41234,7 @@ function envSlug(apiUrl) {
   return slug;
 }
 function currentEnvDir() {
-  return join17(JOURNAL_DIR, envSlug(getSiteUrl()));
+  return join18(JOURNAL_DIR, envSlug(getSiteUrl()));
 }
 function parseMoves(content) {
   const moves = [];
@@ -40891,23 +41250,23 @@ function parseMoves(content) {
   return moves;
 }
 function readMovesFromPath(path9) {
-  if (!existsSync13(path9)) {
+  if (!existsSync14(path9)) {
     return [];
   }
-  return parseMoves(readFileSync14(path9, "utf-8"));
+  return parseMoves(readFileSync15(path9, "utf-8"));
 }
 function listBuckets() {
   const out = [];
   const envDir = currentEnvDir();
-  if (!existsSync13(envDir)) {
+  if (!existsSync14(envDir)) {
     return out;
   }
-  for (const entry of readdirSync4(envDir, { withFileTypes: true })) {
+  for (const entry of readdirSync5(envDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const path9 = join17(envDir, entry.name, JOURNAL_BASENAME);
-    if (existsSync13(path9)) {
+    const path9 = join18(envDir, entry.name, JOURNAL_BASENAME);
+    if (existsSync14(path9)) {
       out.push({ bucket: entry.name, path: path9 });
     }
   }
@@ -40924,22 +41283,23 @@ function oldestCapturedAt(moves) {
   }
   return oldest;
 }
-function sampleJournalFile(path9, maxBytes = JOURNAL_STATS_SAMPLE_BYTES) {
-  const fd = openSync4(path9, "r");
+function sampleJournalFile(path9, maxBytes = JOURNAL_STATS_SAMPLE_BYTES, options = {}) {
+  const fd = openSync5(path9, "r");
   try {
-    const initial = fstatSync(fd);
-    const target = Math.min(initial.size, Math.max(0, maxBytes));
+    const initial = fstatSync2(fd);
+    const start = options.fromDrainCheckpoint ? drainResumeOffset(path9, rotationIdentity(initial)) : 0;
+    const target = Math.min(initial.size - start, Math.max(0, maxBytes));
     const buffer = Buffer.allocUnsafe(target);
     let sampledBytes = 0;
     while (sampledBytes < target) {
-      const count = readSync(fd, buffer, sampledBytes, target - sampledBytes, sampledBytes);
+      const count = readSync2(fd, buffer, sampledBytes, target - sampledBytes, start + sampledBytes);
       if (count === 0) {
         break;
       }
       sampledBytes += count;
     }
-    const stat = fstatSync(fd);
-    const sampled = stat.size > sampledBytes;
+    const stat = fstatSync2(fd);
+    const sampled = stat.size - start > sampledBytes;
     let content = buffer.subarray(0, sampledBytes).toString("utf-8");
     if (sampled) {
       const lastNewline = content.lastIndexOf("\n");
@@ -40949,6 +41309,7 @@ function sampleJournalFile(path9, maxBytes = JOURNAL_STATS_SAMPLE_BYTES) {
     const moves = parseMoves(content);
     return {
       sizeBytes: stat.size,
+      pendingBytes: Math.max(0, stat.size - start),
       mtimeMs: stat.mtimeMs,
       lineCount: sampled && stat.size > 0 ? Math.max(1, lines.length) : lines.length,
       oldestCapturedAt: oldestCapturedAt(moves),
@@ -40956,7 +41317,7 @@ function sampleJournalFile(path9, maxBytes = JOURNAL_STATS_SAMPLE_BYTES) {
       sampledBytes
     };
   } finally {
-    closeSync4(fd);
+    closeSync5(fd);
   }
 }
 function parseFlushingPid(name) {
@@ -40967,7 +41328,7 @@ function parseFlushingPid(name) {
   return Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
 }
 function listFlushingInDir(dir, bucket, options = {}) {
-  if (!existsSync13(dir)) {
+  if (!existsSync14(dir)) {
     return [];
   }
   const out = [];
@@ -40981,10 +41342,10 @@ function listFlushingInDir(dir, bucket, options = {}) {
         entry = entries.readSync();
         continue;
       }
-      const path9 = join17(dir, entry.name);
+      const path9 = join18(dir, entry.name);
       let sample;
       try {
-        sample = sampleJournalFile(path9, remainingBytes);
+        sample = sampleJournalFile(path9, remainingBytes, { fromDrainCheckpoint: true });
       } catch (err) {
         if (err.code === "ENOENT") {
           entry = entries.readSync();
@@ -41008,18 +41369,18 @@ function listFlushingInDir(dir, bucket, options = {}) {
 }
 function listFlushing(options = {}) {
   const envDir = currentEnvDir();
-  if (!existsSync13(envDir)) {
+  if (!existsSync14(envDir)) {
     return [];
   }
   const out = [];
   let remainingBytes = options.sampleBytes ?? JOURNAL_STATS_SAMPLE_BYTES;
   const maxFiles = options.maxFiles ?? Number.POSITIVE_INFINITY;
-  for (const entry of readdirSync4(envDir, { withFileTypes: true })) {
+  for (const entry of readdirSync5(envDir, { withFileTypes: true })) {
     if (out.length >= maxFiles) {
       break;
     }
     if (entry.isDirectory()) {
-      const found = listFlushingInDir(join17(envDir, entry.name), entry.name, {
+      const found = listFlushingInDir(join18(envDir, entry.name), entry.name, {
         sampleBytes: remainingBytes,
         maxFiles: maxFiles - out.length
       });
@@ -41032,6 +41393,17 @@ function listFlushing(options = {}) {
   }
   return out;
 }
+function sweepOrphanedDrainProgress() {
+  const envDir = currentEnvDir();
+  if (!existsSync14(envDir)) {
+    return;
+  }
+  for (const entry of readdirSync5(envDir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      sweepOrphanedDrainCheckpoints(join18(envDir, entry.name));
+    }
+  }
+}
 function bucketStats(options = {}) {
   const out = [];
   let remainingBytes = options.sampleBytes ?? JOURNAL_STATS_SAMPLE_BYTES;
@@ -41077,9 +41449,9 @@ function pendingJournalStats() {
 }
 
 // src/commands/hermes-install.ts
-import { existsSync as existsSync14, readFileSync as readFileSync15, rmSync as rmSync6, statSync as statSync3 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync16, rmSync as rmSync7, statSync as statSync4 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/browser/dist/nodes/identity.js
 var ALIAS = /* @__PURE__ */ Symbol.for("yaml.alias");
@@ -47358,13 +47730,13 @@ var JSON_INDENT3 = 2;
 var CONFIG_MODE = 384;
 var PRIM_BINS4 = [CAPTURE_BIN4, GATE_BIN4, POST_TOOL_USE_BIN3, SESSION_START_BIN4, SESSION_END_BIN3];
 function hermesHome() {
-  return process.env.HERMES_HOME ?? join18(homedir9(), ".hermes");
+  return process.env.HERMES_HOME ?? join19(homedir9(), ".hermes");
 }
 function configPath() {
-  return join18(hermesHome(), "config.yaml");
+  return join19(hermesHome(), "config.yaml");
 }
 function legacyShimPath() {
-  return join18(hermesHome(), "agent-hooks", "prim-shim.sh");
+  return join19(hermesHome(), "agent-hooks", "prim-shim.sh");
 }
 function commandFor2(bin) {
   return stableHookCommand(bin, HERMES_ARGS);
@@ -47478,8 +47850,8 @@ function hookRuntimeResolutions3(hooks) {
 }
 function inspectHookRuntimeResolutions4() {
   const path9 = configPath();
-  if (!existsSync14(path9)) return [];
-  return hookRuntimeResolutions3(readHooks(parseHermesDocument(readFileSync15(path9, "utf8"))));
+  if (!existsSync15(path9)) return [];
+  return hookRuntimeResolutions3(readHooks(parseHermesDocument(readFileSync16(path9, "utf8"))));
 }
 function entryMatchesRegistration3(owned, registration) {
   const expected = entryFor(registration);
@@ -47748,11 +48120,11 @@ function assertMergeValid(before, after, expectedHooks) {
   }
 }
 function readConfigSnapshot(path9) {
-  if (!existsSync14(path9)) return { exists: false, mode: CONFIG_MODE, raw: "" };
+  if (!existsSync15(path9)) return { exists: false, mode: CONFIG_MODE, raw: "" };
   return {
     exists: true,
-    mode: statSync3(path9).mode & 511,
-    raw: readFileSync15(path9, "utf8")
+    mode: statSync4(path9).mode & 511,
+    raw: readFileSync16(path9, "utf8")
   };
 }
 var CONCURRENT_CONFIG_MESSAGE = "Hermes config changed during update; concurrent changes were preserved, retry the command";
@@ -47761,7 +48133,7 @@ function writeHermesConfigSnapshot(path9, before, after, expectedHooks) {
     ensureParent: true,
     mode: before.mode,
     validate(temporaryPath) {
-      const flushed = readFileSync15(temporaryPath, "utf8");
+      const flushed = readFileSync16(temporaryPath, "utf8");
       if (!mergePreservesHermesSemantics(before.raw, flushed, expectedHooks)) {
         throw new Error(INVALID_MERGE_MESSAGE);
       }
@@ -47773,7 +48145,7 @@ function writeHermesConfigSnapshot(path9, before, after, expectedHooks) {
   });
 }
 function removeLegacyShim() {
-  rmSync6(legacyShimPath(), { force: true });
+  rmSync7(legacyShimPath(), { force: true });
 }
 function autoAcceptOf(raw) {
   if (raw.trim().length === 0) {
@@ -47814,7 +48186,7 @@ function performInstall4(opts) {
 }
 function performUninstall4() {
   const path9 = configPath();
-  if (!existsSync14(path9)) {
+  if (!existsSync15(path9)) {
     removeLegacyShim();
     return { path: path9, gate: false, capture: false, autoAccept: false, changed: false };
   }
@@ -47839,7 +48211,7 @@ function performUninstall4() {
 }
 function performStatus4() {
   const path9 = configPath();
-  const raw = existsSync14(path9) ? readFileSync15(path9, "utf8") : "";
+  const raw = existsSync15(path9) ? readFileSync16(path9, "utf8") : "";
   const hooks = raw ? readHooks(parseHermesDocument(raw)) : {};
   return {
     path: path9,
@@ -47893,7 +48265,6 @@ function registerHermesCommands(program3) {
 // src/commands/doctor.ts
 var DAEMON_PROBE_TIMEOUT_MS2 = 500;
 var CONNECTIVITY_TIMEOUT_MS = 3e3;
-var MS_PER_SECOND = 1e3;
 var STALE_PENDING_MS = 3e4;
 var EXIT_UNHEALTHY = 1;
 function classifyDoctor(checks) {
@@ -47929,7 +48300,7 @@ function checkAuth() {
   return classifyAuthCredential(
     credential,
     storedCredential ? getTokenExpiresAt() : void 0,
-    storedCredential && existsSync15(REFRESH_TOKEN_PATH)
+    storedCredential && existsSync16(REFRESH_TOKEN_PATH)
   );
 }
 function classifyDaemonHealth(snapshot, options = {}) {
@@ -48015,8 +48386,19 @@ function classifyDaemonHealth(snapshot, options = {}) {
     };
   }
   if (!snapshot.ingestion?.healthy) {
-    const pending = snapshot.ingestion?.pendingCount ?? 0;
-    const pendingLabel = snapshot.ingestion?.pendingSampled ? `at least ${String(pending)}` : String(pending);
+    if (options.backlogExpected && deliveryBacklogState(snapshot.ingestion) === "draining") {
+      const ingestionStatus2 = options.ingestionStatus ?? decisionIngestionStatus(process.cwd());
+      const live = options.backlog;
+      const progress = live && live.pendingCount === 0 && live.pendingSampled !== true ? "backlog drained; daemon health refreshes on its next sweep" : deliveryBacklogSummary(snapshot.ingestion, options.now, live);
+      return {
+        name: "daemon",
+        status: "warn",
+        detail: `supervised and live${snapshot.version ? ` \xB7 v${snapshot.version}` : ""} \xB7 Decision ingestion ${ingestionStatus2} \xB7 ${progress}`
+      };
+    }
+    const counts = options.backlog ?? snapshot.ingestion;
+    const pending = counts?.pendingCount ?? 0;
+    const pendingLabel = counts?.pendingSampled ? `at least ${String(pending)}` : String(pending);
     return {
       name: "daemon",
       status: "fail",
@@ -48033,17 +48415,23 @@ function classifyDaemonHealth(snapshot, options = {}) {
     detail: `supervised and healthy${snapshot.version ? ` \xB7 v${snapshot.version}` : ""} \xB7 Decision ingestion ${ingestionStatus}`
   };
 }
-async function checkDaemon() {
+async function probeDelivery() {
+  const stats = pendingJournalStats();
+  const now = Date.now();
+  const disabled = daemonExplicitlyDisabled();
+  const expectedVersion = packageVersion();
   let service;
   if (process.platform === "darwin") {
     try {
       service = getLaunchdService();
     } catch (error) {
-      const detail = boundedHealthError(error instanceof Error ? error.message : String(error));
       return {
-        name: "daemon",
-        status: "fail",
-        detail: `launchd status unavailable${detail ? `: ${detail}` : ""}`
+        snapshot: null,
+        launchdError: error instanceof Error ? error.message : String(error),
+        disabled,
+        expectedVersion,
+        stats,
+        now
       };
     }
   }
@@ -48052,53 +48440,74 @@ async function checkDaemon() {
     { callerEnv: getSiteUrl() },
     { timeoutMs: DAEMON_PROBE_TIMEOUT_MS2 }
   );
-  return classifyDaemonHealth(snapshot, {
-    disabled: daemonExplicitlyDisabled(),
-    service,
-    expectedVersion: packageVersion()
+  return { snapshot, service, disabled, expectedVersion, stats, now };
+}
+function daemonCheckVouchesForDrain(check) {
+  return check.name === "daemon" && check.status !== "fail";
+}
+function classifyDelivery(probe, options = {}) {
+  const { stats, now } = probe;
+  const launchdDetail = probe.launchdError === void 0 ? void 0 : boundedHealthError(probe.launchdError);
+  const daemon = probe.launchdError === void 0 ? classifyDaemonHealth(probe.snapshot, {
+    disabled: probe.disabled,
+    service: probe.service,
+    ingestionStatus: probe.ingestionStatus,
+    expectedVersion: probe.expectedVersion,
+    backlogExpected: options.backlogExpected,
+    backlog: {
+      pendingCount: stats.pendingCount,
+      pendingSampled: stats.sampled,
+      oldestPendingAt: stats.oldestPendingAt
+    },
+    now
+  }) : {
+    name: "daemon",
+    status: "fail",
+    detail: `launchd status unavailable${launchdDetail ? `: ${launchdDetail}` : ""}`
+  };
+  const journal = classifyJournal(stats, now, {
+    backlogExpected: options.backlogExpected === true && daemonCheckVouchesForDrain(daemon)
   });
+  return [daemon, journal, classifyStranded(stats)];
 }
-function checkJournal() {
-  const stats = pendingJournalStats();
+function classifyJournal(stats, now, options = {}) {
   const pending = stats.pendingCount;
   const pendingLabel = stats.sampled ? `at least ${String(pending)}` : String(pending);
+  const backlog = (detail) => options.backlogExpected ? {
+    name: "journal",
+    status: "warn",
+    detail: `${formatPendingBacklog(
+      {
+        pendingCount: pending,
+        pendingSampled: stats.sampled,
+        oldestPendingAt: stats.oldestPendingAt
+      },
+      now
+    )} \u2014 draining in the background`
+  } : { name: "journal", status: "fail", detail };
   if (pending === 0) {
     if (stats.sampled) {
-      return {
-        name: "journal",
-        status: "fail",
-        detail: "bounded journal sample could not prove the queue is empty"
-      };
+      return backlog("bounded journal sample could not prove the queue is empty");
     }
     return { name: "journal", status: "ok", detail: "no pending moves" };
   }
   if (stats.oldestPendingAt === void 0) {
-    return {
-      name: "journal",
-      status: "fail",
-      detail: `${pendingLabel} pending with no readable capture timestamp`
-    };
+    const detail = `${pendingLabel} pending with no readable capture timestamp`;
+    return stats.sampled ? backlog(detail) : { name: "journal", status: "fail", detail };
   }
-  const oldestMs = Date.now() - stats.oldestPendingAt;
+  const oldestMs = now - stats.oldestPendingAt;
   const oldestS = Math.round(oldestMs / MS_PER_SECOND);
   if (oldestMs > STALE_PENDING_MS) {
-    return {
-      name: "journal",
-      status: "fail",
-      detail: `${pendingLabel} pending, oldest observed ${String(oldestS)}s \u2014 30s delivery SLA missed`
-    };
+    return backlog(
+      `${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 backlog(`${pendingLabel} pending in bounded sample; 30s delivery SLA cannot be proven`);
   }
   return { name: "journal", status: "ok", detail: `${String(pending)} pending, draining` };
 }
-function checkStranded() {
-  const stats = pendingJournalStats();
+function classifyStranded(stats) {
   if (stats.strandedFileCount === 0 && !stats.strandedSampled) {
     return { name: "stranded", status: "ok", detail: "none" };
   }
@@ -48124,15 +48533,10 @@ function classifyJournalOrganization(bucketCount, retainedBuckets) {
       detail: "all pending buckets match the active credential"
     };
   }
-  const reasonCounts = /* @__PURE__ */ new Map();
-  for (const item of retainedBuckets) {
-    reasonCounts.set(item.reason, (reasonCounts.get(item.reason) ?? 0) + 1);
-  }
-  const reasons = [...reasonCounts].sort(([left], [right]) => left.localeCompare(right)).map(([reason, count]) => `${reason}:${String(count)}`).join(", ");
   return {
     name: "journal-org",
     status: "fail",
-    detail: `${String(retainedBuckets.length)} bucket(s) retained (${reasons})`
+    detail: `${String(retainedBuckets.length)} bucket(s) retained (${summarizeRetainedBuckets(retainedBuckets)})`
   };
 }
 async function checkJournalOrganization() {
@@ -48543,30 +48947,37 @@ function refreshOwnedGlobalHooksForHealth() {
   } catch {
   }
 }
-async function collectChecks() {
+async function independentChecks() {
   refreshOwnedGlobalHooksForHealth();
   const backend = await checkBackend();
-  return [
-    checkAuth(),
-    await checkDaemon(),
-    checkJournal(),
-    checkStranded(),
-    await checkJournalOrganization(),
-    checkFeedbackHooks(),
-    ...checkAgentHooks(),
-    checkHookRuntime(),
-    await checkRepositoryBinding(),
-    checkManagedHook("post-commit", inspectEffectivePostCommitHook),
-    checkManagedHook("post-rewrite", inspectEffectivePostRewriteHook),
-    ...backend,
-    await checkFeedbackCapability()
-  ];
+  return {
+    before: [checkAuth()],
+    after: [
+      await checkJournalOrganization(),
+      checkFeedbackHooks(),
+      ...checkAgentHooks(),
+      checkHookRuntime(),
+      await checkRepositoryBinding(),
+      checkManagedHook("post-commit", inspectEffectivePostCommitHook),
+      checkManagedHook("post-rewrite", inspectEffectivePostRewriteHook),
+      ...backend,
+      await checkFeedbackCapability()
+    ]
+  };
+}
+var DEFAULT_DOCTOR_PROBES = {
+  delivery: probeDelivery,
+  independent: independentChecks
+};
+async function collectChecks(options, probes) {
+  const { before, after } = await probes.independent();
+  return [...before, ...classifyDelivery(await probes.delivery(), options), ...after];
 }
 function icon(status) {
   return status === "ok" ? "\u2713" : status === "warn" ? "\u26A0" : "\u2717";
 }
-async function runDoctor() {
-  const checks = await collectChecks();
+async function runDoctor(options, probes) {
+  const checks = await collectChecks(options, probes);
   const { json, exitCode } = classifyDoctor(checks);
   const headline = json.status === "ok" ? "\u2713 healthy" : json.status === "warn" ? "\u26A0 degraded" : "\u2717 unhealthy";
   process.stderr.write(`[prim] doctor: ${headline}
@@ -48580,101 +48991,104 @@ async function runDoctor() {
     process.exitCode = exitCode;
   }
 }
-function registerDoctorCommands(program3) {
+function registerDoctorCommands(program3, dependencies = {}) {
   program3.command("doctor").description(
     "Check capture and feedback health end to end (auth, supervisor, delivery, server)"
-  ).action(async () => {
-    await runDoctor();
+  ).addOption(new Option("--expect-backlog").hideHelp()).action(async (opts) => {
+    await runDoctor(
+      { backlogExpected: opts.expectBacklog === true },
+      dependencies.probes ?? DEFAULT_DOCTOR_PROBES
+    );
   });
 }
 
 // src/commands/moves.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync12, unlinkSync as unlinkSync5, writeFileSync as writeFileSync9 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync12, unlinkSync as unlinkSync5, writeFileSync as writeFileSync9 } from "fs";
+import { join as join22 } from "path";
 
 // src/flusher.ts
-import { createReadStream, renameSync as renameSync6, unlinkSync as unlinkSync4 } from "fs";
-import { dirname as dirname13, join as join20 } from "path";
+import { createReadStream, renameSync as renameSync6, statSync as statSync5, unlinkSync as unlinkSync4 } from "fs";
+import { dirname as dirname14, join as join21 } from "path";
 
 // src/dead-letter.ts
 import { createHash as createHash9, randomBytes as randomBytes6 } from "crypto";
 import {
-  constants as constants5,
-  chmodSync as chmodSync5,
-  closeSync as closeSync5,
-  existsSync as existsSync16,
+  constants as constants6,
+  chmodSync as chmodSync6,
+  closeSync as closeSync6,
+  existsSync as existsSync17,
   fchmodSync as fchmodSync3,
   fsyncSync as fsyncSync3,
   mkdirSync as mkdirSync11,
-  openSync as openSync5,
+  openSync as openSync6,
   renameSync as renameSync5,
-  rmSync as rmSync7,
+  rmSync as rmSync8,
   writeFileSync as writeFileSync8
 } from "fs";
-import { dirname as dirname12, join as join19 } from "path";
-var DIRECTORY_MODE3 = 448;
-var FILE_MODE2 = 384;
+import { dirname as dirname13, join as join20 } from "path";
+var DIRECTORY_MODE4 = 448;
+var FILE_MODE3 = 384;
 var DEAD_LETTER_DIRNAME = "dead-letter";
 function deadLetterDirectoryForRotation(flushingPath) {
-  return join19(dirname12(flushingPath), DEAD_LETTER_DIRNAME);
+  return join20(dirname13(flushingPath), DEAD_LETTER_DIRNAME);
 }
 function deadLetterPathForRawLine(flushingPath, rawLine) {
   const quarantineId = createHash9("sha256").update(rawLine).digest("hex");
-  return join19(deadLetterDirectoryForRotation(flushingPath), `raw-${quarantineId}.json`);
+  return join20(deadLetterDirectoryForRotation(flushingPath), `raw-${quarantineId}.json`);
 }
 function ensureDeadLetterDirectory(flushingPath, persistDirectory) {
   const directory = deadLetterDirectoryForRotation(flushingPath);
-  mkdirSync11(directory, { recursive: true, mode: DIRECTORY_MODE3 });
-  chmodSync5(directory, DIRECTORY_MODE3);
-  persistDirectory(dirname12(directory));
+  mkdirSync11(directory, { recursive: true, mode: DIRECTORY_MODE4 });
+  chmodSync6(directory, DIRECTORY_MODE4);
+  persistDirectory(dirname13(directory));
   return directory;
 }
-function persistDeadLetter(directory, path9, quarantineId, record2, persistDirectory) {
-  if (existsSync16(path9)) {
+function persistDeadLetter(directory, path9, quarantineId, record3, persistDirectory) {
+  if (existsSync17(path9)) {
     persistDirectory(directory);
     return;
   }
-  const temporaryPath = join19(
+  const temporaryPath = join20(
     directory,
     `.${quarantineId}.${String(process.pid)}.${randomBytes6(8).toString("hex")}.tmp`
   );
-  const flags = constants5.O_CREAT | constants5.O_EXCL | constants5.O_WRONLY | constants5.O_NOFOLLOW;
+  const flags = constants6.O_CREAT | constants6.O_EXCL | constants6.O_WRONLY | constants6.O_NOFOLLOW;
   try {
-    const fd = openSync5(temporaryPath, flags, FILE_MODE2);
+    const fd = openSync6(temporaryPath, flags, FILE_MODE3);
     try {
-      fchmodSync3(fd, FILE_MODE2);
-      writeFileSync8(fd, `${JSON.stringify(record2)}
+      fchmodSync3(fd, FILE_MODE3);
+      writeFileSync8(fd, `${JSON.stringify(record3)}
 `, "utf8");
       fsyncSync3(fd);
     } finally {
-      closeSync5(fd);
+      closeSync6(fd);
     }
     renameSync5(temporaryPath, path9);
     persistDirectory(directory);
   } finally {
-    rmSync7(temporaryPath, { force: true });
+    rmSync8(temporaryPath, { force: true });
   }
 }
 function quarantineMove(flushingPath, move, reason, now = Date.now, options = {}) {
   const persistDirectory = options.syncDirectory ?? syncDirectory;
   const directory = ensureDeadLetterDirectory(flushingPath, persistDirectory);
   const serializedMove = JSON.stringify(move);
-  const record2 = {
+  const record3 = {
     version: 1,
     quarantineId: createHash9("sha256").update(serializedMove).digest("hex"),
     quarantinedAt: now(),
     reason,
     move
   };
-  const path9 = join19(directory, `${record2.quarantineId}.json`);
-  persistDeadLetter(directory, path9, record2.quarantineId, record2, persistDirectory);
-  return record2;
+  const path9 = join20(directory, `${record3.quarantineId}.json`);
+  persistDeadLetter(directory, path9, record3.quarantineId, record3, persistDirectory);
+  return record3;
 }
 function quarantineRawLine(flushingPath, rawLine, now = Date.now, options = {}) {
   const persistDirectory = options.syncDirectory ?? syncDirectory;
   const directory = ensureDeadLetterDirectory(flushingPath, persistDirectory);
   const bytes = Buffer.from(rawLine);
-  const record2 = {
+  const record3 = {
     version: 1,
     recordKind: "raw_line_v1",
     quarantineId: createHash9("sha256").update(bytes).digest("hex"),
@@ -48687,11 +49101,11 @@ function quarantineRawLine(flushingPath, rawLine, now = Date.now, options = {})
   persistDeadLetter(
     directory,
     deadLetterPathForRawLine(flushingPath, bytes),
-    record2.quarantineId,
-    record2,
+    record3.quarantineId,
+    record3,
     persistDirectory
   );
-  return record2;
+  return record3;
 }
 
 // src/ingest-response.ts
@@ -48725,9 +49139,13 @@ function requireDurableIngestAcknowledgement(value, expected, cwd = process.cwd(
 
 // src/flusher.ts
 var BATCH_SIZE = 500;
+var BATCH_MAX_BYTES = 1048576;
 var HTTP_TIMEOUT_MS = 1e4;
 var OPPORTUNISTIC_FLUSH_AFTER_MS = 6e4;
 var ORPHAN_QUARANTINE_MS = 6e4;
+function exceedsBatchBytes(count, bytes, nextBytes, maxBytes) {
+  return count > 0 && bytes + nextBytes > maxBytes;
+}
 function addDrainCounts(left, right) {
   return {
     flushed: left.flushed + right.flushed,
@@ -48738,8 +49156,8 @@ function collectionScopeRoots(batch) {
   return batch.flatMap((move) => {
     const env4 = move.env;
     if (typeof env4 !== "object" || env4 === null || Array.isArray(env4)) return [];
-    const record2 = env4;
-    const root = typeof record2.gitRoot === "string" ? record2.gitRoot : record2.cwd;
+    const record3 = env4;
+    const root = typeof record3.gitRoot === "string" ? record3.gitRoot : record3.cwd;
     return typeof root === "string" && root.length > 0 ? [root] : [];
   });
 }
@@ -48747,8 +49165,8 @@ function isVersionedInvalidMoveDisposition(body) {
   if (typeof body !== "object" || body === null || Array.isArray(body)) {
     return false;
   }
-  const record2 = body;
-  return Object.keys(record2).length === 2 && record2.error === "invalid_move" && record2.errorVersion === 1;
+  const record3 = body;
+  return Object.keys(record3).length === 2 && record3.error === "invalid_move" && record3.errorVersion === 1;
 }
 function deadLetterReason(error) {
   if (error instanceof InvalidJournalEnvelopeError) {
@@ -48771,23 +49189,31 @@ function deadLetterReason(error) {
   }
   return void 0;
 }
-async function* rawJournalLines(input) {
+function mayBeBatchSizeFailure(error) {
+  if (error instanceof HttpError) {
+    return error.status >= 500 && error.status !== 503;
+  }
+  return error instanceof Error && error.name === "TimeoutError";
+}
+async function* rawJournalLines(input, offset) {
   let pending = [];
   let pendingBytes = 0;
+  let end = offset;
   for await (const value of input) {
     const chunk2 = Buffer.isBuffer(value) ? value : Buffer.from(value);
     let start = 0;
     let newline = chunk2.indexOf(10, start);
     while (newline !== -1) {
       const tail = chunk2.subarray(start, newline + 1);
-      if (pending.length === 0) {
-        yield tail;
-      } else {
+      let line = tail;
+      if (pending.length > 0) {
         pending.push(tail);
-        yield Buffer.concat(pending, pendingBytes + tail.length);
+        line = Buffer.concat(pending, pendingBytes + tail.length);
         pending = [];
         pendingBytes = 0;
       }
+      end += line.length;
+      yield { bytes: line, end };
       start = newline + 1;
       newline = chunk2.indexOf(10, start);
     }
@@ -48798,21 +49224,46 @@ async function* rawJournalLines(input) {
     }
   }
   if (pendingBytes > 0) {
-    yield pending.length === 1 ? pending[0] : Buffer.concat(pending, pendingBytes);
+    const bytes = pending.length === 1 ? pending[0] : Buffer.concat(pending, pendingBytes);
+    yield { bytes, end: end + pendingBytes };
   }
 }
+var drainProgressWarned = false;
 async function drainFlushingPath(flushingPath, client, binding, options = {}) {
+  const rotation = rotationIdentity(statSync5(flushingPath));
+  const resumeAt = drainResumeOffset(flushingPath, rotation);
+  const recordProgress = (end) => {
+    if (end === void 0 || end >= rotation.size) {
+      return;
+    }
+    try {
+      writeDrainCheckpoint(flushingPath, { v: 2, offset: end, ...rotation });
+      drainProgressWarned = false;
+    } catch (error) {
+      if (!drainProgressWarned) {
+        drainProgressWarned = true;
+        process.stderr.write(
+          `[prim] could not record drain progress: ${error instanceof Error ? error.message : String(error)}
+`
+        );
+      }
+    }
+  };
+  const reportProgress = (delta) => {
+    options.onProgress?.(delta);
+    return delta;
+  };
   const postBatch = async (batch2) => {
+    const moves = batch2.map((entry) => entry.move);
     try {
-      const request2 = buildOrganizationBoundMoveRequest(batch2, binding);
+      const request2 = buildOrganizationBoundMoveRequest(moves, binding);
       const response = await client.post("/api/cli/moves/ingest", request2, {
         signal: AbortSignal.timeout(HTTP_TIMEOUT_MS)
       });
-      requireDurableIngestAcknowledgement(response, batch2.length, collectionScopeRoots(batch2));
-      return { flushed: batch2.length, quarantined: 0 };
+      requireDurableIngestAcknowledgement(response, moves.length, collectionScopeRoots(moves));
     } catch (error) {
       const reason = deadLetterReason(error);
-      if (!reason) {
+      if (!(reason || mayBeBatchSizeFailure(error))) {
         throw error;
       }
       if (batch2.length > 1) {
@@ -48821,33 +49272,46 @@ async function drainFlushingPath(flushingPath, client, binding, options = {}) {
         const right = await postBatch(batch2.slice(midpoint));
         return addDrainCounts(left, right);
       }
-      const [move] = batch2;
+      if (!reason) {
+        throw error;
+      }
+      const [entry] = batch2;
       const quarantined = quarantineMove(
         flushingPath,
-        move,
+        entry.move,
         reason,
         Date.now,
         options.deadLetterPersistence
       );
+      recordProgress(entry.end);
       process.stderr.write(
         `[prim] quarantined rejected move ${quarantined.quarantineId.slice(0, 12)} (${reason})
 `
       );
-      return { flushed: 0, quarantined: 1 };
+      return reportProgress({ flushed: 0, quarantined: 1 });
     }
+    recordProgress(batch2.at(-1)?.end);
+    return reportProgress({ flushed: batch2.length, quarantined: 0 });
   };
-  const input = createReadStream(flushingPath);
+  const input = createReadStream(flushingPath, { start: resumeAt });
   const decoder = new TextDecoder("utf-8", { fatal: true });
   let batch = [];
+  let batchBytes = 0;
   let counts = { flushed: 0, quarantined: 0 };
+  const postPending = async () => {
+    counts = addDrainCounts(counts, await postBatch(batch));
+    batch = [];
+    batchBytes = 0;
+  };
   try {
-    for await (const rawLine of rawJournalLines(input)) {
+    for await (const { bytes: rawLine, end } of rawJournalLines(input, resumeAt)) {
       if (rawLine.length === 1 && rawLine[0] === 10 || rawLine.length === 2 && rawLine[0] === 13 && rawLine[1] === 10) {
         continue;
       }
+      let move;
       try {
         const line = decoder.decode(rawLine);
-        batch.push(JSON.parse(line));
+        move = JSON.parse(line);
       } catch {
         const quarantined = quarantineRawLine(
           flushingPath,
@@ -48859,24 +49323,35 @@ async function drainFlushingPath(flushingPath, client, binding, options = {}) {
           `[prim] quarantined invalid journal line ${quarantined.quarantineId.slice(0, 12)} (invalid_move)
 `
         );
-        counts.quarantined += 1;
+        counts = addDrainCounts(counts, reportProgress({ flushed: 0, quarantined: 1 }));
+        if (batch.length === 0) {
+          recordProgress(end);
+        }
         continue;
       }
-      if (batch.length === BATCH_SIZE) {
-        counts = addDrainCounts(counts, await postBatch(batch));
-        batch = [];
+      if (exceedsBatchBytes(batch.length, batchBytes, rawLine.length, BATCH_MAX_BYTES)) {
+        await postPending();
+      }
+      batch.push({ move, end });
+      batchBytes += rawLine.length;
+      if (batch.length >= BATCH_SIZE) {
+        await postPending();
       }
     }
     if (batch.length > 0) {
-      counts = addDrainCounts(counts, await postBatch(batch));
+      await postPending();
     }
   } finally {
     input.destroy();
   }
   unlinkSync4(flushingPath);
+  try {
+    removeDrainCheckpoint(flushingPath);
+  } catch {
+  }
   return counts;
 }
-async function drainPath(path9, client, binding) {
+async function drainPath(path9, client, binding, onProgress) {
   const tmpPath = `${path9}.flushing.${String(Date.now())}.${String(process.pid)}`;
   try {
     renameSync6(path9, tmpPath);
@@ -48886,7 +49361,19 @@ async function drainPath(path9, client, binding) {
     }
     throw err;
   }
-  return drainFlushingPath(tmpPath, client, binding);
+  return drainFlushingPath(tmpPath, client, binding, { onProgress });
+}
+async function settleDrain(drain) {
+  let progress = { flushed: 0, quarantined: 0 };
+  try {
+    return {
+      counts: await drain((delta) => {
+        progress = addDrainCounts(progress, delta);
+      })
+    };
+  } catch (error) {
+    return { counts: progress, failure: { error } };
+  }
 }
 function selectRecoverable(files, now, opts = {}) {
   const quarantineMs = opts.quarantineMs ?? ORPHAN_QUARANTINE_MS;
@@ -48903,7 +49390,8 @@ async function recoverOrphans(candidates, options) {
     flushed: 0,
     quarantined: 0,
     errors: [],
-    failedBuckets: /* @__PURE__ */ new Set()
+    failedBuckets: /* @__PURE__ */ new Set(),
+    failedDrainFlushed: 0
   };
   const recoverable = selectRecoverable(candidates, options.now ?? Date.now(), {
     ownerPid: options.ownerPid ?? process.pid,
@@ -48914,28 +49402,41 @@ async function recoverOrphans(candidates, options) {
     if (summary.failedBuckets.has(file.bucket)) {
       continue;
     }
-    try {
-      const counts = await drain(file.path);
-      summary.flushed += counts.flushed;
-      summary.quarantined += counts.quarantined;
-    } catch (err) {
-      summary.errors.push(err);
+    const { counts, failure: failure4 } = await settleDrain((onProgress) => drain(file.path, onProgress));
+    summary.flushed += counts.flushed;
+    summary.quarantined += counts.quarantined;
+    if (failure4) {
+      summary.failedDrainFlushed += counts.flushed;
+      summary.errors.push(failure4.error);
       summary.failedBuckets.add(file.bucket);
     }
   }
   return summary;
 }
 var FlushError = class extends Error {
+  /** Moves the whole sweep acknowledged, across every drain it ran. */
   flushed;
   quarantined;
-  constructor(cause, flushed, quarantined) {
+  /** Buckets the failed sweep held back without sending, as on success. */
+  retained;
+  /**
+   * Of `flushed`, the Moves acknowledged by the drains that failed, before
+   * they failed. Only this shows the failure itself is advancing: `flushed`
+   * also counts other buckets' drains, so a bucket whose drain fails every
+   * time would read as progress while a sibling bucket kept delivering.
+   */
+  failedDrainFlushed;
+  constructor(cause, flushed, quarantined, retained = [], failedDrainFlushed = 0) {
     super(cause instanceof Error ? cause.message : String(cause), { cause });
     this.name = "FlushError";
     this.flushed = flushed;
     this.quarantined = quarantined;
+    this.retained = retained;
+    this.failedDrainFlushed = failedDrainFlushed;
   }
 };
 async function flushOnce() {
+  sweepOrphanedDrainProgress();
   const orphanCandidates = listFlushing({ sampleBytes: 0 });
   const liveBuckets = listBuckets();
   if (orphanCandidates.length === 0 && liveBuckets.length === 0) {
@@ -48952,10 +49453,11 @@ async function flushOnce() {
   const binding = inspection.binding;
   const recovered = await recoverOrphans(
     orphanCandidates.filter((file) => inspection.deliverableBuckets.has(file.bucket)),
-    { drain: (path9) => drainFlushingPath(path9, client, binding) }
+    { drain: (path9, onProgress) => drainFlushingPath(path9, client, binding, { onProgress }) }
   );
   let total = recovered.flushed;
   let quarantined = recovered.quarantined;
+  let failedDrainFlushed = recovered.failedDrainFlushed;
   const errors = recovered.errors;
   for (const { bucket, path: path9 } of liveBuckets) {
     if (!inspection.deliverableBuckets.has(bucket)) {
@@ -48964,21 +49466,29 @@ async function flushOnce() {
     if (recovered.failedBuckets.has(bucket)) {
       continue;
     }
-    try {
-      const counts = await drainPath(path9, client, binding);
-      total += counts.flushed;
-      quarantined += counts.quarantined;
-    } catch (err) {
-      errors.push(err);
+    const { counts, failure: failure4 } = await settleDrain(
+      (onProgress) => drainPath(path9, client, binding, onProgress)
+    );
+    total += counts.flushed;
+    quarantined += counts.quarantined;
+    if (failure4) {
+      failedDrainFlushed += counts.flushed;
+      errors.push(failure4.error);
     }
   }
   if (errors.length > 0) {
-    throw new FlushError(errors[0], total, quarantined);
+    throw new FlushError(
+      errors[0],
+      total,
+      quarantined,
+      inspection.retainedBuckets,
+      failedDrainFlushed
+    );
   }
   return inspection.retainedBuckets.length > 0 ? { flushed: total, quarantined, retained: inspection.retainedBuckets } : { flushed: total, quarantined };
 }
 var flushInFlight;
-var FLUSH_LOCK_PATH = join20(dirname13(JOURNAL_DIR), ".flush.lock");
+var FLUSH_LOCK_PATH = join21(dirname14(JOURNAL_DIR), ".flush.lock");
 var FLUSH_LOCK_TIMEOUT_MS = 250;
 function isFlushLockContended(error) {
   return error instanceof Error && error.message.startsWith("timed out waiting for file lock");
@@ -49003,18 +49513,16 @@ function flush() {
   return attempt;
 }
 function shouldFlushPending(stats, now, thresholdMs = OPPORTUNISTIC_FLUSH_AFTER_MS) {
-  if (stats.sampled) {
+  if (stats.sampled || stats.strandedFileCount > 0 && stats.strandedCount === 0) {
     return true;
   }
   return stats.pendingCount > 0 && (stats.oldestPendingAt === void 0 || now - stats.oldestPendingAt > thresholdMs);
 }
-async function flushIfNeeded() {
+function journalNeedsFlush(now = Date.now()) {
   try {
-    const stats = pendingJournalStats();
-    if (shouldFlushPending(stats, Date.now())) {
-      await flush();
-    }
+    return shouldFlushPending(pendingJournalStats(), now);
   } catch {
+    return false;
   }
 }
 
@@ -49027,7 +49535,7 @@ var EVENT_COL_WIDTH = 20;
 var BUCKET_COL_WIDTH = 20;
 var TAIL_BUCKET_COL_WIDTH = 12;
 var DIR_MODE = 448;
-var FILE_MODE3 = 384;
+var FILE_MODE4 = 384;
 var WORKSPACE_FILE = ".prim/workspace.json";
 function registerMovesCommands(program3) {
   const moves = program3.command("moves").description("Decision Event Pipeline \u2014 local journal");
@@ -49073,7 +49581,7 @@ function registerMovesCommands(program3) {
     }
     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 byteCount = stranded.reduce((n, f) => n + f.pendingBytes, 0);
       const sampled = stranded.some((file) => file.sampled);
       const qualifier = sampled ? "at least " : "";
       console.log(
@@ -49084,7 +49592,7 @@ function registerMovesCommands(program3) {
         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)} ${count.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.pendingBytes).padStart(8)} bytes, ${String(ageS)}s ago (${owner})`
         );
       }
     }
@@ -49112,19 +49620,19 @@ function registerMovesCommands(program3) {
     }
   });
   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 = join21(process.cwd(), ".prim");
-    if (!existsSync17(dir)) {
+    const dir = join22(process.cwd(), ".prim");
+    if (!existsSync18(dir)) {
       mkdirSync12(dir, { recursive: true, mode: DIR_MODE });
     }
-    const file = join21(process.cwd(), WORKSPACE_FILE);
+    const file = join22(process.cwd(), WORKSPACE_FILE);
     writeFileSync9(file, JSON.stringify({ orgId: opts.orgId, boundAt: Date.now() }, null, 2), {
-      mode: FILE_MODE3
+      mode: FILE_MODE4
     });
     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 = join21(process.cwd(), WORKSPACE_FILE);
-    if (!existsSync17(file)) {
+    const file = join22(process.cwd(), WORKSPACE_FILE);
+    if (!existsSync18(file)) {
       console.log("[prim] no workspace binding in cwd");
       return;
     }
@@ -49215,31 +49723,31 @@ function registerReconcileCommands(program3) {
 
 // src/commands/session.ts
 import {
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync13,
-  readFileSync as readFileSync17,
-  readdirSync as readdirSync5,
+  readFileSync as readFileSync18,
+  readdirSync as readdirSync6,
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync10
 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 
 // src/binding.ts
-import { existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
-import { dirname as dirname14, join as join22 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync17 } from "fs";
+import { dirname as dirname15, join as join23 } from "path";
 var PRIM_CONFIG_DIR = primConfigDirectory();
-var SESSIONS_DIR = join22(PRIM_CONFIG_DIR, "sessions");
+var SESSIONS_DIR = join23(PRIM_CONFIG_DIR, "sessions");
 
 // src/commands/session.ts
 var DIR_MODE2 = 448;
-var FILE_MODE4 = 384;
+var FILE_MODE5 = 384;
 function ensureDir() {
-  if (!existsSync19(SESSIONS_DIR)) {
+  if (!existsSync20(SESSIONS_DIR)) {
     mkdirSync13(SESSIONS_DIR, { recursive: true, mode: DIR_MODE2 });
   }
 }
 function markerPath(sessionId) {
-  return join23(SESSIONS_DIR, `${sessionId}.json`);
+  return join24(SESSIONS_DIR, `${sessionId}.json`);
 }
 function registerSessionCommands(program3) {
   const session = program3.command("session").description("Decision Event Pipeline \u2014 session binding markers");
@@ -49250,16 +49758,16 @@ function registerSessionCommands(program3) {
       startedAt: Date.now()
     };
     writeFileSync10(markerPath(sessionId), JSON.stringify(marker, null, 2), {
-      mode: FILE_MODE4
+      mode: FILE_MODE5
     });
     console.log(`[prim] session ${sessionId} bound to org ${opts.orgId}`);
   });
   session.command("list").description("List active session markers").action(() => {
-    if (!existsSync19(SESSIONS_DIR)) {
+    if (!existsSync20(SESSIONS_DIR)) {
       console.log("[prim] no session markers");
       return;
     }
-    const files = readdirSync5(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+    const files = readdirSync6(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
     if (files.length === 0) {
       console.log("[prim] no session markers");
       return;
@@ -49267,7 +49775,7 @@ function registerSessionCommands(program3) {
     for (const f of files) {
       const sessionId = f.replace(/\.json$/, "");
       try {
-        const m = JSON.parse(readFileSync17(join23(SESSIONS_DIR, f), "utf-8"));
+        const m = JSON.parse(readFileSync18(join24(SESSIONS_DIR, f), "utf-8"));
         console.log(`${sessionId}  org=${m.orgId}`);
       } catch {
       }
@@ -49275,7 +49783,7 @@ function registerSessionCommands(program3) {
   });
   session.command("drop <sessionId>").description("Remove a session marker").action((sessionId) => {
     const p = markerPath(sessionId);
-    if (!existsSync19(p)) {
+    if (!existsSync20(p)) {
       console.log(`[prim] no marker for session ${sessionId}`);
       return;
     }
@@ -49286,10 +49794,24 @@ function registerSessionCommands(program3) {
 
 // src/commands/setup.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync20, readFileSync as readFileSync18 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync19 } from "fs";
+import { join as join25 } from "path";
 var EXIT_INCOMPLETE = 1;
 var EXIT_USAGE3 = 2;
+var SETUP_ORCHESTRATOR_ENV = "PRIM_SETUP_ORCHESTRATOR";
+var SETUP_DAEMON_DRAINS_ENV = "PRIM_SETUP_DAEMON_DRAINS";
+function setupStepSpawnOptions(capture, env4 = process.env, options = {}) {
+  return {
+    env: {
+      ...env4,
+      [SETUP_ORCHESTRATOR_ENV]: "1",
+      // Unset rather than inherited when this setup starts no daemon.
+      [SETUP_DAEMON_DRAINS_ENV]: options.startsDaemon === true ? "1" : void 0
+    },
+    stdio: capture ? ["inherit", "pipe", "ignore"] : "inherit",
+    encoding: "utf-8"
+  };
+}
 var SESSION_LABELS = {
   claude: "Claude Code integration",
   codex: "Codex integration",
@@ -49340,7 +49862,7 @@ function planSetupSteps(opts) {
     steps.push({
       key: "health",
       label: "Capture health",
-      args: ["doctor"],
+      args: ["doctor", "--expect-backlog"],
       required: true
     });
   }
@@ -49369,8 +49891,8 @@ function detectProjectConflicts(agent, run) {
   }
   try {
     const root = gitToplevel();
-    const preCommit = root && join24(root, ".git", "hooks", "pre-commit");
-    if (preCommit && existsSync20(preCommit) && readFileSync18(preCommit, "utf-8").includes("prim-pre-commit")) {
+    const preCommit = root && join25(root, ".git", "hooks", "pre-commit");
+    if (preCommit && existsSync21(preCommit) && readFileSync19(preCommit, "utf-8").includes("prim-pre-commit")) {
       conflicts.push(CONFLICT_HOOKS);
     }
   } catch {
@@ -49440,10 +49962,11 @@ function registerSetupCommand(program3, dependencies = {}) {
     const self = process.argv[1];
     const globals = program3.optsWithGlobals();
     const run = dependencies.run ?? ((args, capture = false) => {
-      const r = spawnSync2(process.execPath, [self, ...args], {
-        stdio: capture ? ["inherit", "pipe", "ignore"] : "inherit",
-        encoding: "utf-8"
-      });
+      const r = spawnSync2(
+        process.execPath,
+        [self, ...args],
+        setupStepSpawnOptions(capture, process.env, { startsDaemon: opts.daemon })
+      );
       return { code: r.status ?? 1, stdout: capture ? r.stdout ?? "" : "" };
     });
     const results = {};
@@ -49536,20 +50059,20 @@ function registerSetupCommand(program3, dependencies = {}) {
 // src/commands/skill.ts
 import { createHash as createHash11 } from "crypto";
 import {
-  constants as constants7,
-  closeSync as closeSync7,
-  existsSync as existsSync22,
-  fstatSync as fstatSync3,
-  lstatSync as lstatSync7,
-  openSync as openSync7,
-  readFileSync as readFileSync20,
-  readSync as readSync3,
-  readdirSync as readdirSync7,
-  rmdirSync as rmdirSync2,
+  constants as constants8,
+  closeSync as closeSync8,
+  existsSync as existsSync23,
+  fstatSync as fstatSync4,
+  lstatSync as lstatSync8,
+  openSync as openSync8,
+  readFileSync as readFileSync21,
+  readSync as readSync4,
+  readdirSync as readdirSync8,
+  rmdirSync as rmdirSync3,
   unlinkSync as unlinkSync7
 } from "fs";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname16, join as join27, resolve as resolve8 } from "path";
+import { dirname as dirname17, join as join28, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // node_modules/.pnpm/diff@5.2.2/node_modules/diff/lib/index.mjs
@@ -49719,7 +50242,7 @@ Diff.prototype = {
   tokenize: function tokenize(value) {
     return value.split("");
   },
-  join: function join25(chars) {
+  join: function join26(chars) {
     return chars.join("");
   }
 };
@@ -50057,30 +50580,30 @@ function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
 // src/commands/claude-plugin.ts
 import { createHash as createHash10 } from "crypto";
 import {
-  constants as constants6,
-  closeSync as closeSync6,
-  existsSync as existsSync21,
-  fstatSync as fstatSync2,
-  lstatSync as lstatSync6,
+  constants as constants7,
+  closeSync as closeSync7,
+  existsSync as existsSync22,
+  fstatSync as fstatSync3,
+  lstatSync as lstatSync7,
   mkdirSync as mkdirSync14,
-  openSync as openSync6,
-  readFileSync as readFileSync19,
-  readSync as readSync2,
-  readdirSync as readdirSync6,
+  openSync as openSync7,
+  readFileSync as readFileSync20,
+  readSync as readSync3,
+  readdirSync as readdirSync7,
   realpathSync as realpathSync4,
-  rmSync as rmSync8,
-  rmdirSync
+  rmSync as rmSync9,
+  rmdirSync as rmdirSync2
 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname15, isAbsolute as isAbsolute8, join as join26, relative as relative2, resolve as resolve7, sep as sep2 } from "path";
+import { dirname as dirname16, isAbsolute as isAbsolute8, join as join27, relative as relative2, resolve as resolve7, sep as sep2 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-var __dirname4 = dirname15(fileURLToPath4(import.meta.url));
+var __dirname4 = dirname16(fileURLToPath4(import.meta.url));
 var PLUGIN_DESCRIPTION = "Primitive decision-graph guidance for the prim CLI \u2014 a model-invoked skill installed by prim skill install.";
 var MAX_MANIFEST_BYTES2 = 64 * 1024;
 var MAX_SKILL_BYTES = 1024 * 1024;
 function pluginDirFor(cwd, scope) {
-  const base = scope === "user" ? join26(homedir10(), ".claude") : join26(gitToplevel(cwd) ?? cwd, ".claude");
-  return join26(base, "skills", "prim");
+  const base = scope === "user" ? join27(homedir10(), ".claude") : join27(gitToplevel(cwd) ?? cwd, ".claude");
+  return join27(base, "skills", "prim");
 }
 function resolvePluginDir(cwd, scope) {
   if (scope && scope !== "user" && scope !== "project") {
@@ -50091,10 +50614,10 @@ function resolvePluginDir(cwd, scope) {
 }
 function packageVersion2() {
   let dir = __dirname4;
-  while (dir !== dirname15(dir)) {
+  while (dir !== dirname16(dir)) {
     const p = resolve7(dir, "package.json");
-    if (existsSync21(p)) return JSON.parse(readFileSync19(p, "utf-8")).version;
-    dir = dirname15(dir);
+    if (existsSync22(p)) return JSON.parse(readFileSync20(p, "utf-8")).version;
+    dir = dirname16(dir);
   }
   return "0.0.0";
 }
@@ -50108,12 +50631,12 @@ function renderClaudePlugin() {
   return { manifest: pluginManifest(version), skill: loadSkill(), version };
 }
 function removeDirIfEmpty(dir) {
-  if (existsSync21(dir) && readdirSync6(dir).length === 0) rmdirSync(dir);
+  if (existsSync22(dir) && readdirSync7(dir).length === 0) rmdirSync2(dir);
 }
 function pluginPaths(dir) {
   return {
-    manifestPath: join26(dir, ".claude-plugin", "plugin.json"),
-    skillPath: join26(dir, "SKILL.md")
+    manifestPath: join27(dir, ".claude-plugin", "plugin.json"),
+    skillPath: join27(dir, "SKILL.md")
   };
 }
 function installClaudePlugin(cwd, opts) {
@@ -50121,8 +50644,8 @@ function installClaudePlugin(cwd, opts) {
   if (dir === null) return 1;
   const { manifestPath, skillPath } = pluginPaths(dir);
   const { manifest, skill } = renderClaudePlugin();
-  const manifestCurrent = existsSync21(manifestPath) ? readFileSync19(manifestPath, "utf-8") : null;
-  const skillCurrent = existsSync21(skillPath) ? readFileSync19(skillPath, "utf-8") : null;
+  const manifestCurrent = existsSync22(manifestPath) ? readFileSync20(manifestPath, "utf-8") : null;
+  const skillCurrent = existsSync22(skillPath) ? readFileSync20(skillPath, "utf-8") : null;
   if (manifestCurrent === manifest && skillCurrent === skill) {
     console.log("No changes \u2014 prim skill plugin already up to date.");
     return 0;
@@ -50131,7 +50654,7 @@ function installClaudePlugin(cwd, opts) {
     console.log(`Would write plugin to ${dir} (.claude-plugin/plugin.json + SKILL.md)`);
     return 0;
   }
-  mkdirSync14(join26(dir, ".claude-plugin"), { recursive: true });
+  mkdirSync14(join27(dir, ".claude-plugin"), { recursive: true });
   atomicWrite4(manifestPath, manifest);
   atomicWrite4(skillPath, skill);
   console.log(`Installed prim skill plugin at ${dir}`);
@@ -50145,13 +50668,13 @@ function uninstallClaudePlugin(cwd, opts) {
   const dir = resolvePluginDir(cwd, opts.scope);
   if (dir === null) return 1;
   const { manifestPath, skillPath } = pluginPaths(dir);
-  if (!existsSync21(manifestPath) && !existsSync21(skillPath)) {
+  if (!existsSync22(manifestPath) && !existsSync22(skillPath)) {
     console.log(`prim skill plugin not present at ${dir}`);
     return 0;
   }
-  rmSync8(manifestPath, { force: true });
-  rmSync8(skillPath, { force: true });
-  removeDirIfEmpty(join26(dir, ".claude-plugin"));
+  rmSync9(manifestPath, { force: true });
+  rmSync9(skillPath, { force: true });
+  removeDirIfEmpty(join27(dir, ".claude-plugin"));
   removeDirIfEmpty(dir);
   console.log(`Removed prim skill plugin from ${dir}`);
   return 0;
@@ -50160,7 +50683,7 @@ function statusClaudePlugin(cwd, opts) {
   const dir = resolvePluginDir(cwd, opts.scope);
   if (dir === null) return 1;
   const { skillPath } = pluginPaths(dir);
-  const installed = existsSync21(skillPath);
+  const installed = existsSync22(skillPath);
   if (opts.json) {
     printJson({ installed, target: dir });
     return installed ? 0 : 1;
@@ -50174,7 +50697,7 @@ function statusClaudePlugin(cwd, opts) {
 }
 
 // src/commands/skill.ts
-var __dirname5 = dirname16(fileURLToPath5(import.meta.url));
+var __dirname5 = dirname17(fileURLToPath5(import.meta.url));
 var SKILL_BEGIN = "<!-- BEGIN PRIM SKILL v1 -->";
 var SKILL_END = "<!-- END PRIM SKILL v1 -->";
 var CODEX_GUIDANCE_LIMIT_BYTES = 1024 * 1024;
@@ -50202,25 +50725,25 @@ function sha2563(content) {
 }
 function cursorSkillDirectory(cwd, scope) {
   const base = scope === "user" ? cursorConfigDirectory() : gitToplevel(cwd) ?? cwd;
-  return join27(base, scope === "user" ? "skills" : ".cursor/skills", "prim");
+  return join28(base, scope === "user" ? "skills" : ".cursor/skills", "prim");
 }
 function cursorSkillPaths(cwd, scope) {
   const directory = cursorSkillDirectory(cwd, scope);
   return {
     directory,
-    skill: join27(directory, "SKILL.md"),
-    manifest: join27(directory, CURSOR_SKILL_MANIFEST)
+    skill: join28(directory, "SKILL.md"),
+    manifest: join28(directory, CURSOR_SKILL_MANIFEST)
   };
 }
 function readCursorSkillManifest(path9) {
   try {
-    const value = JSON.parse(readFileSync20(path9, "utf8"));
+    const value = JSON.parse(readFileSync21(path9, "utf8"));
     if (!value || typeof value !== "object" || Array.isArray(value)) return;
-    const record2 = value;
-    if (record2.version !== 1 || record2.owner !== CURSOR_SKILL_OWNER || typeof record2.contentSha256 !== "string" || !/^[0-9a-f]{64}$/u.test(record2.contentSha256)) {
+    const record3 = value;
+    if (record3.version !== 1 || record3.owner !== CURSOR_SKILL_OWNER || typeof record3.contentSha256 !== "string" || !/^[0-9a-f]{64}$/u.test(record3.contentSha256)) {
       return;
     }
-    return record2;
+    return record3;
   } catch {
     return;
   }
@@ -50228,7 +50751,7 @@ function readCursorSkillManifest(path9) {
 function cursorSkillStatus(cwd, scope) {
   const paths = cursorSkillPaths(cwd, scope);
   const manifest = readCursorSkillManifest(paths.manifest);
-  const content = existsSync22(paths.skill) ? readFileSync20(paths.skill, "utf8") : void 0;
+  const content = existsSync23(paths.skill) ? readFileSync21(paths.skill, "utf8") : void 0;
   const owned = manifest !== void 0;
   const installed = owned && content !== void 0 && sha2563(content) === manifest.contentSha256;
   return {
@@ -50246,8 +50769,8 @@ function validCursorSkillScope(scope) {
 function installCursorSkill(cwd, opts) {
   const paths = cursorSkillPaths(cwd, opts.scope);
   const status = cursorSkillStatus(cwd, opts.scope);
-  const manifestExists = existsSync22(paths.manifest);
-  const skillExists = existsSync22(paths.skill);
+  const manifestExists = existsSync23(paths.manifest);
+  const skillExists = existsSync23(paths.skill);
   if (manifestExists && !status.owned || !manifestExists && skillExists || status.edited) {
     console.error(`Refusing to overwrite a foreign or edited Cursor skill at ${paths.skill}`);
     return 1;
@@ -50258,12 +50781,12 @@ function installCursorSkill(cwd, opts) {
     owner: CURSOR_SKILL_OWNER,
     contentSha256: sha2563(content)
   };
-  if (status.installed && readFileSync20(paths.skill, "utf8") === content) {
+  if (status.installed && readFileSync21(paths.skill, "utf8") === content) {
     console.log(`No changes \u2014 Cursor skill already up to date at ${paths.skill}`);
     return 0;
   }
   if (opts.dryRun) {
-    const existing = skillExists ? readFileSync20(paths.skill, "utf8") : "";
+    const existing = skillExists ? readFileSync21(paths.skill, "utf8") : "";
     process.stdout.write(createPatch(paths.skill, existing, content, "current", "proposed"));
     return 0;
   }
@@ -50284,34 +50807,34 @@ function uninstallCursorSkill(cwd, scope) {
     console.error(`Refusing to remove an edited Cursor skill at ${paths.skill}`);
     return 1;
   }
-  if (existsSync22(paths.skill)) unlinkSync7(paths.skill);
-  if (existsSync22(paths.manifest)) unlinkSync7(paths.manifest);
+  if (existsSync23(paths.skill)) unlinkSync7(paths.skill);
+  if (existsSync23(paths.manifest)) unlinkSync7(paths.manifest);
   try {
-    if (readdirSync7(paths.directory).length === 0) rmdirSync2(paths.directory);
+    if (readdirSync8(paths.directory).length === 0) rmdirSync3(paths.directory);
   } catch {
   }
   console.log(`Removed Primitive-owned Cursor skill from ${paths.skill}`);
   return 0;
 }
 function userTargetFor(agent) {
-  if (agent === "claude") return join27(homedir11(), ".claude", "CLAUDE.md");
-  if (agent === "codex") return join27(homedir11(), ".codex", "AGENTS.md");
+  if (agent === "claude") return join28(homedir11(), ".claude", "CLAUDE.md");
+  if (agent === "codex") return join28(homedir11(), ".codex", "AGENTS.md");
   if (agent === "hermes") {
-    return join27(process.env.HERMES_HOME ?? join27(homedir11(), ".hermes"), ".hermes.md");
+    return join28(process.env.HERMES_HOME ?? join28(homedir11(), ".hermes"), ".hermes.md");
   }
   return null;
 }
 function loadSkill() {
   let dir = __dirname5;
-  while (dir !== dirname16(dir)) {
+  while (dir !== dirname17(dir)) {
     const p = resolve8(dir, "SKILL.md");
-    if (existsSync22(p)) return readFileSync20(p, "utf-8");
-    dir = dirname16(dir);
+    if (existsSync23(p)) return readFileSync21(p, "utf-8");
+    dir = dirname17(dir);
   }
   throw new Error("SKILL.md not found in package");
 }
 function detectTargets(cwd) {
-  return TARGET_CANDIDATES.filter((p) => existsSync22(resolve8(cwd, p)));
+  return TARGET_CANDIDATES.filter((p) => existsSync23(resolve8(cwd, p)));
 }
 function detectNewline(content) {
   return content.includes("\r\n") ? "\r\n" : "\n";
@@ -50377,7 +50900,7 @@ function runInstall(cwd, opts) {
   }
   const target = resolveTarget(cwd, opts);
   if (target === null) return 1;
-  const existing = existsSync22(target) ? readFileSync20(target, "utf-8") : "";
+  const existing = existsSync23(target) ? readFileSync21(target, "utf-8") : "";
   const eol = existing ? detectNewline(existing) : "\n";
   const block = composeBlock(loadSkill(), eol);
   const next = applyBlock(existing, block, eol);
@@ -50401,11 +50924,11 @@ function runUninstall(cwd, opts) {
   }
   const target = resolveTarget(cwd, opts);
   if (target === null) return 1;
-  if (!existsSync22(target)) {
+  if (!existsSync23(target)) {
     console.log(`Skill block not present at ${target}`);
     return 0;
   }
-  const existing = readFileSync20(target, "utf-8");
+  const existing = readFileSync21(target, "utf-8");
   const next = removeBlock(existing);
   if (next === null) {
     console.log(`Skill block not present at ${target}`);
@@ -50429,10 +50952,10 @@ function runStatus(cwd, opts) {
   }
   const target = resolveTarget(cwd, opts);
   if (target === null) return 1;
-  const fileExists = existsSync22(target);
+  const fileExists = existsSync23(target);
   let installed = false;
   if (fileExists) {
-    const content = readFileSync20(target, "utf-8");
+    const content = readFileSync21(target, "utf-8");
     installed = content.includes(SKILL_BEGIN) && content.includes(SKILL_END);
   }
   if (opts.json) {
@@ -50469,13 +50992,13 @@ function registerSkillCommands(program3) {
 }
 
 // src/commands/statusline.ts
-import { readFileSync as readFileSync21 } from "fs";
-import { dirname as dirname17, resolve as resolve9 } from "path";
+import { readFileSync as readFileSync22 } from "fs";
+import { dirname as dirname18, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var STATUSLINE_TIMEOUT_MS = 200;
 function readPackageVersion() {
   try {
-    const here = dirname17(fileURLToPath6(import.meta.url));
+    const here = dirname18(fileURLToPath6(import.meta.url));
     const candidates = [
       // Schema-v2 runtimes staged a manifest beside this standalone bundle.
       // Keep resolving it while those legacy launchers transition to schema v3.
@@ -50485,7 +51008,7 @@ function readPackageVersion() {
     ];
     for (const path9 of candidates) {
       try {
-        const pkg2 = JSON.parse(readFileSync21(path9, "utf-8"));
+        const pkg2 = JSON.parse(readFileSync22(path9, "utf-8"));
         if (pkg2.version) {
           return pkg2.version;
         }
@@ -50899,28 +51422,272 @@ function registerWelcomeCommand(program3, deps = { getClient }) {
   });
 }
 
+// src/daemon/self-heal.ts
+import { spawn as spawn4 } from "child_process";
+
+// src/lib/unattended.ts
+var UNATTENDED_ENV = "PRIM_UNATTENDED";
+function unattendedEnv(env4 = process.env) {
+  return { ...env4, [UNATTENDED_ENV]: "1" };
+}
+function isUnattended(env4 = process.env) {
+  return env4[UNATTENDED_ENV] === "1";
+}
+
+// src/daemon/self-heal.ts
+function kickDaemonEnsure(options = {}) {
+  const primEntry = options.primEntry === void 0 ? binFile("prim") : options.primEntry;
+  if (!primEntry) {
+    return false;
+  }
+  try {
+    const args = [primEntry, "daemon", "ensure"];
+    if (options.latestBootstrap ?? (options.platform ?? process.platform) === "darwin") {
+      args.push("--latest-bootstrap");
+    }
+    const child = (options.spawnProcess ?? spawn4)(
+      options.nodeEntry ?? process.execPath,
+      args,
+      // Unattended: neither SessionStart's repair nor a drift heal is a person
+      // running prim, so the child (and its descendants) never heal in turn.
+      { detached: true, stdio: "ignore", env: unattendedEnv() }
+    );
+    child.once("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/daemon/drift-heal.ts
+var ATTEMPT_MARKER_MODE = 384;
+var ATTEMPT_MARKER_MAX_BYTES = 1024;
+var PATH_SEPARATORS = /[\\/]/u;
+var DAEMON_DRIFT_HEAL_ENV = "PRIM_DAEMON_DRIFT_HEAL";
+var DAEMON_DRIFT_HEAL_RETRY_MS = 60 * 60 * 1e3;
+function readAttempt(path9) {
+  const file = readBoundedRegularFile(path9, ATTEMPT_MARKER_MAX_BYTES);
+  if (!file) return null;
+  try {
+    const value = JSON.parse(file.text);
+    if (typeof value !== "object" || value === null) return null;
+    const attempt = value;
+    return typeof attempt.attemptedAt === "number" && Number.isFinite(attempt.attemptedAt) && typeof attempt.fromVersion === "string" && typeof attempt.toVersion === "string" ? attempt : null;
+  } catch {
+    return null;
+  }
+}
+function claimHeld() {
+  throw new Error("another command holds the daemon drift-heal claim");
+}
+function claimAttempt(markerPath2, attempt) {
+  const previous = readAttempt(markerPath2);
+  const elapsed = previous ? attempt.attemptedAt - previous.attemptedAt : Number.POSITIVE_INFINITY;
+  if (elapsed >= 0 && elapsed < DAEMON_DRIFT_HEAL_RETRY_MS) return false;
+  atomicWriteFile(markerPath2, `${JSON.stringify(attempt)}
+`, { mode: ATTEMPT_MARKER_MODE });
+  return true;
+}
+function isInstalledPackage(root) {
+  return root?.split(PATH_SEPARATORS).includes("node_modules") === true;
+}
+function needsHeal(launcher, toVersion) {
+  const order = compareSemver(launcher.runtimeVersion, toVersion);
+  return order === -1 || order === 0 && !launcher.runnable;
+}
+function startDriftHeal(options) {
+  if ((options.platform ?? process.platform) !== "darwin") return false;
+  const env4 = options.env ?? process.env;
+  if (env4[DAEMON_DRIFT_HEAL_ENV] === "0") return false;
+  const root = options.packageRoot === void 0 ? packageRoot() : options.packageRoot;
+  if (!isInstalledPackage(root)) return false;
+  const euid = options.euid ?? process.geteuid?.();
+  if (euid === void 0 || euid === 0) return false;
+  const paths = { env: env4, homeDir: options.homeDir };
+  if (daemonExplicitlyDisabled(paths)) return false;
+  const launcher = (options.selectedLauncher ?? (() => selectedDaemonLauncher(paths)))();
+  if (!launcher || launcher.ownerUid !== euid) return false;
+  const toVersion = options.cliVersion === void 0 ? packageVersion() : options.cliVersion;
+  if (!(toVersion && needsHeal(launcher, toVersion))) return false;
+  if (!apiUrlsMatch(
+    getSiteUrlForEnvironment(launcher.apiUrl),
+    getSiteUrlForEnvironment(env4.PRIM_API_URL)
+  )) {
+    return false;
+  }
+  const runsConfigRoot = options.launchAgentRunsConfigRoot ?? (() => launchAgentRunsConfigRoot(paths));
+  if (!runsConfigRoot()) return false;
+  const primEntry = options.primEntry === void 0 ? binFile("prim") : options.primEntry;
+  if (!primEntry) return false;
+  const attempt = {
+    attemptedAt: (options.nowMs ?? Date.now)(),
+    fromVersion: launcher.runtimeVersion,
+    toVersion
+  };
+  const claimed = withFileLockSync(
+    daemonDriftHealClaimPath(paths),
+    () => claimAttempt(daemonDriftHealMarkerPath(paths), attempt),
+    { timeoutMs: 0, sleep: claimHeld }
+  );
+  if (!claimed) return false;
+  return kickDaemonEnsure({
+    primEntry,
+    nodeEntry: options.nodeEntry,
+    spawnProcess: options.spawnProcess,
+    latestBootstrap: false
+  });
+}
+function healDaemonDrift(options = {}) {
+  try {
+    return startDriftHeal(options);
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/background-flush.ts
+import { spawn as spawn5 } from "child_process";
+import { readFileSync as readFileSync23 } from "fs";
+
+// src/daemon/health.ts
+import { chmodSync as chmodSync7, existsSync as existsSync24, mkdirSync as mkdirSync15, renameSync as renameSync7, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname19, join as join29 } from "path";
+var HEARTBEAT_FRESH_MS = 9e4;
+var DAEMON_HEALTH_PATH = join29(primConfigDirectory(), "daemon-health.json");
+
+// src/lib/background-flush.ts
+function record2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function daemonOwnsDrain(options = {}) {
+  try {
+    const expectedVersion = options.expectedVersion === void 0 ? packageVersion() : options.expectedVersion;
+    if (!expectedVersion) return false;
+    const health = record2(
+      JSON.parse(readFileSync23(options.healthPath ?? DAEMON_HEALTH_PATH, "utf8"))
+    );
+    const heartbeat = record2(health?.heartbeat);
+    const ingestion = record2(health?.ingestion);
+    if (!(health && heartbeat && ingestion)) return false;
+    if (health.schemaVersion !== 1 || health.version !== expectedVersion) return false;
+    const daemonSiteUrl = health.siteUrl;
+    if (typeof daemonSiteUrl !== "string" || envSlug(daemonSiteUrl) !== envSlug(options.siteUrl ?? getSiteUrl())) {
+      return false;
+    }
+    if (health.needsReauth === true) return false;
+    const pid = health.pid;
+    if (typeof pid !== "number" || !(options.isAlive ?? processIsAlive)(pid)) return false;
+    const lastSuccessAt = heartbeat.lastSuccessAt;
+    const now = options.now ?? Date.now();
+    return heartbeat.consecutiveFailures === 0 && typeof lastSuccessAt === "number" && lastSuccessAt <= now && now - lastSuccessAt < HEARTBEAT_FRESH_MS && ingestion.consecutiveFailures === 0;
+  } catch {
+    return false;
+  }
+}
+function startBackgroundFlush(options = {}) {
+  try {
+    if ((options.daemonOwnsDrain ?? daemonOwnsDrain)()) return false;
+    if (!(options.needsFlush ?? journalNeedsFlush)()) return false;
+    const primEntry = options.primEntry === void 0 ? binFile("prim") : options.primEntry;
+    if (!primEntry) return false;
+    const child = (options.spawnProcess ?? spawn5)(
+      options.nodeEntry ?? process.execPath,
+      [primEntry, "moves", "flush"],
+      // Ignored stdio matters as much as detaching: a child holding inherited
+      // pipes would keep a caller that captures them (spawnSync) waiting.
+      // windowsHide keeps the detached child from opening a console window.
+      // The child is unattended even when its parent is not: `doctor` or
+      // `statusline` must not reach the daemon drift heal through its drain.
+      { detached: true, stdio: "ignore", windowsHide: true, env: unattendedEnv() }
+    );
+    child.once("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/lib/startup-background.ts
 var ROOT_OPTIONS = /* @__PURE__ */ new Set(["-y", "--yes", "--non-interactive"]);
+var HELP_OPTIONS = /* @__PURE__ */ new Set(["-h", "--help"]);
+var DAEMON_HEAL_COMMANDS = /* @__PURE__ */ new Map([
+  // Credentials; `auth login` is how a person returns to a daemon held for re-auth.
+  ["auth", /* @__PURE__ */ new Set(["api-keys", "login", "set-token", "status"])],
+  // Reading and curating the decision graph: the everyday attended surface.
+  [
+    "decisions",
+    /* @__PURE__ */ new Set([
+      "cascade",
+      "check",
+      "confirm",
+      "create",
+      "demote",
+      "link",
+      "promote",
+      "publish",
+      "ratify",
+      "recent",
+      "repairs",
+      "rescope",
+      "restore",
+      "show",
+      "supersede",
+      "unlink",
+      "withdraw"
+    ])
+  ],
+  ["reconcile", "any"],
+  // Repository connection, activation, and journal plumbing a person steers.
+  // Hook-side `moves flush` drains are unattended and never reach this table.
+  ["github", /* @__PURE__ */ new Set(["connect"])],
+  ["enable", "any"],
+  ["moves", /* @__PURE__ */ new Set(["bind", "drop", "flush", "status", "tail"])],
+  ["session", /* @__PURE__ */ new Set(["drop", "list", "start"])],
+  // Installing or inspecting an integration, never removing one.
+  ["claude", /* @__PURE__ */ new Set(["install", "preauth", "status"])],
+  ["codex", /* @__PURE__ */ new Set(["install", "status"])],
+  ["cursor", /* @__PURE__ */ new Set(["install", "status"])],
+  ["hermes", /* @__PURE__ */ new Set(["install", "status"])],
+  ["hooks", /* @__PURE__ */ new Set(["install"])],
+  ["skill", /* @__PURE__ */ new Set(["install", "status"])],
+  ["welcome", "any"]
+]);
 function commandArguments(argv) {
   let index = 0;
   while (ROOT_OPTIONS.has(argv[index] ?? "")) index += 1;
   return argv.slice(index);
 }
+function mayHealDaemon(argv, env4) {
+  if (isUnattended(env4) || env4[SETUP_ORCHESTRATOR_ENV] === "1") return false;
+  const args = commandArguments(argv);
+  if (args.some((arg) => HELP_OPTIONS.has(arg))) return false;
+  const [command, subcommand] = args;
+  const allowed = command === void 0 ? void 0 : DAEMON_HEAL_COMMANDS.get(command);
+  if (allowed === void 0) return false;
+  return allowed === "any" || subcommand !== void 0 && allowed.has(subcommand);
+}
 function runStartupBackgroundWork(argv, env4, work) {
-  const [command, subcommand] = commandArguments(argv);
+  const args = commandArguments(argv);
+  const [command, subcommand] = args;
   const uninstall = command === "uninstall" || env4[UNINSTALL_ORCHESTRATOR_ENV] === "1";
   if (uninstall) return;
   work.notify();
-  if (command !== "moves" || subcommand !== "flush") work.flush().catch(() => {
-  });
+  const setupDaemonDrains = command === "setup" && !args.includes("--no-daemon") || env4[SETUP_DAEMON_DRAINS_ENV] === "1";
+  if (!setupDaemonDrains && (command !== "moves" || subcommand !== "flush")) work.flush();
+  if (mayHealDaemon(argv, env4)) work.healDaemon();
 }
 
 // src/index.ts
-var __dirname6 = dirname18(fileURLToPath7(import.meta.url));
-var pkg = JSON.parse(readFileSync22(resolve10(__dirname6, "../package.json"), "utf-8"));
+var __dirname6 = dirname20(fileURLToPath7(import.meta.url));
+var pkg = JSON.parse(readFileSync24(resolve10(__dirname6, "../package.json"), "utf-8"));
 runStartupBackgroundWork(process.argv.slice(2), process.env, {
   notify: () => updateNotifier({ pkg }).notify(),
-  flush: () => flushIfNeeded()
+  flush: () => startBackgroundFlush(),
+  healDaemon: () => healDaemonDrift()
 });
 var program2 = new Command();
 program2.name("prim").description("CLI for Primitive's decision graph").version(pkg.version).option("-y, --yes", "auto-confirm prompts").option(