@integrity-labs/agt-cli 0.28.693 → 0.28.695

package/dist/lib/manager-worker.js

@@ -54,7 +54,7 @@ import {
   safeWriteJsonAtomic,
   setConfigHash,
   tripClass
-} from "../chunk-HAOMTMPE.js";
+} from "../chunk-A2W4K7IH.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -112,7 +112,7 @@ import {
   takeZombieDetection,
   toOpencodeModel,
   writeEgressAllowlist
-} from "../chunk-4ARKV2GJ.js";
+} from "../chunk-OUERGATQ.js";
 import {
   ACCOUNT_ENFORCEMENT_MARKER_FILENAME,
   AnchorSessionClient,
@@ -136,6 +136,7 @@ import {
   appendDmFooter,
   attributeTranscriptUsageByRun,
   buildFailureCategoryPromptLines,
+  buildHostUsageReading,
   buildScheduledTaskContextBlocks,
   classifyActor,
   classifyCursorAdvance,
@@ -181,6 +182,7 @@ import {
   parseDeliveryTarget,
   parseTranscriptUsage,
   parseUsageBanner,
+  parseUsageReport,
   peekCurrentSession,
   pickNewerClassification,
   remoteMcpServerKey,
@@ -190,10 +192,11 @@ import {
   resolveDmTarget,
   serializeAccountEnforcementMarker,
   sessionTranscriptDir,
+  stabiliseResetInstant,
   subagentActivityAgeSeconds,
   sumTranscriptUsageInWindow,
   transcriptActivityAgeSeconds
-} from "../chunk-BV2ZQRFB.js";
+} from "../chunk-XB2RCS5S.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
@@ -2504,6 +2507,89 @@ async function maybeReportUsageBanner(args) {
   }
 }
 
+// src/lib/host-usage-poller.ts
+var HOST_USAGE_POLL_INTERVAL_MS = 15 * 60 * 1e3;
+var HOST_USAGE_POLL_TIMEOUT_MS = 6e4;
+var USAGE_COMMAND_ARGS = ["-p", "/usage", "--output-format", "json"];
+var state2 = {
+  lastPolledAt: 0,
+  inFlight: false,
+  lastWeekResetsAt: null,
+  lastSessionResetsAt: null
+};
+function extractUsageText(stdout) {
+  try {
+    const parsed = JSON.parse(stdout);
+    if (!parsed || typeof parsed !== "object") return null;
+    const envelope = parsed;
+    if (envelope.is_error === true) return null;
+    return typeof envelope.result === "string" ? envelope.result : null;
+  } catch {
+    return null;
+  }
+}
+async function maybePollHostUsage(deps) {
+  const { api: api2, runUsageCommand, authMode, cliVersion, log: log2 } = deps;
+  const now = deps.now ?? /* @__PURE__ */ new Date();
+  const nowMs = now.getTime();
+  if (state2.inFlight) return;
+  if (nowMs - state2.lastPolledAt < HOST_USAGE_POLL_INTERVAL_MS) return;
+  state2.inFlight = true;
+  try {
+    let reading;
+    try {
+      const { stdout, failed } = await runUsageCommand();
+      const text = failed ? null : extractUsageText(stdout);
+      reading = buildHostUsageReading({
+        report: text === null ? null : parseUsageReport(text, now),
+        readAt: now,
+        cliVersion,
+        authMode,
+        pollFailed: failed
+      });
+    } catch (err) {
+      log2(`[host-usage] /usage poll failed: ${err.message}`);
+      reading = buildHostUsageReading({
+        report: null,
+        readAt: now,
+        cliVersion,
+        authMode,
+        pollFailed: true
+      });
+    }
+    const weekResetsAt = stabiliseResetInstant(state2.lastWeekResetsAt, reading.weekResetsAt);
+    const sessionResetsAt = stabiliseResetInstant(
+      state2.lastSessionResetsAt,
+      reading.sessionResetsAt
+    );
+    await api2.post("/host/usage-readings", {
+      state: reading.state,
+      week_pct: reading.weekPct,
+      week_resets_at: weekResetsAt ? weekResetsAt.toISOString() : null,
+      session_pct: reading.sessionPct,
+      session_resets_at: sessionResetsAt ? sessionResetsAt.toISOString() : null,
+      read_at: reading.readAt.toISOString(),
+      cli_version: reading.cliVersion,
+      source: reading.source,
+      unknown_reason: reading.unknownReason
+    });
+    state2.lastWeekResetsAt = weekResetsAt;
+    state2.lastSessionResetsAt = sessionResetsAt;
+    if (reading.state === "ok") {
+      log2(
+        `[host-usage] week ${reading.weekPct}%` + (weekResetsAt ? ` (resets ${weekResetsAt.toISOString()})` : "") + `, session ${reading.sessionPct}%`
+      );
+    } else if (reading.state === "unknown") {
+      log2(`[host-usage] reading unknown: ${reading.unknownReason}`);
+    }
+  } catch (err) {
+    log2(`[host-usage] post failed: ${err.message}`);
+  } finally {
+    state2.lastPolledAt = nowMs;
+    state2.inFlight = false;
+  }
+}
+
 // src/lib/claude-account-fingerprint.ts
 import { createHash as createHash6 } from "crypto";
 import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
@@ -2785,12 +2871,12 @@ import { join as join13 } from "path";
 var MIN_CHECK_INTERVAL_MS2 = 6e4;
 var TRANSCRIPT_MTIME_WINDOW_MS = 2 * 24 * 60 * 60 * 1e3;
 var MAX_ENTRIES_PER_POST = 200;
-var state2 = /* @__PURE__ */ new Map();
+var state3 = /* @__PURE__ */ new Map();
 async function maybeReportTokenUsage(args) {
   const { api: api2, codeName, agentId, log: log2 } = args;
   const now = args.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
-  const existing = state2.get(codeName);
+  const existing = state3.get(codeName);
   if (existing && nowMs - existing.lastCheckedAt < MIN_CHECK_INTERVAL_MS2) {
     return;
   }
@@ -2801,7 +2887,7 @@ async function maybeReportTokenUsage(args) {
   try {
     dirEntries = readdirSync(dir);
   } catch {
-    state2.set(codeName, next);
+    state3.set(codeName, next);
     return;
   }
   const pending2 = [];
@@ -2866,7 +2952,7 @@ async function maybeReportTokenUsage(args) {
     }
   }
   if (pending2.length === 0) {
-    state2.set(codeName, next);
+    state3.set(codeName, next);
     return;
   }
   let reported = 0;
@@ -2903,7 +2989,7 @@ async function maybeReportTokenUsage(args) {
   if (reported > 0) {
     log2(`[token-usage] reported ${reported} entr${reported === 1 ? "y" : "ies"} for '${codeName}'`);
   }
-  state2.set(codeName, next);
+  state3.set(codeName, next);
 }
 
 // src/lib/workflow-run-reconciler.ts
@@ -3183,7 +3269,7 @@ function selectEvalBackend(opts) {
     }
   };
 }
-var state3 = /* @__PURE__ */ new Map();
+var state4 = /* @__PURE__ */ new Map();
 function channelRefTokens(channelRef) {
   return channelRef.split(":").slice(1).filter((p) => p && p !== "dm");
 }
@@ -3359,11 +3445,11 @@ async function maybeEvaluateConversations(args) {
   const { api: api2, backend, codeName, agentId, log: log2 } = args;
   const now = args.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
-  const existing = state3.get(codeName);
+  const existing = state4.get(codeName);
   if (existing && nowMs - existing.lastCheckedAt < MIN_CHECK_INTERVAL_MS4) {
     return;
   }
-  state3.set(codeName, { lastCheckedAt: nowMs });
+  state4.set(codeName, { lastCheckedAt: nowMs });
   let pending2;
   try {
     const resp = await api2.get(
@@ -3644,7 +3730,7 @@ function scrubSensitive(text) {
   for (const re of SECRET_PATTERNS) out = out.replace(re, "[redacted]");
   return out;
 }
-var state4 = /* @__PURE__ */ new Map();
+var state5 = /* @__PURE__ */ new Map();
 function buildExtractionPrompt(channel, transcript) {
   return `You are extracting durable, reusable memories from one completed ${channel} conversation between an AI agent and an end-user. A good memory is a stable preference, fact, correction, or recurring work context that will help the agent in FUTURE conversations \u2014 not a one-off task detail or pleasantry.
 
@@ -3698,11 +3784,11 @@ async function maybeExtractMemories(args) {
   const { api: api2, backend, codeName, agentId, log: log2 } = args;
   const now = args.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
-  const existing = state4.get(codeName);
+  const existing = state5.get(codeName);
   if (existing && nowMs - existing.lastCheckedAt < MIN_CHECK_INTERVAL_MS5) {
     return;
   }
-  state4.set(codeName, { lastCheckedAt: nowMs });
+  state5.set(codeName, { lastCheckedAt: nowMs });
   let pending2;
   try {
     const resp = await api2.get(
@@ -4699,7 +4785,7 @@ async function reportCoverage(args, cursors, touched, log2) {
 // src/lib/tool-call-audit.ts
 var MIN_CHECK_INTERVAL_MS6 = 10 * 6e4;
 var ENTITLEMENT_RECHECK_MS = 30 * 6e4;
-var state5 = /* @__PURE__ */ new Map();
+var state6 = /* @__PURE__ */ new Map();
 function entitlementLatch(entry, nowMs) {
   if (!entry?.notEntitledAt) return false;
   return !hasElapsed(entry.notEntitledAt, nowMs, ENTITLEMENT_RECHECK_MS);
@@ -4714,13 +4800,13 @@ async function maybeScanToolCalls(args) {
   const nowFn = args.now ?? Date.now;
   const nowMs = nowFn();
   try {
-    const existing = state5.get(codeName);
+    const existing = state6.get(codeName);
     if (existing && !hasElapsed(existing.lastCheckedAt, nowMs, MIN_CHECK_INTERVAL_MS6)) return;
     if (entitlementLatch(existing, nowMs)) {
-      state5.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: existing?.notEntitledAt ?? null });
+      state6.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: existing?.notEntitledAt ?? null });
       return;
     }
-    state5.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: existing?.notEntitledAt ?? null });
+    state6.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: existing?.notEntitledAt ?? null });
     const loggingMode = readAgentLoggingMode(codeName, args.homeDir);
     const hashOnly = loggingModeWithholdsTargets(loggingMode);
     if (loggingMode.mode === null) {
@@ -4752,9 +4838,9 @@ async function maybeScanToolCalls(args) {
       ...args.cursorPath === void 0 ? {} : { cursorPath: args.cursorPath }
     });
     if (summary.notEntitled) {
-      state5.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: nowMs });
+      state6.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: nowMs });
     } else if (summary.callsIngested > 0) {
-      state5.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: null });
+      state6.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: null });
     }
   } catch (err) {
     log2(`[tool-call-audit] ${codeName}: scan failed: ${err.message}`);
@@ -4768,7 +4854,7 @@ import { join as join21 } from "path";
 var MIN_CHECK_INTERVAL_MS7 = 6e4;
 var STATS_CACHE_PATH = join21(homedir12(), ".claude", "stats-cache.json");
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-var state6 = { lastObservedDate: null, lastCheckedAt: 0 };
+var state7 = { lastObservedDate: null, lastCheckedAt: 0 };
 function selectNewDailyRows(raw, lastObservedDate) {
   let parsed;
   try {
@@ -4807,8 +4893,8 @@ async function maybeReportActivityCache(args) {
   const { api: api2, log: log2 } = args;
   const now = args.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
-  if (nowMs - state6.lastCheckedAt < MIN_CHECK_INTERVAL_MS7) return;
-  state6.lastCheckedAt = nowMs;
+  if (nowMs - state7.lastCheckedAt < MIN_CHECK_INTERVAL_MS7) return;
+  state7.lastCheckedAt = nowMs;
   if (!existsSync5(STATS_CACHE_PATH)) {
     return;
   }
@@ -4819,12 +4905,12 @@ async function maybeReportActivityCache(args) {
     log2(`[activity-cache] readFileSync failed: ${err.message}`);
     return;
   }
-  const rows = selectNewDailyRows(raw, state6.lastObservedDate);
+  const rows = selectNewDailyRows(raw, state7.lastObservedDate);
   if (rows.length === 0) return;
   for (const row of rows) {
     try {
       await api2.post("/host/activity-observations", row);
-      state6.lastObservedDate = row.date;
+      state7.lastObservedDate = row.date;
     } catch (err) {
       log2(
         `[activity-cache] POST /host/activity-observations failed for date=${row.date}: ${err.message}`
@@ -6010,21 +6096,21 @@ function nudgeIntervalForCount(nudgeCount, fullCadenceMs, maxCadenceMs) {
   const exponent = Math.max(0, Math.min(nudgeCount - 1, 8));
   return Math.min(fullCadenceMs * 3 ** exponent, Math.max(maxCadenceMs, fullCadenceMs));
 }
-function shouldNudgeUnchangedBoard(signature, state8, now, fullCadenceMs, maxCadenceMs = fullCadenceMs) {
-  if (!state8) return true;
-  if (state8.signature !== signature) return true;
-  return now - state8.nudgedAt >= nudgeIntervalForCount(state8.nudgeCount ?? 1, fullCadenceMs, maxCadenceMs);
+function shouldNudgeUnchangedBoard(signature, state9, now, fullCadenceMs, maxCadenceMs = fullCadenceMs) {
+  if (!state9) return true;
+  if (state9.signature !== signature) return true;
+  return now - state9.nudgedAt >= nudgeIntervalForCount(state9.nudgeCount ?? 1, fullCadenceMs, maxCadenceMs);
 }
 function failureRetryIntervalForCount(failureCount, baseMs, maxMs) {
   const exponent = Math.max(0, Math.min(failureCount - 1, 8));
   return Math.min(baseMs * 3 ** exponent, Math.max(maxMs, baseMs));
 }
 var KANBAN_NOTICE_BREAKER_THRESHOLD = 5;
-function shouldAttemptNoticeEnqueue(state8, now, baseMs, maxMs, breakerThreshold = KANBAN_NOTICE_BREAKER_THRESHOLD) {
-  const failures = state8?.failureCount ?? 0;
+function shouldAttemptNoticeEnqueue(state9, now, baseMs, maxMs, breakerThreshold = KANBAN_NOTICE_BREAKER_THRESHOLD) {
+  const failures = state9?.failureCount ?? 0;
   if (failures <= 0) return { attempt: true, breakerOpen: false };
   const breakerOpen = failures >= breakerThreshold;
-  const failedAt = state8?.failedAt;
+  const failedAt = state9?.failedAt;
   const due = failedAt === void 0 || failedAt > now || now - failedAt >= failureRetryIntervalForCount(failures, baseMs, maxMs);
   return { attempt: due, breakerOpen };
 }
@@ -6314,7 +6400,7 @@ function loadKanbanNudgeState(target, configDir) {
 function saveKanbanNudgeState(source, configDir) {
   const path = getKanbanNudgeStateFile(configDir);
   const agents = {};
-  for (const [codeName, state8] of source) agents[codeName] = state8;
+  for (const [codeName, state9] of source) agents[codeName] = state9;
   try {
     writeFileSync9(path, JSON.stringify({ version: KANBAN_NUDGE_STATE_VERSION, agents }, null, 2));
   } catch {
@@ -7154,8 +7240,8 @@ async function runScheduledCardDelivery(codeName, agentId, cardId, completedBy,
     markScheduledCardDeliveryComplete(cardId);
     return "terminal";
   }
-  const state8 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
-  const task = state8.tasks[card.source_ref];
+  const state9 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
+  const task = state9.tasks[card.source_ref];
   if (!task) {
     log(`[scheduled-kanban] delivery: no scheduler task for source_ref=${card.source_ref} on '${codeName}' \u2014 skipping`);
     markScheduledCardDeliveryComplete(cardId);
@@ -7607,16 +7693,16 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
   const prevHash = agentState.knownTasksHashes.get(agent.agent_id);
   if (combinedHash !== prevHash) {
     const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
-    const state9 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
-    claudeSchedulerStates.set(codeName, state9);
+    const state10 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
+    claudeSchedulerStates.set(codeName, state10);
     agentState.knownTasksHashes.set(agent.agent_id, combinedHash);
     log(`[claude-scheduler] Tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
   }
   if (!claudeSchedulerStates.has(codeName)) {
     claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
   }
-  const state8 = claudeSchedulerStates.get(codeName);
-  const ready = getReadyTasks(state8, inFlightClaudeTasks);
+  const state9 = claudeSchedulerStates.get(codeName);
+  const ready = getReadyTasks(state9, inFlightClaudeTasks);
   if (ready.length === 0) return;
   const limitedUntil = readUsageCapUntil({ codeName, projectDir: getProjectDir(codeName) });
   if (limitedUntil) {
@@ -7759,17 +7845,17 @@ function candidateTranscriptPaths(dir) {
   return { paths, complete };
 }
 function foldToolCallBrackets(codeName, eventsByPath, nowMs) {
-  const state8 = brackets.get(codeName) ?? {
+  const state9 = brackets.get(codeName) ?? {
     open: /* @__PURE__ */ new Map(),
     closed: []
   };
   const nextOpen = /* @__PURE__ */ new Map();
   const openOut = [];
-  const paths = /* @__PURE__ */ new Set([...state8.open.keys(), ...eventsByPath.keys()]);
+  const paths = /* @__PURE__ */ new Set([...state9.open.keys(), ...eventsByPath.keys()]);
   for (const path of paths) {
-    const carried = state8.open.get(path) ?? [];
+    const carried = state9.open.get(path) ?? [];
     const paired = pairToolCallBrackets(eventsByPath.get(path) ?? [], carried);
-    state8.closed.push(...paired.brackets);
+    state9.closed.push(...paired.brackets);
     const live = paired.open.filter((c) => nowMs - c.startMs <= MAX_BRACKET_DEFERRAL_MS);
     if (live.length > 0) {
       nextOpen.set(path, live);
@@ -7779,7 +7865,7 @@ function foldToolCallBrackets(codeName, eventsByPath, nowMs) {
   const keepFrom = nowMs - GATE_MAX_BUCKET_AGE_MS;
   const seen = /* @__PURE__ */ new Set();
   const closed = [];
-  for (const b of state8.closed) {
+  for (const b of state9.closed) {
     if (b.endMs < keepFrom) continue;
     const key = `${b.id}\0${b.startMs}\0${b.endMs}`;
     if (seen.has(key)) continue;
@@ -8053,8 +8139,8 @@ function countDefunct(cgroupDir, readText) {
     if (stat2 == null) continue;
     const close = stat2.lastIndexOf(")");
     if (close < 0) continue;
-    const state8 = stat2.slice(close + 1).trim().charAt(0);
-    if (state8 === "Z") defunct += 1;
+    const state9 = stat2.slice(close + 1).trim().charAt(0);
+    if (state9 === "Z") defunct += 1;
   }
   return defunct;
 }
@@ -9225,16 +9311,16 @@ async function syncAndCheckOpencodeScheduler(agent, tasks, refreshData) {
   const tasksHash = createHash15("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
   if (knownOpencodeTaskHashes.get(agent.agent_id) !== tasksHash) {
     const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
-    const state9 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
-    opencodeSchedulerStates.set(codeName, state9);
+    const state10 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
+    opencodeSchedulerStates.set(codeName, state10);
     knownOpencodeTaskHashes.set(agent.agent_id, tasksHash);
     log(`[opencode-scheduler] tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
   }
   if (!opencodeSchedulerStates.has(codeName)) {
     opencodeSchedulerStates.set(codeName, loadSchedulerState(codeName));
   }
-  const state8 = opencodeSchedulerStates.get(codeName);
-  const ready = getReadyTasks(state8, inFlightOpencodeTasks);
+  const state9 = opencodeSchedulerStates.get(codeName);
+  const ready = getReadyTasks(state9, inFlightOpencodeTasks);
   if (ready.length === 0) return;
   if (!isOpencodeSessionHealthy(codeName)) {
     log(`[opencode-scheduler] '${codeName}' has ${ready.length} due task(s) but no healthy serve yet - deferring`);
@@ -10109,10 +10195,10 @@ function recordWedgeForCards(states, inProgressCardIds, nowMs, config2) {
 function pruneCardStates(states, liveInProgressCardIds, nowMs, config2) {
   const live = liveInProgressCardIds instanceof Set ? liveInProgressCardIds : new Set(liveInProgressCardIds);
   const next = /* @__PURE__ */ new Map();
-  for (const [id, state8] of states) {
+  for (const [id, state9] of states) {
     if (!live.has(id)) continue;
-    if (nowMs - state8.lastWedgeAtMs > config2.cooldownMs) continue;
-    next.set(id, state8);
+    if (nowMs - state9.lastWedgeAtMs > config2.cooldownMs) continue;
+    next.set(id, state9);
   }
   return next;
 }
@@ -11053,8 +11139,8 @@ var KNOWN_SAFE_TAIL_SIGNATURES = /* @__PURE__ */ new Set(["session_id_in_use"]);
 function shouldSkipRevokedCleanup(previousKnownStatus) {
   return previousKnownStatus === "revoked";
 }
-function hasRevokedResiduals(state8) {
-  return state8.gatewayRunning || state8.portAllocated || state8.provisionDirExists;
+function hasRevokedResiduals(state9) {
+  return state9.gatewayRunning || state9.portAllocated || state9.provisionDirExists;
 }
 var pendingSessionRestarts = /* @__PURE__ */ new Map();
 var lastRestartWasExternal = /* @__PURE__ */ new Map();
@@ -11256,12 +11342,12 @@ function maybeClearStaleTrip(agent) {
   const marker = getAutoResumeMarker(codeName);
   const isSelfResume = marker !== void 0 && Date.now() - marker.autoResumedAt < AUTO_RESUME_SELF_WINDOW_MS;
   if (!isSelfResume) deleteAutoResumeMarker(codeName);
-  state7 = {
-    ...state7,
+  state8 = {
+    ...state8,
     circuitBreakerTrips: restartBreaker.serialize(),
     circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
   };
-  send({ type: "state-update", state: state7 });
+  send({ type: "state-update", state: state8 });
 }
 var autoResumeMarkers = /* @__PURE__ */ new Map();
 function autoResumeMarkerKey(codeName) {
@@ -11354,12 +11440,12 @@ function maybeAutoResume(agent) {
       restartBreaker.clear(codeName);
       reportedTrips.delete(codeName);
       dependencyRecoveryLedger.clear(codeName);
-      state7 = {
-        ...state7,
+      state8 = {
+        ...state8,
         circuitBreakerTrips: restartBreaker.serialize(),
         circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
       };
-      send({ type: "state-update", state: state7 });
+      send({ type: "state-update", state: state8 });
       log(`[auto-resume] agent=${codeName} resumed \u2014 re-trip within backoff window will stay paused (ENG-6088)`);
     } else {
       autoResumeStandDowns.add(`${codeName}:${trippedAt}`);
@@ -11468,12 +11554,12 @@ async function maybeResumeReconcile(agent) {
       restartBreaker.clear(codeName);
       reportedTrips.delete(codeName);
       dependencyRecoveryLedger.clear(codeName);
-      state7 = {
-        ...state7,
+      state8 = {
+        ...state8,
         circuitBreakerTrips: restartBreaker.serialize(),
         circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
       };
-      send({ type: "state-update", state: state7 });
+      send({ type: "state-update", state: state8 });
       log(`[resume-reconciler] agent=${codeName} resumed \u2014 a re-trip within the backoff window will latch unstable (ENG-6383)`);
     } else {
       autoResumeStandDowns.add(standDownKey);
@@ -11754,7 +11840,7 @@ var pendingDayRolloverReset = /* @__PURE__ */ new Set();
 var dayRolloverInboundHold = /* @__PURE__ */ new Map();
 var INBOUND_HOLD_EPISODE_GAP_MS = 12e4;
 async function channelInboundActivityAgeSecondsFor(codeName) {
-  const { newestPendingInboundActivityMtimeMs } = await import("../responsiveness-probe-H3UBUTW7.js");
+  const { newestPendingInboundActivityMtimeMs } = await import("../responsiveness-probe-VJP2AHNR.js");
   const newest = newestPendingInboundActivityMtimeMs(dirname10(paneLogPath(codeName)));
   if (newest === null) return null;
   return Math.max(0, Math.floor((Date.now() - newest) / 1e3));
@@ -11903,7 +11989,7 @@ function restartGateFor(codeName, reason) {
 }
 function isHostBusyForForcedUpdate(opts) {
   const now = /* @__PURE__ */ new Date();
-  for (const agent of state7.agents) {
+  for (const agent of state8.agents) {
     const decision = decideRestartGate({
       window: null,
       paneLogAgeSeconds: paneLogAgeSecondsFor(agent.codeName),
@@ -11936,7 +12022,7 @@ function runPendingForcedUpdate() {
     relaxed
   } = decidePendingForcedUpdate({
     requestedAt: requestedUpdateAt,
-    lastProcessedAt: state7.lastUpdateRequestProcessedAt ?? null,
+    lastProcessedAt: state8.lastUpdateRequestProcessedAt ?? null,
     deferStreak: forcedUpdateDeferStreak,
     nowMs: Date.now(),
     isHostBusy: (isRelaxed) => isHostBusyForForcedUpdate({ relaxed: isRelaxed })
@@ -11970,7 +12056,7 @@ function runPendingForcedUpdate() {
   log(
     forcedUpdate === "consume-deadline" ? `[self-update] WARN "Update CLI now" requested at ${requestedUpdateAt} has been pending ${describePendingFor(pendingForMs)} and the host still reads busy \u2014 running the window-bypassing self-update anyway (ENG-8449 hard deadline). A live turn may be interrupted; the operator asked for this update explicitly.` : `[self-update] "Update CLI now" requested at ${requestedUpdateAt} \u2014 running window-bypassing self-update now (host idle${relaxed ? ", relaxed gate" : ""}).`
   );
-  const prevProcessedAt = state7.lastUpdateRequestProcessedAt ?? null;
+  const prevProcessedAt = state8.lastUpdateRequestProcessedAt ?? null;
   void checkAndUpdateCli({ force: true }).then((outcome) => {
     if (!shouldConsumeForcedUpdate(outcome)) {
       log(
@@ -11981,11 +12067,11 @@ function runPendingForcedUpdate() {
     log(
       outcome === "updated" ? `[self-update] "Update CLI now" completed \u2014 upgrade installed; manager restart scheduled.` : `[self-update] "Update CLI now" completed \u2014 host was already on the latest in-channel build; nothing to install.`
     );
-    state7.lastUpdateRequestProcessedAt = requestedUpdateAt;
+    state8.lastUpdateRequestProcessedAt = requestedUpdateAt;
     try {
-      atomicWriteFileSync(getStateFile(), JSON.stringify(state7, null, 2));
+      atomicWriteFileSync(getStateFile(), JSON.stringify(state8, null, 2));
     } catch (err) {
-      state7.lastUpdateRequestProcessedAt = prevProcessedAt;
+      state8.lastUpdateRequestProcessedAt = prevProcessedAt;
       log(
         `[self-update] failed to persist update-request ack; retrying next poll: ${err.message}`
       );
@@ -12345,7 +12431,7 @@ var STALE_TASK_THRESHOLD_MS = (() => {
 })();
 var taskDisplayInfo = /* @__PURE__ */ new Map();
 var activeChannels = /* @__PURE__ */ new Map();
-var state7 = {
+var state8 = {
   pid: process.pid,
   startedAt: (/* @__PURE__ */ new Date()).toISOString(),
   lastPollAt: null,
@@ -12402,7 +12488,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.693" : "dev";
+var agtCliVersion = true ? "0.28.695" : "dev";
 function resolveBrewPath(execFileSync3) {
   try {
     const out = execFileSync3("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -13391,6 +13477,46 @@ async function runClaudeRuntimeAuthProbe() {
     });
   }
 }
+async function runHostUsageCommand() {
+  try {
+    const childEnv = { ...process.env };
+    await applyClaudeAuthToEnv(childEnv, "host-usage-poll");
+    const emptyMcp = ensureEvalEmptyMcpConfig();
+    const args = [
+      ...USAGE_COMMAND_ARGS,
+      "--mcp-config",
+      emptyMcp,
+      "--strict-mcp-config",
+      "--permission-mode",
+      "auto",
+      "--allowedTools",
+      ""
+    ];
+    const { stdout } = await execFilePromiseLong(resolveClaudeBinary(), args, {
+      cwd: homedir17(),
+      timeout: HOST_USAGE_POLL_TIMEOUT_MS,
+      stdin: "ignore",
+      env: childEnv,
+      onSpawn: (pid) => registerClaudeSpawn({ pid, started_at: Date.now(), kind: "conv-eval" }),
+      onExit: (pid) => unregisterClaudeSpawn(pid)
+    });
+    return { stdout, failed: false };
+  } catch (err) {
+    if (err instanceof ChildProcessError) return { stdout: err.stdout ?? "", failed: true };
+    return { stdout: "", failed: true };
+  }
+}
+async function maybePollHostUsageFromCycle() {
+  const { execFileSync: execFileSync3 } = await import("child_process");
+  if (!claudeBinaryInstalled(execFileSync3)) return;
+  await maybePollHostUsage({
+    api,
+    runUsageCommand: runHostUsageCommand,
+    authMode: getCachedClaudeAuthMode(),
+    cliVersion: cachedFrameworkVersion,
+    log
+  });
+}
 async function checkClaudeAuth() {
   try {
     const report = await detectClaudeAuth();
@@ -13561,21 +13687,21 @@ function recordChannelSyncFailure(failures, agentId, reason, now) {
   failures.set(agentId, next);
   return next;
 }
-function shouldLogChannelSyncFailure(state8) {
-  if (state8.attempts === 1) return true;
-  if (state8.attempts <= CHANNEL_SYNC_FREE_ATTEMPTS) return false;
-  return state8.attempts > state8.loggedAtAttempt;
+function shouldLogChannelSyncFailure(state9) {
+  if (state9.attempts === 1) return true;
+  if (state9.attempts <= CHANNEL_SYNC_FREE_ATTEMPTS) return false;
+  return state9.attempts > state9.loggedAtAttempt;
 }
 function stuckChannelSyncs(failures, now, thresholdMs = CHANNEL_SYNC_STUCK_AFTER_MS) {
   const out = [];
-  for (const [agentId, state8] of failures) {
-    const stuckForMs = now - state8.since;
+  for (const [agentId, state9] of failures) {
+    const stuckForMs = now - state9.since;
     if (stuckForMs < thresholdMs) continue;
     out.push({
       agent_id: agentId,
-      attempts: state8.attempts,
+      attempts: state9.attempts,
       stuck_for_seconds: Math.floor(stuckForMs / 1e3),
-      reason: state8.lastReason
+      reason: state9.lastReason
     });
   }
   out.sort((a, b) => b.stuck_for_seconds - a.stuck_for_seconds);
@@ -13863,7 +13989,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-PPBLGH2J.js");
+      const { collectDiagnostics } = await import("../persistent-session-PEY2TMJI.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor)
@@ -13959,6 +14085,7 @@ async function pollCycleInner() {
   }
   maybeUpgradeClaudeCode().catch((err) => log(`[claude-code-upgrade] Check failed: ${err.message}`));
   maybeProbeClaudeRuntimeAuth().catch((err) => log(`[runtime-auth-probe] Check failed: ${err.message}`));
+  maybePollHostUsageFromCycle().catch((err) => log(`[host-usage] Check failed: ${err.message}`));
   try {
     registeredAgentsCache.clear();
     const hostId = await getHostId();
@@ -13969,7 +14096,7 @@ async function pollCycleInner() {
     const now = Date.now();
     if (now - lastVersionCheckAt > VERSION_CHECK_INTERVAL_MS) {
       try {
-        const firstAgent = state7.agents[0];
+        const firstAgent = state8.agents[0];
         const versionAdapter = firstAgent ? resolveAgentFramework(firstAgent.codeName) : getFramework(DEFAULT_FRAMEWORK);
         if (versionAdapter.getVersion) {
           cachedFrameworkVersion = await versionAdapter.getVersion();
@@ -13980,7 +14107,7 @@ async function pollCycleInner() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-PPBLGH2J.js");
+      const { collectDiagnostics } = await import("../persistent-session-PEY2TMJI.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor) : void 0;
       let tailscaleHostname;
@@ -14013,7 +14140,7 @@ async function pollCycleInner() {
         const errId = createHash17("sha256").update(errText).digest("hex").slice(0, 12);
         log(`Claude auth detection failed (error_id=${errId})`);
       }
-      const hostHasClaudeCode = state7.agents.some(
+      const hostHasClaudeCode = state8.agents.some(
         (a) => agentFrameworkCache.get(a.codeName) === "claude-code"
       );
       if (hostHasClaudeCode) {
@@ -14092,7 +14219,7 @@ async function pollCycleInner() {
         // ENG-6692: ack the last consumed "Update CLI now" timestamp so the API
         // clears hosts.update_requested_at. Echoes our persisted dedup marker;
         // null until we've ever consumed one.
-        update_request_processed_at: state7.lastUpdateRequestProcessedAt ?? null
+        update_request_processed_at: state8.lastUpdateRequestProcessedAt ?? null
       });
       if (hbResp?.maintenance_window) {
         cachedMaintenanceWindow = hbResp.maintenance_window;
@@ -14132,7 +14259,7 @@ async function pollCycleInner() {
         collectPanelessActivityProbes,
         getResponsivenessIntervalMs,
         occupancyQualificationClassifications
-      } = await import("../responsiveness-probe-H3UBUTW7.js");
+      } = await import("../responsiveness-probe-VJP2AHNR.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -14242,7 +14369,7 @@ async function pollCycleInner() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-H3UBUTW7.js");
+        } = await import("../responsiveness-probe-VJP2AHNR.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-NDP36U7O.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -14398,7 +14525,7 @@ async function pollCycleInner() {
     }
     try {
       const { scrapeMcpFailedBannerCount } = await import("../pane-mcp-banner-scraper-JA437JIB.js");
-      const { probeSessionAuth } = await import("../session-auth-dead-K3XQNN5A.js");
+      const { probeSessionAuth } = await import("../session-auth-dead-QCZ2EOVS.js");
       const observations = [];
       const pendingCacheCommits = [];
       const modelApiErrorReportingOn = hostFlagStore().getBoolean("model-api-error-reporting");
@@ -14479,7 +14606,7 @@ async function pollCycleInner() {
       const requested = agent.restart_requested_at ?? null;
       if (!requested) continue;
       if (restartInFlight.has(agent.agent_id)) continue;
-      const prev = state7.agents.find((a) => a.agentId === agent.agent_id);
+      const prev = state8.agents.find((a) => a.agentId === agent.agent_id);
       const lastProcessed = prev?.lastRestartProcessedAt ?? null;
       const alreadyServiced = lastProcessed != null && Date.parse(lastProcessed) >= Date.parse(requested);
       if (!alreadyServiced) {
@@ -14560,7 +14687,7 @@ async function pollCycleInner() {
     managedPruneLedger = createManagedPruneLedger();
     for (const agent of processOrder) {
       if (restartInFlight.has(agent.agent_id)) {
-        const existing = state7.agents.find((a) => a.agentId === agent.agent_id);
+        const existing = state8.agents.find((a) => a.agentId === agent.agent_id);
         if (existing) {
           agentStates.push(existing);
           continue;
@@ -14570,7 +14697,7 @@ async function pollCycleInner() {
         await processAgent(agent, agentStates, managedToolkits);
       } catch (err) {
         log(`Error processing agent '${agent.code_name}': ${err.message}`);
-        const existing = state7.agents.find((a) => a.agentId === agent.agent_id);
+        const existing = state8.agents.find((a) => a.agentId === agent.agent_id);
         if (existing) {
           agentStates.push(existing);
         } else {
@@ -14601,12 +14728,12 @@ async function pollCycleInner() {
     if (crossAgentPrune) log(crossAgentPrune);
     const restartAckStateChanged = applyRestartAcks({
       agentStates,
-      priorAgents: state7.agents,
+      priorAgents: state8.agents,
       restartAcks
     });
     if (restartAckStateChanged) {
       try {
-        const ackedState = { ...state7, agents: agentStates };
+        const ackedState = { ...state8, agents: agentStates };
         atomicWriteFileSync(getStateFile(), JSON.stringify(ackedState, null, 2));
       } catch (err) {
         log(`[restart] failed to persist ack immediately: ${err.message}`);
@@ -14628,7 +14755,7 @@ async function pollCycleInner() {
     } catch {
     }
     const currentIds = new Set(agents.map((a) => a.agent_id));
-    for (const prev of state7.agents) {
+    for (const prev of state8.agents) {
       if (!currentIds.has(prev.agentId)) {
         log(`Agent '${prev.codeName}' removed from host (deleted or unassigned)`);
         const adapter = resolveAgentFramework(prev.codeName);
@@ -14790,10 +14917,10 @@ async function pollCycleInner() {
       }
     } catch {
     }
-    state7 = {
-      ...state7,
+    state8 = {
+      ...state8,
       lastPollAt: (/* @__PURE__ */ new Date()).toISOString(),
-      pollCount: state7.pollCount + 1,
+      pollCount: state8.pollCount + 1,
       agents: agentStates,
       // ENG-5441: serialise trip state on every poll so manager restarts
       // never silently clear a tripped breaker. Cheap — only tripped
@@ -14807,9 +14934,9 @@ async function pollCycleInner() {
       consecutivePollFailures = 0;
     }
     verifyPendingRestarts(Date.now());
-    send({ type: "state-update", state: state7 });
+    send({ type: "state-update", state: state8 });
   } catch (err) {
-    state7.errorCount++;
+    state8.errorCount++;
     const message = err.message;
     log(`Poll error: ${message}`);
     send({ type: "error", message });
@@ -15105,11 +15232,11 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const marker = getAutoResumeMarker(agent.code_name);
       const isSelfResume = marker !== void 0 && Date.now() - marker.autoResumedAt < AUTO_RESUME_SELF_WINDOW_MS;
       if (!isSelfResume && deleteAutoResumeMarker(agent.code_name)) {
-        state7 = {
-          ...state7,
+        state8 = {
+          ...state8,
           circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
         };
-        send({ type: "state-update", state: state7 });
+        send({ type: "state-update", state: state8 });
         log(`[auto-resume] Cleared auto-resume marker for '${agent.code_name}' on operator resume \u2014 credit re-armed (ENG-6088)`);
       }
     }
@@ -15140,7 +15267,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
     });
   } catch (err) {
     log(`Refresh failed for '${agent.code_name}': ${err.message}`);
-    const existing = state7.agents.find((a) => a.agentId === agent.agent_id);
+    const existing = state8.agents.find((a) => a.agentId === agent.agent_id);
     agentStates.push(existing ?? {
       agentId: agent.agent_id,
       codeName: agent.code_name,
@@ -15204,7 +15331,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
   const charterVersion = refreshData.charter.version;
   const toolsVersion = refreshData.tools.version;
   const known = agentState.knownVersions.get(agent.agent_id);
-  let lastProvisionAt = state7.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
+  let lastProvisionAt = state8.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
   const quarantinedChannels = channelQuarantineStore().getQuarantinedKeys(agent.code_name);
   const currentChannelIds = setWithout(
     launchableChannelIds(refreshData.channel_configs),
@@ -15659,18 +15786,18 @@ async function processAgent(agent, agentStates, managedToolkits) {
       agentState.knownChannels.set(agent.agent_id, currentChannelIds);
     }
   } else {
-    const state8 = recordChannelSyncFailure(
+    const state9 = recordChannelSyncFailure(
       channelSyncFailures,
       agent.agent_id,
       channelConfigFailureReason || "reason not recorded",
       Date.now()
     );
-    if (shouldLogChannelSyncFailure(state8)) {
-      state8.loggedAtAttempt = state8.attempts;
-      const stuckForSeconds = Math.floor((Date.now() - state8.since) / 1e3);
-      const waitMs = channelSyncBackoffMs(state8.attempts);
+    if (shouldLogChannelSyncFailure(state9)) {
+      state9.loggedAtAttempt = state9.attempts;
+      const stuckForSeconds = Math.floor((Date.now() - state9.since) / 1e3);
+      const waitMs = channelSyncBackoffMs(state9.attempts);
       log(
-        `[channels] Credential sync did not converge for '${agent.code_name}' \u2014 attempt ${state8.attempts}, stuck ${stuckForSeconds}s, next retry in ${Math.round(waitMs / 1e3)}s. Cause: ${state8.lastReason}. Diff left live (ENG-9252).`
+        `[channels] Credential sync did not converge for '${agent.code_name}' \u2014 attempt ${state9.attempts}, stuck ${stuckForSeconds}s, next retry in ${Math.round(waitMs / 1e3)}s. Cause: ${state9.lastReason}. Diff left live (ENG-9252).`
       );
     }
   }
@@ -15970,7 +16097,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       log(`Failed to provision direct-chat channel for '${agent.code_name}': ${err.message}`);
     }
   }
-  let lastSecretsProvisionAt = state7.agents.find((a) => a.agentId === agent.agent_id)?.lastSecretsProvisionAt ?? null;
+  let lastSecretsProvisionAt = state8.agents.find((a) => a.agentId === agent.agent_id)?.lastSecretsProvisionAt ?? null;
   let secretsHash = agentState.knownSecretsHashes.get(agent.agent_id) ?? null;
   try {
     const secretsData = await api.post("/host/secrets", { agent_id: agent.agent_id });
@@ -17854,9 +17981,9 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash17("sha256")
   } else if (!claudeSchedulerStates.has(codeName)) {
     claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
   }
-  const state8 = claudeSchedulerStates.get(codeName);
-  if (state8) {
-    const ready = getReadyTasks(state8, inFlightClaudeTasks);
+  const state9 = claudeSchedulerStates.get(codeName);
+  if (state9) {
+    const ready = getReadyTasks(state9, inFlightClaudeTasks);
     if (ready.length > 0) {
       log(`[persistent-session] ${ready.length} ready task(s) for '${codeName}': ${ready.map((t) => `${t.name}(next=${t.nextFireAt ? new Date(t.nextFireAt).toISOString() : "null"})`).join(", ")}`);
     }
@@ -17950,19 +18077,19 @@ function recordRealtimeRebindFailure(failures, agentId, status, now) {
   return next;
 }
 function realtimeRebindDue(failures, now) {
-  for (const state8 of failures.values()) if (now >= state8.nextAttemptAt) return true;
+  for (const state9 of failures.values()) if (now >= state9.nextAttemptAt) return true;
   return false;
 }
 function stuckRealtimeRebinds(failures, now, thresholdMs = REALTIME_REBIND_STUCK_AFTER_MS) {
   const out = [];
-  for (const [agentId, state8] of failures) {
-    const stuckForMs = now - state8.since;
+  for (const [agentId, state9] of failures) {
+    const stuckForMs = now - state9.since;
     if (stuckForMs < thresholdMs) continue;
     out.push({
       agent_id: agentId,
-      attempts: state8.attempts,
+      attempts: state9.attempts,
       stuck_for_seconds: Math.floor(stuckForMs / 1e3),
-      status: state8.lastStatus
+      status: state9.lastStatus
     });
   }
   out.sort((a, b) => b.stuck_for_seconds - a.stuck_for_seconds);
@@ -17985,8 +18112,8 @@ function pruneRealtimeRebindState(failures, liveAgentIds) {
 function holdRealtimeRebindInFlight(failures, agentIds, now, graceMs = REALTIME_REBIND_IN_FLIGHT_GRACE_MS) {
   const until = now + graceMs;
   for (const agentId of agentIds) {
-    const state8 = failures.get(agentId);
-    if (state8) state8.nextAttemptAt = Math.max(state8.nextAttemptAt, until);
+    const state9 = failures.get(agentId);
+    if (state9) state9.nextAttemptAt = Math.max(state9.nextAttemptAt, until);
   }
 }
 var realtimeAssignStarted = false;
@@ -18107,7 +18234,7 @@ function restartReasonStampsTiming(reason) {
   return reason === "integration-change";
 }
 async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
-  const prev = state7.agents.find((a) => a.agentId === agentId);
+  const prev = state8.agents.find((a) => a.agentId === agentId);
   const codeName = prev?.codeName;
   if (!codeName) return;
   const lastProcessed = prev?.lastRestartProcessedAt ?? null;
@@ -18158,7 +18285,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
     void api.post("/host/restart-ack", { host_id: hostId, agent_id: agentId, restart_requested_at: requestedAt }).catch((err) => log(`[restart-lane] ack failed for '${codeName}': ${err.message}`));
     void (async () => {
       try {
-        const { collectDiagnostics } = await import("../persistent-session-PPBLGH2J.js");
+        const { collectDiagnostics } = await import("../persistent-session-PEY2TMJI.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor)
@@ -18169,7 +18296,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
     })();
     prev.lastRestartProcessedAt = requestedAt;
     try {
-      atomicWriteFileSync(getStateFile(), JSON.stringify(state7, null, 2));
+      atomicWriteFileSync(getStateFile(), JSON.stringify(state8, null, 2));
     } catch (err) {
       log(`[restart-lane] failed to persist ack for '${codeName}': ${err.message}`);
     }
@@ -18179,7 +18306,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
   }
 }
 async function respawnAgentAfterMcpStop(codeName, reason) {
-  const prev = state7.agents.find((a) => a.codeName === codeName);
+  const prev = state8.agents.find((a) => a.codeName === codeName);
   if (!prev) return;
   const agentId = prev.agentId;
   if (restartInFlight.has(agentId)) return;
@@ -18209,7 +18336,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-PPBLGH2J.js");
+      const { collectDiagnostics } = await import("../persistent-session-PEY2TMJI.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor)
@@ -18430,18 +18557,18 @@ function ensureRealtimeIntegrationContextStarted(agentStates) {
         );
       },
       onSubscriptionLost: (agentId, status) => {
-        const state8 = recordRealtimeRebindFailure(
+        const state9 = recordRealtimeRebindFailure(
           realtimeRebindFailures,
           agentId,
           status,
           Date.now()
         );
-        const waitMs = realtimeRebindBackoffMs(state8.attempts);
-        if (state8.attempts === 1 || state8.attempts > state8.loggedAtAttempt) {
-          state8.loggedAtAttempt = state8.attempts;
-          const stuckForSeconds = Math.floor((Date.now() - state8.since) / 1e3);
+        const waitMs = realtimeRebindBackoffMs(state9.attempts);
+        if (state9.attempts === 1 || state9.attempts > state9.loggedAtAttempt) {
+          state9.loggedAtAttempt = state9.attempts;
+          const stuckForSeconds = Math.floor((Date.now() - state9.since) / 1e3);
           log(
-            `[realtime] Token rotation subscription lost for agent ${agentId} (${status}) \u2014 attempt ${state8.attempts}, stuck ${stuckForSeconds}s, next rebind in ${Math.round(waitMs / 1e3)}s (ENG-9265)`
+            `[realtime] Token rotation subscription lost for agent ${agentId} (${status}) \u2014 attempt ${state9.attempts}, stuck ${stuckForSeconds}s, next rebind in ${Math.round(waitMs / 1e3)}s (ENG-9265)`
           );
         }
         if (waitMs === 0) subscribedIntegrationContextAgentIds = /* @__PURE__ */ new Set();
@@ -18657,10 +18784,10 @@ function getKanbanNudgeState(codeName) {
 function loadKanbanNudgeStateFromDisk() {
   loadKanbanNudgeState(kanbanNudgeStateByCode, channelHashCacheDir());
 }
-function setKanbanNudgeState(codeName, state8) {
+function setKanbanNudgeState(codeName, state9) {
   const key = kanbanNudgeStateKey(codeName);
   if (key !== codeName) kanbanNudgeStateByCode.delete(codeName);
-  kanbanNudgeStateByCode.set(key, state8);
+  kanbanNudgeStateByCode.set(key, state9);
   saveKanbanNudgeState(kanbanNudgeStateByCode, channelHashCacheDir());
 }
 function clearKanbanNudgeState(codeName) {
@@ -18841,7 +18968,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-Q5OIAZWC.js");
+  } = await import("../claude-pair-runtime-MRA4KSDR.js");
   for (const pairId of pendingResp.cancelled_pair_ids ?? []) {
     log(`[claude-pair] sweeping orphan tmux session for pair ${pairId.slice(0, 8)}`);
     const killed = await killPairSession(pairTmuxSession(pairId));
@@ -19479,7 +19606,7 @@ async function driveArtifactStreaming() {
 }
 async function driveArtifactStreamingInner() {
   const liveIds = /* @__PURE__ */ new Set();
-  for (const agent of state7.agents) {
+  for (const agent of state8.agents) {
     if (!agent.agentId || !agent.codeName || agent.status !== "active") continue;
     liveIds.add(agent.agentId);
     let scanner = artifactScanners.get(agent.agentId);
@@ -19512,7 +19639,7 @@ async function postLivenessHeartbeat() {
     await api.post("/host/heartbeat", {
       host_id: hostId,
       agt_version: agtCliVersion,
-      last_poll_at: state7.lastPollAt ?? void 0,
+      last_poll_at: state8.lastPollAt ?? void 0,
       // The delay actually in force, so the monitor compares against reality
       // rather than a constant — a manager riding out an API outage under the
       // ENG-5041 backoff must not be paged as stopped.
@@ -19689,8 +19816,8 @@ function startManager(opts) {
       const raw = readFileSync29(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
-        state7.agents = parsed.agents;
-        log(`[startup] rehydrated ${state7.agents.length} agent state(s) from ${stateFile}`);
+        state8.agents = parsed.agents;
+        log(`[startup] rehydrated ${state8.agents.length} agent state(s) from ${stateFile}`);
       }
       if (parsed.circuitBreakerTrips && typeof parsed.circuitBreakerTrips === "object") {
         restartBreaker.hydrate(parsed.circuitBreakerTrips);
@@ -19703,9 +19830,9 @@ function startManager(opts) {
         if (n > 0) log(`[startup] rehydrated ${n} auto-resume marker(s) (ENG-6088)`);
       }
       if (typeof parsed.lastUpdateRequestProcessedAt === "string" || parsed.lastUpdateRequestProcessedAt === null) {
-        state7.lastUpdateRequestProcessedAt = parsed.lastUpdateRequestProcessedAt;
-        if (state7.lastUpdateRequestProcessedAt) {
-          log(`[startup] rehydrated update-request ack at ${state7.lastUpdateRequestProcessedAt} (ENG-6692)`);
+        state8.lastUpdateRequestProcessedAt = parsed.lastUpdateRequestProcessedAt;
+        if (state8.lastUpdateRequestProcessedAt) {
+          log(`[startup] rehydrated update-request ack at ${state8.lastUpdateRequestProcessedAt} (ENG-6692)`);
         }
       }
     }
@@ -19725,7 +19852,7 @@ function startManager(opts) {
     }
     try {
       refreshSlackRestartContextHints(
-        state7.agents.map((a) => a.codeName),
+        state8.agents.map((a) => a.codeName),
         { log }
       );
     } catch (err) {