@adhdev/daemon-standalone 1.0.58-rc.18 → 1.0.58-rc.20

package/dist/index.js

@@ -31672,9 +31672,9 @@ var require_streamx = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/b4a/index.js
+// ../../node_modules/tar-stream/node_modules/b4a/index.js
 var require_b4a2 = __commonJS({
-  "../daemon-core/node_modules/b4a/index.js"(exports2, module2) {
+  "../../node_modules/tar-stream/node_modules/b4a/index.js"(exports2, module2) {
     "use strict";
     function isBuffer(value) {
       return Buffer.isBuffer(value) || value instanceof Uint8Array;
@@ -31830,9 +31830,9 @@ var require_b4a2 = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/headers.js
+// ../../node_modules/tar-stream/headers.js
 var require_headers = __commonJS({
-  "../daemon-core/node_modules/tar-stream/headers.js"(exports2) {
+  "../../node_modules/tar-stream/headers.js"(exports2) {
     "use strict";
     var b4a = require_b4a2();
     var ZEROS = "0000000000000000000";
@@ -32093,9 +32093,9 @@ var require_headers = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/extract.js
+// ../../node_modules/tar-stream/extract.js
 var require_extract = __commonJS({
-  "../daemon-core/node_modules/tar-stream/extract.js"(exports2, module2) {
+  "../../node_modules/tar-stream/extract.js"(exports2, module2) {
     "use strict";
     var { Writable, Readable, getStreamError } = require_streamx();
     var FIFO = require_fast_fifo();
@@ -32438,9 +32438,9 @@ var require_extract = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/constants.js
+// ../../node_modules/tar-stream/constants.js
 var require_constants = __commonJS({
-  "../daemon-core/node_modules/tar-stream/constants.js"(exports2, module2) {
+  "../../node_modules/tar-stream/constants.js"(exports2, module2) {
     "use strict";
     var constants = {
       // just for envs without fs
@@ -32459,9 +32459,9 @@ var require_constants = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/pack.js
+// ../../node_modules/tar-stream/pack.js
 var require_pack = __commonJS({
-  "../daemon-core/node_modules/tar-stream/pack.js"(exports2, module2) {
+  "../../node_modules/tar-stream/pack.js"(exports2, module2) {
     "use strict";
     var { Readable, Writable, getStreamError } = require_streamx();
     var b4a = require_b4a2();
@@ -32694,9 +32694,9 @@ var require_pack = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/index.js
+// ../../node_modules/tar-stream/index.js
 var require_tar_stream = __commonJS({
-  "../daemon-core/node_modules/tar-stream/index.js"(exports2) {
+  "../../node_modules/tar-stream/index.js"(exports2) {
     "use strict";
     exports2.extract = require_extract();
     exports2.pack = require_pack();
@@ -32939,9 +32939,9 @@ var require_pump = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-fs/index.js
+// ../../node_modules/tar-fs/index.js
 var require_tar_fs = __commonJS({
-  "../daemon-core/node_modules/tar-fs/index.js"(exports2) {
+  "../../node_modules/tar-fs/index.js"(exports2) {
     "use strict";
     var tar = require_tar_stream();
     var pump = require_pump();
@@ -36885,10 +36885,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "2469ba9094ea503986699b3d4913998da22c18f0" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "2469ba90" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.18" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-26T13:15:55.276Z" : void 0);
+      const commit = readInjected(true ? "079b401790e71ed1ad71665990e7acd3747efd78" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "079b4017" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.20" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-26T18:21:35.498Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -61612,7 +61612,7 @@ ${rendered}`, "utf-8");
           allowAutoPublishSubmoduleMainCommits: args.allowAutoPublishSubmoduleMainCommits === true
         });
       }
-      const earlyBlockers = collectPreflightBlockers(current, requestedBranch);
+      const earlyBlockers = collectPreflightBlockers(current, requestedBranch, updateSubmodules);
       if (earlyBlockers.length > 0) {
         const blockCode = chooseBlockCode(current, earlyBlockers);
         const result2 = {
@@ -62058,7 +62058,7 @@ ${rendered}`, "utf-8");
       const aheadOnly = /* @__PURE__ */ new Set(["branch_has_local_commits"]);
       return blockers.every((reason) => aheadOnly.has(reason));
     }
-    function collectPreflightBlockers(status, requestedBranch) {
+    function collectPreflightBlockers(status, requestedBranch, updateSubmodules) {
       const blockers = [];
       if (!status.isGitRepo) blockers.push("not_git_repo");
       if (!status.branch) blockers.push("detached_head_or_unknown_branch");
@@ -62067,12 +62067,16 @@ ${rendered}`, "utf-8");
       if (status.upstreamStatus !== "fresh") blockers.push("upstream_not_fresh");
       if (status.hasConflicts) blockers.push("conflicts_present");
       if (status.staged > 0) blockers.push("staged_changes_present");
-      if (status.modified > 0) blockers.push("modified_changes_present");
+      const tolerateGitlinkDriftAlone = updateSubmodules === true;
+      const pureDriftSubmoduleCount = tolerateGitlinkDriftAlone ? (Array.isArray(status.submodules) ? status.submodules : []).filter(
+        (submodule) => submodule.outOfSync && !submodule.dirty && !submodule.error
+      ).length : 0;
+      if (status.modified - pureDriftSubmoduleCount > 0) blockers.push("modified_changes_present");
       if (status.untracked > 0) blockers.push("untracked_changes_present");
       if (status.deleted > 0) blockers.push("deleted_changes_present");
       if (status.renamed > 0) blockers.push("renamed_changes_present");
       if (status.stashCount > 0) blockers.push("stash_entries_present");
-      blockers.push(...collectSubmoduleBlockers(status, "pre"));
+      blockers.push(...collectSubmoduleBlockers(status, "pre", tolerateGitlinkDriftAlone));
       if (status.ahead > 0 && status.behind > 0) {
         blockers.push("branch_diverged_from_upstream");
         blockers.push("branch_has_local_commits");
@@ -62092,13 +62096,14 @@ ${rendered}`, "utf-8");
       blockers.push(...collectSubmoduleBlockers(status, "post"));
       return blockers;
     }
-    function collectSubmoduleBlockers(status, phase) {
+    function collectSubmoduleBlockers(status, phase, tolerateGitlinkDriftAlone = false) {
       const submodules = Array.isArray(status.submodules) ? status.submodules : [];
       const blockers = [];
       for (const submodule of submodules) {
         if (submodule.error) blockers.push(`${phase}_submodule_status_error:${submodule.path}`);
         if (submodule.dirty) blockers.push(`${phase}_submodule_dirty:${submodule.path}`);
-        if (submodule.outOfSync) blockers.push(`${phase}_submodule_out_of_sync:${submodule.path}`);
+        const outOfSyncIsToleratedDrift = tolerateGitlinkDriftAlone && submodule.outOfSync && !submodule.dirty && !submodule.error;
+        if (submodule.outOfSync && !outOfSyncIsToleratedDrift) blockers.push(`${phase}_submodule_out_of_sync:${submodule.path}`);
       }
       return blockers;
     }
@@ -65167,6 +65172,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const fresh = isQuotaSnapshotFresh(facts, quota, policy, now);
       const confidence = quota.status === "ok" && fresh ? CONFIDENCE_CURRENT : isStructurallyUnmeasurable(quota) ? CONFIDENCE_RETAINED_STRUCTURAL : CONFIDENCE_RETAINED_AGED;
       const window = axis === "session" ? quota.session : quota.weekly;
+      if (!isWindowTrustworthy(window, facts, quota, policy, now)) return void 0;
       const remaining = remainingPercent(window);
       if (remaining === void 0) return void 0;
       const resetsAt = Number(window?.resetsAt);
@@ -65259,11 +65265,18 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return `QUOTA GATE: skipping recovery relaunch for node ${nodeId} \u2014 ${cause} and the node has no gate-clear alternative${taskId ? `; task ${taskId}` : ""} stays queued until a quota window resets`;
     }
-    function quotaRiskSnapshotForCandidates(node, orderedProviderTypes, policy, now = Date.now(), context) {
+    function quotaRiskSnapshotForCandidates(node, orderedProviderTypes, policy, now = Date.now(), context, ranking) {
+      const resolvedRanking = ranking ?? rankProvidersByQuotaGate(node, orderedProviderTypes, policy, now, context);
+      const evidenceByProvider = new Map(
+        (resolvedRanking.rankingEvidence ?? []).map((evidence) => [evidence.providerType, evidence])
+      );
       return orderedProviderTypes.map((providerType) => {
-        const w = expiryRiskForRanking(node, providerType, "weekly", policy, now, context);
+        const evidence = evidenceByProvider.get(providerType);
+        const axis = evidence?.axis ?? (resolvedRanking.sessionAxisActive ? "session" : "weekly");
+        const w = expiryRiskForRanking(node, providerType, axis, policy, now, context);
         return {
           providerType,
+          axis,
           ...w ? {
             remainingPercent: w.remainingPercent,
             risk: w.risk,
@@ -66186,8 +66199,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     });
     function buildProviderSelectionDiagnostics(args) {
       const now = args.now ?? Date.now();
-      const riskSnapshot = quotaRiskSnapshotForCandidates(args.node, args.ranked.clear, args.quotaRouting, now, args.quotaFactsContext);
-      const allRisks = quotaRiskSnapshotForCandidates(args.node, args.candidateSlots.map((candidate) => candidate.providerType), args.quotaRouting, now, args.quotaFactsContext);
+      const riskSnapshot = quotaRiskSnapshotForCandidates(args.node, args.ranked.clear, args.quotaRouting, now, args.quotaFactsContext, args.ranked);
+      const allRisks = quotaRiskSnapshotForCandidates(args.node, args.candidateSlots.map((candidate) => candidate.providerType), args.quotaRouting, now, args.quotaFactsContext, args.ranked);
       const riskByProvider = new Map(allRisks.map((snapshot) => [snapshot.providerType, snapshot]));
       const scoreDetails = args.task ? args.usableSlots.map((candidate, selectionRank) => {
         const selectionCapacity = slotCapacityRemaining(
@@ -69108,7 +69121,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (policy.maxBehind !== void 0 && behind > policy.maxBehind) return false;
       if (policy.requireCleanSubmodules) {
         const submodules = Array.isArray(dryRun.current?.submodules) ? dryRun.current.submodules : [];
-        if (submodules.some((submodule) => submodule?.dirty || submodule?.outOfSync || submodule?.error)) return false;
+        if (submodules.some((submodule) => submodule?.dirty || submodule?.error)) return false;
       }
       return true;
     }
@@ -69147,9 +69160,12 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         inlineMesh: mesh,
         ...submoduleIgnorePaths ? { submoduleIgnorePaths } : {},
         trigger: args.trigger,
-        // Preserve the pre-fix self-only semantics for submodules: the local idle path
-        // never updated submodules (updateSubmodules:false), so the remote path matches.
-        updateSubmodules: false
+        // Mirror the manual mesh_fast_forward_node update_submodules behavior: if the
+        // ff-only merge moves a submodule gitlink, run `git submodule update --init
+        // --recursive` in the same cycle so the checkout never drifts from the gitlink.
+        // Without this, drift accumulates and self-blocks every subsequent auto-ff
+        // (collectPreflightBlockers treats out-of-sync submodules as a hard blocker).
+        updateSubmodules: true
       };
       try {
         const remoteDry = await dispatchMeshCommand(args.daemonId, "fast_forward_mesh_node", {
@@ -69183,7 +69199,9 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           workspace: args.workspace,
           execute: false,
           dryRun: true,
-          updateSubmodules: false,
+          // See delegateRemoteAutoFastForward's updateSubmodules comment: mirrors the
+          // manual tool so a gitlink-moving ff cannot leave the submodule drifted.
+          updateSubmodules: true,
           submoduleIgnorePaths,
           trigger: args.trigger
         });
@@ -69194,7 +69212,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           workspace: args.workspace,
           execute: true,
           dryRun: false,
-          updateSubmodules: false,
+          updateSubmodules: true,
           submoduleIgnorePaths,
           trigger: args.trigger
         });
@@ -69295,6 +69313,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
             ...baseBranch ? { branch: baseBranch } : {},
             mode: "merge",
             execute: true,
+            // Same gitlink-drift-prevention rationale as executeLocalAutoFastForward /
+            // delegateRemoteAutoFastForward — this path pushed the base branch itself,
+            // so a submodule gitlink bump here is exactly as likely.
+            updateSubmodules: true,
             trigger: "refine_post_push_catchup",
             allowAutoPublishSubmoduleMainCommits: mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true
           });
@@ -69829,33 +69851,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         targetPinGeneratingCreditMs = /* @__PURE__ */ new Map();
       }
     });
-    function selectQuotaBusyFallback(args) {
-      const { clearOrder, candidates, busyProviderType, probe } = args;
-      const slotByProvider = /* @__PURE__ */ new Map();
-      for (const candidate of candidates) {
-        if (!slotByProvider.has(candidate.providerType)) {
-          slotByProvider.set(candidate.providerType, candidate);
-        }
-      }
-      const skipped = [];
-      const seen = /* @__PURE__ */ new Set([busyProviderType]);
-      for (const providerType of clearOrder) {
-        if (seen.has(providerType)) continue;
-        seen.add(providerType);
-        const candidate = slotByProvider.get(providerType);
-        if (!candidate) continue;
-        if (probe(candidate)) {
-          return { outcome: "fallback", candidate, skipped };
-        }
-        skipped.push(providerType);
-      }
-      return { outcome: "exhausted", skipped };
-    }
-    var init_mesh_quota_fallback = __esm2({
-      "src/mesh/mesh-quota-fallback.ts"() {
-        "use strict";
-      }
-    });
     function localCoordinatorDaemonId() {
       return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
     }
@@ -70304,6 +70299,167 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_difficulty_floor();
       }
     });
+    function liveSessionsForNode(components, meshId, nodeId) {
+      try {
+        const instances = components.instanceManager?.getByCategory?.("cli") || [];
+        const sessions = [];
+        for (const inst of instances) {
+          const state = inst.getState?.();
+          if (!state) continue;
+          const settings = state.settings || {};
+          if (readNonEmptyString(settings.meshNodeFor) !== meshId) continue;
+          const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+          if (!daemonIdsEquivalent(instNodeId, nodeId)) continue;
+          const status = readNonEmptyString(state.status).toLowerCase();
+          if (isTerminalSessionStatus(status)) continue;
+          const sessionId = readNonEmptyString(state.instanceId);
+          if (!sessionId) continue;
+          sessions.push({
+            sessionId,
+            ...readNonEmptyString(settings.providerType) ? { providerType: String(settings.providerType) } : {}
+          });
+        }
+        return sessions;
+      } catch (e) {
+        LOG2.warn("MeshQueue", `Live-session lookup failed for node ${nodeId} (mesh ${meshId}): ${e?.message || e}`);
+        return [];
+      }
+    }
+    function buildDispatchFailedPinnedNotice(opts) {
+      const { taskId, targetSessionId, nodeId, error: error48, liveSessions } = opts;
+      const errorLine = error48 ? ` (${error48})` : "";
+      const others = liveSessions.filter((s2) => !sessionIdsEquivalent(s2.sessionId, targetSessionId));
+      const liveList = others.length > 0 ? `Other live session(s) currently on node '${nodeId}': ${others.map((s2) => `${s2.sessionId}${s2.providerType ? ` (${s2.providerType})` : ""}`).join(", ")}.` : `No other live session was found on node '${nodeId}' at notification time.`;
+      return `[System] Dispatch to pinned session '${targetSessionId}' failed for task ${taskId}${errorLine} and the task returned to pending, STILL PINNED to that same session \u2014 it will keep retrying against it (with backoff) until it either succeeds or a slower liveness backstop (dead-target grace / pin TTL, up to 15min) clears the pin. Do not send a fresh task to '${targetSessionId}' \u2014 it just failed to accept one.
+${liveList}
+If the pin is stale (session is actually gone), re-target now instead of waiting: mesh_queue_requeue(task_id='${taskId}', target_session_id=<live session id>) to re-pin, or mesh_queue_requeue(task_id='${taskId}', clear_target_session=true) to let any compatible session on the node claim it. If this looks transient (session mid-boot/reconnect), no action is needed \u2014 the retry will likely succeed on its own.`;
+    }
+    function notifyCoordinatorOfPinnedDispatchFailure(components, opts) {
+      const targetSessionId = readNonEmptyString(opts.targetSessionId);
+      if (!targetSessionId) return;
+      const liveSessions = liveSessionsForNode(components, opts.meshId, opts.nodeId);
+      const coordinatorMessage = buildDispatchFailedPinnedNotice({
+        taskId: opts.taskId,
+        targetSessionId,
+        nodeId: opts.nodeId,
+        error: opts.error,
+        liveSessions
+      });
+      const targetCoordinatorDaemonId = readNonEmptyString(opts.sourceCoordinatorDaemonId) || readNonEmptyString(loadConfig2().machineId);
+      const targetCoordinatorSessionId = readNonEmptyString(opts.sourceCoordinatorSessionId);
+      LOG2.warn("MeshQueue", `COORD-NOTIFY-STUCK: dispatch of pinned task ${opts.taskId} to session ${targetSessionId} (node ${opts.nodeId}, mesh ${opts.meshId}) failed and requeued with pin intact.`);
+      try {
+        queuePendingMeshCoordinatorEvent({
+          event: "mesh:dispatch_blocked",
+          meshId: opts.meshId,
+          nodeLabel: opts.nodeId,
+          nodeId: opts.nodeId,
+          metadataEvent: {
+            source: "mesh_pinned_dispatch_failed",
+            taskId: opts.taskId,
+            reason: DISPATCH_FAILED_PINNED_REASON,
+            targetSessionId,
+            liveSessionIds: liveSessions.map((s2) => s2.sessionId),
+            coordinatorMessage
+          },
+          coordinatorMessage,
+          queuedAt: Date.now(),
+          ...targetCoordinatorDaemonId ? { targetCoordinatorDaemonId } : {},
+          ...targetCoordinatorSessionId ? { targetCoordinatorSessionId } : {}
+        });
+      } catch (e) {
+        LOG2.warn("MeshQueue", `Failed to surface pinned-dispatch-failure notification for task ${opts.taskId} (mesh ${opts.meshId}): ${e?.message || e}`);
+      }
+    }
+    function buildReclaimedPinnedNotice(opts) {
+      const { taskId, targetSessionId, nodeId, reclaimReason, silentForMs, liveSessions } = opts;
+      const silentMin = Math.round(silentForMs / 6e4);
+      const others = liveSessions.filter((s2) => !sessionIdsEquivalent(s2.sessionId, targetSessionId));
+      const liveList = others.length > 0 ? `Other live session(s) currently on node '${nodeId}': ${others.map((s2) => `${s2.sessionId}${s2.providerType ? ` (${s2.providerType})` : ""}`).join(", ")}.` : `No other live session was found on node '${nodeId}' at notification time.`;
+      return `[System] Task ${taskId} was reclaimed from pinned session '${targetSessionId}' (node '${nodeId}') after ${silentMin}min with no confirmed progress (${reclaimReason}), and returned to pending STILL PINNED to that same session \u2014 it will keep re-offering itself ONLY to '${targetSessionId}' and to nothing else. If that session is actually gone or wedged, it will keep failing silently until you act.
+${liveList}
+Re-target now if the pin is stale: mesh_queue_requeue(task_id='${taskId}', target_session_id=<live session id>) to re-pin, or mesh_queue_requeue(task_id='${taskId}', clear_target_session=true) to let any compatible session on the node claim it. If '${targetSessionId}' is expected to reconnect and resume, no action is needed.`;
+    }
+    function notifyCoordinatorOfPinnedReclaim(components, opts) {
+      const targetSessionId = readNonEmptyString(opts.targetSessionId);
+      if (!targetSessionId) return;
+      const liveSessions = liveSessionsForNode(components, opts.meshId, opts.nodeId);
+      const coordinatorMessage = buildReclaimedPinnedNotice({
+        taskId: opts.taskId,
+        targetSessionId,
+        nodeId: opts.nodeId,
+        reclaimReason: opts.reclaimReason,
+        silentForMs: opts.silentForMs,
+        liveSessions
+      });
+      const targetCoordinatorDaemonId = readNonEmptyString(opts.sourceCoordinatorDaemonId) || readNonEmptyString(loadConfig2().machineId);
+      const targetCoordinatorSessionId = readNonEmptyString(opts.sourceCoordinatorSessionId);
+      LOG2.warn("MeshQueue", `COORD-NOTIFY-STUCK: pinned task ${opts.taskId} reclaimed from session ${targetSessionId} (node ${opts.nodeId}, mesh ${opts.meshId}) after ${Math.round(opts.silentForMs / 6e4)}min silence and requeued with pin intact.`);
+      try {
+        queuePendingMeshCoordinatorEvent({
+          event: "mesh:dispatch_blocked",
+          meshId: opts.meshId,
+          nodeLabel: opts.nodeId,
+          nodeId: opts.nodeId,
+          metadataEvent: {
+            source: "mesh_pinned_stranded_reclaim",
+            taskId: opts.taskId,
+            reason: RECLAIMED_PINNED_REASON,
+            targetSessionId,
+            liveSessionIds: liveSessions.map((s2) => s2.sessionId),
+            coordinatorMessage
+          },
+          coordinatorMessage,
+          queuedAt: Date.now(),
+          ...targetCoordinatorDaemonId ? { targetCoordinatorDaemonId } : {},
+          ...targetCoordinatorSessionId ? { targetCoordinatorSessionId } : {}
+        });
+      } catch (e) {
+        LOG2.warn("MeshQueue", `Failed to surface pinned-reclaim notification for task ${opts.taskId} (mesh ${opts.meshId}): ${e?.message || e}`);
+      }
+    }
+    var DISPATCH_FAILED_PINNED_REASON;
+    var RECLAIMED_PINNED_REASON;
+    var init_mesh_dispatch_failed_notify = __esm2({
+      "src/mesh/mesh-dispatch-failed-notify.ts"() {
+        "use strict";
+        init_logger();
+        init_dist();
+        init_mesh_events_utils();
+        init_mesh_events_pending();
+        init_config();
+        init_mesh_candidacy_predicates();
+        DISPATCH_FAILED_PINNED_REASON = "pinned_session_dispatch_failed";
+        RECLAIMED_PINNED_REASON = "pinned_session_reclaimed_stranded";
+      }
+    });
+    function selectQuotaBusyFallback(args) {
+      const { clearOrder, candidates, busyProviderType, probe } = args;
+      const slotByProvider = /* @__PURE__ */ new Map();
+      for (const candidate of candidates) {
+        if (!slotByProvider.has(candidate.providerType)) {
+          slotByProvider.set(candidate.providerType, candidate);
+        }
+      }
+      const skipped = [];
+      const seen = /* @__PURE__ */ new Set([busyProviderType]);
+      for (const providerType of clearOrder) {
+        if (seen.has(providerType)) continue;
+        seen.add(providerType);
+        const candidate = slotByProvider.get(providerType);
+        if (!candidate) continue;
+        if (probe(candidate)) {
+          return { outcome: "fallback", candidate, skipped };
+        }
+        skipped.push(providerType);
+      }
+      return { outcome: "exhausted", skipped };
+    }
+    var init_mesh_quota_fallback = __esm2({
+      "src/mesh/mesh-quota-fallback.ts"() {
+        "use strict";
+      }
+    });
     function localCoordinatorDaemonId2() {
       return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
     }
@@ -70591,6 +70747,16 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           });
           if (requeued?.status === "failed") {
             LOG2.error("MeshQueue", `Task ${ctx.task.id} (mesh ${ctx.meshId}) failed after repeated dispatch failures to node ${ctx.nodeId} \u2014 the worker never started it: ${requeued.cancelReason || "dispatch_never_started"}. Dependents were unblocked.`);
+          } else if (requeued?.status === "pending" && readNonEmptyString(requeued.targetSessionId)) {
+            notifyCoordinatorOfPinnedDispatchFailure(ctx.components, {
+              meshId: ctx.meshId,
+              taskId: ctx.task.id,
+              targetSessionId: requeued.targetSessionId,
+              nodeId: ctx.nodeId,
+              error: e?.message,
+              sourceCoordinatorSessionId: ctx.sourceCoordinatorSessionId,
+              sourceCoordinatorDaemonId: ctx.sourceCoordinatorDaemonId
+            });
           }
         }
         try {
@@ -70862,6 +71028,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
               providerType,
               task,
               transport: "remote",
+              components,
               ...sourceCoordinatorSessionId ? { sourceCoordinatorSessionId } : {},
               ...localDaemonIdForDispatch ? { sourceCoordinatorDaemonId: localDaemonIdForDispatch } : {},
               ...routingDecision ? { routingDecision } : {}
@@ -70933,6 +71100,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           providerType,
           task,
           transport: "local",
+          components,
           ...readNonEmptyString(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString(task.sourceCoordinatorSessionId) } : {},
           ...localCoordinatorDaemonId2() ? { sourceCoordinatorDaemonId: localCoordinatorDaemonId2() } : {},
           ...routingDecision ? { routingDecision } : {}
@@ -71734,6 +71902,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_auto_fast_forward();
         init_mesh_skip_notify();
         init_mesh_task_parking();
+        init_mesh_dispatch_failed_notify();
         init_mesh_scheduling_fitness();
         init_mesh_queue_observability();
         init_mesh_routing_decision();
@@ -79491,6 +79660,17 @@ ${cleanBody}`;
               meshId,
               event: "agent:generating_completed"
             }, `delivered ${Math.round((nowMs - dispatchedAtMs) / 1e3)}s ${reclaimReason} \u2192 ${reclaimedLost.status}`);
+            if (reclaimedLost.status === "pending" && readNonEmptyString(reclaimedLost.targetSessionId) && row.assignedNodeId) {
+              notifyCoordinatorOfPinnedReclaim(components, {
+                meshId,
+                taskId: row.id,
+                targetSessionId: reclaimedLost.targetSessionId,
+                nodeId: row.assignedNodeId,
+                reclaimReason,
+                silentForMs: nowMs - dispatchedAtMs,
+                ...readNonEmptyString(row.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: row.sourceCoordinatorSessionId } : {}
+              });
+            }
           }
           continue;
         }
@@ -79645,6 +79825,7 @@ ${cleanBody}`;
         init_mesh_event_forwarding();
         init_mesh_turn_ledger();
         init_mesh_turn_presentation();
+        init_mesh_dispatch_failed_notify();
         ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
         DELIVERED_NO_TURN_DEADLINE_MS = 15 * 6e4;
         NATIVE_SOURCE_ACTIVITY_STALE_MS = 10 * 6e4;
@@ -81347,6 +81528,78 @@ ${cleanBody}`;
         WHOLE_SCREEN = -1;
       }
     });
+    var mesh_refine_executor_liveness_exports = {};
+    __export2(mesh_refine_executor_liveness_exports, {
+      buildRefineExecutorStamp: () => buildRefineExecutorStamp,
+      currentRefineExecutorBootId: () => currentRefineExecutorBootId,
+      evaluateRefineExecutorLiveness: () => evaluateRefineExecutorLiveness,
+      readRefineExecutorStamp: () => readRefineExecutorStamp
+    });
+    function buildRefineExecutorStamp(nowIso) {
+      return {
+        host: (0, import_node_os2.hostname)(),
+        pid: process.pid,
+        bootId: BOOT_ID,
+        stampedAt: nowIso ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    function currentRefineExecutorBootId() {
+      return BOOT_ID;
+    }
+    function defaultIsPidAlive(pid) {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch (e) {
+        if (e?.code === "ESRCH") return false;
+        return true;
+      }
+    }
+    function evaluateRefineExecutorLiveness(stamp2, opts = {}) {
+      const s2 = stamp2;
+      if (!s2 || typeof s2 !== "object") {
+        return { liveness: "unknown", reason: "no_executor_stamp" };
+      }
+      const pid = typeof s2.pid === "number" && Number.isInteger(s2.pid) && s2.pid > 0 ? s2.pid : void 0;
+      const host = typeof s2.host === "string" && s2.host.trim() ? s2.host.trim() : void 0;
+      if (!pid || !host) {
+        return { liveness: "unknown", reason: "incomplete_executor_stamp" };
+      }
+      const localHost = opts.localHost ?? (0, import_node_os2.hostname)();
+      if (host !== localHost) {
+        return { liveness: "unknown", reason: `executor_stamp_from_other_host:${host}` };
+      }
+      const localBootId = opts.localBootId ?? BOOT_ID;
+      const localPid = opts.localPid ?? process.pid;
+      if (pid === localPid && s2.bootId && s2.bootId === localBootId) {
+        return { liveness: "alive", reason: "executor_is_this_process" };
+      }
+      if (pid === localPid && s2.bootId && s2.bootId !== localBootId) {
+        return { liveness: "dead", reason: "executor_pid_recycled_by_this_process" };
+      }
+      const probe = opts.isPidAlive ?? defaultIsPidAlive;
+      let alive;
+      try {
+        alive = probe(pid);
+      } catch {
+        return { liveness: "unknown", reason: "liveness_probe_failed" };
+      }
+      return alive ? { liveness: "alive", reason: `executor_pid_${pid}_alive` } : { liveness: "dead", reason: `executor_pid_${pid}_gone` };
+    }
+    function readRefineExecutorStamp(payload) {
+      const stamp2 = payload?.refineJob?.executor ?? payload?.executor;
+      if (!stamp2 || typeof stamp2 !== "object") return void 0;
+      return stamp2;
+    }
+    var import_node_os2;
+    var BOOT_ID;
+    var init_mesh_refine_executor_liveness = __esm2({
+      "src/mesh/mesh-refine-executor-liveness.ts"() {
+        "use strict";
+        import_node_os2 = require("os");
+        BOOT_ID = `${process.pid}-${Date.now().toString(36)}-${Math.floor(Math.random() * 1e9).toString(36)}`;
+      }
+    });
     var pty_transport_exports = {};
     __export2(pty_transport_exports, {
       NodePtyTransportFactory: () => NodePtyTransportFactory,
@@ -86435,78 +86688,6 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
         waitQueue = [];
       }
     });
-    var mesh_refine_executor_liveness_exports = {};
-    __export2(mesh_refine_executor_liveness_exports, {
-      buildRefineExecutorStamp: () => buildRefineExecutorStamp,
-      currentRefineExecutorBootId: () => currentRefineExecutorBootId,
-      evaluateRefineExecutorLiveness: () => evaluateRefineExecutorLiveness,
-      readRefineExecutorStamp: () => readRefineExecutorStamp
-    });
-    function buildRefineExecutorStamp(nowIso) {
-      return {
-        host: (0, import_node_os2.hostname)(),
-        pid: process.pid,
-        bootId: BOOT_ID,
-        stampedAt: nowIso ?? (/* @__PURE__ */ new Date()).toISOString()
-      };
-    }
-    function currentRefineExecutorBootId() {
-      return BOOT_ID;
-    }
-    function defaultIsPidAlive(pid) {
-      try {
-        process.kill(pid, 0);
-        return true;
-      } catch (e) {
-        if (e?.code === "ESRCH") return false;
-        return true;
-      }
-    }
-    function evaluateRefineExecutorLiveness(stamp2, opts = {}) {
-      const s2 = stamp2;
-      if (!s2 || typeof s2 !== "object") {
-        return { liveness: "unknown", reason: "no_executor_stamp" };
-      }
-      const pid = typeof s2.pid === "number" && Number.isInteger(s2.pid) && s2.pid > 0 ? s2.pid : void 0;
-      const host = typeof s2.host === "string" && s2.host.trim() ? s2.host.trim() : void 0;
-      if (!pid || !host) {
-        return { liveness: "unknown", reason: "incomplete_executor_stamp" };
-      }
-      const localHost = opts.localHost ?? (0, import_node_os2.hostname)();
-      if (host !== localHost) {
-        return { liveness: "unknown", reason: `executor_stamp_from_other_host:${host}` };
-      }
-      const localBootId = opts.localBootId ?? BOOT_ID;
-      const localPid = opts.localPid ?? process.pid;
-      if (pid === localPid && s2.bootId && s2.bootId === localBootId) {
-        return { liveness: "alive", reason: "executor_is_this_process" };
-      }
-      if (pid === localPid && s2.bootId && s2.bootId !== localBootId) {
-        return { liveness: "dead", reason: "executor_pid_recycled_by_this_process" };
-      }
-      const probe = opts.isPidAlive ?? defaultIsPidAlive;
-      let alive;
-      try {
-        alive = probe(pid);
-      } catch {
-        return { liveness: "unknown", reason: "liveness_probe_failed" };
-      }
-      return alive ? { liveness: "alive", reason: `executor_pid_${pid}_alive` } : { liveness: "dead", reason: `executor_pid_${pid}_gone` };
-    }
-    function readRefineExecutorStamp(payload) {
-      const stamp2 = payload?.refineJob?.executor ?? payload?.executor;
-      if (!stamp2 || typeof stamp2 !== "object") return void 0;
-      return stamp2;
-    }
-    var import_node_os2;
-    var BOOT_ID;
-    var init_mesh_refine_executor_liveness = __esm2({
-      "src/mesh/mesh-refine-executor-liveness.ts"() {
-        "use strict";
-        import_node_os2 = require("os");
-        BOOT_ID = `${process.pid}-${Date.now().toString(36)}-${Math.floor(Math.random() * 1e9).toString(36)}`;
-      }
-    });
     function resolveRefineResumeDispatchGraceMs() {
       return resolveTunedReconcileMs("MESH_REFINE_RESUME_DISPATCH_GRACE_MS", 6e4, 0, 10 * 6e4);
     }
@@ -88702,29 +88883,6 @@ ${e?.stderr || ""}`;
         RETRYABLE_BASE_MOVEMENT_CODES = /* @__PURE__ */ new Set(["base_moved", "base_locked", "base_cas_undeterminable"]);
       }
     });
-    var channel_migration_exports = {};
-    __export2(channel_migration_exports, {
-      migrateProviderChannelConfig: () => migrateProviderChannelConfig
-    });
-    function migrateProviderChannelConfig(env2 = process.env) {
-      const config2 = loadConfig2();
-      const existing = (config2.providerChannel ?? "").trim();
-      if (existing) {
-        return { migrated: false, channel: existing === "preview" ? "preview" : "stable" };
-      }
-      const durableEnv = { ...env2 };
-      delete durableEnv[PROVIDER_CHANNEL_ENV_VAR];
-      const channel = resolveProviderChannel(void 0, durableEnv, config2.updateChannel);
-      updateConfig({ providerChannel: channel });
-      return { migrated: true, channel };
-    }
-    var init_channel_migration = __esm2({
-      "src/providers/channel/channel-migration.ts"() {
-        "use strict";
-        init_config();
-        init_contract();
-      }
-    });
     var require_canonicalize = __commonJS2({
       "../../vendor/seqscribe/node_modules/canonicalize/lib/canonicalize.js"(exports22, module22) {
         "use strict";
@@ -88760,6 +88918,29 @@ ${e?.stderr || ""}`;
         };
       }
     });
+    var channel_migration_exports = {};
+    __export2(channel_migration_exports, {
+      migrateProviderChannelConfig: () => migrateProviderChannelConfig
+    });
+    function migrateProviderChannelConfig(env2 = process.env) {
+      const config2 = loadConfig2();
+      const existing = (config2.providerChannel ?? "").trim();
+      if (existing) {
+        return { migrated: false, channel: existing === "preview" ? "preview" : "stable" };
+      }
+      const durableEnv = { ...env2 };
+      delete durableEnv[PROVIDER_CHANNEL_ENV_VAR];
+      const channel = resolveProviderChannel(void 0, durableEnv, config2.updateChannel);
+      updateConfig({ providerChannel: channel });
+      return { migrated: true, channel };
+    }
+    var init_channel_migration = __esm2({
+      "src/providers/channel/channel-migration.ts"() {
+        "use strict";
+        init_config();
+        init_contract();
+      }
+    });
     var index_exports = {};
     __export2(index_exports, {
       ADHDEV_AUTHORITY_ID: () => ADHDEV_AUTHORITY_ID,
@@ -103862,6 +104043,170 @@ ${marker}`,
         appendUpgradeLog(`Stale staging cleanup skipped (${error48?.code || "error"}): ${error48?.message || String(error48)}`);
       }
     }
+    function resolvePosixBinNames(packageName) {
+      const base = packageName.startsWith("@") ? packageName.split("/")[1] : packageName;
+      const names = [base];
+      if (packageName === "@adhdev/daemon-standalone") {
+        names.push("adhdev-standalone");
+      }
+      return names;
+    }
+    function smokeTestInstalledBins(prefix, packageName) {
+      const binDir = path33.join(prefix, "bin");
+      const names = resolvePosixBinNames(packageName);
+      const baseShim = path33.join(binDir, names[0]);
+      if (!fs26.existsSync(baseShim)) {
+        throw new Error(`installed CLI shim is missing: ${baseShim}`);
+      }
+      for (const name of names) {
+        const shimPath = path33.join(binDir, name);
+        if (!fs26.existsSync(shimPath)) continue;
+        (0, import_child_process8.execFileSync)(shimPath, ["--version"], {
+          encoding: "utf8",
+          stdio: "pipe",
+          timeout: 3e4,
+          ...process.platform === "win32" ? { windowsHide: true } : {}
+        });
+      }
+    }
+    function backupPosixInstall(options) {
+      try {
+        fs26.mkdirSync(options.configDir, { recursive: true });
+        const backupDir = fs26.mkdtempSync(path33.join(options.configDir, "upgrade-backup-"));
+        fs26.cpSync(options.packageRoot, path33.join(backupDir, "package"), { recursive: true });
+        const binShims = [];
+        const binDir = path33.join(options.installPrefix, "bin");
+        for (const name of resolvePosixBinNames(options.packageName)) {
+          const shim = path33.join(binDir, name);
+          if (fs26.existsSync(shim)) {
+            fs26.cpSync(shim, path33.join(backupDir, `bin-${name}`), { recursive: true });
+            binShims.push(shim);
+          }
+        }
+        return { backupDir, packageRoot: options.packageRoot, binShims };
+      } catch (error48) {
+        appendUpgradeLog(`Install backup failed (${error48?.code || "error"}): ${error48?.message || String(error48)} \u2014 proceeding without a rollback snapshot`, options.configDir);
+        return null;
+      }
+    }
+    function restorePosixInstall(backup) {
+      fs26.rmSync(backup.packageRoot, { recursive: true, force: true });
+      fs26.cpSync(path33.join(backup.backupDir, "package"), backup.packageRoot, { recursive: true });
+      for (const shim of backup.binShims) {
+        fs26.cpSync(path33.join(backup.backupDir, `bin-${path33.basename(shim)}`), shim, { recursive: true });
+      }
+    }
+    function runPosixInPlaceUpgrade(options) {
+      const { payload, installCommand, restartArgv } = options;
+      const configDir = getConfigDir2();
+      const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
+      const { packageRoot, installPrefix } = installCommand.surface;
+      try {
+        for (const entry of fs26.readdirSync(configDir)) {
+          if (entry.startsWith("upgrade-preflight-")) {
+            safeRemoveStaleEntry(path33.join(configDir, entry), "Removed stale pre-flight staging prefix");
+          }
+        }
+      } catch {
+      }
+      const preflightPrefix = (() => {
+        fs26.mkdirSync(configDir, { recursive: true });
+        return fs26.mkdtempSync(path33.join(configDir, "upgrade-preflight-"));
+      })();
+      try {
+        appendUpgradeLog(`Pre-flight: installing ${spec} into throwaway prefix ${preflightPrefix}`);
+        execNpmCommandSync(
+          ["install", "-g", spec, "--prefix", preflightPrefix],
+          {
+            encoding: "utf8",
+            stdio: "pipe",
+            maxBuffer: 20 * 1024 * 1024,
+            env: buildInstallEnvWithNodeOnPath()
+          },
+          installCommand.surface
+        );
+        smokeTestInstalledBins(preflightPrefix, payload.packageName);
+        appendUpgradeLog(`Pre-flight smoke gate passed for ${spec}`);
+      } catch (error48) {
+        const detail = error48?.message || String(error48);
+        appendUpgradeLog(`Pre-flight smoke gate FAILED for ${spec}: ${detail} \u2014 existing install left untouched`);
+        emitUpgradeFailureNotice([
+          `adhdev ${spec} was NOT installed: the package installs but its CLI does not run (\`--version\` failed).`,
+          `Detail: ${detail}`,
+          "Your previous version is untouched and the daemon was restarted on it.",
+          "This is a broken published package \u2014 retry once a fixed version is published."
+        ], configDir, { targetVersion: payload.targetVersion });
+        spawnDetachedDaemonRestart(restartArgv, payload.cwd);
+        throw new Error(`Pre-flight smoke gate failed for ${spec}: ${detail}`);
+      } finally {
+        safeRemoveStaleEntry(preflightPrefix, "Removed pre-flight staging prefix");
+      }
+      const backup = packageRoot && installPrefix ? backupPosixInstall({ packageRoot, installPrefix, packageName: payload.packageName, configDir }) : null;
+      if (backup) {
+        appendUpgradeLog(`Backed up current install to ${backup.backupDir}`);
+      } else {
+        appendUpgradeLog("No rollback snapshot available (package root unresolved or backup failed); relying on the pre-flight gate alone");
+      }
+      const rollbackAndRestart = (cause) => {
+        if (backup) {
+          try {
+            restorePosixInstall(backup);
+            appendUpgradeLog("Rollback restored the previous install");
+            safeRemoveStaleEntry(backup.backupDir, "Removed upgrade backup after rollback");
+          } catch (error48) {
+            appendUpgradeLog(`ROLLBACK FAILED (${error48?.code || "error"}): ${error48?.message || String(error48)} \u2014 snapshot retained at ${backup.backupDir}`);
+            emitUpgradeFailureNotice([
+              `adhdev ${spec} install failed (${cause}) AND the automatic rollback failed.`,
+              `A snapshot of the previous working install is preserved at: ${backup.backupDir}`,
+              "To recover manually, reinstall the previous version:",
+              `  ${buildManualRecoveryCommand(installCommand)}`
+            ], configDir, { targetVersion: payload.targetVersion });
+            spawnDetachedDaemonRestart(restartArgv, payload.cwd);
+            throw new Error(`Install failed and rollback failed for ${spec}: ${cause}`);
+          }
+        }
+        emitUpgradeFailureNotice([
+          `adhdev ${spec} install failed (${cause}); the previous version was ${backup ? "restored" : "left as-is (no snapshot available)"}.`,
+          `The daemon was restarted on the previous version. See ${getUpgradeLogPath(configDir)} for the full trace.`,
+          "To retry manually:",
+          `  ${buildManualRecoveryCommand(installCommand)}`
+        ], configDir, { targetVersion: payload.targetVersion });
+        spawnDetachedDaemonRestart(restartArgv, payload.cwd);
+      };
+      let installOutput = "";
+      try {
+        installOutput = String((0, import_child_process8.execFileSync)(
+          installCommand.command,
+          installCommand.args,
+          {
+            encoding: "utf8",
+            stdio: "pipe",
+            maxBuffer: 20 * 1024 * 1024,
+            env: buildInstallEnvWithNodeOnPath(),
+            ...installCommand.execOptions
+          }
+        ));
+      } catch (error48) {
+        rollbackAndRestart(`npm install exited non-zero: ${error48?.message || String(error48)}`);
+        throw error48;
+      }
+      if (installOutput.trim()) {
+        appendUpgradeLog(installOutput.trim());
+      }
+      if (installPrefix) {
+        try {
+          smokeTestInstalledBins(installPrefix, payload.packageName);
+        } catch (error48) {
+          rollbackAndRestart(`installed CLI failed its --version smoke test: ${error48?.message || String(error48)}`);
+          throw error48;
+        }
+      }
+      if (backup) {
+        safeRemoveStaleEntry(backup.backupDir, "Removed upgrade backup after successful install");
+      }
+      spawnDetachedDaemonRestart(restartArgv, payload.cwd);
+      clearUpgradeFailureNotice();
+    }
     function spawnDetachedDaemonUpgradeHelper(payload) {
       const env2 = buildUpgradeHelperChildEnv(payload);
       const child = (0, import_child_process9.spawn)(process.execPath, process.argv.slice(1), {
@@ -103986,6 +104331,10 @@ ${marker}`,
       }
       await stopForeignNativeAddonHolders(installCommand.surface.packageRoot, { parentPid: payload.parentPid });
       cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
+      if (process.platform !== "win32") {
+        runPosixInPlaceUpgrade({ payload, installCommand, restartArgv });
+        return;
+      }
       const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
       appendUpgradeLog(`Installing ${spec}`);
       const maxInstallAttempts = process.platform === "win32" ? 3 : 1;
@@ -104104,6 +104453,7 @@ ${marker}`,
     init_build_info();
     init_track_identity();
     init_coordinator_registry();
+    init_mesh_refine_executor_liveness();
     init_types();
     init_deps();
     init_refresh();
@@ -104141,7 +104491,15 @@ ${marker}`,
           // that omits this field must remain "unknown" to remote consumers.
           daemonBuild: { ...getDaemonBuildInfo(), track: TRACK },
           upgradeFailure: readUpgradeFailureNotice(),
-          providerChannelStaleness: ctx.deps.providerLoader?.getChannelStalenessSnapshot?.() ?? null
+          providerChannelStaleness: ctx.deps.providerLoader?.getChannelStalenessSnapshot?.() ?? null,
+          // Per-process id, minted once at module load (mesh-refine-executor-
+          // liveness.ts) — differs across a real process restart even if the
+          // OS reissues the same pid, unlike daemonBuild.builtAt (build time,
+          // not boot time) or machine uptime (survives a daemon restart
+          // untouched). A coordinator that called restart_daemon_node can
+          // read this before and after (per the clientHint retry delay) and
+          // compare: same id means the daemon never actually exited/re-spawned.
+          bootId: currentRefineExecutorBootId()
         };
       },
       /**
@@ -104575,15 +104933,17 @@ ${marker}`,
           if (direction !== null && direction < 0) {
             LOG2.warn("Upgrade", `allowDowngrade set \u2014 proceeding with DOWNGRADE from v${runningVersion} to v${latest} on the ${TRACK} track`);
           }
+          const killSessionHost = args?.killSessionHost === true;
           spawnDetachedDaemonUpgradeHelper({
             packageName: pkgName,
             targetVersion: latest,
             parentPid: process.pid,
             restartArgv: process.argv.slice(1),
             cwd: process.cwd(),
-            sessionHostAppName: resolveSessionHostAppName()
+            sessionHostAppName: resolveSessionHostAppName(),
+            killSessionHost
           });
-          LOG2.info("Upgrade", `Scheduled detached ${TRACK} upgrade to v${latest}`);
+          LOG2.info("Upgrade", `Scheduled detached ${TRACK} upgrade to v${latest}${killSessionHost ? " (killSessionHost requested)" : ""}`);
           setTimeout(() => {
             LOG2.info("Upgrade", "Exiting daemon so detached upgrader can continue...");
             process.exit(0);
@@ -104597,6 +104957,7 @@ ${marker}`,
             npmTag,
             outcome: "scheduled",
             targetVersion: latest,
+            killSessionHost,
             // No `currentVersion` here on purpose: this response is about a
             // SCHEDULED move, and daemon-upgrade-scheduled-intent.test.ts
             // pins that it must not read as "already on the target". The
@@ -126232,12 +126593,12 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         warnings.push("forced restart over active sessions \u2014 in-flight turns were interrupted and the in-memory pendingOutboundQueue is permanently lost (no persistence/restore path).");
       }
       if (args.killSessionHost) {
-        warnings.push("killSessionHost: the session-host process was stopped \u2014 ALL hosted CLI sessions on this machine are destroyed (hard refresh).");
+        warnings.push("killSessionHost requested: the detached restart helper will attempt to stop the session-host process after this daemon exits \u2014 if it succeeds, ALL hosted CLI sessions on this machine are destroyed (hard refresh). This response cannot confirm the stop succeeded; check the daemon's upgrade log, or call get_status_metadata and compare bootId before/after, to verify.");
       }
       if (process.platform === "win32") {
-        warnings.push("Windows: the daemon restart/upgrade path stops the session-host regardless of options \u2014 all hosted sessions terminate.");
+        warnings.push("Windows: the daemon restart/upgrade path attempts to stop the session-host regardless of options \u2014 all hosted sessions are expected to terminate.");
       } else {
-        warnings.push("POSIX: hosted PTY sessions survive a plain daemon restart and rebind on next boot (unless killSessionHost was set).");
+        warnings.push("POSIX: hosted PTY sessions are expected to survive a plain daemon restart and rebind on next boot, unless killSessionHost was requested (and the stop attempt succeeds).");
       }
       return warnings;
     }
@@ -126250,6 +126611,11 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         ...result,
         mode,
         restarted: restarting,
+        // HONESTY: what was REQUESTED, always reported regardless of outcome
+        // (which this process cannot know — see restartWarnings). Do not
+        // rename this to something implying success; sessionHostKillRequested
+        // is the accurate name for "the flag was set and forwarded".
+        sessionHostKillRequested: killSessionHost,
         ...restarting ? {
           warnings: restartWarnings({ killSessionHost, forced: opts.forced }),
           // MCP IPC has no automatic reconnect/retry — tell the caller when to
@@ -139000,835 +139366,69 @@ data: ${JSON.stringify(msg.data)}
       };
     }
     init_require_whitelist();
-    async function initDaemonComponents2(config2) {
-      applyProcessHardening();
-      installProviderProcessShim();
-      installGlobalInterceptor();
-      loadMeshCoordinatorRegistry();
-      const upgradeFailureNotice = readUpgradeFailureNotice();
-      if (upgradeFailureNotice) {
-        const age = upgradeFailureNotice.ageLabel ? `${upgradeFailureNotice.ageLabel}, recorded ${upgradeFailureNotice.recordedAt}` : "recorded at an unknown time";
-        const target = upgradeFailureNotice.targetVersion ? `, attempted target v${upgradeFailureNotice.targetVersion}` : "";
-        const running = (config2.statusVersion || "").trim().replace(/^v/, "");
-        const supersededHint = upgradeFailureNotice.targetVersion && running && upgradeFailureNotice.targetVersion.replace(/^v/, "") !== running ? ` This notice targets a DIFFERENT version than the one now running (v${running}) \u2014 it is most likely a stale record of an earlier attempt, not a report about this boot.` : "";
-        LOG2.warn("Upgrade", `Previous daemon upgrade FAILED and was rolled back \u2014 this daemon is running the previous version. Notice (${age}${target}) at ${upgradeFailureNotice.noticePath}:
-${upgradeFailureNotice.notice}${supersededHint}`);
+    var import_fs21 = require("fs");
+    var import_path24 = require("path");
+    init_config();
+    init_logger();
+    var FLEET_SECRET_FILE = "seqscribe-fleet-secret.json";
+    function fleetSecretPath(env2) {
+      return (0, import_path24.join)(getConfigDir2(env2), FLEET_SECRET_FILE);
+    }
+    function loadStoredFleetSecret(env2) {
+      const path63 = fleetSecretPath(env2);
+      if (!(0, import_fs21.existsSync)(path63)) return null;
+      let raw;
+      try {
+        raw = (0, import_fs21.readFileSync)(path63, "utf-8");
+      } catch (err) {
+        LOG2.warn(
+          "Seqscribe",
+          `fleet secret file unreadable (${err instanceof Error ? err.message : String(err)}); ignoring it`
+        );
+        return null;
       }
       try {
-        const { migrateProviderChannelConfig: migrateProviderChannelConfig2 } = await Promise.resolve().then(() => (init_channel_migration(), channel_migration_exports));
-        const migration = migrateProviderChannelConfig2();
-        if (migration.migrated) {
-          LOG2.info("Providers", `Recorded explicit providerChannel=${migration.channel} in config (migrated from build-track/updateChannel derivation)`);
+        const parsed = JSON.parse(raw);
+        if (parsed !== null && typeof parsed === "object" && typeof parsed.secret === "string" && parsed.secret.length > 0 && Number.isInteger(parsed.version) && parsed.version >= 1) {
+          const { secret, version: version2 } = parsed;
+          return { secret, version: version2 };
         }
       } catch {
       }
-      const appConfig = loadConfig2();
-      const providerSourceMode = appConfig.providerSourceMode || "normal";
-      const disableUpstream = providerSourceMode === "no-upstream";
-      const providerLoader = new ProviderLoader({
-        logFn: config2.providerLogFn,
-        // Shared config projection — keeps this site, launch.ts, and the CLI
-        // factory from drifting (the launch path once dropped userDir/sourceMode).
-        ...providerLoaderConfigOptions(appConfig),
-        // The boot path resolves sourceMode with an explicit 'normal' default
-        // for the disableUpstream derivation above — keep that authoritative.
-        sourceMode: providerSourceMode,
-        // Enables the daemon-update = provider-activation stamp (option C):
-        // a boot on a NEW daemon version runs one verified sync; same-version
-        // boots stay network-free.
-        daemonVersion: config2.statusVersion
-      });
-      providerLoader.loadAll();
-      providerLoader.registerToDetector();
-      const hasExplicitChannelSignal = Boolean(
-        appConfig.providerChannel && appConfig.providerChannel.trim() || (process.env[PROVIDER_CHANNEL_ENV_VAR] ?? "").trim() || isPreviewReleaseChannel(appConfig.updateChannel)
-      );
-      const resolvedConfigDir = getConfigDir2();
-      const channelMismatch = configDirChannelMismatch(resolvedConfigDir, providerLoader.channel, hasExplicitChannelSignal);
-      if (channelMismatch) {
-        LOG2.warn("Init", `Config dir looks like the ${channelMismatch.impliedTrack} track (${resolvedConfigDir}) but the resolved provider channel is '${channelMismatch.channel}'. This usually means the build-track stamp (__ADHDEV_BUILD_CHANNEL__) was absent for this process \u2014 e.g. running via tsx/ts-node instead of a built bundle \u2014 so provider-channel resolution fell through to its 'stable' default instead of following ADHDEV_CONFIG_DIR. Impact: providers installed under the OTHER channel's store will not be visible (can present as 0 providers loaded). Fix: set ADHDEV_PROVIDER_CHANNEL=${channelMismatch.impliedTrack} (or config.providerChannel) explicitly for this process, or run the built bundle instead of source.`);
+      LOG2.warn("Seqscribe", "fleet secret file is malformed; ignoring it (provisional mode)");
+      return null;
+    }
+    function storeFleetSecret(secret, version2, env2) {
+      if (typeof secret !== "string" || secret.length === 0) {
+        throw new Error("storeFleetSecret requires a non-empty secret string");
       }
-      void providerLoader.maybeFirstSyncVerifiedChannel().then(async (report) => {
-        if (!report) return null;
-        if (report.status === "error") {
-          LOG2.warn("Init", `Verified channel first-sync failed (last-known-good preserved): ${report.errors.map((e) => e.code).join(", ") || "unknown"}`);
-        } else if (report.activated.length > 0) {
-          LOG2.info("Init", `Verified channel first-sync activated ${report.activated.length} providers (${providerLoader.channel})`);
-          providerLoader.registerToDetector();
-          await refreshProviderAvailability();
-          config2.onStatusChange?.();
-        }
-        return report;
-      }).then(async (firstSyncReport) => {
-        if (firstSyncReport) return;
-        const report = await providerLoader.maybeSyncVerifiedChannelOnDaemonUpdate();
-        if (!report) return;
-        if (report.status === "error") {
-          LOG2.warn("Init", `Daemon-update channel sync failed (last-known-good preserved, retries next boot): ${report.errors.map((e) => e.code).join(", ") || "unknown"}`);
-        } else if (report.activated.length > 0) {
-          LOG2.info("Init", `Daemon-update channel sync activated ${report.activated.length} providers (${providerLoader.channel})`);
-          providerLoader.registerToDetector();
-          await refreshProviderAvailability();
-          config2.onStatusChange?.();
-        }
-      }).catch((e) => LOG2.warn("Init", `Verified channel boot sync error: ${e?.message || e}`));
-      const runStalenessProbe = async () => {
-        try {
-          const snap = await providerLoader.checkVerifiedChannelStaleness();
-          if (snap.error) {
-            LOG2.debug("Provider", `Channel staleness probe failed (kept previous snapshot): ${snap.error}`);
-          } else if (snap.staleTypes.length > 0 || snap.newTypes.length > 0) {
-            LOG2.info("Provider", `Channel staleness: ${snap.staleTypes.length} stale [${snap.staleTypes.join(", ")}], ${snap.newTypes.length} never-installed [${snap.newTypes.join(", ")}] (${snap.channel})`);
-            config2.onStatusChange?.();
-          }
-        } catch (e) {
-          LOG2.debug("Provider", `Channel staleness probe error: ${e?.message || e}`);
-        }
-      };
-      const stalenessInitialTimer = setTimeout(() => {
-        void runStalenessProbe();
-      }, 10 * 6e4);
-      stalenessInitialTimer.unref?.();
-      const stalenessIntervalTimer = setInterval(() => {
-        void runStalenessProbe();
-      }, 24 * 60 * 6e4);
-      stalenessIntervalTimer.unref?.();
-      const providerStalenessProbe = {
-        stop() {
-          clearTimeout(stalenessInitialTimer);
-          clearInterval(stalenessIntervalTimer);
-        }
-      };
-      setDefaultProviderLoader(providerLoader);
-      const versionArchive = new VersionArchive();
-      providerLoader.setVersionArchive(versionArchive);
-      setTimeout(() => {
-        void detectAllVersions(providerLoader, versionArchive).then((versionResults) => {
-          const installedProviders = versionResults.filter((v) => v.installed);
-          const withVersion = installedProviders.filter((v) => v.version);
-          LOG2.info("Init", `Provider versions: ${installedProviders.length} installed, ${withVersion.length} versioned`);
-          for (const v of withVersion) {
-            LOG2.info("Init", `  ${v.type} (${v.category}): v${v.version}${v.warning ? " \u26A0 " + v.warning : ""}`);
-          }
-          const noVersion = installedProviders.filter((v) => !v.version);
-          if (noVersion.length > 0) {
-            LOG2.warn("Init", `  ${noVersion.length} installed but version unknown: ${noVersion.map((v) => v.type).join(", ")}`);
-          }
-        }).catch(() => {
-        });
-      }, 0);
-      const instanceManager = new ProviderInstanceManager();
-      const cdpManagers = /* @__PURE__ */ new Map();
-      const sessionRegistry = new SessionRegistry();
-      setTranscriptClaimLivenessProbe((owner) => {
-        const match = /^iid:(.+)$/.exec(owner);
-        if (!match) return true;
-        return sessionRegistry.get(match[1]) !== void 0;
-      });
-      const detectedIdesRef = { value: [] };
-      let agentStreamManager = null;
-      let poller = null;
-      const refreshProviderAvailability = async (providerType) => {
-        const targetProvider = providerType ? providerLoader.getMeta(providerLoader.resolveAlias(providerType)) : null;
-        const targetCategory = targetProvider?.category;
-        if (!providerType || targetCategory === "cli" || targetCategory === "acp") {
-          if (providerType && targetProvider) {
-            const detected = await detectCLI(targetProvider.type, providerLoader, { includeVersion: false });
-            providerLoader.setCliDetectionResults([{
-              id: targetProvider.type,
-              installed: !!detected,
-              path: detected?.path
-            }], false);
-          } else {
-            providerLoader.setCliDetectionResults(await detectCLIs(providerLoader, { includeVersion: false }), true);
-          }
-        }
-        if (!providerType || targetCategory === "ide") {
-          detectedIdesRef.value = await detectIDEs(providerLoader);
-          providerLoader.setIdeDetectionResults(detectedIdesRef.value, true);
-        }
-      };
-      const cliManager = new DaemonCliManager({
-        ...config2.cliManagerDeps,
-        getInstanceManager: () => instanceManager,
-        getSessionRegistry: () => sessionRegistry
-      }, providerLoader);
-      LOG2.info("Init", "Detecting IDEs...");
-      await refreshProviderAvailability();
-      const installed = detectedIdesRef.value.filter((i) => i.installed);
-      LOG2.info("Init", `Found ${installed.length} IDE(s): ${installed.map((i) => i.id).join(", ") || "none"}`);
-      const cdpSetupContext = {
-        providerLoader,
-        instanceManager,
-        cdpManagers,
-        sessionRegistry
-      };
-      const cdpInitializer = new DaemonCdpInitializer({
-        providerLoader,
-        cdpManagers,
-        enabledIdes: config2.enabledIdes || loadConfig2().enabledIdes || void 0,
-        onConnected: async (ideType, manager, managerKey) => {
-          await setupIdeInstance(cdpSetupContext, { ideType, manager, managerKey });
-          await config2.onCdpManagerSetup?.(ideType, manager, managerKey);
-        },
-        onDisconnected: async (_ideType, _manager, managerKey) => {
-          sessionRegistry.unregisterByManagerKey(managerKey);
-          const instanceKey = `ide:${managerKey}`;
-          const ideInstance = instanceManager.getInstance(instanceKey);
-          if (ideInstance) {
-            instanceManager.removeInstance(instanceKey);
-            LOG2.info("IDE", `Instance removed after detach: ${instanceKey}`);
-          }
-          if (ideInstance?.getInstanceId) {
-            agentStreamManager?.resetParentSession(ideInstance.getInstanceId());
-          }
-          config2.onStatusChange?.();
-        }
-      });
-      await cdpInitializer.connectAll(detectedIdesRef.value);
-      cdpInitializer.startPeriodicScan(config2.cdpScanIntervalMs ?? DEFAULT_CDP_SCAN_INTERVAL_MS);
-      cdpInitializer.startDiscovery(DEFAULT_CDP_DISCOVERY_INTERVAL_MS);
-      const commandHandler = new DaemonCommandHandler({
-        cdpManagers,
-        ideType: "unknown",
-        adapters: cliManager.adapters,
-        providerLoader,
-        instanceManager,
-        sessionRegistry,
-        gitCommandServices: createDefaultGitCommandServices({
-          // T7: fold this daemon's cached provider versions + build version onto the
-          // git_status envelope so the mesh coordinator self-heals each node's
-          // providerVersions/build (the blue version chips) — these are per-machine
-          // RUNTIME facts (e.g. this node has claude-cli@2.1.168 while the
-          // coordinator has @2.1.170), so they stay reported. Non-blocking: reads a
-          // TTL cache, lazily refreshed. (setDefaultProviderLoader is registered
-          // above so getCachedProviderVersions is not empty — see the 380556d3
-          // version-chip lesson.)
-          //
-          // Slots are NOT reported: they are coordinator-owned config
-          // (node.policy.slots for every node, resolved via
-          // resolveNodeCapabilitySlots), not a per-machine runtime fact — the
-          // reporter round-trip for slots was removed (REMOTE-NODE-SLOTS-
-          // COORDINATOR-LOCAL fix).
-          getReporterProviderVersions: () => {
-            const providerVersions = getCachedProviderVersions(providerLoader);
-            const daemonBuildVersion = getDaemonBuildInfo().version;
-            return {
-              ...Object.keys(providerVersions).length > 0 ? { providerVersions } : {},
-              ...daemonBuildVersion && daemonBuildVersion !== "unknown" ? { daemonBuildVersion } : {}
-            };
-          }
-        }),
-        onProviderSettingChanged: async (providerType) => {
-          await refreshProviderAvailability(providerType);
-          config2.onStatusChange?.();
-        },
-        onProviderSourceConfigChanged: async () => {
-          await refreshProviderAvailability();
-          config2.onStatusChange?.();
-        },
-        onBeforeSendChat: config2.onBeforeSendChat
-      });
-      agentStreamManager = new DaemonAgentStreamManager(
-        LOG2.forComponent("AgentStream").asLogFn(),
-        providerLoader,
-        sessionRegistry
-      );
-      commandHandler.setAgentStreamManager(agentStreamManager);
-      const router = new DaemonCommandRouter({
-        commandHandler,
-        cliManager,
-        cdpManagers,
-        providerLoader,
-        instanceManager,
-        detectedIdes: detectedIdesRef,
-        sessionRegistry,
-        onCdpManagerCreated: async (ideType, manager) => {
-          await setupIdeInstance(cdpSetupContext, { ideType, manager });
-          await config2.onCdpManagerSetup?.(ideType, manager, ideType);
-        },
-        onIdeConnected: () => poller?.start(),
-        onStatusChange: config2.onStatusChange,
-        onMeshStateChange: config2.onMeshStateChange,
-        onPostChatCommand: config2.onPostChatCommand,
-        sessionHostControl: config2.sessionHostControl,
-        statusInstanceId: config2.statusInstanceId,
-        statusVersion: config2.statusVersion,
-        getMeshPeerConnectionStatus: config2.getMeshPeerConnectionStatus,
-        dispatchMeshCommand: config2.dispatchMeshCommand,
-        updateLocalMeshOwnedSession: config2.updateLocalMeshOwnedSession,
-        getCdpLogFn: config2.getCdpLogFn || ((ideType) => LOG2.forComponent(`CDP:${ideType}`).asLogFn())
-      });
-      poller = new AgentStreamPoller({
-        agentStreamManager,
-        providerLoader,
-        instanceManager,
-        cdpManagers,
-        sessionRegistry,
-        onStreamsUpdated: config2.onStreamsUpdated
+      if (!Number.isInteger(version2) || version2 < 1) {
+        throw new Error("storeFleetSecret requires an integer version >= 1");
+      }
+      const dir = getConfigDir2(env2);
+      if (!(0, import_fs21.existsSync)(dir)) {
+        (0, import_fs21.mkdirSync)(dir, { recursive: true, mode: 448 });
+      }
+      const path63 = (0, import_path24.join)(dir, FLEET_SECRET_FILE);
+      const tmp = `${path63}.tmp-${process.pid}`;
+      (0, import_fs21.writeFileSync)(tmp, JSON.stringify({ secret, version: version2 }, null, 2), {
+        encoding: "utf-8",
+        mode: 384
       });
-      poller.start();
-      instanceManager.startTicking(config2.tickIntervalMs ?? 5e3);
-      const components = {
-        providerLoader,
-        instanceManager,
-        cliManager,
-        commandHandler,
-        agentStreamManager,
-        router,
-        poller,
-        cdpInitializer,
-        cdpManagers,
-        sessionRegistry,
-        detectedIdes: detectedIdesRef,
-        refreshProviderAvailability,
-        dispatchMeshCommand: config2.dispatchMeshCommand,
-        getMeshPeerConnectionStatus: config2.getMeshPeerConnectionStatus,
-        onMeshCoordinatorEventForwarded: config2.onMeshCoordinatorEventForwarded,
-        statusInstanceId: config2.statusInstanceId
-      };
-      setupMeshEventForwarding(components);
       try {
-        migratePendingEventsJsonlToSqlite();
-      } catch {
-      }
-      components.meshReconcileLoop = setupMeshReconcileLoop(components);
-      components.quotaRefreshLoop = setupQuotaRefreshLoop(components);
-      components.quotaEventRefresh = setupQuotaEventRefresh(components);
-      components.providerStalenessProbe = providerStalenessProbe;
-      setImmediate(() => {
-        const isQuotaProviderEnabled = quotaProviderEnabledFromLoader(components.providerLoader);
+        (0, import_fs21.renameSync)(tmp, path63);
+      } catch (err) {
         try {
-          hydrateQuotaCacheFromDisk(process.env, isQuotaProviderEnabled);
+          (0, import_fs21.unlinkSync)(tmp);
         } catch {
         }
-        refreshQuotaCacheOnBoot(isQuotaProviderEnabled);
-      });
-      setImmediate(() => void router.resumePendingRefineJobsOnStartup());
-      components.eventLoopMonitor = startEventLoopMonitor();
-      setImmediate(() => router.resumeDeferredRestartsOnStartup());
-      return components;
-    }
-    async function startDaemonDevSupport2(options) {
-      const devServer = new DevServer({
-        providerLoader: options.components.providerLoader,
-        cdpManagers: options.components.cdpManagers,
-        instanceManager: options.components.instanceManager,
-        cliManager: options.components.cliManager,
-        logFn: options.logFn,
-        onProviderSourceConfigChanged: async () => {
-          await options.components.refreshProviderAvailability();
-        }
-      });
-      await devServer.start();
-      options.components.providerLoader.watch();
-      return devServer;
-    }
-    async function shutdownDaemonComponents2(components) {
-      const {
-        poller,
-        cdpInitializer,
-        agentStreamManager,
-        cliManager,
-        instanceManager,
-        cdpManagers,
-        meshReconcileLoop,
-        quotaRefreshLoop,
-        quotaEventRefresh,
-        providerStalenessProbe,
-        eventLoopMonitor
-      } = components;
-      poller.stop();
-      cdpInitializer.stop();
-      try {
-        eventLoopMonitor?.stop();
-      } catch {
-      }
-      try {
-        meshReconcileLoop?.stop();
-      } catch {
-      }
-      try {
-        quotaRefreshLoop?.stop();
-      } catch {
+        throw err;
       }
       try {
-        quotaEventRefresh?.stop();
+        (0, import_fs21.chmodSync)(path63, 384);
       } catch {
       }
-      try {
-        providerStalenessProbe?.stop();
-      } catch {
-      }
-      try {
-        if (agentStreamManager) {
-          await agentStreamManager.dispose(cdpManagers);
-        }
-      } catch (e) {
-        LOG2.warn("Shutdown", `AgentStream dispose: ${e?.message}`);
-      }
-      try {
-        cliManager.detachAll();
-      } catch {
-      }
-      try {
-        instanceManager.removeByCategory("cli", { dispose: false });
-      } catch {
-      }
-      try {
-        instanceManager.disposeAll();
-      } catch {
-      }
-      for (const m of cdpManagers.values()) {
-        try {
-          m.disconnect();
-        } catch {
-        }
-      }
-      cdpManagers.clear();
-      try {
-        MeshRuntimeStore.getInstance().vacuum();
-      } catch {
-      }
-    }
-    var import_http2 = require("http");
-    var import_ws22 = require("ws");
-    init_logger();
-    init_ipc_protocol();
-    function buildIpcStatusHttpResponse(method, url2, payload) {
-      if (method && method.toUpperCase() !== "GET") {
-        return { statusCode: 405, body: { ok: false, error: "method not allowed" } };
-      }
-      const path63 = url2 ? url2.split("?")[0] : url2;
-      const KNOWN_ROUTES = ["/", "/status", "/health", "/api/v1/status", "/api/status"];
-      if (path63 && !KNOWN_ROUTES.includes(path63)) {
-        return { statusCode: 404, body: { ok: false, error: "not found" } };
-      }
-      return { statusCode: 200, body: payload };
-    }
-    async function startLocalIpcServer2(opts) {
-      const logCategory = opts.logCategory || "IPC";
-      const clients = /* @__PURE__ */ new Set();
-      let httpServer = null;
-      let wss = null;
-      let listening = false;
-      httpServer = (0, import_http2.createServer)((req, res) => {
-        const payload = {
-          ok: true,
-          pid: process.pid,
-          wsPath: DAEMON_WS_PATH2,
-          port: opts.port,
-          status: opts.buildStatusPayload()
-        };
-        const response = buildIpcStatusHttpResponse(req.method, req.url, payload);
-        const body = JSON.stringify(response.body);
-        res.writeHead(response.statusCode, {
-          "Content-Type": "application/json",
-          "Content-Length": Buffer.byteLength(body),
-          "Connection": "close"
-        });
-        res.end(body);
-      });
-      wss = new import_ws22.WebSocketServer({ noServer: true });
-      wss.on("connection", (ws) => handleConnection(ws));
-      httpServer.on("upgrade", (req, socket, head) => {
-        const wsUrl = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
-        if (wsUrl.pathname !== DAEMON_WS_PATH2) {
-          socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
-          socket.destroy();
-          return;
-        }
-        wss.handleUpgrade(req, socket, head, (ws) => {
-          wss.emit("connection", ws, req);
-        });
-      });
-      function handleConnection(ws) {
-        clients.add(ws);
-        sendWelcome(ws);
-        opts.onClientConnected?.(ws);
-        ws.on("message", (raw) => {
-          void handleMessage(ws, raw.toString());
-        });
-        ws.on("close", () => {
-          clients.delete(ws);
-          opts.onClientDisconnected?.(ws);
-        });
-        ws.on("error", () => {
-          clients.delete(ws);
-          opts.onClientDisconnected?.(ws);
-        });
-      }
-      function sendWelcome(ws) {
-        try {
-          ws.send(JSON.stringify({
-            type: "daemon:welcome",
-            payload: opts.buildWelcomePayload()
-          }));
-        } catch (error48) {
-          LOG2.warn(logCategory, `Failed to send welcome: ${error48?.message || error48}`);
-        }
-      }
-      async function handleMessage(ws, raw) {
-        let msg;
-        try {
-          msg = JSON.parse(raw);
-        } catch {
-          return;
-        }
-        if (!msg || typeof msg !== "object") return;
-        if (msg.type === "ext:register") {
-          sendWelcome(ws);
-          return;
-        }
-        if (msg.type !== "ext:command") return;
-        const payload = msg.payload && typeof msg.payload === "object" ? msg.payload : {};
-        const command = typeof payload.command === "string" ? payload.command : "";
-        const args = payload.args && typeof payload.args === "object" ? payload.args : {};
-        const requestId = typeof payload.requestId === "string" ? payload.requestId : typeof payload.messageId === "string" ? payload.messageId : `ipc-${Date.now()}`;
-        if (!command) {
-          ws.send(JSON.stringify({
-            type: "ext:command_result",
-            payload: { requestId, success: false, error: "command required" }
-          }));
-          return;
-        }
-        try {
-          const result = await opts.handleCommand({ command, args, requestId, ws });
-          ws.send(JSON.stringify({
-            type: "ext:command_result",
-            payload: {
-              requestId,
-              success: result.success,
-              result: result.result,
-              error: result.error,
-              ...result.extra || {}
-            }
-          }));
-        } catch (error48) {
-          ws.send(JSON.stringify({
-            type: "ext:command_result",
-            payload: {
-              requestId,
-              success: false,
-              error: error48?.message || String(error48)
-            }
-          }));
-        }
-      }
-      await new Promise((resolve31, reject) => {
-        const onError = (error48) => {
-          httpServer?.off("listening", onListening);
-          reject(error48);
-        };
-        const onListening = () => {
-          httpServer?.off("error", onError);
-          listening = true;
-          resolve31();
-        };
-        httpServer.once("error", onError);
-        httpServer.once("listening", onListening);
-        httpServer.listen(opts.port, "127.0.0.1");
-      });
-      LOG2.info(logCategory, `Local IPC listening on ws://127.0.0.1:${opts.port}${DAEMON_WS_PATH2}`);
-      return {
-        isListening: () => listening,
-        broadcast(type2, payload) {
-          const message = JSON.stringify({ type: type2, payload });
-          for (const client of clients) {
-            if (client.readyState !== import_ws22.WebSocket.OPEN) continue;
-            try {
-              client.send(message);
-            } catch {
-            }
-          }
-        },
-        async close() {
-          for (const client of clients) {
-            try {
-              client.close();
-            } catch {
-            }
-          }
-          clients.clear();
-          await new Promise((resolve31) => {
-            if (!httpServer) {
-              resolve31();
-              return;
-            }
-            httpServer.close(() => resolve31());
-          });
-          httpServer = null;
-          wss = null;
-          listening = false;
-        }
-      };
-    }
-    init_fsm_evaluator();
-    init_fsm_loader();
-    var crypto8 = __toESM2(require("crypto"));
-    var import_node_fs10 = require("fs");
-    var import_node_path6 = require("path");
-    init_provider_cli_shared();
-    var import_node_fs11 = require("fs");
-    var import_node_path7 = require("path");
-    init_manifest();
-    var V1_PRIMITIVE_CATALOG = Object.freeze({
-      acp: [
-        "adhdev:acp/session-protocol@1"
-      ],
-      tui: [
-        "adhdev:tui/prompt-marker@1",
-        "adhdev:tui/spinner@1",
-        "adhdev:tui/settled-prompt@1",
-        "adhdev:tui/assistant-block@1",
-        "adhdev:tui/tool-block@1",
-        "adhdev:tui/thinking-block@1",
-        "adhdev:tui/user-echo@1",
-        "adhdev:tui/modal@1",
-        "adhdev:tui/modal-as-message@1",
-        "adhdev:tui/footer-chrome@1",
-        "adhdev:tui/welcome-screen@1",
-        "adhdev:tui/visible-region@1",
-        "adhdev:tui/cue-ordering@1",
-        "adhdev:tui/dispatch-order@1",
-        "adhdev:tui/index-finder@1",
-        "adhdev:tui/status-downgrade@1",
-        "adhdev:tui/approval-stitching@1",
-        "adhdev:tui/approval-squash@1",
-        "adhdev:tui/media-input@1",
-        "adhdev:tui/session-id-extraction@1",
-        "adhdev:tui/error-detection@1"
-      ],
-      nativeHistory: [
-        "adhdev:native-history/codex-rollout@1",
-        "adhdev:native-history/claude-jsonl@1",
-        "adhdev:native-history/anthropic-cli-transcript@1",
-        "adhdev:native-history/hermes-session@1"
-      ],
-      cliCapability: [
-        "adhdev:cli/capability-list@1",
-        "adhdev:cli/control-state@1",
-        "adhdev:cli/capability-action@1",
-        "adhdev:cli/control-toggle@1",
-        "adhdev:cli/picker-open@1",
-        "adhdev:cli/picker-set@1"
-      ],
-      common: [
-        "adhdev:common/setting-boolean@1",
-        "adhdev:common/setting-number@1",
-        "adhdev:common/setting-string@1",
-        "adhdev:common/setting-select@1",
-        "adhdev:common/capability-input@1",
-        "adhdev:common/capability-output@1",
-        "adhdev:common/capability-controls@1",
-        "adhdev:common/auth-env-var@1",
-        "adhdev:common/auth-cli-command@1",
-        "adhdev:common/spawn@1",
-        "adhdev:common/timeouts@1",
-        "adhdev:common/resume@1",
-        "adhdev:common/mesh-coordinator@1"
-      ],
-      override: [
-        "adhdev:override/cli-parse-session@1",
-        "adhdev:override/cli-detect-status@1",
-        "adhdev:override/cli-parse-approval@1",
-        "adhdev:override/cli-parse-output@1",
-        "adhdev:override/cli-read-native-history@1",
-        "adhdev:override/cli-list-native-history@1",
-        "adhdev:override/cli-capability-handler@1"
-      ]
-    });
-    var V1_ALL_PRIMITIVES = Object.freeze(
-      Object.values(V1_PRIMITIVE_CATALOG).flat()
-    );
-    var V1_CONTRACT_VERSION = "1.0.0";
-    var fs65 = __toESM2(require("fs"));
-    var import_chalk2 = __toESM2((init_source(), __toCommonJS(source_exports)));
-    init_dist();
-    var CLAUDE_NO_API_LINE = "Claude has no quota API \u2014 adhdev borrows your statusLine to read it.";
-    var CLAUDE_WRAP_NOT_REPLACE_LINE = "Install wraps (not replaces) your statusline, so nothing is lost.";
-    function windowCue(quota) {
-      if (quota.metadata?.failureKind === "no-data" && (quota.session || quota.weekly)) return "stale";
-      if (quota.metadata?.lastGoodWindows === true) return "refreshing";
-      return void 0;
-    }
-    function formatWindow(label, window, cue = void 0) {
-      if (!window) {
-        return `  ${label.padEnd(8)} ${import_chalk2.default.gray("not reported")}`;
-      }
-      const percent = `${window.usedPercent.toFixed(1)}%`;
-      const bar = renderBar(window.usedPercent);
-      const reset = window.resetsAt === null ? "" : import_chalk2.default.gray(`  resets ${formatRelative(window.resetsAt)}`);
-      const marker = cue === "refreshing" ? import_chalk2.default.gray("  (refreshing)") : cue === "stale" ? import_chalk2.default.gray("  (stale)") : "";
-      return `  ${label.padEnd(8)} ${bar} ${percent.padStart(6)} used${reset}${marker}`;
-    }
-    function renderBar(usedPercent) {
-      const width = 20;
-      const filled = Math.round(Math.min(100, Math.max(0, usedPercent)) / 100 * width);
-      const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
-      if (usedPercent >= 90) return import_chalk2.default.red(bar);
-      if (usedPercent >= 70) return import_chalk2.default.yellow(bar);
-      return import_chalk2.default.green(bar);
-    }
-    function formatRelative(atMs) {
-      const deltaMs = atMs - Date.now();
-      if (deltaMs <= 0) {
-        return "now";
-      }
-      const minutes = Math.round(deltaMs / 6e4);
-      if (minutes < 60) return `in ${minutes}m`;
-      const hours = Math.floor(minutes / 60);
-      if (hours < 24) return `in ${hours}h ${minutes % 60}m`;
-      return `in ${Math.floor(hours / 24)}d ${hours % 24}h`;
-    }
-    function truncate(value, max) {
-      return value.length <= max ? value : `${value.slice(0, max - 1)}\u2026`;
-    }
-    function formatAgo(atMs) {
-      const deltaMs = Date.now() - atMs;
-      if (deltaMs <= 0) return "just now";
-      const minutes = Math.round(deltaMs / 6e4);
-      if (minutes < 1) return "just now";
-      if (minutes < 60) return `${minutes}m ago`;
-      const hours = Math.floor(minutes / 60);
-      if (hours < 24) return `${hours}h ${minutes % 60}m ago`;
-      return `${Math.floor(hours / 24)}d ${hours % 24}h ago`;
-    }
-    function printQuota2(name, quota) {
-      console.log();
-      const account = formatQuotaAccount(quota);
-      console.log(account ? `${import_chalk2.default.bold(name)}  ${import_chalk2.default.gray(account)}` : import_chalk2.default.bold(name));
-      if (quota.status === "ok" || quota.session || quota.weekly) {
-        const cue = windowCue(quota);
-        console.log(formatWindow("5 hour", quota.session, cue));
-        console.log(formatWindow("7 day", quota.weekly, cue));
-      }
-      if (quota.error) {
-        const tone = quota.status === "unavailable" ? import_chalk2.default.gray : import_chalk2.default.yellow;
-        console.log(`  ${tone(quota.error)}`);
-        if (quota.provider === "claude-cli" && quota.error.includes("claude:install")) {
-          console.log(`  ${import_chalk2.default.gray(CLAUDE_NO_API_LINE)}`);
-          console.log(`  ${import_chalk2.default.gray(CLAUDE_WRAP_NOT_REPLACE_LINE)}`);
-        }
-      }
-      console.log();
-    }
-    function printQuotaRefreshOutcome2(entries) {
-      console.log();
-      if (entries.length === 0) {
-        console.log(import_chalk2.default.gray("  Nothing to refresh."));
-        console.log();
-        return;
-      }
-      const refreshed = entries.filter((e) => e.outcome === "refreshed");
-      if (refreshed.length > 0) {
-        console.log(import_chalk2.default.green(`\u2713 Refreshed ${refreshed.map((e) => e.provider).join(", ")}`));
-      }
-      for (const entry of entries) {
-        if (entry.outcome === "refreshed") continue;
-        if (entry.outcome === "cooldown") {
-          console.log(import_chalk2.default.yellow(`\u2022 ${entry.provider}: rate-limited \u2014 not re-probed`));
-          if (typeof entry.retryAtMs === "number" && Number.isFinite(entry.retryAtMs)) {
-            console.log(import_chalk2.default.gray(`  Retrying no earlier than ${formatRelative(entry.retryAtMs)}.`));
-          }
-          console.log(import_chalk2.default.gray("  The numbers shown are the last good reading."));
-          console.log(import_chalk2.default.gray("  Re-probing now would extend the provider's own throttle."));
-          continue;
-        }
-        console.log(import_chalk2.default.gray(`\u2022 ${entry.provider}: ${entry.reason || entry.outcome}`));
-      }
-      console.log();
-    }
-    function printClaudeInstallResult2(result) {
-      console.log();
-      console.log(
-        import_chalk2.default.green(
-          result.outcome === "repaired" ? "\u2713 Claude Code quota reporting repaired" : result.outcome === "reinstalled" ? "\u2713 Claude Code quota reporting re-installed" : result.outcome === "wrapped" ? "\u2713 Claude Code quota reporting installed around your statusline" : "\u2713 Claude Code quota reporting installed"
-        )
-      );
-      if (result.outcome === "repaired") {
-        console.log(import_chalk2.default.gray("  Your statusLine pointed at a script that no longer exists:"));
-        console.log(import_chalk2.default.gray(`    ${truncate(result.repairedFrom ?? "unknown path", 100)}`));
-        console.log(import_chalk2.default.gray("  It now points at the current wrapper."));
-      }
-      if (result.originalCommand) {
-        console.log(import_chalk2.default.gray("  Your existing statusline is preserved and still runs:"));
-        console.log(import_chalk2.default.gray(`    ${truncate(result.originalCommand, 100)}`));
-        console.log(import_chalk2.default.gray(`  Backup: ${result.paths.backupFile}`));
-      } else if (result.outcome === "installed") {
-        console.log(import_chalk2.default.gray("  You had no statusline configured; one was not added."));
-      }
-      if (result.volatileWrapperReason) {
-        console.log(
-          import_chalk2.default.yellow(`  ! The wrapper was written under ${result.volatileWrapperReason}.`)
-        );
-        console.log(import_chalk2.default.gray(`    ${result.paths.wrapperFile}`));
-        console.log(import_chalk2.default.gray("    Claude Code will fail to load it once that path is gone;"));
-        console.log(import_chalk2.default.gray("    re-run `adhdev quota claude:install` from a normal install to fix."));
-      }
-      console.log();
-      console.log(import_chalk2.default.gray("  Open a Claude Code session, then run `adhdev quota claude`."));
-      console.log(import_chalk2.default.gray("  Undo any time with `adhdev quota claude:uninstall`."));
-      console.log();
-    }
-    function printClaudeUninstallResult2(result) {
-      console.log();
-      if (result.outcome === "restored") {
-        console.log(import_chalk2.default.green("\u2713 Your original statusline has been restored"));
-      } else if (result.outcome === "removed") {
-        console.log(import_chalk2.default.green("\u2713 Claude Code quota reporting removed"));
-        console.log(import_chalk2.default.gray("  You had no statusline before install, so none was left behind."));
-      } else {
-        console.log(import_chalk2.default.yellow("\u2022 Claude Code quota reporting was not installed"));
-        console.log(import_chalk2.default.gray("  Your statusLine setting was left untouched."));
-      }
-      console.log();
-    }
-    function printClaudeStatuslineStatus2(status) {
-      console.log();
-      if (status.installed) {
-        console.log(import_chalk2.default.green("\u2713 Installed"));
-        console.log(
-          import_chalk2.default.gray(
-            status.wrappedCommand ? `  Wrapping your statusline: ${truncate(status.wrappedCommand, 100)}` : "  You had no statusline before install."
-          )
-        );
-        console.log(import_chalk2.default.gray(`  Wrapper: ${status.paths.wrapperFile}`));
-        console.log(import_chalk2.default.gray(`  Backup: ${status.paths.backupFile}`));
-        let snapshotMtimeMs = null;
-        try {
-          snapshotMtimeMs = fs65.statSync(status.paths.snapshotFile).mtimeMs;
-        } catch {
-        }
-        console.log(import_chalk2.default.gray(
-          snapshotMtimeMs === null ? "  Last snapshot: none yet \u2014 open a Claude Code session to record one" : `  Last snapshot: ${formatAgo(snapshotMtimeMs)} (${status.paths.snapshotFile})`
-        ));
-        console.log(import_chalk2.default.gray("  Undo with `adhdev quota claude:uninstall`."));
-      } else if (status.failureKind === "wrapper-missing") {
-        console.log(import_chalk2.default.red("\u2717 Broken \u2014 the configured wrapper no longer exists"));
-        console.log(import_chalk2.default.gray(`  statusLine points at: ${truncate(status.danglingWrapperPath ?? "unknown path", 100)}`));
-        console.log(import_chalk2.default.gray("  Claude Code runs that command every prompt and it fails, so"));
-        console.log(import_chalk2.default.gray("  no quota is being captured and your statusline is blank."));
-        if (status.wrappedCommand) {
-          console.log(import_chalk2.default.gray(`  Your own statusline is still recorded: ${truncate(status.wrappedCommand, 80)}`));
-        }
-        console.log(import_chalk2.default.gray("  Repair with `adhdev quota claude:install`."));
-        console.log(import_chalk2.default.gray("  Or clear it with `adhdev quota claude:uninstall`."));
-      } else {
-        console.log(import_chalk2.default.yellow("\u2022 Not installed"));
-        if (status.foreignStatusLine) {
-          console.log(import_chalk2.default.gray("  You have your own statusLine configured; install would wrap it."));
-        }
-        console.log(import_chalk2.default.gray(`  ${CLAUDE_NO_API_LINE}`));
-        console.log(import_chalk2.default.gray(`  ${CLAUDE_WRAP_NOT_REPLACE_LINE}`));
-        console.log(import_chalk2.default.gray("  Set up with `adhdev quota claude:install`."));
-      }
-      console.log();
-    }
-    function printQuotaInstallError2(message) {
-      console.error(import_chalk2.default.red(`
-\u2717 ${message}
-`));
+      LOG2.info("Seqscribe", `fleet secret stored (v${version2})`);
     }
     var import_fs22 = require("fs");
     var import_path25 = require("path");
@@ -145648,70 +145248,6 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       const authority = createFleetAuthority({ secret });
       return { authority, hooks: authority };
     }
-    var import_fs21 = require("fs");
-    var import_path24 = require("path");
-    init_config();
-    init_logger();
-    var FLEET_SECRET_FILE = "seqscribe-fleet-secret.json";
-    function fleetSecretPath(env2) {
-      return (0, import_path24.join)(getConfigDir2(env2), FLEET_SECRET_FILE);
-    }
-    function loadStoredFleetSecret(env2) {
-      const path63 = fleetSecretPath(env2);
-      if (!(0, import_fs21.existsSync)(path63)) return null;
-      let raw;
-      try {
-        raw = (0, import_fs21.readFileSync)(path63, "utf-8");
-      } catch (err) {
-        LOG2.warn(
-          "Seqscribe",
-          `fleet secret file unreadable (${err instanceof Error ? err.message : String(err)}); ignoring it`
-        );
-        return null;
-      }
-      try {
-        const parsed = JSON.parse(raw);
-        if (parsed !== null && typeof parsed === "object" && typeof parsed.secret === "string" && parsed.secret.length > 0 && Number.isInteger(parsed.version) && parsed.version >= 1) {
-          const { secret, version: version2 } = parsed;
-          return { secret, version: version2 };
-        }
-      } catch {
-      }
-      LOG2.warn("Seqscribe", "fleet secret file is malformed; ignoring it (provisional mode)");
-      return null;
-    }
-    function storeFleetSecret(secret, version2, env2) {
-      if (typeof secret !== "string" || secret.length === 0) {
-        throw new Error("storeFleetSecret requires a non-empty secret string");
-      }
-      if (!Number.isInteger(version2) || version2 < 1) {
-        throw new Error("storeFleetSecret requires an integer version >= 1");
-      }
-      const dir = getConfigDir2(env2);
-      if (!(0, import_fs21.existsSync)(dir)) {
-        (0, import_fs21.mkdirSync)(dir, { recursive: true, mode: 448 });
-      }
-      const path63 = (0, import_path24.join)(dir, FLEET_SECRET_FILE);
-      const tmp = `${path63}.tmp-${process.pid}`;
-      (0, import_fs21.writeFileSync)(tmp, JSON.stringify({ secret, version: version2 }, null, 2), {
-        encoding: "utf-8",
-        mode: 384
-      });
-      try {
-        (0, import_fs21.renameSync)(tmp, path63);
-      } catch (err) {
-        try {
-          (0, import_fs21.unlinkSync)(tmp);
-        } catch {
-        }
-        throw err;
-      }
-      try {
-        (0, import_fs21.chmodSync)(path63, 384);
-      } catch {
-      }
-      LOG2.info("Seqscribe", `fleet secret stored (v${version2})`);
-    }
     var TOPIC_SEGMENT_UNSAFE = /[^a-z0-9_-]+/g;
     function sanitizeSegment(raw, fallback) {
       const cleaned = raw.toLowerCase().replace(TOPIC_SEGMENT_UNSAFE, "_").replace(/^_+|_+$/g, "");
@@ -145912,6 +145448,860 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         close
       };
     }
+    function tryOpenDaemonSeqscribeNode(options = {}) {
+      const env2 = options.env ?? process.env;
+      try {
+        return openSeqscribeNode({
+          daemonId: options.daemonId,
+          ...options.dbPath ? { dbPath: options.dbPath } : {},
+          env: env2,
+          storedFleetSecret: loadStoredFleetSecret(env2)?.secret ?? null
+        });
+      } catch (error48) {
+        LOG2.warn(
+          "Seqscribe",
+          `node unavailable; daemon will continue without replication: ${error48 instanceof Error ? error48.message : String(error48)}`
+        );
+        return void 0;
+      }
+    }
+    async function initDaemonComponents2(config2) {
+      applyProcessHardening();
+      installProviderProcessShim();
+      installGlobalInterceptor();
+      loadMeshCoordinatorRegistry();
+      const upgradeFailureNotice = readUpgradeFailureNotice();
+      if (upgradeFailureNotice) {
+        const age = upgradeFailureNotice.ageLabel ? `${upgradeFailureNotice.ageLabel}, recorded ${upgradeFailureNotice.recordedAt}` : "recorded at an unknown time";
+        const target = upgradeFailureNotice.targetVersion ? `, attempted target v${upgradeFailureNotice.targetVersion}` : "";
+        const running = (config2.statusVersion || "").trim().replace(/^v/, "");
+        const supersededHint = upgradeFailureNotice.targetVersion && running && upgradeFailureNotice.targetVersion.replace(/^v/, "") !== running ? ` This notice targets a DIFFERENT version than the one now running (v${running}) \u2014 it is most likely a stale record of an earlier attempt, not a report about this boot.` : "";
+        LOG2.warn("Upgrade", `Previous daemon upgrade FAILED and was rolled back \u2014 this daemon is running the previous version. Notice (${age}${target}) at ${upgradeFailureNotice.noticePath}:
+${upgradeFailureNotice.notice}${supersededHint}`);
+      }
+      try {
+        const { migrateProviderChannelConfig: migrateProviderChannelConfig2 } = await Promise.resolve().then(() => (init_channel_migration(), channel_migration_exports));
+        const migration = migrateProviderChannelConfig2();
+        if (migration.migrated) {
+          LOG2.info("Providers", `Recorded explicit providerChannel=${migration.channel} in config (migrated from build-track/updateChannel derivation)`);
+        }
+      } catch {
+      }
+      const appConfig = loadConfig2();
+      const providerSourceMode = appConfig.providerSourceMode || "normal";
+      const disableUpstream = providerSourceMode === "no-upstream";
+      const providerLoader = new ProviderLoader({
+        logFn: config2.providerLogFn,
+        // Shared config projection — keeps this site, launch.ts, and the CLI
+        // factory from drifting (the launch path once dropped userDir/sourceMode).
+        ...providerLoaderConfigOptions(appConfig),
+        // The boot path resolves sourceMode with an explicit 'normal' default
+        // for the disableUpstream derivation above — keep that authoritative.
+        sourceMode: providerSourceMode,
+        // Enables the daemon-update = provider-activation stamp (option C):
+        // a boot on a NEW daemon version runs one verified sync; same-version
+        // boots stay network-free.
+        daemonVersion: config2.statusVersion
+      });
+      providerLoader.loadAll();
+      providerLoader.registerToDetector();
+      const hasExplicitChannelSignal = Boolean(
+        appConfig.providerChannel && appConfig.providerChannel.trim() || (process.env[PROVIDER_CHANNEL_ENV_VAR] ?? "").trim() || isPreviewReleaseChannel(appConfig.updateChannel)
+      );
+      const resolvedConfigDir = getConfigDir2();
+      const channelMismatch = configDirChannelMismatch(resolvedConfigDir, providerLoader.channel, hasExplicitChannelSignal);
+      if (channelMismatch) {
+        LOG2.warn("Init", `Config dir looks like the ${channelMismatch.impliedTrack} track (${resolvedConfigDir}) but the resolved provider channel is '${channelMismatch.channel}'. This usually means the build-track stamp (__ADHDEV_BUILD_CHANNEL__) was absent for this process \u2014 e.g. running via tsx/ts-node instead of a built bundle \u2014 so provider-channel resolution fell through to its 'stable' default instead of following ADHDEV_CONFIG_DIR. Impact: providers installed under the OTHER channel's store will not be visible (can present as 0 providers loaded). Fix: set ADHDEV_PROVIDER_CHANNEL=${channelMismatch.impliedTrack} (or config.providerChannel) explicitly for this process, or run the built bundle instead of source.`);
+      }
+      void providerLoader.maybeFirstSyncVerifiedChannel().then(async (report) => {
+        if (!report) return null;
+        if (report.status === "error") {
+          LOG2.warn("Init", `Verified channel first-sync failed (last-known-good preserved): ${report.errors.map((e) => e.code).join(", ") || "unknown"}`);
+        } else if (report.activated.length > 0) {
+          LOG2.info("Init", `Verified channel first-sync activated ${report.activated.length} providers (${providerLoader.channel})`);
+          providerLoader.registerToDetector();
+          await refreshProviderAvailability();
+          config2.onStatusChange?.();
+        }
+        return report;
+      }).then(async (firstSyncReport) => {
+        if (firstSyncReport) return;
+        const report = await providerLoader.maybeSyncVerifiedChannelOnDaemonUpdate();
+        if (!report) return;
+        if (report.status === "error") {
+          LOG2.warn("Init", `Daemon-update channel sync failed (last-known-good preserved, retries next boot): ${report.errors.map((e) => e.code).join(", ") || "unknown"}`);
+        } else if (report.activated.length > 0) {
+          LOG2.info("Init", `Daemon-update channel sync activated ${report.activated.length} providers (${providerLoader.channel})`);
+          providerLoader.registerToDetector();
+          await refreshProviderAvailability();
+          config2.onStatusChange?.();
+        }
+      }).catch((e) => LOG2.warn("Init", `Verified channel boot sync error: ${e?.message || e}`));
+      const runStalenessProbe = async () => {
+        try {
+          const snap = await providerLoader.checkVerifiedChannelStaleness();
+          if (snap.error) {
+            LOG2.debug("Provider", `Channel staleness probe failed (kept previous snapshot): ${snap.error}`);
+          } else if (snap.staleTypes.length > 0 || snap.newTypes.length > 0) {
+            LOG2.info("Provider", `Channel staleness: ${snap.staleTypes.length} stale [${snap.staleTypes.join(", ")}], ${snap.newTypes.length} never-installed [${snap.newTypes.join(", ")}] (${snap.channel})`);
+            config2.onStatusChange?.();
+          }
+        } catch (e) {
+          LOG2.debug("Provider", `Channel staleness probe error: ${e?.message || e}`);
+        }
+      };
+      const stalenessInitialTimer = setTimeout(() => {
+        void runStalenessProbe();
+      }, 10 * 6e4);
+      stalenessInitialTimer.unref?.();
+      const stalenessIntervalTimer = setInterval(() => {
+        void runStalenessProbe();
+      }, 24 * 60 * 6e4);
+      stalenessIntervalTimer.unref?.();
+      const providerStalenessProbe = {
+        stop() {
+          clearTimeout(stalenessInitialTimer);
+          clearInterval(stalenessIntervalTimer);
+        }
+      };
+      setDefaultProviderLoader(providerLoader);
+      const versionArchive = new VersionArchive();
+      providerLoader.setVersionArchive(versionArchive);
+      setTimeout(() => {
+        void detectAllVersions(providerLoader, versionArchive).then((versionResults) => {
+          const installedProviders = versionResults.filter((v) => v.installed);
+          const withVersion = installedProviders.filter((v) => v.version);
+          LOG2.info("Init", `Provider versions: ${installedProviders.length} installed, ${withVersion.length} versioned`);
+          for (const v of withVersion) {
+            LOG2.info("Init", `  ${v.type} (${v.category}): v${v.version}${v.warning ? " \u26A0 " + v.warning : ""}`);
+          }
+          const noVersion = installedProviders.filter((v) => !v.version);
+          if (noVersion.length > 0) {
+            LOG2.warn("Init", `  ${noVersion.length} installed but version unknown: ${noVersion.map((v) => v.type).join(", ")}`);
+          }
+        }).catch(() => {
+        });
+      }, 0);
+      const instanceManager = new ProviderInstanceManager();
+      const cdpManagers = /* @__PURE__ */ new Map();
+      const sessionRegistry = new SessionRegistry();
+      setTranscriptClaimLivenessProbe((owner) => {
+        const match = /^iid:(.+)$/.exec(owner);
+        if (!match) return true;
+        return sessionRegistry.get(match[1]) !== void 0;
+      });
+      const detectedIdesRef = { value: [] };
+      let agentStreamManager = null;
+      let poller = null;
+      const refreshProviderAvailability = async (providerType) => {
+        const targetProvider = providerType ? providerLoader.getMeta(providerLoader.resolveAlias(providerType)) : null;
+        const targetCategory = targetProvider?.category;
+        if (!providerType || targetCategory === "cli" || targetCategory === "acp") {
+          if (providerType && targetProvider) {
+            const detected = await detectCLI(targetProvider.type, providerLoader, { includeVersion: false });
+            providerLoader.setCliDetectionResults([{
+              id: targetProvider.type,
+              installed: !!detected,
+              path: detected?.path
+            }], false);
+          } else {
+            providerLoader.setCliDetectionResults(await detectCLIs(providerLoader, { includeVersion: false }), true);
+          }
+        }
+        if (!providerType || targetCategory === "ide") {
+          detectedIdesRef.value = await detectIDEs(providerLoader);
+          providerLoader.setIdeDetectionResults(detectedIdesRef.value, true);
+        }
+      };
+      const cliManager = new DaemonCliManager({
+        ...config2.cliManagerDeps,
+        getInstanceManager: () => instanceManager,
+        getSessionRegistry: () => sessionRegistry
+      }, providerLoader);
+      LOG2.info("Init", "Detecting IDEs...");
+      await refreshProviderAvailability();
+      const installed = detectedIdesRef.value.filter((i) => i.installed);
+      LOG2.info("Init", `Found ${installed.length} IDE(s): ${installed.map((i) => i.id).join(", ") || "none"}`);
+      const cdpSetupContext = {
+        providerLoader,
+        instanceManager,
+        cdpManagers,
+        sessionRegistry
+      };
+      const cdpInitializer = new DaemonCdpInitializer({
+        providerLoader,
+        cdpManagers,
+        enabledIdes: config2.enabledIdes || loadConfig2().enabledIdes || void 0,
+        onConnected: async (ideType, manager, managerKey) => {
+          await setupIdeInstance(cdpSetupContext, { ideType, manager, managerKey });
+          await config2.onCdpManagerSetup?.(ideType, manager, managerKey);
+        },
+        onDisconnected: async (_ideType, _manager, managerKey) => {
+          sessionRegistry.unregisterByManagerKey(managerKey);
+          const instanceKey = `ide:${managerKey}`;
+          const ideInstance = instanceManager.getInstance(instanceKey);
+          if (ideInstance) {
+            instanceManager.removeInstance(instanceKey);
+            LOG2.info("IDE", `Instance removed after detach: ${instanceKey}`);
+          }
+          if (ideInstance?.getInstanceId) {
+            agentStreamManager?.resetParentSession(ideInstance.getInstanceId());
+          }
+          config2.onStatusChange?.();
+        }
+      });
+      await cdpInitializer.connectAll(detectedIdesRef.value);
+      cdpInitializer.startPeriodicScan(config2.cdpScanIntervalMs ?? DEFAULT_CDP_SCAN_INTERVAL_MS);
+      cdpInitializer.startDiscovery(DEFAULT_CDP_DISCOVERY_INTERVAL_MS);
+      const commandHandler = new DaemonCommandHandler({
+        cdpManagers,
+        ideType: "unknown",
+        adapters: cliManager.adapters,
+        providerLoader,
+        instanceManager,
+        sessionRegistry,
+        gitCommandServices: createDefaultGitCommandServices({
+          // T7: fold this daemon's cached provider versions + build version onto the
+          // git_status envelope so the mesh coordinator self-heals each node's
+          // providerVersions/build (the blue version chips) — these are per-machine
+          // RUNTIME facts (e.g. this node has claude-cli@2.1.168 while the
+          // coordinator has @2.1.170), so they stay reported. Non-blocking: reads a
+          // TTL cache, lazily refreshed. (setDefaultProviderLoader is registered
+          // above so getCachedProviderVersions is not empty — see the 380556d3
+          // version-chip lesson.)
+          //
+          // Slots are NOT reported: they are coordinator-owned config
+          // (node.policy.slots for every node, resolved via
+          // resolveNodeCapabilitySlots), not a per-machine runtime fact — the
+          // reporter round-trip for slots was removed (REMOTE-NODE-SLOTS-
+          // COORDINATOR-LOCAL fix).
+          getReporterProviderVersions: () => {
+            const providerVersions = getCachedProviderVersions(providerLoader);
+            const daemonBuildVersion = getDaemonBuildInfo().version;
+            return {
+              ...Object.keys(providerVersions).length > 0 ? { providerVersions } : {},
+              ...daemonBuildVersion && daemonBuildVersion !== "unknown" ? { daemonBuildVersion } : {}
+            };
+          }
+        }),
+        onProviderSettingChanged: async (providerType) => {
+          await refreshProviderAvailability(providerType);
+          config2.onStatusChange?.();
+        },
+        onProviderSourceConfigChanged: async () => {
+          await refreshProviderAvailability();
+          config2.onStatusChange?.();
+        },
+        onBeforeSendChat: config2.onBeforeSendChat
+      });
+      agentStreamManager = new DaemonAgentStreamManager(
+        LOG2.forComponent("AgentStream").asLogFn(),
+        providerLoader,
+        sessionRegistry
+      );
+      commandHandler.setAgentStreamManager(agentStreamManager);
+      const router = new DaemonCommandRouter({
+        commandHandler,
+        cliManager,
+        cdpManagers,
+        providerLoader,
+        instanceManager,
+        detectedIdes: detectedIdesRef,
+        sessionRegistry,
+        onCdpManagerCreated: async (ideType, manager) => {
+          await setupIdeInstance(cdpSetupContext, { ideType, manager });
+          await config2.onCdpManagerSetup?.(ideType, manager, ideType);
+        },
+        onIdeConnected: () => poller?.start(),
+        onStatusChange: config2.onStatusChange,
+        onMeshStateChange: config2.onMeshStateChange,
+        onPostChatCommand: config2.onPostChatCommand,
+        sessionHostControl: config2.sessionHostControl,
+        statusInstanceId: config2.statusInstanceId,
+        statusVersion: config2.statusVersion,
+        getMeshPeerConnectionStatus: config2.getMeshPeerConnectionStatus,
+        dispatchMeshCommand: config2.dispatchMeshCommand,
+        updateLocalMeshOwnedSession: config2.updateLocalMeshOwnedSession,
+        getCdpLogFn: config2.getCdpLogFn || ((ideType) => LOG2.forComponent(`CDP:${ideType}`).asLogFn())
+      });
+      poller = new AgentStreamPoller({
+        agentStreamManager,
+        providerLoader,
+        instanceManager,
+        cdpManagers,
+        sessionRegistry,
+        onStreamsUpdated: config2.onStreamsUpdated
+      });
+      poller.start();
+      instanceManager.startTicking(config2.tickIntervalMs ?? 5e3);
+      const components = {
+        providerLoader,
+        instanceManager,
+        cliManager,
+        commandHandler,
+        agentStreamManager,
+        router,
+        poller,
+        cdpInitializer,
+        cdpManagers,
+        sessionRegistry,
+        detectedIdes: detectedIdesRef,
+        refreshProviderAvailability,
+        dispatchMeshCommand: config2.dispatchMeshCommand,
+        getMeshPeerConnectionStatus: config2.getMeshPeerConnectionStatus,
+        onMeshCoordinatorEventForwarded: config2.onMeshCoordinatorEventForwarded,
+        statusInstanceId: config2.statusInstanceId
+      };
+      components.seqscribeNode = tryOpenDaemonSeqscribeNode({ daemonId: config2.statusInstanceId });
+      setupMeshEventForwarding(components);
+      try {
+        migratePendingEventsJsonlToSqlite();
+      } catch {
+      }
+      components.meshReconcileLoop = setupMeshReconcileLoop(components);
+      components.quotaRefreshLoop = setupQuotaRefreshLoop(components);
+      components.quotaEventRefresh = setupQuotaEventRefresh(components);
+      components.providerStalenessProbe = providerStalenessProbe;
+      setImmediate(() => {
+        const isQuotaProviderEnabled = quotaProviderEnabledFromLoader(components.providerLoader);
+        try {
+          hydrateQuotaCacheFromDisk(process.env, isQuotaProviderEnabled);
+        } catch {
+        }
+        refreshQuotaCacheOnBoot(isQuotaProviderEnabled);
+      });
+      setImmediate(() => void router.resumePendingRefineJobsOnStartup());
+      components.eventLoopMonitor = startEventLoopMonitor();
+      setImmediate(() => router.resumeDeferredRestartsOnStartup());
+      return components;
+    }
+    async function startDaemonDevSupport2(options) {
+      const devServer = new DevServer({
+        providerLoader: options.components.providerLoader,
+        cdpManagers: options.components.cdpManagers,
+        instanceManager: options.components.instanceManager,
+        cliManager: options.components.cliManager,
+        logFn: options.logFn,
+        onProviderSourceConfigChanged: async () => {
+          await options.components.refreshProviderAvailability();
+        }
+      });
+      await devServer.start();
+      options.components.providerLoader.watch();
+      return devServer;
+    }
+    async function shutdownDaemonComponents2(components) {
+      const {
+        poller,
+        cdpInitializer,
+        agentStreamManager,
+        cliManager,
+        instanceManager,
+        cdpManagers,
+        meshReconcileLoop,
+        quotaRefreshLoop,
+        quotaEventRefresh,
+        providerStalenessProbe,
+        eventLoopMonitor,
+        seqscribeNode
+      } = components;
+      poller.stop();
+      cdpInitializer.stop();
+      try {
+        eventLoopMonitor?.stop();
+      } catch {
+      }
+      try {
+        meshReconcileLoop?.stop();
+      } catch {
+      }
+      try {
+        quotaRefreshLoop?.stop();
+      } catch {
+      }
+      try {
+        quotaEventRefresh?.stop();
+      } catch {
+      }
+      try {
+        providerStalenessProbe?.stop();
+      } catch {
+      }
+      try {
+        if (agentStreamManager) {
+          await agentStreamManager.dispose(cdpManagers);
+        }
+      } catch (e) {
+        LOG2.warn("Shutdown", `AgentStream dispose: ${e?.message}`);
+      }
+      try {
+        cliManager.detachAll();
+      } catch {
+      }
+      try {
+        instanceManager.removeByCategory("cli", { dispose: false });
+      } catch {
+      }
+      try {
+        instanceManager.disposeAll();
+      } catch {
+      }
+      for (const m of cdpManagers.values()) {
+        try {
+          m.disconnect();
+        } catch {
+        }
+      }
+      cdpManagers.clear();
+      try {
+        await seqscribeNode?.close();
+      } catch (error48) {
+        LOG2.warn("Shutdown", `Seqscribe close: ${error48 instanceof Error ? error48.message : String(error48)}`);
+      }
+      try {
+        MeshRuntimeStore.getInstance().vacuum();
+      } catch {
+      }
+    }
+    var import_http2 = require("http");
+    var import_ws3 = require("ws");
+    init_logger();
+    init_ipc_protocol();
+    function buildIpcStatusHttpResponse(method, url2, payload) {
+      if (method && method.toUpperCase() !== "GET") {
+        return { statusCode: 405, body: { ok: false, error: "method not allowed" } };
+      }
+      const path63 = url2 ? url2.split("?")[0] : url2;
+      const KNOWN_ROUTES = ["/", "/status", "/health", "/api/v1/status", "/api/status"];
+      if (path63 && !KNOWN_ROUTES.includes(path63)) {
+        return { statusCode: 404, body: { ok: false, error: "not found" } };
+      }
+      return { statusCode: 200, body: payload };
+    }
+    async function startLocalIpcServer2(opts) {
+      const logCategory = opts.logCategory || "IPC";
+      const clients = /* @__PURE__ */ new Set();
+      let httpServer = null;
+      let wss = null;
+      let listening = false;
+      httpServer = (0, import_http2.createServer)((req, res) => {
+        const payload = {
+          ok: true,
+          pid: process.pid,
+          wsPath: DAEMON_WS_PATH2,
+          port: opts.port,
+          status: opts.buildStatusPayload()
+        };
+        const response = buildIpcStatusHttpResponse(req.method, req.url, payload);
+        const body = JSON.stringify(response.body);
+        res.writeHead(response.statusCode, {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body),
+          "Connection": "close"
+        });
+        res.end(body);
+      });
+      wss = new import_ws3.WebSocketServer({ noServer: true });
+      wss.on("connection", (ws) => handleConnection(ws));
+      httpServer.on("upgrade", (req, socket, head) => {
+        const wsUrl = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
+        if (wsUrl.pathname !== DAEMON_WS_PATH2) {
+          socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+          socket.destroy();
+          return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+          wss.emit("connection", ws, req);
+        });
+      });
+      function handleConnection(ws) {
+        clients.add(ws);
+        sendWelcome(ws);
+        opts.onClientConnected?.(ws);
+        ws.on("message", (raw) => {
+          void handleMessage(ws, raw.toString());
+        });
+        ws.on("close", () => {
+          clients.delete(ws);
+          opts.onClientDisconnected?.(ws);
+        });
+        ws.on("error", () => {
+          clients.delete(ws);
+          opts.onClientDisconnected?.(ws);
+        });
+      }
+      function sendWelcome(ws) {
+        try {
+          ws.send(JSON.stringify({
+            type: "daemon:welcome",
+            payload: opts.buildWelcomePayload()
+          }));
+        } catch (error48) {
+          LOG2.warn(logCategory, `Failed to send welcome: ${error48?.message || error48}`);
+        }
+      }
+      async function handleMessage(ws, raw) {
+        let msg;
+        try {
+          msg = JSON.parse(raw);
+        } catch {
+          return;
+        }
+        if (!msg || typeof msg !== "object") return;
+        if (msg.type === "ext:register") {
+          sendWelcome(ws);
+          return;
+        }
+        if (msg.type !== "ext:command") return;
+        const payload = msg.payload && typeof msg.payload === "object" ? msg.payload : {};
+        const command = typeof payload.command === "string" ? payload.command : "";
+        const args = payload.args && typeof payload.args === "object" ? payload.args : {};
+        const requestId = typeof payload.requestId === "string" ? payload.requestId : typeof payload.messageId === "string" ? payload.messageId : `ipc-${Date.now()}`;
+        if (!command) {
+          ws.send(JSON.stringify({
+            type: "ext:command_result",
+            payload: { requestId, success: false, error: "command required" }
+          }));
+          return;
+        }
+        try {
+          const result = await opts.handleCommand({ command, args, requestId, ws });
+          ws.send(JSON.stringify({
+            type: "ext:command_result",
+            payload: {
+              requestId,
+              success: result.success,
+              result: result.result,
+              error: result.error,
+              ...result.extra || {}
+            }
+          }));
+        } catch (error48) {
+          ws.send(JSON.stringify({
+            type: "ext:command_result",
+            payload: {
+              requestId,
+              success: false,
+              error: error48?.message || String(error48)
+            }
+          }));
+        }
+      }
+      await new Promise((resolve31, reject) => {
+        const onError = (error48) => {
+          httpServer?.off("listening", onListening);
+          reject(error48);
+        };
+        const onListening = () => {
+          httpServer?.off("error", onError);
+          listening = true;
+          resolve31();
+        };
+        httpServer.once("error", onError);
+        httpServer.once("listening", onListening);
+        httpServer.listen(opts.port, "127.0.0.1");
+      });
+      LOG2.info(logCategory, `Local IPC listening on ws://127.0.0.1:${opts.port}${DAEMON_WS_PATH2}`);
+      return {
+        isListening: () => listening,
+        broadcast(type2, payload) {
+          const message = JSON.stringify({ type: type2, payload });
+          for (const client of clients) {
+            if (client.readyState !== import_ws3.WebSocket.OPEN) continue;
+            try {
+              client.send(message);
+            } catch {
+            }
+          }
+        },
+        async close() {
+          for (const client of clients) {
+            try {
+              client.close();
+            } catch {
+            }
+          }
+          clients.clear();
+          await new Promise((resolve31) => {
+            if (!httpServer) {
+              resolve31();
+              return;
+            }
+            httpServer.close(() => resolve31());
+          });
+          httpServer = null;
+          wss = null;
+          listening = false;
+        }
+      };
+    }
+    init_fsm_evaluator();
+    init_fsm_loader();
+    var crypto8 = __toESM2(require("crypto"));
+    var import_node_fs10 = require("fs");
+    var import_node_path6 = require("path");
+    init_provider_cli_shared();
+    var import_node_fs11 = require("fs");
+    var import_node_path7 = require("path");
+    init_manifest();
+    var V1_PRIMITIVE_CATALOG = Object.freeze({
+      acp: [
+        "adhdev:acp/session-protocol@1"
+      ],
+      tui: [
+        "adhdev:tui/prompt-marker@1",
+        "adhdev:tui/spinner@1",
+        "adhdev:tui/settled-prompt@1",
+        "adhdev:tui/assistant-block@1",
+        "adhdev:tui/tool-block@1",
+        "adhdev:tui/thinking-block@1",
+        "adhdev:tui/user-echo@1",
+        "adhdev:tui/modal@1",
+        "adhdev:tui/modal-as-message@1",
+        "adhdev:tui/footer-chrome@1",
+        "adhdev:tui/welcome-screen@1",
+        "adhdev:tui/visible-region@1",
+        "adhdev:tui/cue-ordering@1",
+        "adhdev:tui/dispatch-order@1",
+        "adhdev:tui/index-finder@1",
+        "adhdev:tui/status-downgrade@1",
+        "adhdev:tui/approval-stitching@1",
+        "adhdev:tui/approval-squash@1",
+        "adhdev:tui/media-input@1",
+        "adhdev:tui/session-id-extraction@1",
+        "adhdev:tui/error-detection@1"
+      ],
+      nativeHistory: [
+        "adhdev:native-history/codex-rollout@1",
+        "adhdev:native-history/claude-jsonl@1",
+        "adhdev:native-history/anthropic-cli-transcript@1",
+        "adhdev:native-history/hermes-session@1"
+      ],
+      cliCapability: [
+        "adhdev:cli/capability-list@1",
+        "adhdev:cli/control-state@1",
+        "adhdev:cli/capability-action@1",
+        "adhdev:cli/control-toggle@1",
+        "adhdev:cli/picker-open@1",
+        "adhdev:cli/picker-set@1"
+      ],
+      common: [
+        "adhdev:common/setting-boolean@1",
+        "adhdev:common/setting-number@1",
+        "adhdev:common/setting-string@1",
+        "adhdev:common/setting-select@1",
+        "adhdev:common/capability-input@1",
+        "adhdev:common/capability-output@1",
+        "adhdev:common/capability-controls@1",
+        "adhdev:common/auth-env-var@1",
+        "adhdev:common/auth-cli-command@1",
+        "adhdev:common/spawn@1",
+        "adhdev:common/timeouts@1",
+        "adhdev:common/resume@1",
+        "adhdev:common/mesh-coordinator@1"
+      ],
+      override: [
+        "adhdev:override/cli-parse-session@1",
+        "adhdev:override/cli-detect-status@1",
+        "adhdev:override/cli-parse-approval@1",
+        "adhdev:override/cli-parse-output@1",
+        "adhdev:override/cli-read-native-history@1",
+        "adhdev:override/cli-list-native-history@1",
+        "adhdev:override/cli-capability-handler@1"
+      ]
+    });
+    var V1_ALL_PRIMITIVES = Object.freeze(
+      Object.values(V1_PRIMITIVE_CATALOG).flat()
+    );
+    var V1_CONTRACT_VERSION = "1.0.0";
+    var fs65 = __toESM2(require("fs"));
+    var import_chalk2 = __toESM2((init_source(), __toCommonJS(source_exports)));
+    init_dist();
+    var CLAUDE_NO_API_LINE = "Claude has no quota API \u2014 adhdev borrows your statusLine to read it.";
+    var CLAUDE_WRAP_NOT_REPLACE_LINE = "Install wraps (not replaces) your statusline, so nothing is lost.";
+    function windowCue(quota) {
+      if (quota.metadata?.failureKind === "no-data" && (quota.session || quota.weekly)) return "stale";
+      if (quota.metadata?.lastGoodWindows === true) return "refreshing";
+      return void 0;
+    }
+    function formatWindow(label, window, cue = void 0) {
+      if (!window) {
+        return `  ${label.padEnd(8)} ${import_chalk2.default.gray("not reported")}`;
+      }
+      const percent = `${window.usedPercent.toFixed(1)}%`;
+      const bar = renderBar(window.usedPercent);
+      const reset = window.resetsAt === null ? "" : import_chalk2.default.gray(`  resets ${formatRelative(window.resetsAt)}`);
+      const marker = cue === "refreshing" ? import_chalk2.default.gray("  (refreshing)") : cue === "stale" ? import_chalk2.default.gray("  (stale)") : "";
+      return `  ${label.padEnd(8)} ${bar} ${percent.padStart(6)} used${reset}${marker}`;
+    }
+    function renderBar(usedPercent) {
+      const width = 20;
+      const filled = Math.round(Math.min(100, Math.max(0, usedPercent)) / 100 * width);
+      const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+      if (usedPercent >= 90) return import_chalk2.default.red(bar);
+      if (usedPercent >= 70) return import_chalk2.default.yellow(bar);
+      return import_chalk2.default.green(bar);
+    }
+    function formatRelative(atMs) {
+      const deltaMs = atMs - Date.now();
+      if (deltaMs <= 0) {
+        return "now";
+      }
+      const minutes = Math.round(deltaMs / 6e4);
+      if (minutes < 60) return `in ${minutes}m`;
+      const hours = Math.floor(minutes / 60);
+      if (hours < 24) return `in ${hours}h ${minutes % 60}m`;
+      return `in ${Math.floor(hours / 24)}d ${hours % 24}h`;
+    }
+    function truncate(value, max) {
+      return value.length <= max ? value : `${value.slice(0, max - 1)}\u2026`;
+    }
+    function formatAgo(atMs) {
+      const deltaMs = Date.now() - atMs;
+      if (deltaMs <= 0) return "just now";
+      const minutes = Math.round(deltaMs / 6e4);
+      if (minutes < 1) return "just now";
+      if (minutes < 60) return `${minutes}m ago`;
+      const hours = Math.floor(minutes / 60);
+      if (hours < 24) return `${hours}h ${minutes % 60}m ago`;
+      return `${Math.floor(hours / 24)}d ${hours % 24}h ago`;
+    }
+    function printQuota2(name, quota) {
+      console.log();
+      const account = formatQuotaAccount(quota);
+      console.log(account ? `${import_chalk2.default.bold(name)}  ${import_chalk2.default.gray(account)}` : import_chalk2.default.bold(name));
+      if (quota.status === "ok" || quota.session || quota.weekly) {
+        const cue = windowCue(quota);
+        console.log(formatWindow("5 hour", quota.session, cue));
+        console.log(formatWindow("7 day", quota.weekly, cue));
+      }
+      if (quota.error) {
+        const tone = quota.status === "unavailable" ? import_chalk2.default.gray : import_chalk2.default.yellow;
+        console.log(`  ${tone(quota.error)}`);
+        if (quota.provider === "claude-cli" && quota.error.includes("claude:install")) {
+          console.log(`  ${import_chalk2.default.gray(CLAUDE_NO_API_LINE)}`);
+          console.log(`  ${import_chalk2.default.gray(CLAUDE_WRAP_NOT_REPLACE_LINE)}`);
+        }
+      }
+      console.log();
+    }
+    function printQuotaRefreshOutcome2(entries) {
+      console.log();
+      if (entries.length === 0) {
+        console.log(import_chalk2.default.gray("  Nothing to refresh."));
+        console.log();
+        return;
+      }
+      const refreshed = entries.filter((e) => e.outcome === "refreshed");
+      if (refreshed.length > 0) {
+        console.log(import_chalk2.default.green(`\u2713 Refreshed ${refreshed.map((e) => e.provider).join(", ")}`));
+      }
+      for (const entry of entries) {
+        if (entry.outcome === "refreshed") continue;
+        if (entry.outcome === "cooldown") {
+          console.log(import_chalk2.default.yellow(`\u2022 ${entry.provider}: rate-limited \u2014 not re-probed`));
+          if (typeof entry.retryAtMs === "number" && Number.isFinite(entry.retryAtMs)) {
+            console.log(import_chalk2.default.gray(`  Retrying no earlier than ${formatRelative(entry.retryAtMs)}.`));
+          }
+          console.log(import_chalk2.default.gray("  The numbers shown are the last good reading."));
+          console.log(import_chalk2.default.gray("  Re-probing now would extend the provider's own throttle."));
+          continue;
+        }
+        console.log(import_chalk2.default.gray(`\u2022 ${entry.provider}: ${entry.reason || entry.outcome}`));
+      }
+      console.log();
+    }
+    function printClaudeInstallResult2(result) {
+      console.log();
+      console.log(
+        import_chalk2.default.green(
+          result.outcome === "repaired" ? "\u2713 Claude Code quota reporting repaired" : result.outcome === "reinstalled" ? "\u2713 Claude Code quota reporting re-installed" : result.outcome === "wrapped" ? "\u2713 Claude Code quota reporting installed around your statusline" : "\u2713 Claude Code quota reporting installed"
+        )
+      );
+      if (result.outcome === "repaired") {
+        console.log(import_chalk2.default.gray("  Your statusLine pointed at a script that no longer exists:"));
+        console.log(import_chalk2.default.gray(`    ${truncate(result.repairedFrom ?? "unknown path", 100)}`));
+        console.log(import_chalk2.default.gray("  It now points at the current wrapper."));
+      }
+      if (result.originalCommand) {
+        console.log(import_chalk2.default.gray("  Your existing statusline is preserved and still runs:"));
+        console.log(import_chalk2.default.gray(`    ${truncate(result.originalCommand, 100)}`));
+        console.log(import_chalk2.default.gray(`  Backup: ${result.paths.backupFile}`));
+      } else if (result.outcome === "installed") {
+        console.log(import_chalk2.default.gray("  You had no statusline configured; one was not added."));
+      }
+      if (result.volatileWrapperReason) {
+        console.log(
+          import_chalk2.default.yellow(`  ! The wrapper was written under ${result.volatileWrapperReason}.`)
+        );
+        console.log(import_chalk2.default.gray(`    ${result.paths.wrapperFile}`));
+        console.log(import_chalk2.default.gray("    Claude Code will fail to load it once that path is gone;"));
+        console.log(import_chalk2.default.gray("    re-run `adhdev quota claude:install` from a normal install to fix."));
+      }
+      console.log();
+      console.log(import_chalk2.default.gray("  Open a Claude Code session, then run `adhdev quota claude`."));
+      console.log(import_chalk2.default.gray("  Undo any time with `adhdev quota claude:uninstall`."));
+      console.log();
+    }
+    function printClaudeUninstallResult2(result) {
+      console.log();
+      if (result.outcome === "restored") {
+        console.log(import_chalk2.default.green("\u2713 Your original statusline has been restored"));
+      } else if (result.outcome === "removed") {
+        console.log(import_chalk2.default.green("\u2713 Claude Code quota reporting removed"));
+        console.log(import_chalk2.default.gray("  You had no statusline before install, so none was left behind."));
+      } else {
+        console.log(import_chalk2.default.yellow("\u2022 Claude Code quota reporting was not installed"));
+        console.log(import_chalk2.default.gray("  Your statusLine setting was left untouched."));
+      }
+      console.log();
+    }
+    function printClaudeStatuslineStatus2(status) {
+      console.log();
+      if (status.installed) {
+        console.log(import_chalk2.default.green("\u2713 Installed"));
+        console.log(
+          import_chalk2.default.gray(
+            status.wrappedCommand ? `  Wrapping your statusline: ${truncate(status.wrappedCommand, 100)}` : "  You had no statusline before install."
+          )
+        );
+        console.log(import_chalk2.default.gray(`  Wrapper: ${status.paths.wrapperFile}`));
+        console.log(import_chalk2.default.gray(`  Backup: ${status.paths.backupFile}`));
+        let snapshotMtimeMs = null;
+        try {
+          snapshotMtimeMs = fs65.statSync(status.paths.snapshotFile).mtimeMs;
+        } catch {
+        }
+        console.log(import_chalk2.default.gray(
+          snapshotMtimeMs === null ? "  Last snapshot: none yet \u2014 open a Claude Code session to record one" : `  Last snapshot: ${formatAgo(snapshotMtimeMs)} (${status.paths.snapshotFile})`
+        ));
+        console.log(import_chalk2.default.gray("  Undo with `adhdev quota claude:uninstall`."));
+      } else if (status.failureKind === "wrapper-missing") {
+        console.log(import_chalk2.default.red("\u2717 Broken \u2014 the configured wrapper no longer exists"));
+        console.log(import_chalk2.default.gray(`  statusLine points at: ${truncate(status.danglingWrapperPath ?? "unknown path", 100)}`));
+        console.log(import_chalk2.default.gray("  Claude Code runs that command every prompt and it fails, so"));
+        console.log(import_chalk2.default.gray("  no quota is being captured and your statusline is blank."));
+        if (status.wrappedCommand) {
+          console.log(import_chalk2.default.gray(`  Your own statusline is still recorded: ${truncate(status.wrappedCommand, 80)}`));
+        }
+        console.log(import_chalk2.default.gray("  Repair with `adhdev quota claude:install`."));
+        console.log(import_chalk2.default.gray("  Or clear it with `adhdev quota claude:uninstall`."));
+      } else {
+        console.log(import_chalk2.default.yellow("\u2022 Not installed"));
+        if (status.foreignStatusLine) {
+          console.log(import_chalk2.default.gray("  You have your own statusLine configured; install would wrap it."));
+        }
+        console.log(import_chalk2.default.gray(`  ${CLAUDE_NO_API_LINE}`));
+        console.log(import_chalk2.default.gray(`  ${CLAUDE_WRAP_NOT_REPLACE_LINE}`));
+        console.log(import_chalk2.default.gray("  Set up with `adhdev quota claude:install`."));
+      }
+      console.log();
+    }
+    function printQuotaInstallError2(message) {
+      console.error(import_chalk2.default.red(`
+\u2717 ${message}
+`));
+    }
     async function appendAssistantJournal(handle, kind, payload) {
       if (!handle.topics.some((d) => d.topic === ASSISTANT_JOURNAL_TOPIC)) {
         throw new Error(
@@ -146128,6 +146518,11 @@ Options:
 
 Environment:
   ADHDEV_SESSION_HOST_NAME   Override session host namespace (default: adhdev-standalone)
+  ADHDEV_STANDALONE_PORT     Port to listen on when --port is not given (default: 3847).
+                             An explicit --port always wins over this.
+  ADHDEV_CONFIG_DIR          Override the state/profile directory (default: ~/.adhdev-standalone).
+                             Inherited from the environment, not just set explicitly \u2014 see the
+                             startup warning if this points at a directory a live daemon owns.
   --help, -h             Show this help message
 
 Runtime commands:
@@ -146156,6 +146551,15 @@ function normalizeStandalonePort(raw) {
   }
   return port;
 }
+var STANDALONE_PORT_ENV_VAR = "ADHDEV_STANDALONE_PORT";
+function resolveStandalonePortEnvOverride(env2 = process.env) {
+  const raw = env2[STANDALONE_PORT_ENV_VAR]?.trim();
+  if (!raw) return void 0;
+  if (!/^\d+$/.test(raw)) return void 0;
+  const port = Number(raw);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) return void 0;
+  return port;
+}
 var FLAG_SPECS = [
   { names: ["--port", "-p"], takesValue: true },
   { names: ["--host", "-H"], takesValue: true },
@@ -147569,7 +147973,7 @@ var StandaloneServer = class {
     if (!options.host && persistedStandaloneBindHost !== STANDALONE_BIND_HOST_DEFAULT) {
       saveStandaloneBindHostPreference(persistedStandaloneBindHost);
     }
-    const port = options.port || DEFAULT_PORT;
+    const port = options.port || resolveStandalonePortEnvOverride() || DEFAULT_PORT;
     (0, import_daemon_core3.setLogInstancePort)(port);
     process.env.ADHDEV_COORDINATOR_MCP_TRANSPORT = "local";
     process.env.ADHDEV_COORDINATOR_MCP_PORT = String(port);
@@ -147694,8 +148098,20 @@ var StandaloneServer = class {
       if (this.topicRegistry.hasSubscriptions("workspace.git")) void this.topicRegistry.flushNow("workspace.git");
     }, STATUS_INTERVAL);
     this.running = true;
-    await new Promise((resolve2) => {
+    await new Promise((resolve2, reject) => {
+      const onError = (err) => {
+        this.running = false;
+        if (err.code === "EADDRINUSE") {
+          reject(new Error(
+            `Port ${port} is already in use \u2014 another process (possibly another ADHDev daemon) is listening on ${host}:${port}. Use --port <port> or set ADHDEV_STANDALONE_PORT to pick a different one.`
+          ));
+        } else {
+          reject(err);
+        }
+      };
+      this.httpServer.once("error", onError);
       this.httpServer.listen(port, host, () => {
+        this.httpServer.off("error", onError);
         resolve2();
       });
     });