@adhdev/daemon-standalone 1.0.35-rc.1 → 1.0.35-rc.3

package/dist/index.js

@@ -33319,10 +33319,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "65e293b631711246fb672d34f817058f4b78ef74" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "65e293b6" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.35-rc.1" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-04T22:59:22.024Z" : void 0);
+      const commit = readInjected(true ? "3875b913f032a9f2012318bcb7904a2c96f6f965" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "3875b913" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.35-rc.3" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-05T03:04:28.158Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -35186,11 +35186,11 @@ child.on('exit', () => process.exit(0));
       fs32.writeFileSync(temp, contents, mode === void 0 ? "utf-8" : { encoding: "utf-8", mode });
       fs32.renameSync(temp, file2);
     }
-    function installClaudeStatusline(env2 = process.env) {
+    function installClaudeStatusline2(env2 = process.env) {
       const paths = resolveInstallPaths(env2);
       const settingsResult = readJsonFile(paths.settingsFile);
       if (settingsResult.kind === "invalid") {
-        throw new StatuslineInstallError(
+        throw new StatuslineInstallError2(
           `${settingsResult.reason}. Fix or move the file, then retry.`
         );
       }
@@ -35258,11 +35258,11 @@ child.on('exit', () => process.exit(0));
         statusLine
       };
     }
-    function uninstallClaudeStatusline(env2 = process.env) {
+    function uninstallClaudeStatusline2(env2 = process.env) {
       const paths = resolveInstallPaths(env2);
       const settingsResult = readJsonFile(paths.settingsFile);
       if (settingsResult.kind === "invalid") {
-        throw new StatuslineInstallError(
+        throw new StatuslineInstallError2(
           `${settingsResult.reason}. Fix the file by hand, then retry.`
         );
       }
@@ -35303,7 +35303,7 @@ child.on('exit', () => process.exit(0));
       } catch {
       }
     }
-    function readStatuslineStatus(env2 = process.env) {
+    function readStatuslineStatus2(env2 = process.env) {
       const paths = resolveInstallPaths(env2);
       const settingsResult = readJsonFile(paths.settingsFile);
       const settings = settingsResult.kind === "ok" ? settingsResult.value : {};
@@ -35322,7 +35322,7 @@ child.on('exit', () => process.exit(0));
     var fs32;
     var path52;
     var WRAPPER_MARKER;
-    var StatuslineInstallError;
+    var StatuslineInstallError2;
     var init_install = __esm2({
       "src/quota/statusline/install.ts"() {
         "use strict";
@@ -35332,7 +35332,7 @@ child.on('exit', () => process.exit(0));
         init_paths();
         init_wrapper_source();
         WRAPPER_MARKER = "adhdev-statusline";
-        StatuslineInstallError = class extends Error {
+        StatuslineInstallError2 = class extends Error {
         };
       }
     });
@@ -35362,7 +35362,7 @@ child.on('exit', () => process.exit(0));
       }
       return windowFromPercent(record2.usedPercent, windowMinutes2, record2.resetsAt);
     }
-    async function fetchClaudeQuota(overrides = {}) {
+    async function fetchClaudeQuota2(overrides = {}) {
       const deps = resolveDeps(overrides);
       const paths = resolveInstallPaths(deps.env);
       let raw;
@@ -35419,7 +35419,7 @@ child.on('exit', () => process.exit(0));
     function missingSnapshotFailure(env2) {
       let installed = false;
       try {
-        installed = readStatuslineStatus(env2).installed;
+        installed = readStatuslineStatus2(env2).installed;
       } catch {
       }
       return quotaFailure(
@@ -35538,7 +35538,7 @@ child.on('exit', () => process.exit(0));
         }
       };
     }
-    async function fetchCodexQuota(overrides = {}) {
+    async function fetchCodexQuota2(overrides = {}) {
       const deps = resolveDeps(overrides);
       return new Promise((resolve29) => {
         let child;
@@ -35861,7 +35861,7 @@ child.on('exit', () => process.exit(0));
       const at = new Date(header).getTime();
       return Number.isNaN(at) ? void 0 : at;
     }
-    async function fetchKimiQuota(overrides = {}) {
+    async function fetchKimiQuota2(overrides = {}) {
       const deps = resolveDeps(overrides);
       const credentialsResult = readCredentials(deps);
       if (credentialsResult.kind === "missing") {
@@ -36009,11 +36009,19 @@ child.on('exit', () => process.exit(0));
         hasRecentCliActivity: () => hasRecentCliActivity(components.instanceManager.collectHotChatSessionStates())
       });
     }
+    function refreshQuotaCacheOnBoot() {
+      if (bootRefreshInFlight || readQuotaCache() !== void 0) return;
+      bootRefreshInFlight = true;
+      void refreshQuotaCacheOnce().catch((e) => LOG2.warn("Quota", `Boot quota refresh failed: ${e?.message || e}`)).finally(() => {
+        bootRefreshInFlight = false;
+      });
+    }
     var QUOTA_REFRESH_INTERVAL_MS;
     var QUOTA_ACTIVITY_WINDOW_MS;
     var REFRESHERS;
     var cache;
     var WORKING_STATUSES;
+    var bootRefreshInFlight;
     var init_refresh = __esm2({
       "src/quota/refresh.ts"() {
         "use strict";
@@ -36024,9 +36032,9 @@ child.on('exit', () => process.exit(0));
         QUOTA_REFRESH_INTERVAL_MS = 15 * 60 * 1e3;
         QUOTA_ACTIVITY_WINDOW_MS = 20 * 60 * 1e3;
         REFRESHERS = [
-          { provider: "claude-cli", fetch: () => fetchClaudeQuota() },
-          { provider: "codex-cli", fetch: () => fetchCodexQuota() },
-          { provider: "kimi", fetch: () => fetchKimiQuota() }
+          { provider: "claude-cli", fetch: () => fetchClaudeQuota2() },
+          { provider: "codex-cli", fetch: () => fetchCodexQuota2() },
+          { provider: "kimi", fetch: () => fetchKimiQuota2() }
         ];
         cache = /* @__PURE__ */ new Map();
         WORKING_STATUSES = /* @__PURE__ */ new Set([
@@ -36039,6 +36047,7 @@ child.on('exit', () => process.exit(0));
           "no_progress",
           "long_generating"
         ]);
+        bootRefreshInFlight = false;
       }
     });
     function buildLocalNodeFacts(deps) {
@@ -39386,6 +39395,10 @@ Next step: ${nextStep}`;
       }
       return { attempt, opened: inserted };
     }
+    function mergeLegacyHint(legacy, sessionId) {
+      if (!legacy) return sessionId ? { sessionId } : void 0;
+      return { ...sessionId ? { sessionId } : {}, ...legacy };
+    }
     function ensureLegacyTurnAttempt(args) {
       const store = MeshRuntimeStore.getInstance();
       const seq2 = typeof args.dispatchNonce === "number" ? args.dispatchNonce : 0;
@@ -39438,7 +39451,7 @@ Next step: ${nextStep}`;
       const nowIso = new Date(nowMs).toISOString();
       const attempt = resolveAttemptForTask(args.meshId, args.taskId, {
         attemptId: args.attemptId,
-        legacy: args.legacy ?? (args.sessionId ? { sessionId: args.sessionId } : void 0)
+        legacy: mergeLegacyHint(args.legacy, args.sessionId)
       });
       if (!attempt) return null;
       const current = store.getCurrentTurnAttempt(args.meshId, args.taskId);
@@ -39515,7 +39528,7 @@ Next step: ${nextStep}`;
       const nowIso = new Date(nowMs).toISOString();
       const attempt = resolveAttemptForTask(args.meshId, args.taskId, {
         attemptId: args.attemptId,
-        legacy: args.legacy ?? (args.sessionId ? { sessionId: args.sessionId } : void 0)
+        legacy: mergeLegacyHint(args.legacy, args.sessionId)
       });
       if (!attempt) return null;
       const current = store.getCurrentTurnAttempt(args.meshId, args.taskId);
@@ -39803,7 +39816,7 @@ Next step: ${nextStep}`;
       const nowIso = new Date(nowMs).toISOString();
       const attempt = resolveAttemptForTask(proposal.meshId, proposal.taskId, {
         attemptId: proposal.attemptId,
-        legacy: proposal.legacy ?? (proposal.sessionId ? { sessionId: proposal.sessionId } : void 0)
+        legacy: mergeLegacyHint(proposal.legacy, proposal.sessionId)
       });
       if (!attempt) {
         noteRejectedProposal("unknown_attempt");
@@ -39995,6 +40008,92 @@ Next step: ${nextStep}`;
         return [];
       }
     }
+    function reclaimOrphanedTurnAttempts(meshId, nowMs = Date.now()) {
+      const result = { closed: 0, skipped: 0 };
+      let rows;
+      try {
+        rows = MeshRuntimeStore.getInstance().listSupersededNonterminalTurnAttempts(meshId);
+      } catch {
+        return result;
+      }
+      if (rows.length === 0) return result;
+      const store = MeshRuntimeStore.getInstance();
+      const nowIso = new Date(nowMs).toISOString();
+      for (const row of rows) {
+        try {
+          const { committed } = store.commitTurnAttemptTerminal(
+            row.attemptId,
+            "cancelled",
+            SUPERSEDED_BY_ATTEMPT_REASON,
+            nowIso
+          );
+          if (committed) {
+            result.closed += 1;
+            store.insertTurnEvent({
+              eventId: (0, import_crypto5.randomUUID)(),
+              meshId,
+              attemptId: row.attemptId,
+              taskId: row.taskId,
+              kind: "cancelled",
+              dedupeKey: SUPERSEDED_BY_ATTEMPT_REASON,
+              occurredAtMs: nowMs,
+              recordedAt: nowIso
+            });
+          } else {
+            result.skipped += 1;
+          }
+        } catch {
+          result.skipped += 1;
+        }
+      }
+      if (result.closed > 0) {
+        LOG2.info("TurnLedger", `Orphan reclaim: closed ${result.closed} superseded nonterminal turn attempt(s) for mesh ${meshId}${result.skipped > 0 ? ` (${result.skipped} skipped \u2014 already terminal)` : ""}`);
+      }
+      return result;
+    }
+    function reclaimQueueTerminatedTurnAttempts(meshId, nowMs = Date.now()) {
+      const result = { closed: 0, skipped: 0 };
+      let rows;
+      try {
+        rows = MeshRuntimeStore.getInstance().listQueueTerminatedNonterminalTurnAttempts(meshId);
+      } catch {
+        return result;
+      }
+      if (rows.length === 0) return result;
+      const store = MeshRuntimeStore.getInstance();
+      const nowIso = new Date(nowMs).toISOString();
+      for (const row of rows) {
+        try {
+          const { committed } = store.commitTurnAttemptTerminal(
+            row.attemptId,
+            "cancelled",
+            SUPERSEDED_BY_QUEUE_TERMINAL_REASON,
+            nowIso
+          );
+          if (committed) {
+            result.closed += 1;
+            store.insertTurnEvent({
+              eventId: (0, import_crypto5.randomUUID)(),
+              meshId,
+              attemptId: row.attemptId,
+              taskId: row.taskId,
+              kind: "cancelled",
+              dedupeKey: SUPERSEDED_BY_QUEUE_TERMINAL_REASON,
+              occurredAtMs: nowMs,
+              recordedAt: nowIso
+            });
+          } else {
+            result.skipped += 1;
+          }
+        } catch {
+          result.skipped += 1;
+        }
+      }
+      if (result.closed > 0) {
+        LOG2.info("TurnLedger", `Queue-terminal reclaim: closed ${result.closed} nonterminal turn attempt(s) whose queue row already finished for mesh ${meshId}${result.skipped > 0 ? ` (${result.skipped} skipped \u2014 already terminal)` : ""}`);
+      }
+      return result;
+    }
     function enqueueTerminalOutbox(args) {
       const nowMs = args.nowMs ?? Date.now();
       const nowIso = new Date(nowMs).toISOString();
@@ -40090,6 +40189,8 @@ Next step: ${nextStep}`;
     var MAX_SUSPENSION_LOG_KEYS;
     var suspensionLogKeys;
     var MAX_REDRIVES_PER_ATTEMPT;
+    var SUPERSEDED_BY_ATTEMPT_REASON;
+    var SUPERSEDED_BY_QUEUE_TERMINAL_REASON;
     var sessionOrderChains;
     var init_mesh_turn_ledger = __esm2({
       "src/mesh/mesh-turn-ledger.ts"() {
@@ -40134,6 +40235,8 @@ Next step: ${nextStep}`;
         MAX_SUSPENSION_LOG_KEYS = 200;
         suspensionLogKeys = /* @__PURE__ */ new Set();
         MAX_REDRIVES_PER_ATTEMPT = 1;
+        SUPERSEDED_BY_ATTEMPT_REASON = "superseded_by_attempt";
+        SUPERSEDED_BY_QUEUE_TERMINAL_REASON = "superseded_by_queue_terminal";
         sessionOrderChains = /* @__PURE__ */ new Map();
       }
     });
@@ -45257,11 +45360,44 @@ Next step: ${nextStep}`;
            * Stage 6's presentation layer resolves sessions (not tasks) — read_chat,
            * session status, dashboard and the restart gate all key on sessionId.
            */
+          /**
+           * The attempt that governs a session's presented execution status.
+           *
+           * A nonterminal attempt is preferred (an in-flight turn outranks a finished
+           * one), but ONLY when it is its task's CURRENT attempt — i.e. no higher
+           * attempt_seq exists for the same task.
+           *
+           * ORPHAN-LEGACY-ATTEMPT (fix ③): without that restriction, a stranded
+           * lower-seq row (classically a `legacy-<taskId>-0` minted mid-turn while the
+           * real dispatch already held seq >= 1) outranks the real, COMPLETED attempt
+           * purely because it is nonterminal. Such a row is unreachable by
+           * construction — every ACK and every completion targets the current attempt,
+           * and the reducer's stale-attempt guard refuses to mutate a non-current row —
+           * so it stays `generating` forever and pins the session's presented status to
+           * `generating` even though its turn finished. Fixes ① (no new orphans) and ②
+           * (close the existing ones) address the rows themselves; this guard is the
+           * read-side safety net for any that still slip through, e.g. mid-flight
+           * before the reclaim sweep runs.
+           *
+           * `attempt_seq DESC` is the final tie-break, not decoration: attempts of one
+           * task are routinely written inside the same millisecond, so `updated_at`
+           * alone leaves ties that SQLite may resolve either way — which would make
+           * the selection (and therefore the presented session status) flap between
+           * runs. Preferring the newer attempt is the correct resolution.
+           */
           getLatestTurnAttemptForSession(sessionId) {
             const row = this.db.prepare(`
-            SELECT * FROM mesh_turn_attempts
-            WHERE session_id = ?
-            ORDER BY (terminal_outcome IS NULL) DESC, updated_at DESC LIMIT 1
+            SELECT a.* FROM mesh_turn_attempts a
+            WHERE a.session_id = ?
+            ORDER BY
+                (a.terminal_outcome IS NULL AND NOT EXISTS (
+                    SELECT 1 FROM mesh_turn_attempts b
+                    WHERE b.mesh_id = a.mesh_id AND b.task_id = a.task_id
+                      AND b.attempt_seq > a.attempt_seq
+                )) DESC,
+                a.updated_at DESC,
+                a.attempt_seq DESC
+            LIMIT 1
         `).get(sessionId);
             return row ? meshTurnAttemptFromRow(row) : null;
           }
@@ -45277,6 +45413,83 @@ Next step: ${nextStep}`;
         `).all(meshId, taskId);
             return rows.map(meshTurnAttemptFromRow);
           }
+          /**
+           * ORPHAN-LEGACY-ATTEMPT (fix ②): nonterminal attempts that a HIGHER-seq
+           * attempt of the same task has superseded.
+           *
+           * Such a row is unreachable by construction: `getCurrentTurnAttempt` returns
+           * the max-seq row, so every ACK and every completion proposal resolves to the
+           * newer attempt and the reducer's stale-attempt guard explicitly refuses to
+           * mutate the older one. Nothing in the system can ever move it to terminal —
+           * it would sit at `generating` indefinitely, and (before fix ③) outrank the
+           * real completed attempt when presenting the session's status.
+           *
+           * Deliberately keyed on seq supersession rather than on the `legacy-` id
+           * prefix: the id form is a symptom of one known minting path, whereas
+           * "a newer attempt exists for this task" is the actual unreachability
+           * condition and covers any future path that strands a row the same way.
+           */
+          listSupersededNonterminalTurnAttempts(meshId) {
+            const rows = this.db.prepare(`
+            SELECT a.* FROM mesh_turn_attempts a
+            WHERE a.mesh_id = ?
+              AND a.terminal_outcome IS NULL
+              AND EXISTS (
+                  SELECT 1 FROM mesh_turn_attempts b
+                  WHERE b.mesh_id = a.mesh_id AND b.task_id = a.task_id
+                    AND b.attempt_seq > a.attempt_seq
+              )
+            ORDER BY a.created_at ASC
+        `).all(meshId);
+            return rows.map(meshTurnAttemptFromRow);
+          }
+          /**
+           * QUEUE-TERMINAL-ATTEMPT: nonterminal attempts whose task's `mesh_queue` row
+           * is ALREADY terminal (`completed` / `failed` / `cancelled`).
+           *
+           * The queue row is an independent writer from the turn-ledger reducer — see
+           * Stage 5's rollout gate (some paths, e.g. mission cascade / requeueTask auto-
+           * fail, flip the queue row through the legacy/shadow path without ever
+           * routing a completion proposal through the reducer). When the queue has
+           * already recorded a terminal outcome for a task, that is independent proof
+           * the work is done, so an attempt row still sitting nonterminal is not a live
+           * turn being protected — it is a finished task that was never told. Closing
+           * it cannot kill a real in-flight turn: a genuinely active turn has its queue
+           * row still `pending`/`assigned`, which this predicate excludes by
+           * construction (only `completed`/`failed`/`cancelled` queue rows qualify).
+           *
+           * `EXISTS` (not a JOIN) so a task_id with NO matching queue row — nothing to
+           * compare against — is excluded rather than treated as a false match; a NULL
+           * comparison in a JOIN would silently drop or wrongly include such rows
+           * depending on the join type, which is exactly the ambiguity this predicate
+           * must not have. Measured on the live ledger (RCA 2b3d260d): 14 of 735
+           * nonterminal attempts match, 2 of 721 `delivered`-stage rows — a live turn
+           * is essentially never caught by this condition.
+           *
+           * Deliberately independent of `attempt_seq` / current-vs-superseded: unlike
+           * listSupersededNonterminalTurnAttempts, this predicate targets the SOLE
+           * (and therefore trivially "current") attempt of a task just as often as a
+           * stale one — a task with only ONE attempt whose queue row is terminal is
+           * exactly the residue class this exists to close (confirmed case: a
+           * `waiting_choice` attempt whose queue row already reads `cancelled`).
+           * `reclaimOrphanedTurnAttempts` (seq supersession) runs first in the same
+           * restart-recovery sweep, so a stale non-current sibling row is already
+           * closed by the time this predicate's SELECT runs.
+           */
+          listQueueTerminatedNonterminalTurnAttempts(meshId) {
+            const rows = this.db.prepare(`
+            SELECT a.* FROM mesh_turn_attempts a
+            WHERE a.mesh_id = ?
+              AND a.terminal_outcome IS NULL
+              AND EXISTS (
+                  SELECT 1 FROM mesh_queue q
+                  WHERE q.mesh_id = a.mesh_id AND q.id = a.task_id
+                    AND q.status IN ('completed', 'failed', 'cancelled')
+              )
+            ORDER BY a.created_at ASC
+        `).all(meshId);
+            return rows.map(meshTurnAttemptFromRow);
+          }
           /** Nonterminal attempts — the restart-recovery reconstruction set. */
           listActiveTurnAttempts(meshId) {
             const rows = this.db.prepare(`
@@ -64516,6 +64729,14 @@ ${cleanBody}`;
         void (async () => {
           try {
             for (const mesh of listMeshes()) {
+              const reclaimed = reclaimOrphanedTurnAttempts(mesh.id);
+              if (reclaimed.closed > 0) {
+                LOG2.info("TurnLedger", `Restart recovery: reclaimed ${reclaimed.closed} orphaned (superseded) turn attempt(s) for mesh ${mesh.id}`);
+              }
+              const queueReclaimed = reclaimQueueTerminatedTurnAttempts(mesh.id);
+              if (queueReclaimed.closed > 0) {
+                LOG2.info("TurnLedger", `Restart recovery: reclaimed ${queueReclaimed.closed} nonterminal turn attempt(s) whose queue row already finished for mesh ${mesh.id}`);
+              }
               const recovered = reconstructActiveAttempts(mesh.id);
               if (recovered.length > 0) {
                 LOG2.info("TurnLedger", `Restart recovery: reconstructed ${recovered.length} active turn attempt(s) for mesh ${mesh.id} (${recovered.map((a) => `${a.taskId.slice(0, 8)}@${a.stage}`).join(", ")})`);
@@ -73143,7 +73364,7 @@ ${lastSnapshot}`;
       STALE_TERMINAL_REFINE_WINDOW_MS: () => STALE_TERMINAL_REFINE_WINDOW_MS,
       STANDALONE_CDP_SCAN_INTERVAL_MS: () => STANDALONE_CDP_SCAN_INTERVAL_MS2,
       SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory2,
-      StatuslineInstallError: () => StatuslineInstallError,
+      StatuslineInstallError: () => StatuslineInstallError2,
       TREE_DIGEST_ALGORITHM: () => TREE_DIGEST_ALGORITHM,
       TerminalAdapter: () => TerminalAdapter,
       TurnSnapshotTracker: () => TurnSnapshotTracker,
@@ -73249,9 +73470,9 @@ ${lastSnapshot}`;
       execNpmCommandSync: () => execNpmCommandSync,
       expandDaemonIdForms: () => expandDaemonIdForms,
       fastForwardMeshNode: () => fastForwardMeshNode,
-      fetchClaudeQuota: () => fetchClaudeQuota,
-      fetchCodexQuota: () => fetchCodexQuota,
-      fetchKimiQuota: () => fetchKimiQuota,
+      fetchClaudeQuota: () => fetchClaudeQuota2,
+      fetchCodexQuota: () => fetchCodexQuota2,
+      fetchKimiQuota: () => fetchKimiQuota2,
       filterActivityChatMessages: () => filterActivityChatMessages,
       filterChatMessagesByVisibility: () => filterChatMessagesByVisibility,
       filterInternalChatMessages: () => filterInternalChatMessages,
@@ -73315,7 +73536,7 @@ ${lastSnapshot}`;
       hashSignatureParts: () => hashSignatureParts,
       initDaemonComponents: () => initDaemonComponents2,
       insertDirectDispatch: () => insertDirectDispatch,
-      installClaudeStatusline: () => installClaudeStatusline,
+      installClaudeStatusline: () => installClaudeStatusline2,
       installExtensions: () => installExtensions,
       installGlobalInterceptor: () => installGlobalInterceptor,
       interactivePromptFromClaudeAskUserQuestion: () => interactivePromptFromClaudeAskUserQuestion,
@@ -73417,6 +73638,11 @@ ${lastSnapshot}`;
       prepareSessionChatTailUpdate: () => prepareSessionChatTailUpdate2,
       prepareSessionModalUpdate: () => prepareSessionModalUpdate2,
       presentationFromAttemptRow: () => presentationFromAttemptRow,
+      printClaudeInstallResult: () => printClaudeInstallResult2,
+      printClaudeStatuslineStatus: () => printClaudeStatuslineStatus2,
+      printClaudeUninstallResult: () => printClaudeUninstallResult2,
+      printQuota: () => printQuota2,
+      printQuotaInstallError: () => printQuotaInstallError2,
       probeCdpPort: () => probeCdpPort,
       pruneOperatingNotes: () => pruneOperatingNotes,
       pruneStaleDirectDispatches: () => pruneStaleDirectDispatches,
@@ -73433,7 +73659,7 @@ ${lastSnapshot}`;
       readMeshCompletionSummary: () => readMeshCompletionSummary,
       readOperatingNotes: () => readOperatingNotes,
       readSessionUsage: () => readSessionUsage,
-      readStatuslineStatus: () => readStatuslineStatus,
+      readStatuslineStatus: () => readStatuslineStatus2,
       readTokenCount: () => readTokenCount,
       readV2EnvelopeFromWire: () => readV2EnvelopeFromWire,
       reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
@@ -73521,7 +73747,7 @@ ${lastSnapshot}`;
       totalTokens: () => totalTokens,
       triggerMeshQueue: () => triggerMeshQueue,
       turnStageToSurfaceStatus: () => turnStageToSurfaceStatus,
-      uninstallClaudeStatusline: () => uninstallClaudeStatusline,
+      uninstallClaudeStatusline: () => uninstallClaudeStatusline2,
       unregisterMeshCoordinator: () => unregisterMeshCoordinator,
       updateConfig: () => updateConfig,
       updateDirectDispatchStatus: () => updateDirectDispatchStatus,
@@ -85693,6 +85919,14 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     init_snapshot2();
     init_build_info();
     init_coordinator_registry();
+    init_types();
+    init_deps();
+    init_refresh();
+    init_kimi();
+    init_codex();
+    init_claude();
+    init_install();
+    init_snapshot();
     var statusMetaHandlers = {
       set_user_name: async (_ctx, args) => {
         const name = args?.userName;
@@ -85713,9 +85947,18 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         return { success: true, status: snapshot, daemonBuild: getDaemonBuildInfo() };
       },
       get_machine_runtime_stats: async (_ctx, _args) => {
+        const quota = readQuotaCache();
         return {
           success: true,
-          machine: buildMachineInfo2("full"),
+          machine: {
+            ...buildMachineInfo2("full"),
+            // Omit the key entirely rather than shipping `quota: undefined`
+            // — same "never reported" vs "reported empty" contract as
+            // buildLocalNodeFacts (mesh/node-facts.ts). `'quota' in machine`
+            // must stay false until the refresh loop's first tick.
+            ...quota ? { quota } : {},
+            machineNickname: loadConfig2().machineNickname
+          },
           timestamp: Date.now()
         };
       },
@@ -85737,6 +85980,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         const launchInfo = adapter && typeof adapter.getLaunchInfo === "function" ? adapter.getLaunchInfo() : void 0;
         const providerType = target?.providerType || coord?.cliType || "";
         const providerMetaForSession = providerType ? ctx.deps.providerLoader.resolve?.(providerType) || ctx.deps.providerLoader.getMeta(providerType) : void 0;
+        const quota = readQuotaCache();
         return {
           success: true,
           session: {
@@ -85752,6 +85996,14 @@ ${formatManifestValidationIssues2(validation.issues)}`,
             runtimeMetadata: runtimeMeta,
             launch: launchInfo
           },
+          // Machine-scoped, not session-scoped: this daemon is the one the
+          // dialog already talked to (ctx handles the routing), so it can
+          // answer for its own machine's quota with no mesh lookup. Cache
+          // read only — see the import comment above. Key omitted entirely
+          // (not `quota: undefined`) until the refresh loop's first tick —
+          // same never-reported-vs-reported-empty contract as node-facts.ts.
+          ...quota ? { quota } : {},
+          machineNickname: loadConfig2().machineNickname,
           coordinator: coord ? {
             meshId: coord.meshId,
             startedAt: coord.startedAt,
@@ -120316,6 +120568,7 @@ data: ${JSON.stringify(msg.data)}
       setupMeshEventForwarding(components);
       components.meshReconcileLoop = setupMeshReconcileLoop(components);
       components.quotaRefreshLoop = setupQuotaRefreshLoop(components);
+      setImmediate(() => refreshQuotaCacheOnBoot());
       setImmediate(() => void router.resumePendingRefineJobsOnStartup());
       setImmediate(() => router.resumeDeferredRestartsOnStartup());
       return components;
@@ -120638,14 +120891,107 @@ data: ${JSON.stringify(msg.data)}
       Object.values(V1_PRIMITIVE_CATALOG).flat()
     );
     var V1_CONTRACT_VERSION = "1.0.0";
-    init_types();
-    init_deps();
-    init_refresh();
-    init_kimi();
-    init_codex();
-    init_claude();
-    init_install();
-    init_snapshot();
+    var import_chalk2 = __toESM2((init_source(), __toCommonJS(source_exports)));
+    function formatWindow(label, window) {
+      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)}`);
+      return `  ${label.padEnd(8)} ${bar} ${percent.padStart(6)} used${reset}`;
+    }
+    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 printQuota2(name, quota) {
+      console.log();
+      console.log(import_chalk2.default.bold(name));
+      if (quota.status === "ok" || quota.session || quota.weekly) {
+        console.log(formatWindow("5 hour", quota.session));
+        console.log(formatWindow("7 day", quota.weekly));
+      }
+      if (quota.error) {
+        const tone = quota.status === "unavailable" ? import_chalk2.default.gray : import_chalk2.default.yellow;
+        console.log(`  ${tone(quota.error)}`);
+      }
+      console.log();
+    }
+    function printClaudeInstallResult2(result) {
+      console.log();
+      console.log(
+        import_chalk2.default.green(
+          result.outcome === "reinstalled" ? "\u2713 Claude Code quota reporting re-installed" : "\u2713 Claude Code quota reporting installed"
+        )
+      );
+      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 {
+        console.log(import_chalk2.default.gray("  You had no statusline configured; one was not added."));
+      }
+      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(`  Snapshot: ${status.paths.snapshotFile}`));
+      } 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("  Set up with `adhdev quota claude:install`."));
+      }
+      console.log();
+    }
+    function printQuotaInstallError2(message) {
+      console.error(import_chalk2.default.red(`
+\u2717 ${message}
+`));
+    }
   }
 });
 
@@ -120771,6 +121117,8 @@ var STANDALONE_HELP_TEXT = `
 Usage: adhdev-standalone [options]
        adhdev-standalone list [--all]
        adhdev-standalone attach <sessionId> [--read-only|--takeover]
+       adhdev-standalone quota <claude|codex|kimi>
+       adhdev-standalone quota claude:install | claude:uninstall | claude:status
 
 Options:
   --port, -p <port>      Port to run the standalone server on (default: 3847)
@@ -120791,6 +121139,7 @@ Runtime commands:
   list, runtimes      Show hosted CLI runtimes
   attach              Attach local terminal to a runtime
   open                Open a local terminal window running adhmux for a runtime
+  quota               Show remaining plan quota for your AI coding agents
 `;
 var PUBLIC_ANY_ADDRESSES = /* @__PURE__ */ new Set(["0.0.0.0", "::"]);
 function normalizeStandaloneHostAddress(raw) {
@@ -120889,8 +121238,8 @@ function parseStandaloneCliArgs(args) {
 }
 
 // src/index.ts
-var import_daemon_core2 = __toESM(require_dist3());
 var import_daemon_core3 = __toESM(require_dist3());
+var import_daemon_core4 = __toESM(require_dist3());
 
 // src/session-host.ts
 var childProcess = __toESM(require("child_process"));
@@ -120970,6 +121319,69 @@ async function proxySessionHostAttach(target, options = {}) {
   return runSessionHostCli(args);
 }
 
+// src/quota-cli.ts
+var import_daemon_core2 = __toESM(require_dist3());
+var QUOTA_HELP_TEXT = `
+Usage: adhdev quota <provider>
+       adhdev quota claude:install | claude:uninstall | claude:status
+
+Providers:
+  claude    Show Claude Code plan usage (requires \`adhdev quota claude:install\`)
+  codex     Show Codex CLI plan usage (queries codex app-server live)
+  kimi      Show Kimi Code plan usage (queries the Kimi API live)
+
+Claude Code setup (codex/kimi need no setup \u2014 they query live):
+  claude:install     Set up Claude Code quota reporting by wrapping your statusline
+  claude:uninstall   Remove Claude Code quota reporting and restore your original statusline
+  claude:status      Show whether Claude Code quota reporting is set up
+`;
+async function runQuotaCommand(args) {
+  const sub = args[0];
+  switch (sub) {
+    case "claude":
+      (0, import_daemon_core2.printQuota)("Claude Code", await (0, import_daemon_core2.fetchClaudeQuota)());
+      return 0;
+    case "codex":
+      (0, import_daemon_core2.printQuota)("Codex CLI", await (0, import_daemon_core2.fetchCodexQuota)());
+      return 0;
+    case "kimi":
+      (0, import_daemon_core2.printQuota)("Kimi Code", await (0, import_daemon_core2.fetchKimiQuota)());
+      return 0;
+    case "claude:install":
+    case "claude-install": {
+      try {
+        (0, import_daemon_core2.printClaudeInstallResult)((0, import_daemon_core2.installClaudeStatusline)());
+        return 0;
+      } catch (err) {
+        if (err instanceof import_daemon_core2.StatuslineInstallError) {
+          (0, import_daemon_core2.printQuotaInstallError)(err.message);
+          return 1;
+        }
+        throw err;
+      }
+    }
+    case "claude:uninstall":
+    case "claude-uninstall": {
+      try {
+        (0, import_daemon_core2.printClaudeUninstallResult)((0, import_daemon_core2.uninstallClaudeStatusline)());
+        return 0;
+      } catch (err) {
+        if (err instanceof import_daemon_core2.StatuslineInstallError) {
+          (0, import_daemon_core2.printQuotaInstallError)(err.message);
+          return 1;
+        }
+        throw err;
+      }
+    }
+    case "claude:status":
+      (0, import_daemon_core2.printClaudeStatuslineStatus)((0, import_daemon_core2.readStatuslineStatus)());
+      return 0;
+    default:
+      console.log(QUOTA_HELP_TEXT);
+      return sub === void 0 || sub === "--help" || sub === "-h" ? 0 : 1;
+  }
+}
+
 // src/startup-restore-policy.ts
 function shouldAutoRestoreHostedSessionsOnStartup(env2 = process.env) {
   const raw = typeof env2.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP === "string" ? env2.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP.trim().toLowerCase() : "";
@@ -121394,7 +121806,7 @@ async function getWorkspaceSocketInfo(workspaceName) {
 }
 
 // src/index.ts
-var import_daemon_core4 = __toESM(require_dist3());
+var import_daemon_core5 = __toESM(require_dist3());
 
 // src/raw-terminal-http.ts
 function parseRawTerminalPath(pathname) {
@@ -121582,7 +121994,7 @@ async function handleInteractivePromptHttpRequest(options) {
 // src/index.ts
 var DEFAULT_PORT = 3847;
 var STATUS_INTERVAL = 2e3;
-var CHAT_OUTPUT_ACTIVITY_HOT_MS = import_daemon_core4.DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS;
+var CHAT_OUTPUT_ACTIVITY_HOT_MS = import_daemon_core5.DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS;
 var CHAT_OUTPUT_FLUSH_DEBOUNCE_MS = 700;
 var STANDALONE_AUTH_SESSION_COOKIE = "adhdev_standalone_session";
 var STANDALONE_PASSWORD_CONFIG_FILE = "standalone-auth.json";
@@ -121591,14 +122003,14 @@ var STANDALONE_BIND_HOST_DEFAULT = "127.0.0.1";
 var PASSWORD_KEYLEN = 64;
 var DEFAULT_SESSION_TTL_MS = 1e3 * 60 * 60 * 24 * 30;
 function getStandalonePasswordConfigPath() {
-  const dir = (0, import_daemon_core2.getConfigDir)();
+  const dir = (0, import_daemon_core3.getConfigDir)();
   if (!fs3.existsSync(dir)) {
     fs3.mkdirSync(dir, { recursive: true, mode: 448 });
   }
   return path4.join(dir, STANDALONE_PASSWORD_CONFIG_FILE);
 }
 function getStandaloneConfigJsonPath() {
-  const dir = (0, import_daemon_core2.getConfigDir)();
+  const dir = (0, import_daemon_core3.getConfigDir)();
   if (!fs3.existsSync(dir)) {
     fs3.mkdirSync(dir, { recursive: true, mode: 448 });
   }
@@ -121787,7 +122199,7 @@ var StandaloneServer = class {
   wsSessionModalSubscriptions = /* @__PURE__ */ new Map();
   wsDaemonMetadataSubscriptions = /* @__PURE__ */ new Map();
   wsGitSubscriptions = /* @__PURE__ */ new Map();
-  gitWorkspaceMonitor = (0, import_daemon_core2.createGitWorkspaceMonitor)();
+  gitWorkspaceMonitor = (0, import_daemon_core3.createGitWorkspaceMonitor)();
   authToken = null;
   passwordConfigPath = getStandalonePasswordConfigPath();
   passwordConfig = null;
@@ -121826,19 +122238,19 @@ var StandaloneServer = class {
   rawTerminalService() {
     const endpoint = this.sessionHostEndpoint || void 0;
     return {
-      readScreen: (sessionId) => (0, import_daemon_core2.withRawTerminalAttachment)(
+      readScreen: (sessionId) => (0, import_daemon_core3.withRawTerminalAttachment)(
         { endpoint, sessionId, mode: "read" },
         (attachment) => attachment.readScreenText()
       ),
-      readState: (sessionId) => (0, import_daemon_core2.withRawTerminalAttachment)(
+      readState: (sessionId) => (0, import_daemon_core3.withRawTerminalAttachment)(
         { endpoint, sessionId, mode: "read" },
         (attachment) => attachment.readState()
       ),
-      writeInput: (sessionId, text) => (0, import_daemon_core2.withRawTerminalAttachment)(
+      writeInput: (sessionId, text) => (0, import_daemon_core3.withRawTerminalAttachment)(
         { endpoint, sessionId, mode: "write" },
         (attachment) => attachment.writeInput(text)
       ),
-      writeKeys: (sessionId, keys) => (0, import_daemon_core2.withRawTerminalAttachment)(
+      writeKeys: (sessionId, keys) => (0, import_daemon_core3.withRawTerminalAttachment)(
         { endpoint, sessionId, mode: "write" },
         (attachment) => attachment.writeKeys(keys)
       )
@@ -121865,7 +122277,7 @@ var StandaloneServer = class {
       resolvePrompt: async (sessionId, response) => {
         const instanceKey = resolveInstanceKey(sessionId);
         if (!instanceKey) throw new Error(`Unknown session: ${sessionId}`);
-        const normalized = (0, import_daemon_core2.normalizeInteractivePromptResponse)(response);
+        const normalized = (0, import_daemon_core3.normalizeInteractivePromptResponse)(response);
         this.components?.instanceManager.sendEvent(instanceKey, "interactive_prompt_response", normalized);
         this.scheduleBroadcastStatus();
       }
@@ -122031,7 +122443,7 @@ var StandaloneServer = class {
   }
   async start(options = {}) {
     const persistedStandaloneBindHost = loadStandaloneBindHostPreference();
-    const cfg = (0, import_daemon_core2.loadConfig)();
+    const cfg = (0, import_daemon_core3.loadConfig)();
     if (!options.host && persistedStandaloneBindHost !== STANDALONE_BIND_HOST_DEFAULT) {
       saveStandaloneBindHostPreference(persistedStandaloneBindHost);
     }
@@ -122056,7 +122468,7 @@ var StandaloneServer = class {
     this.authToken = options.token || process.env.ADHDEV_TOKEN || null;
     this.passwordConfig = loadStandalonePasswordConfig(this.passwordConfigPath);
     const statusInstanceId = `standalone_${cfg.machineId || "mach_unknown"}`;
-    this.components = await (0, import_daemon_core2.initDaemonComponents)({
+    this.components = await (0, import_daemon_core3.initDaemonComponents)({
       cliManagerDeps: {
         getServerConn: () => null,
         getP2p: () => ({
@@ -122080,7 +122492,7 @@ var StandaloneServer = class {
         removeAgentTracking: () => {
         },
         hostedRuntimeManagerTag: "adhdev-standalone",
-        createPtyTransportFactory: ({ runtimeId, providerType, workspace, cliArgs, providerSessionId, attachExisting }) => new import_daemon_core2.SessionHostPtyTransportFactory({
+        createPtyTransportFactory: ({ runtimeId, providerType, workspace, cliArgs, providerSessionId, attachExisting }) => new import_daemon_core3.SessionHostPtyTransportFactory({
           endpoint: sessionHostEndpoint,
           ensureReady: async () => {
             const activeEndpoint = await this.ensureActiveSessionHostEndpoint();
@@ -122111,7 +122523,7 @@ var StandaloneServer = class {
       sessionHostControl,
       onStreamsUpdated: (ideType, streams) => {
         if (!this.components) return;
-        (0, import_daemon_core2.forwardAgentStreamsToIdeInstance)(this.components.instanceManager, ideType, streams);
+        (0, import_daemon_core3.forwardAgentStreamsToIdeInstance)(this.components.instanceManager, ideType, streams);
         this.scheduleBroadcastStatus();
       },
       tickIntervalMs: 3e3,
@@ -122121,7 +122533,7 @@ var StandaloneServer = class {
       await this.components.cliManager.restoreHostedSessions();
     }
     if (options.dev) {
-      this.devServer = await (0, import_daemon_core2.startDaemonDevSupport)({
+      this.devServer = await (0, import_daemon_core3.startDaemonDevSupport)({
         components: this.components,
         logFn: (msg) => console.log(msg)
       });
@@ -122166,11 +122578,11 @@ var StandaloneServer = class {
     });
     if (standaloneIpcEnabled()) {
       try {
-        this.ipcServer = await (0, import_daemon_core2.startLocalIpcServer)({
-          port: import_daemon_core3.DEFAULT_DAEMON_PORT,
+        this.ipcServer = await (0, import_daemon_core3.startLocalIpcServer)({
+          port: import_daemon_core4.DEFAULT_DAEMON_PORT,
           buildStatusPayload: () => {
             if (!this.components) return null;
-            return (0, import_daemon_core2.buildStatusSnapshot)({
+            return (0, import_daemon_core3.buildStatusSnapshot)({
               allStates: this.components.instanceManager.collectAllStates(),
               cdpManagers: this.components.cdpManagers,
               providerLoader: this.components.providerLoader,
@@ -122178,7 +122590,7 @@ var StandaloneServer = class {
                 ...ide,
                 path: ide.path ?? void 0
               })),
-              instanceId: `standalone_${(0, import_daemon_core2.loadConfig)().machineId || "daemon"}`,
+              instanceId: `standalone_${(0, import_daemon_core3.loadConfig)().machineId || "daemon"}`,
               version: pkgVersion,
               profile: "metadata"
             });
@@ -122188,7 +122600,7 @@ var StandaloneServer = class {
             serverConnected: false,
             // standalone never has a cloud server connection
             cdpConnected: (this.components?.cdpManagers.size || 0) > 0,
-            localPort: import_daemon_core3.DEFAULT_DAEMON_PORT,
+            localPort: import_daemon_core4.DEFAULT_DAEMON_PORT,
             cliAgents: this.components ? this.components.instanceManager.collectAllStates().filter((state) => state?.category === "cli").map((state) => String(state?.instanceId || "")).filter(Boolean) : [],
             sessionHostConnected: false,
             mode: "standalone"
@@ -122213,8 +122625,8 @@ var StandaloneServer = class {
           }
         });
       } catch (e) {
-        const msg = e?.code === "EADDRINUSE" ? `Port ${import_daemon_core3.DEFAULT_DAEMON_PORT} already in use; standalone IPC compatibility mode disabled for this run.` : `Failed to start standalone IPC compatibility server: ${e?.message || e}`;
-        import_daemon_core2.LOG.warn("IPC", msg);
+        const msg = e?.code === "EADDRINUSE" ? `Port ${import_daemon_core4.DEFAULT_DAEMON_PORT} already in use; standalone IPC compatibility mode disabled for this run.` : `Failed to start standalone IPC compatibility server: ${e?.message || e}`;
+        import_daemon_core3.LOG.warn("IPC", msg);
       }
     }
     console.log("");
@@ -122234,9 +122646,9 @@ var StandaloneServer = class {
       console.log("   \u{1F510} Password auth: enabled");
     }
     if (this.ipcServer?.isListening()) {
-      console.log(`   IPC: ws://127.0.0.1:${import_daemon_core3.DEFAULT_DAEMON_PORT}${import_daemon_core3.DAEMON_WS_PATH} (for adhdev mcp --mode ipc)`);
+      console.log(`   IPC: ws://127.0.0.1:${import_daemon_core4.DEFAULT_DAEMON_PORT}${import_daemon_core4.DAEMON_WS_PATH} (for adhdev mcp --mode ipc)`);
     } else if (standaloneIpcEnabled()) {
-      console.log(`   IPC: disabled (port ${import_daemon_core3.DEFAULT_DAEMON_PORT} unavailable)`);
+      console.log(`   IPC: disabled (port ${import_daemon_core4.DEFAULT_DAEMON_PORT} unavailable)`);
     }
     if (shouldWarnForPublicUnauthenticatedHost({ host, hasTokenAuth: !!this.authToken, hasPasswordAuth: !!this.passwordConfig })) {
       console.warn("   \u26A0\uFE0F  Public host mode is enabled without any auth.");
@@ -122945,7 +123357,7 @@ var StandaloneServer = class {
     if (msg.topic === "workspace.git") {
       const params = msg.params;
       if (!params?.workspace) return;
-      const normalized = (0, import_daemon_core2.normalizeGitWorkspaceSubscriptionParams)(params);
+      const normalized = (0, import_daemon_core3.normalizeGitWorkspaceSubscriptionParams)(params);
       const subs = this.wsGitSubscriptions.get(ws) || /* @__PURE__ */ new Map();
       this.wsGitSubscriptions.set(ws, subs);
       subs.get(msg.key)?.subscription.dispose();
@@ -122994,21 +123406,21 @@ var StandaloneServer = class {
       ...request.historySessionId ? { historySessionId: request.historySessionId } : {},
       ...state.cursor.tailLimit > 0 ? { tailLimit: state.cursor.tailLimit } : {}
     });
-    if ((0, import_daemon_core2.isMissingLiveSessionResult)(result)) {
+    if ((0, import_daemon_core3.isMissingLiveSessionResult)(result)) {
       const now = Date.now();
-      const missing = (0, import_daemon_core2.recordMissingSessionAttempt)(state.missingSession, now);
+      const missing = (0, import_daemon_core3.recordMissingSessionAttempt)(state.missingSession, now);
       state.missingSession = missing;
       const message = `[chat_tail] session ${request.targetSessionId} is not in the live registry`;
-      if ((0, import_daemon_core2.shouldWarnForMissingSession)(missing)) {
+      if ((0, import_daemon_core3.shouldWarnForMissingSession)(missing)) {
         missing.warned = true;
-        import_daemon_core2.LOG.warn("Standalone", `${message} \u2014 backing off, and dropping the subscription if it stays absent`);
+        import_daemon_core3.LOG.warn("Standalone", `${message} \u2014 backing off, and dropping the subscription if it stays absent`);
       } else {
-        import_daemon_core2.LOG.debug("Standalone", `${message} (miss #${missing.consecutiveMisses})`);
+        import_daemon_core3.LOG.debug("Standalone", `${message} (miss #${missing.consecutiveMisses})`);
       }
       return null;
     }
     if (state.missingSession) state.missingSession = void 0;
-    const prepared = (0, import_daemon_core2.prepareSessionChatTailUpdate)({
+    const prepared = (0, import_daemon_core3.prepareSessionChatTailUpdate)({
       key,
       sessionId: request.targetSessionId,
       ...request.historySessionId ? { historySessionId: request.historySessionId } : {},
@@ -123072,7 +123484,7 @@ var StandaloneServer = class {
     const now = Date.now();
     const snapshot = this.buildSharedSnapshot("live");
     const underDeliveredSessionIds = this.getUnderDeliveredChatSessionIds();
-    const hotSessions = (0, import_daemon_core4.classifyHotChatSessionsForSubscriptionFlush)(
+    const hotSessions = (0, import_daemon_core5.classifyHotChatSessionsForSubscriptionFlush)(
       snapshot.sessions,
       this.hotWsChatSessionIds,
       {
@@ -123132,7 +123544,7 @@ var StandaloneServer = class {
     } catch {
       return /* @__PURE__ */ new Set();
     }
-    const { settled, nextStatus } = (0, import_daemon_core4.detectNewlySettledCompletedSessions)(
+    const { settled, nextStatus } = (0, import_daemon_core5.detectNewlySettledCompletedSessions)(
       snapshot.sessions,
       this.lastObservedSessionStatus
     );
@@ -123179,11 +123591,11 @@ var StandaloneServer = class {
         if (!subs || subs.size === 0) continue;
         for (const [key, sub] of subs.entries()) {
           const targetSessionId = sub.request.params.targetSessionId;
-          const decision = (0, import_daemon_core2.decideMissingSessionAttempt)(sub.missingSession, now);
+          const decision = (0, import_daemon_core3.decideMissingSessionAttempt)(sub.missingSession, now);
           if (decision.action === "skip") continue;
           if (decision.action === "drop") {
             subs.delete(key);
-            import_daemon_core2.LOG.info("Standalone", `[chat_tail] subscription dropped: session=${targetSessionId} key=${key} \u2014 live session absent for ${Math.round((now - (sub.missingSession?.firstMissingAt ?? now)) / 1e3)}s`);
+            import_daemon_core3.LOG.info("Standalone", `[chat_tail] subscription dropped: session=${targetSessionId} key=${key} \u2014 live session absent for ${Math.round((now - (sub.missingSession?.firstMissingAt ?? now)) / 1e3)}s`);
             continue;
           }
           const isForced = forceSessionIds?.has(targetSessionId) === true;
@@ -123193,13 +123605,13 @@ var StandaloneServer = class {
           tasks.push({ ws, key, sub });
         }
       }
-      await (0, import_daemon_core2.runAsyncBatch)(tasks, async ({ ws, key, sub }) => {
+      await (0, import_daemon_core3.runAsyncBatch)(tasks, async ({ ws, key, sub }) => {
         try {
           const update = await this.buildChatTailUpdate(sub.request.params, sub, key);
           if (!update || ws.readyState !== import_ws.WebSocket.OPEN) return;
           ws.send(JSON.stringify({ type: "topic_update", update }));
         } catch (error48) {
-          import_daemon_core2.LOG.warn("Standalone", `[chat_tail] skipped session=${sub.request.params.targetSessionId} key=${key} error=${error48?.message || error48}`);
+          import_daemon_core3.LOG.warn("Standalone", `[chat_tail] skipped session=${sub.request.params.targetSessionId} key=${key} error=${error48?.message || error48}`);
         }
       }, { concurrency: 4 });
     } finally {
@@ -123228,7 +123640,7 @@ var StandaloneServer = class {
     return {
       topic: "machine.runtime",
       key,
-      machine: (0, import_daemon_core2.buildMachineInfo)("full"),
+      machine: (0, import_daemon_core3.buildMachineInfo)("full"),
       seq: state.seq,
       timestamp: now
     };
@@ -123297,7 +123709,7 @@ var StandaloneServer = class {
     const activeModal = modalState.activeModal;
     const status = String(modalState.status || "idle");
     const title = typeof modalState.title === "string" ? modalState.title : void 0;
-    const prepared = (0, import_daemon_core2.prepareSessionModalUpdate)({
+    const prepared = (0, import_daemon_core3.prepareSessionModalUpdate)({
       key,
       sessionId: state.request.params.targetSessionId,
       status,
@@ -123332,14 +123744,14 @@ var StandaloneServer = class {
     const now = Date.now();
     state.seq += 1;
     state.lastSentAt = now;
-    const cfgSnap = (0, import_daemon_core2.loadConfig)();
+    const cfgSnap = (0, import_daemon_core3.loadConfig)();
     const status = this.buildSharedSnapshot("metadata");
     const includeSessions = state.request.params.includeSessions === true;
     if (includeSessions) {
       if (this.components?.router) {
         const nodes = this.components.router.getCachedInlineMeshNodes();
         for (const node of nodes) {
-          const meshSessions = (0, import_daemon_core2.readCachedInlineMeshActiveSessionDetails)(node);
+          const meshSessions = (0, import_daemon_core3.readCachedInlineMeshActiveSessionDetails)(node);
           for (const session of meshSessions) {
             status.sessions.push(session);
           }
@@ -123392,7 +123804,7 @@ var StandaloneServer = class {
         tasks.push({ ws, key, sub });
       });
     }
-    await (0, import_daemon_core2.runAsyncBatch)(tasks, async ({ ws, key, sub }) => {
+    await (0, import_daemon_core3.runAsyncBatch)(tasks, async ({ ws, key, sub }) => {
       try {
         const monitorUpdate = await sub.subscription.refresh();
         const current = this.wsGitSubscriptions.get(ws)?.get(key);
@@ -123404,16 +123816,16 @@ var StandaloneServer = class {
         };
         ws.send(JSON.stringify({ type: "topic_update", update }));
       } catch (error48) {
-        import_daemon_core2.LOG.warn("Standalone", `[workspace.git] skipped workspace=${sub.request.params.workspace} key=${key} error=${error48?.message || error48}`);
+        import_daemon_core3.LOG.warn("Standalone", `[workspace.git] skipped workspace=${sub.request.params.workspace} key=${key} error=${error48?.message || error48}`);
       }
     }, { concurrency: 2 });
   }
   // ─── Core Logic ───
   buildSharedSnapshot(profile = "full") {
-    const cfgSnap = (0, import_daemon_core2.loadConfig)();
+    const cfgSnap = (0, import_daemon_core3.loadConfig)();
     const machineId = cfgSnap.machineId || "mach_unknown";
     const allStates = this.components.instanceManager.collectAllStates();
-    return (0, import_daemon_core2.buildStatusSnapshot)({
+    return (0, import_daemon_core3.buildStatusSnapshot)({
       allStates,
       cdpManagers: this.components.cdpManagers,
       providerLoader: this.components.providerLoader,
@@ -123453,8 +123865,8 @@ var StandaloneServer = class {
     }
   }
   getStatus(snapshot = this.buildSharedSnapshot("full")) {
-    const cfgSnap = (0, import_daemon_core2.loadConfig)();
-    const machineRuntime = (0, import_daemon_core2.buildMachineInfo)("full");
+    const cfgSnap = (0, import_daemon_core3.loadConfig)();
+    const machineRuntime = (0, import_daemon_core3.buildMachineInfo)("full");
     return {
       ...snapshot,
       id: snapshot.instanceId,
@@ -123474,7 +123886,7 @@ var StandaloneServer = class {
     };
   }
   getWsStatus(snapshot = this.buildSharedSnapshot("live")) {
-    const availableProviders = this.components?.providerLoader ? (0, import_daemon_core2.buildAvailableProviders)(this.components.providerLoader) : void 0;
+    const availableProviders = this.components?.providerLoader ? (0, import_daemon_core3.buildAvailableProviders)(this.components.providerLoader) : void 0;
     return {
       instanceId: snapshot.instanceId,
       machine: snapshot.machine,
@@ -123575,7 +123987,7 @@ var StandaloneServer = class {
     this.lastStatusBroadcastAt = Date.now();
     const msg = JSON.stringify({ type: "status", data: status });
     const cdpCount = [...this.components.cdpManagers.values()].filter((m) => m.isConnected).length;
-    import_daemon_core2.LOG.debug("Broadcast", `status \u2192 ${this.clients.size} client(s), ${status.sessions?.length || 0} session(s), ${cdpCount} CDP`);
+    import_daemon_core3.LOG.debug("Broadcast", `status \u2192 ${this.clients.size} client(s), ${status.sessions?.length || 0} session(s), ${cdpCount} CDP`);
     for (const client of this.clients) {
       if (client.readyState === import_ws.WebSocket.OPEN) {
         client.send(msg);
@@ -123631,7 +124043,7 @@ var StandaloneServer = class {
       this.ipcServer = null;
     }
     if (this.components) {
-      await (0, import_daemon_core2.shutdownDaemonComponents)(this.components);
+      await (0, import_daemon_core3.shutdownDaemonComponents)(this.components);
     }
     this.sessionHostControl = null;
     if (this.httpServer) {
@@ -123643,7 +124055,7 @@ var StandaloneServer = class {
   }
 };
 async function main() {
-  const helperMode = await (0, import_daemon_core2.maybeRunDaemonUpgradeHelperFromEnv)();
+  const helperMode = await (0, import_daemon_core3.maybeRunDaemonUpgradeHelperFromEnv)();
   if (helperMode) {
     return;
   }
@@ -123665,6 +124077,10 @@ async function main() {
     const exitCode = await proxySessionHostList(showAll);
     process.exit(exitCode);
   }
+  if (primaryCommand === "quota") {
+    const exitCode = await runQuotaCommand(args.slice(1));
+    process.exit(exitCode);
+  }
   let parsed;
   try {
     parsed = parseStandaloneCliArgs(args);