@raysonmeng/agentbridge 0.1.16 → 0.1.17

package/dist/daemon.js

@@ -1,8 +1,11 @@
 #!/usr/bin/env bun
 // @bun
+var __require = import.meta.require;
 
 // src/daemon.ts
-import { rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync8, realpathSync as realpathSync2, rmSync as rmSync2 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join11 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/contract-version.ts
@@ -26,11 +29,11 @@ function defineNumber(value, fallback) {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 var BUILD_INFO = Object.freeze({
-  version: defineString("0.1.16", "0.0.0-source"),
-  commit: defineString("1dc5e4f", "source"),
+  version: defineString("0.1.17", "0.0.0-source"),
+  commit: defineString("0d1e1bd", "source"),
   bundle: defineBundle("dist"),
   contractVersion: defineNumber(1, CONTRACT_VERSION),
-  codeHash: defineString("1fc975838e46", "source")
+  codeHash: defineString("c22387f3269f", "source")
 });
 function daemonStatusBuildInfo() {
   return { ...BUILD_INFO };
@@ -3402,7 +3405,17 @@ var DEFAULT_BUDGET_CONFIG = {
     balanced: { effort: "medium" },
     eco: { effort: "low" }
   },
-  strategy: "conserve"
+  maximize: {
+    targetUtil: 98,
+    reserveSlopePctPerHour: 0.4,
+    reserveMaxPct: 7,
+    finishingHorizonMinutes: 30,
+    resumeHysteresisPct: 5
+  },
+  allocation: {
+    minRunwayRatio: 50,
+    minRunwayGapHours: 2
+  }
 };
 var DEFAULT_CONFIG = {
   version: "1.0",
@@ -3455,6 +3468,34 @@ function findShapeViolation(raw) {
         }
       }
     }
+    if ("maximize" in budget) {
+      const maximize = budget.maximize;
+      if (!isRecord(maximize)) {
+        return "budget.maximize is present but not an object";
+      }
+      for (const key of [
+        "targetUtil",
+        "reserveSlopePctPerHour",
+        "reserveMaxPct",
+        "finishingHorizonMinutes",
+        "resumeHysteresisPct"
+      ]) {
+        if (key in maximize && !isCoercibleNumber(maximize[key])) {
+          return `budget.maximize.${key} is present but not a number`;
+        }
+      }
+    }
+    if ("allocation" in budget) {
+      const allocation = budget.allocation;
+      if (!isRecord(allocation)) {
+        return "budget.allocation is present but not an object";
+      }
+      for (const key of ["minRunwayRatio", "minRunwayGapHours"]) {
+        if (key in allocation && !isCoercibleNumber(allocation[key])) {
+          return `budget.allocation.${key} is present but not a number`;
+        }
+      }
+    }
   }
   return null;
 }
@@ -3462,7 +3503,7 @@ function hasCustomDecisionValues(config) {
   const d = DEFAULT_CONFIG;
   const b = config.budget;
   const db = d.budget;
-  return config.idleShutdownSeconds !== d.idleShutdownSeconds || config.turnCoordination.attentionWindowSeconds !== d.turnCoordination.attentionWindowSeconds || config.codex.appPort !== d.codex.appPort || config.codex.proxyPort !== d.codex.proxyPort || b.enabled !== db.enabled || b.pollSeconds !== db.pollSeconds || b.pauseAt !== db.pauseAt || b.resumeBelow !== db.resumeBelow || b.syncDriftPct !== db.syncDriftPct || b.parallel.minRemainingPct !== db.parallel.minRemainingPct || b.parallel.timeWindowSec !== db.parallel.timeWindowSec || b.codexTierControl !== db.codexTierControl;
+  return config.idleShutdownSeconds !== d.idleShutdownSeconds || config.turnCoordination.attentionWindowSeconds !== d.turnCoordination.attentionWindowSeconds || config.codex.appPort !== d.codex.appPort || config.codex.proxyPort !== d.codex.proxyPort || b.enabled !== db.enabled || b.pollSeconds !== db.pollSeconds || b.pauseAt !== db.pauseAt || b.resumeBelow !== db.resumeBelow || b.syncDriftPct !== db.syncDriftPct || b.parallel.minRemainingPct !== db.parallel.minRemainingPct || b.parallel.timeWindowSec !== db.parallel.timeWindowSec || b.codexTierControl !== db.codexTierControl || b.maximize.targetUtil !== db.maximize.targetUtil || b.maximize.reserveSlopePctPerHour !== db.maximize.reserveSlopePctPerHour || b.maximize.reserveMaxPct !== db.maximize.reserveMaxPct || b.maximize.finishingHorizonMinutes !== db.maximize.finishingHorizonMinutes || b.maximize.resumeHysteresisPct !== db.maximize.resumeHysteresisPct || b.allocation.minRunwayRatio !== db.allocation.minRunwayRatio || b.allocation.minRunwayGapHours !== db.allocation.minRunwayGapHours;
 }
 function normalizeInteger(value, fallback) {
   if (typeof value === "number" && Number.isFinite(value))
@@ -3480,8 +3521,41 @@ function normalizeBoundedInteger(value, fallback, min, max) {
     return fallback;
   return parsed;
 }
-function normalizeStrategy(value, fallback) {
-  return value === "conserve" || value === "maximize" ? value : fallback;
+function normalizeBoundedNumber(value, fallback, min, max) {
+  let parsed;
+  if (typeof value === "number") {
+    parsed = value;
+  } else if (typeof value === "string" && value.trim() !== "") {
+    parsed = Number(value);
+  } else {
+    return fallback;
+  }
+  if (!Number.isFinite(parsed))
+    return fallback;
+  if (parsed < min || parsed > max)
+    return fallback;
+  return parsed;
+}
+function normalizeMaximizeConfig(raw, pauseAt, fallback = DEFAULT_BUDGET_CONFIG.maximize) {
+  const m = isRecord(raw) ? raw : {};
+  const normalized = {
+    targetUtil: normalizeBoundedInteger(m.targetUtil, fallback.targetUtil, 90, 99),
+    reserveSlopePctPerHour: normalizeBoundedNumber(m.reserveSlopePctPerHour, fallback.reserveSlopePctPerHour, 0, 5),
+    reserveMaxPct: normalizeBoundedInteger(m.reserveMaxPct, fallback.reserveMaxPct, 0, 30),
+    finishingHorizonMinutes: normalizeBoundedInteger(m.finishingHorizonMinutes, fallback.finishingHorizonMinutes, 5, 180),
+    resumeHysteresisPct: normalizeBoundedInteger(m.resumeHysteresisPct, fallback.resumeHysteresisPct, 1, 30)
+  };
+  if (normalized.targetUtil <= pauseAt) {
+    return { ...DEFAULT_BUDGET_CONFIG.maximize };
+  }
+  return normalized;
+}
+function normalizeAllocationConfig(raw, fallback = DEFAULT_BUDGET_CONFIG.allocation) {
+  const a = isRecord(raw) ? raw : {};
+  return {
+    minRunwayRatio: normalizeBoundedInteger(a.minRunwayRatio, fallback.minRunwayRatio, 10, 100),
+    minRunwayGapHours: normalizeBoundedInteger(a.minRunwayGapHours, fallback.minRunwayGapHours, 1, 168)
+  };
 }
 function normalizeBoolean(value, fallback) {
   if (typeof value === "boolean")
@@ -3532,7 +3606,8 @@ function normalizeBudgetConfig(raw, fallback = DEFAULT_BUDGET_CONFIG) {
     },
     codexTierControl: normalizeBoolean(budget.codexTierControl, fallback.codexTierControl) && codexTiers.full !== null,
     codexTiers,
-    strategy: normalizeStrategy(budget.strategy, fallback.strategy)
+    maximize: normalizeMaximizeConfig(budget.maximize, pauseAt, fallback.maximize),
+    allocation: normalizeAllocationConfig(budget.allocation, fallback.allocation)
   };
 }
 function applyBudgetEnvOverrides(budget, env = process.env) {
@@ -3548,7 +3623,17 @@ function applyBudgetEnvOverrides(budget, env = process.env) {
     },
     codexTierControl: env.AGENTBRIDGE_BUDGET_CODEX_TIER_CONTROL ?? budget.codexTierControl,
     codexTiers: budget.codexTiers,
-    strategy: env.AGENTBRIDGE_BUDGET_STRATEGY ?? budget.strategy
+    maximize: {
+      targetUtil: env.AGENTBRIDGE_BUDGET_TARGET_UTIL ?? budget.maximize.targetUtil,
+      reserveSlopePctPerHour: env.AGENTBRIDGE_BUDGET_RESERVE_SLOPE_PCT_PER_HOUR ?? budget.maximize.reserveSlopePctPerHour,
+      reserveMaxPct: env.AGENTBRIDGE_BUDGET_RESERVE_MAX_PCT ?? budget.maximize.reserveMaxPct,
+      finishingHorizonMinutes: env.AGENTBRIDGE_BUDGET_FINISHING_HORIZON_MINUTES ?? budget.maximize.finishingHorizonMinutes,
+      resumeHysteresisPct: env.AGENTBRIDGE_BUDGET_RESUME_HYSTERESIS_PCT ?? budget.maximize.resumeHysteresisPct
+    },
+    allocation: {
+      minRunwayRatio: env.AGENTBRIDGE_BUDGET_MIN_RUNWAY_RATIO ?? budget.allocation.minRunwayRatio,
+      minRunwayGapHours: env.AGENTBRIDGE_BUDGET_MIN_RUNWAY_GAP_HOURS ?? budget.allocation.minRunwayGapHours
+    }
   };
   return normalizeBudgetConfig(overlay, budget);
 }
@@ -3661,6 +3746,9 @@ class ConfigService {
   }
 }
 
+// src/budget/budget-coordinator.ts
+import { homedir as homedir2 } from "os";
+
 // src/budget/budget-gate.ts
 function matchingGateReset(usage) {
   if (!usage)
@@ -3672,28 +3760,225 @@ function matchingGateReset(usage) {
     return 0;
   return Math.min(...candidates.map((window) => window.resetEpoch));
 }
-function resumeBlockingEpoch(usage, cfg, now) {
+function retryAfterMsForResume(resumeAfterEpoch, nowMs) {
+  if (resumeAfterEpoch === null)
+    return;
+  const remainingMs = resumeAfterEpoch * 1000 - nowMs;
+  return remainingMs > 0 ? remainingMs : undefined;
+}
+
+// src/budget/types.ts
+var STALE_MAX_AGE_SEC = 600;
+
+// src/budget/budget-decision.ts
+var AGENT_LABEL = {
+  claude: "Claude",
+  codex: "Codex"
+};
+var WINDOW_LABEL = {
+  fiveHour: "5h",
+  weekly: "\u5468"
+};
+var WINDOW_KEYS = ["fiveHour", "weekly"];
+var MAX_TIME_TO_RESET_HOURS = 7 * 24;
+var FINISHING_MARGIN_MIN_PCT = 1;
+var FINISHING_MARGIN_MAX_PCT = 10;
+var DYNAMIC_LINE_CEILING_PCT = 99;
+function pct(value) {
+  return `${Math.round(value * 10) / 10}%`;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function clampedTimeToResetHours(window, now) {
+  return Math.min((window.resetEpoch - now) / 3600, MAX_TIME_TO_RESET_HOURS);
+}
+function isDecisionGrade(usage, now) {
+  if (!usage)
+    return false;
+  const freshWindow = usage.fiveHour !== null && usage.fiveHour.resetEpoch > now || usage.weekly !== null && usage.weekly.resetEpoch > now;
+  if (!freshWindow)
+    return false;
+  if (usage.fetchedAt > 0 && now - usage.fetchedAt > STALE_MAX_AGE_SEC)
+    return false;
+  return true;
+}
+function dynamicPauseAt(window, burnRatePctPerHour, cfg, now) {
+  const m = cfg.maximize;
+  const rawTimeToResetHours = (window.resetEpoch - now) / 3600;
+  if (rawTimeToResetHours <= 0)
+    return 100;
+  const tH = clampedTimeToResetHours(window, now);
+  const finishingMarginPct = clamp(burnRatePctPerHour * (m.finishingHorizonMinutes / 60), FINISHING_MARGIN_MIN_PCT, FINISHING_MARGIN_MAX_PCT);
+  const projectedAtReset = window.util + burnRatePctPerHour * tH;
+  if (projectedAtReset <= m.targetUtil) {
+    if (window.util >= m.targetUtil)
+      return "admission-closed";
+    if (tH < m.finishingHorizonMinutes / 60 && window.util >= m.targetUtil - finishingMarginPct) {
+      return "admission-closed";
+    }
+    return 100;
+  }
+  const reservePct = Math.min(m.reserveMaxPct, m.reserveSlopePctPerHour * tH);
+  const line = m.targetUtil - finishingMarginPct - reservePct;
+  return clamp(line, cfg.pauseAt, Math.max(cfg.pauseAt, DYNAMIC_LINE_CEILING_PCT));
+}
+function dynamicWindowVerdict(window, cfg, now) {
+  const rate = confidentRate(window);
+  if (rate === null)
+    return { kind: "degraded" };
+  if (window.resetEpoch <= now)
+    return { kind: "degraded" };
+  const line = dynamicPauseAt(window, rate, cfg, now);
+  if (line === "admission-closed")
+    return { kind: "admission-closed" };
+  const projectedAtReset = window.util + rate * clampedTimeToResetHours(window, now);
+  if (projectedAtReset <= cfg.maximize.targetUtil) {
+    return { kind: "will-not-fill", projectedAtReset };
+  }
+  return { kind: "will-fill", line };
+}
+function confidentRate(window) {
+  if (window.burnConfident !== true)
+    return null;
+  if (typeof window.burnRate !== "number" || !Number.isFinite(window.burnRate) || window.burnRate < 0) {
+    return null;
+  }
+  return window.burnRate;
+}
+function maximizeWindowEntry(window, cfg, now) {
+  const rate = confidentRate(window);
+  if (rate === null) {
+    return { blocks: window.util >= cfg.pauseAt, line: null, admission: false };
+  }
+  const line = dynamicPauseAt(window, rate, cfg, now);
+  if (line === "admission-closed") {
+    return { blocks: window.util >= cfg.pauseAt, line: null, admission: true };
+  }
+  return { blocks: window.util >= line, line, admission: false };
+}
+function maximizeWindowBlocksResume(window, cfg, now) {
+  const rate = confidentRate(window);
+  if (rate === null) {
+    return window.util >= cfg.resumeBelow;
+  }
+  const line = dynamicPauseAt(window, rate, cfg, now);
+  const hyst = cfg.maximize.resumeHysteresisPct;
+  if (line === "admission-closed") {
+    return window.util >= cfg.pauseAt - hyst;
+  }
+  if (line === 100)
+    return false;
+  return window.util >= line - hyst;
+}
+function freshWindows(usage, now) {
+  const out = [];
+  for (const key of WINDOW_KEYS) {
+    const window = usage[key];
+    if (window && window.resetEpoch > now)
+      out.push({ key, window });
+  }
+  return out;
+}
+var NO_PAUSE = { pause: false, window: null, line: null, reason: "" };
+function fallbackPauseReason(agent, usage, cfg) {
+  return `${AGENT_LABEL[agent]} gateUtil ${pct(usage.gateUtil)} \u2265 pauseAt ${pct(cfg.pauseAt)}\uFF08\u515C\u5E95\u5224\u636E\uFF09`;
+}
+function agentShouldPause(agent, usage, cfg, now) {
+  if (!usage)
+    return NO_PAUSE;
+  if (!isDecisionGrade(usage, now))
+    return NO_PAUSE;
+  const windows = freshWindows(usage, now);
+  if (windows.length === 0) {
+    if (usage.gateUtil >= cfg.pauseAt) {
+      return { pause: true, window: null, line: null, reason: fallbackPauseReason(agent, usage, cfg) };
+    }
+    return NO_PAUSE;
+  }
+  for (const { key, window } of windows) {
+    const verdict = maximizeWindowEntry(window, cfg, now);
+    if (verdict.blocks) {
+      return {
+        pause: true,
+        window: key,
+        line: verdict.line,
+        reason: buildMaximizeReason(agent, key, window, verdict, cfg)
+      };
+    }
+  }
+  return NO_PAUSE;
+}
+function buildMaximizeReason(agent, key, window, verdict, cfg) {
+  const head = `${AGENT_LABEL[agent]} ${WINDOW_LABEL[key]}\u7A97\u53E3 util ${pct(window.util)}`;
+  if (verdict.line !== null) {
+    const rate = window.burnRate;
+    const rateText = typeof rate === "number" ? `\uFF0C\u71C3\u5C3D\u7387\u2248${pct(rate)}/h` : "";
+    return `${head} \u2265 \u52A8\u6001\u6682\u505C\u7EBF ${pct(verdict.line)}${rateText}`;
+  }
+  if (verdict.admission) {
+    return `${head} \u89E6\u53D1\u6536\u5C3E\u4FDD\u62A4\u786C\u7EBF\uFF08\u2265 pauseAt ${pct(cfg.pauseAt)}\uFF09`;
+  }
+  return `${head} \u2265 pauseAt ${pct(cfg.pauseAt)}\uFF08\u71C3\u5C3D\u7387\u91C7\u6837\u4E2D\uFF0C\u9000\u515C\u5E95\u5224\u636E\uFF09`;
+}
+function agentCanResume(usage, cfg, now) {
+  if (!isDecisionGrade(usage, now))
+    return false;
+  if (usage.rateLimitedUntil > now)
+    return false;
+  const windows = freshWindows(usage, now);
+  for (const { window } of windows) {
+    if (maximizeWindowBlocksResume(window, cfg, now))
+      return false;
+  }
+  return true;
+}
+function effectiveDynamicLine(usage, cfg, now) {
+  if (!usage || !isDecisionGrade(usage, now))
+    return null;
+  let bestLine = null;
+  let bestHeadroom = Number.POSITIVE_INFINITY;
+  for (const { window } of freshWindows(usage, now)) {
+    const rate = confidentRate(window);
+    if (rate === null)
+      continue;
+    const line = dynamicPauseAt(window, rate, cfg, now);
+    if (line === "admission-closed" || line >= 100)
+      continue;
+    const headroom = line - window.util;
+    if (headroom < bestHeadroom) {
+      bestHeadroom = headroom;
+      bestLine = line;
+    }
+  }
+  return bestLine;
+}
+function resumeBlockingEpochFor(usage, cfg, now) {
   if (!usage)
     return 0;
   if (usage.rateLimitedUntil > now)
     return usage.rateLimitedUntil;
-  if (usage.gateUtil >= cfg.resumeBelow)
-    return matchingGateReset(usage);
-  return 0;
+  if (!isDecisionGrade(usage, now)) {
+    const reset = matchingGateReset(usage);
+    return reset > now ? reset : 0;
+  }
+  const blockingResets = freshWindows(usage, now).filter(({ window }) => maximizeWindowBlocksResume(window, cfg, now)).map(({ window }) => window.resetEpoch).filter((epoch) => epoch > 0);
+  if (blockingResets.length === 0)
+    return 0;
+  return Math.min(...blockingResets);
 }
 
-// src/budget/types.ts
-var STALE_MAX_AGE_SEC = 600;
-
 // src/budget/budget-state.ts
-var AGENT_LABEL = {
+var NO_RUNWAY = { claude: null, codex: null };
+var UNDERUTILIZATION_MIN_WASTE_PCT = 10;
+var AGENT_LABEL2 = {
   claude: "Claude",
   codex: "Codex"
 };
 var CODEX_BALANCED_WARN_UTIL = 60;
 var CODEX_ECO_WARN_UTIL = 80;
 var CLAUDE_ADVICE_WARN_UTIL = 80;
-function pct(value) {
+function pct2(value) {
   return `${Math.round(value * 10) / 10}%`;
 }
 function formatEpoch(epoch) {
@@ -3703,40 +3988,23 @@ function formatEpoch(epoch) {
 }
 function usageSummary(name, usage) {
   if (!usage)
-    return `${AGENT_LABEL[name]} \u672A\u77E5`;
-  return `${AGENT_LABEL[name]} gate=${pct(usage.gateUtil)} warn=${pct(usage.warnUtil)} 5h\u91CD\u7F6E=${formatEpoch(usage.fiveHour?.resetEpoch ?? 0)}`;
+    return `${AGENT_LABEL2[name]} \u672A\u77E5`;
+  return `${AGENT_LABEL2[name]} gate=${pct2(usage.gateUtil)} warn=${pct2(usage.warnUtil)} 5h\u91CD\u7F6E=${formatEpoch(usage.fiveHour?.resetEpoch ?? 0)}`;
 }
 function resumeAfterEpoch(claude, codex, cfg, now) {
   const epochs = [
-    resumeBlockingEpoch(claude, cfg, now),
-    resumeBlockingEpoch(codex, cfg, now)
+    resumeBlockingEpochFor(claude, cfg, now),
+    resumeBlockingEpochFor(codex, cfg, now)
   ].filter((epoch) => epoch > 0);
   if (epochs.length === 0)
     return null;
   return Math.max(...epochs);
 }
-function isDecisionGrade(usage, now) {
-  if (!usage)
-    return false;
-  const freshWindow = usage.fiveHour !== null && usage.fiveHour.resetEpoch > now || usage.weekly !== null && usage.weekly.resetEpoch > now;
-  if (!freshWindow)
-    return false;
-  if (usage.fetchedAt > 0 && now - usage.fetchedAt > STALE_MAX_AGE_SEC)
-    return false;
-  return true;
-}
 function pauseTrigger(agent, usage, cfg, now) {
-  if (!usage)
-    return null;
-  if (!isDecisionGrade(usage, now))
+  const decision = agentShouldPause(agent, usage, cfg, now);
+  if (!decision.pause)
     return null;
-  if (usage.gateUtil >= cfg.pauseAt) {
-    return {
-      agent,
-      reason: `${AGENT_LABEL[agent]} gateUtil ${pct(usage.gateUtil)} \u2265 pauseAt ${pct(cfg.pauseAt)}`
-    };
-  }
-  return null;
+  return { agent, reason: decision.reason };
 }
 function driftFor(claude, codex, cfg) {
   if (!claude || !codex)
@@ -3751,33 +4019,75 @@ function driftFor(claude, codex, cfg) {
     lighter: drift > 0 ? "codex" : "claude"
   };
 }
-function parallelState(claude, codex, cfg, now) {
-  if (!claude || !codex)
-    return { recommended: false, reason: null };
-  if (claude.remaining <= cfg.parallel.minRemainingPct || codex.remaining <= cfg.parallel.minRemainingPct) {
-    return { recommended: false, reason: null };
+function runwayBalance(claudeRunway, codexRunway, cfg) {
+  const ch = claudeRunway.seconds / 3600;
+  const xh = codexRunway.seconds / 3600;
+  const lo = Math.min(ch, xh);
+  const hi = Math.max(ch, xh);
+  const ratioPct = hi <= 0 ? 100 : Math.round(100 * lo / hi);
+  const gapHours = Math.abs(ch - xh);
+  if (ratioPct < cfg.allocation.minRunwayRatio && gapHours >= cfg.allocation.minRunwayGapHours) {
+    const shorter = ch < xh ? "claude" : "codex";
+    return { heavier: shorter, lighter: shorter === "claude" ? "codex" : "claude" };
   }
-  const claudeReset = claude.fiveHour?.resetEpoch ?? 0;
-  const codexReset = codex.fiveHour?.resetEpoch ?? 0;
-  if (claudeReset <= now || codexReset <= now)
-    return { recommended: false, reason: null };
-  const nearestResetSec = Math.min(claudeReset - now, codexReset - now);
-  if (nearestResetSec >= cfg.parallel.timeWindowSec)
-    return { recommended: false, reason: null };
-  const minutes = Math.ceil(nearestResetSec / 60);
+  return null;
+}
+function allocationDrift(claude, codex, runway, cfg) {
+  const warnDrift = driftFor(claude, codex, cfg);
+  if (!claude || !codex || !runway.claude || !runway.codex) {
+    return { drift: warnDrift, basis: "warn" };
+  }
+  const balance = runwayBalance(runway.claude, runway.codex, cfg);
   return {
-    recommended: true,
-    reason: `\u53CC\u65B9\u5269\u4F59\u989D\u5EA6\u5747\u9AD8\u4E8E ${pct(cfg.parallel.minRemainingPct)}\uFF0C\u6700\u8FD1 5h \u6876\u7EA6 ${minutes} \u5206\u949F\u540E\u91CD\u7F6E`
+    drift: {
+      pct: warnDrift.pct,
+      heavier: balance?.heavier ?? null,
+      lighter: balance?.lighter ?? null
+    },
+    basis: "runway"
   };
 }
+function runwayHoursText(runway) {
+  if (!runway)
+    return "\u672A\u77E5";
+  return `~${(runway.seconds / 3600).toFixed(1)}h`;
+}
+function underutilizationState(claude, codex, cfg, now) {
+  let top = null;
+  for (const [agent, usage] of [["claude", claude], ["codex", codex]]) {
+    const weekly = usage?.weekly;
+    if (!weekly)
+      continue;
+    const verdict = dynamicWindowVerdict(weekly, cfg, now);
+    if (verdict.kind !== "will-not-fill")
+      continue;
+    const waste = Math.round((cfg.maximize.targetUtil - verdict.projectedAtReset) * 10) / 10;
+    if (waste < UNDERUTILIZATION_MIN_WASTE_PCT)
+      continue;
+    if (top === null || waste > top.waste) {
+      top = { agent, projected: verdict.projectedAtReset, waste, resetEpoch: weekly.resetEpoch };
+    }
+  }
+  if (top === null)
+    return { recommended: false, reason: null };
+  const hoursToReset = Math.max(0, (top.resetEpoch - now) / 3600);
+  const reason = [
+    "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011\u989D\u5EA6\u5C06\u6B20\u8F7D\uFF0C\u5EFA\u8BAE\u63D0\u9AD8\u5E76\u884C/\u59D4\u6D3E\u5BC6\u5EA6\u3002",
+    `${AGENT_LABEL2[top.agent]} \u6309\u5F53\u524D\u71C3\u5C3D\u7387\u5468\u7A97\u53E3\u5237\u65B0\u65F6\u53EA\u4F1A\u7528\u5230 ~${pct2(top.projected)}\uFF0C` + `\u8DDD\u5237\u65B0\u8FD8\u6709 ~${hoursToReset.toFixed(1)}h \u2014\u2014 \u5EFA\u8BAE\u62C6\u66F4\u591A\u5E76\u884C\u5B50\u4EFB\u52A1/\u63D0\u9AD8\u59D4\u6D3E\u5BC6\u5EA6\uFF0C` + `\u5426\u5219\u7EA6 ${pct2(top.waste)} \u5468\u989D\u5EA6\u5C06\u4F5C\u5E9F\u3002`
+  ].join(`
+`);
+  return { recommended: true, reason };
+}
 function renderBudgetInterventionDirective(claude, codex, side, reason, resumeEpoch, cfg) {
   const resumeText = `\u9884\u8BA1\u6062\u590D\u65F6\u95F4\uFF08\u4EE5\u5B9E\u6D4B\u4E3A\u51C6\uFF1B\u63D0\u524D\u5237\u65B0\u4F1A\u66F4\u65E9\u89E3\u9664\uFF09\uFF1A${formatEpoch(resumeEpoch)}\u3002`;
+  const resumeCondSingle = `\u5404\u7A97\u53E3 util \u56DE\u843D\u81F3\u52A8\u6001\u6682\u505C\u7EBF \u2212 ${pct2(cfg.maximize.resumeHysteresisPct)} \u4EE5\u4E0B\u6216\u5BF9\u5E94\u7A97\u53E3\u5237\u65B0`;
+  const resumeCondBoth = `\u5404\u7A97\u53E3 util \u90FD\u56DE\u843D\u81F3\u52A8\u6001\u6682\u505C\u7EBF \u2212 ${pct2(cfg.maximize.resumeHysteresisPct)} \u4EE5\u4E0B\u6216\u5BF9\u5E94\u7A97\u53E3\u5237\u65B0`;
   if (side === "claude") {
     return [
       "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011Claude \u4FA7\u989D\u5EA6\u7D27\u5F20\uFF0C\u8FDB\u5165\u63A5\u529B\u6A21\u5F0F\u3002",
       `\u89E6\u53D1\u65B9\uFF1AClaude\uFF1B\u539F\u56E0\uFF1A${reason}\u3002`,
       `${usageSummary("claude", claude)}\uFF1B${usageSummary("codex", codex)}\u3002`,
-      `\u6062\u590D\u53C2\u8003\uFF1AClaude gateUtil \u4F4E\u4E8E ${pct(cfg.resumeBelow)} \u4E14\u6CA1\u6709\u6709\u6548 rate_limit\uFF1B${resumeText}`,
+      `\u6062\u590D\u53C2\u8003\uFF1AClaude ${resumeCondSingle} \u4E14\u6CA1\u6709\u6709\u6548 rate_limit\uFF1B${resumeText}`,
       "\u8BF7\u7ACB\u5373\u4EA4\u63A5\uFF1A\u628A\u5269\u4F59\u4EFB\u52A1\u6E05\u5355\u3001\u5173\u952E\u4E0A\u4E0B\u6587\u3001\u4EA7\u51FA\u4F4D\u7F6E\u3001\u9A8C\u6536\u6807\u51C6\u6253\u5305\u6210\u4E00\u6761 reply \u53D1\u7ED9 Codex\u3002",
       "\u4EA4\u63A5\u540E Claude \u505C\u624B\uFF1B\u8981\u6C42 Codex \u5728\u5355 turn \u5185\u5C3D\u91CF\u5B8C\u6210\uFF0C\u5C3E\u5DF4\u5199 checkpoint\uFF0C\u6682\u505C\u671F\u4E0D\u8981\u671F\u5F85 Claude \u56DE\u590D\u3002"
     ].join(`
@@ -3788,7 +4098,7 @@ function renderBudgetInterventionDirective(claude, codex, side, reason, resumeEp
       "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011Codex \u4FA7\u989D\u5EA6\u7D27\u5F20\uFF0C\u6682\u505C\u59D4\u6D3E\u3002",
       `\u89E6\u53D1\u65B9\uFF1ACodex\uFF1B\u539F\u56E0\uFF1A${reason}\u3002`,
       `${usageSummary("claude", claude)}\uFF1B${usageSummary("codex", codex)}\u3002`,
-      `\u6062\u590D\u53C2\u8003\uFF1ACodex gateUtil \u4F4E\u4E8E ${pct(cfg.resumeBelow)} \u4E14\u6CA1\u6709\u6709\u6548 rate_limit\uFF1B${resumeText}`,
+      `\u6062\u590D\u53C2\u8003\uFF1ACodex ${resumeCondSingle} \u4E14\u6CA1\u6709\u6709\u6548 rate_limit\uFF1B${resumeText}`,
       "\u8BF7 Claude \u5199 checkpoint\uFF0C\u5E76\u53EF solo \u63A8\u8FDB\u4E0D\u4F9D\u8D56 Codex \u7684\u72EC\u7ACB\u90E8\u5206\uFF1B\u4E0D\u8981\u7EE7\u7EED\u5411 Codex \u59D4\u6D3E\uFF0C\u6807\u6CE8\u6E05\u695A\u5206\u5DE5\u65AD\u70B9\u3002"
     ].join(`
 `);
@@ -3797,30 +4107,26 @@ function renderBudgetInterventionDirective(claude, codex, side, reason, resumeEp
     "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011\u8FDB\u5165\u8054\u5408\u6682\u505C\u3002",
     `\u89E6\u53D1\u65B9\uFF1A\u53CC\u65B9\uFF1B\u539F\u56E0\uFF1A${reason}\u3002`,
     `${usageSummary("claude", claude)}\uFF1B${usageSummary("codex", codex)}\u3002`,
-    `\u6062\u590D\u6761\u4EF6\uFF1AClaude \u4E0E Codex \u7684 gateUtil \u90FD\u4F4E\u4E8E ${pct(cfg.resumeBelow)}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\uFF1B${resumeText}`,
+    `\u6062\u590D\u6761\u4EF6\uFF1AClaude \u4E0E Codex \u7684 ${resumeCondBoth}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\uFF1B${resumeText}`,
     "\u8BF7\u6536\u5C3E\u5F53\u524D\u6B65\u3001\u5199 checkpoint\u3001\u505C\u6B62\u7EE7\u7EED\u59D4\u6D3E\uFF1Bpause \u671F\u95F4\u4E0D\u8981\u91CD\u8BD5\u5411 Codex \u53D1\u9001 reply\u3002"
   ].join(`
 `);
 }
-function balanceDirective(claude, codex, drift, parallel) {
-  const heavier = drift.heavier ? AGENT_LABEL[drift.heavier] : "\u672A\u77E5";
-  const lighter = drift.lighter ? AGENT_LABEL[drift.lighter] : "\u672A\u77E5";
-  const lines = [
-    "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011\u68C0\u6D4B\u5230\u53CC\u65B9\u7528\u91CF\u6BD4\u4F8B\u6F02\u79FB\u3002",
-    `${usageSummary("claude", claude)}\uFF1B${usageSummary("codex", codex)}\u3002`,
-    `${heavier} \u6BD4 ${lighter} \u9AD8 ${pct(Math.abs(drift.pct))}\uFF0C\u8BF7\u4F18\u5148\u628A\u540E\u7EED\u53EF\u62C6\u5206\u4EFB\u52A1\u5206\u7ED9 ${lighter}\uFF0C\u76F4\u5230 warnUtil \u63A5\u8FD1\u3002`
-  ];
-  if (parallel.recommended && parallel.reason) {
-    lines.push(`${parallel.reason}\uFF1B\u53EF\u8BA9 ${lighter} \u627F\u62C5\u66F4\u591A\u5E76\u884C\u5B50\u4EFB\u52A1\uFF0C\u517C\u987E\u5747\u8861\u4E0E\u63D0\u901F\u3002`);
-  }
-  return lines.join(`
+function balanceDirective(claude, codex, drift, basis, runway) {
+  const heavier = drift.heavier ? AGENT_LABEL2[drift.heavier] : "\u672A\u77E5";
+  const lighter = drift.lighter ? AGENT_LABEL2[drift.lighter] : "\u672A\u77E5";
+  if (basis === "runway") {
+    return [
+      "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011\u6309\u5269\u4F59\u53EF\u5DE5\u4F5C\u65F6\u95F4\u9700\u8981\u5747\u8861\u3002",
+      `${usageSummary("claude", claude)}\uFF1B${usageSummary("codex", codex)}\u3002`,
+      `Claude \u6309\u5F53\u524D\u71C3\u5C3D\u7387\u7EA6\u53EF\u518D\u5DE5\u4F5C ${runwayHoursText(runway.claude)}\u3001` + `Codex ${runwayHoursText(runway.codex)}\uFF08\u7A97\u53E3\u4E3A\u7EA6\u675F\uFF09\uFF1B` + `runway \u8F83\u77ED\u7684\u4E00\u4FA7\u662F ${heavier}\uFF0C\u8BF7\u628A\u540E\u7EED\u53EF\u62C6\u5206\u4EFB\u52A1\u4F18\u5148\u6D3E\u7ED9 ${lighter}\u3002`
+    ].join(`
 `);
-}
-function parallelDirective(claude, codex, parallel) {
+  }
   return [
-    "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011\u5F53\u524D\u989D\u5EA6\u5BCC\u4F59\u4E14\u4E34\u8FD1 5h \u7ED3\u7B97\uFF0C\u5EFA\u8BAE\u52A8\u6001\u5E76\u884C\u3002",
+    "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011\u68C0\u6D4B\u5230\u53CC\u65B9\u7528\u91CF\u6BD4\u4F8B\u6F02\u79FB\u3002",
     `${usageSummary("claude", claude)}\uFF1B${usageSummary("codex", codex)}\u3002`,
-    `${parallel.reason}\uFF1B\u53EF\u4EE5\u62C6\u66F4\u591A\u72EC\u7ACB\u5B50\u4EFB\u52A1\u5E76\u884C\u63A8\u8FDB\u3002`
+    `${heavier} \u6BD4 ${lighter} \u9AD8 ${pct2(Math.abs(drift.pct))}\uFF0C\u8BF7\u4F18\u5148\u628A\u540E\u7EED\u53EF\u62C6\u5206\u4EFB\u52A1\u5206\u7ED9 ${lighter}\uFF0C\u76F4\u5230 warnUtil \u63A5\u8FD1\u3002`
   ].join(`
 `);
 }
@@ -3838,16 +4144,19 @@ function claudeAdviceFor(claude, now) {
     return null;
   if (claude.warnUtil < CLAUDE_ADVICE_WARN_UTIL)
     return null;
-  return `Claude warnUtil ${pct(claude.warnUtil)} \u5DF2\u504F\u9AD8\uFF1B\u540E\u7EED\u53EF\u62C6\u5206 subagent \u5EFA\u8BAE\u964D\u6863\u5230 haiku/sonnet\uFF0C\u5E76\u4FDD\u7559\u9AD8\u96BE\u5EA6\u4E3B\u7EBF\u7ED9\u5F53\u524D\u4F1A\u8BDD\u3002`;
+  return `Claude warnUtil ${pct2(claude.warnUtil)} \u5DF2\u504F\u9AD8\uFF1B\u540E\u7EED\u53EF\u62C6\u5206 subagent \u5EFA\u8BAE\u964D\u6863\u5230 haiku/sonnet\uFF0C\u5E76\u4FDD\u7559\u9AD8\u96BE\u5EA6\u4E3B\u7EBF\u7ED9\u5F53\u524D\u4F1A\u8BDD\u3002`;
 }
-function computeBudgetState(claude, codex, cfg, now) {
+function computeBudgetState(claude, codex, cfg, now, runway = NO_RUNWAY) {
   const triggers = [
     pauseTrigger("claude", claude, cfg, now),
     pauseTrigger("codex", codex, cfg, now)
   ].filter((trigger) => trigger !== null);
   const paused = triggers.length > 0;
-  const drift = driftFor(claude, codex, cfg);
-  const parallel = paused ? { recommended: false, reason: null } : parallelState(claude, codex, cfg, now);
+  const { drift, basis } = allocationDrift(claude, codex, runway, cfg);
+  const parallel = { recommended: false, reason: null };
+  const adviceEligible = !paused && claude !== null && codex !== null && claude.rateLimitedUntil <= now && codex.rateLimitedUntil <= now && isDecisionGrade(claude, now) && isDecisionGrade(codex, now);
+  const balanceActive = adviceEligible && drift.heavier !== null && drift.lighter !== null;
+  const underutilization = adviceEligible && !balanceActive ? underutilizationState(claude, codex, cfg, now) : { recommended: false, reason: null };
   const resetEpochs = {
     claude: matchingGateReset(claude),
     codex: matchingGateReset(codex)
@@ -3856,18 +4165,18 @@ function computeBudgetState(claude, codex, cfg, now) {
   let phase = "normal";
   if (paused)
     phase = "paused";
-  else if (drift.heavier && drift.lighter)
+  else if (balanceActive)
     phase = "balance";
-  else if (parallel.recommended)
-    phase = "parallel";
+  else if (underutilization.recommended)
+    phase = "underutilized";
   const pauseSide = !paused ? null : triggers.length > 1 ? "both" : triggers[0].agent;
   let directiveToClaude = null;
   if (phase === "paused") {
     directiveToClaude = renderBudgetInterventionDirective(claude, codex, pauseSide ?? "both", triggers.map((trigger) => trigger.reason).join("\uFF1B"), filteredResumeAfterEpoch, cfg);
   } else if (phase === "balance" && claude && codex) {
-    directiveToClaude = balanceDirective(claude, codex, drift, parallel);
-  } else if (phase === "parallel" && claude && codex) {
-    directiveToClaude = parallelDirective(claude, codex, parallel);
+    directiveToClaude = balanceDirective(claude, codex, drift, basis, runway);
+  } else if (phase === "underutilized") {
+    directiveToClaude = underutilization.reason;
   }
   return {
     phase,
@@ -3883,18 +4192,84 @@ function computeBudgetState(claude, codex, cfg, now) {
       resetEpochs
     },
     parallel,
+    underutilization,
     effort: { claudeAdvice: claudeAdviceFor(claude, now), codexTier: codexTierFor(codex, now) },
     directiveToClaude
   };
 }
 
+// src/budget/advice-cooldown.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
+var DEFAULT_ADVICE_COOLDOWN_SEC = 1800;
+var COOLDOWN_FILENAME = "advice-cooldown.json";
+function resolveAdviceCooldownSec(env = process.env) {
+  const raw = env.AGENTBRIDGE_BUDGET_ADVICE_COOLDOWN_SEC;
+  if (raw === undefined || raw.trim() === "")
+    return DEFAULT_ADVICE_COOLDOWN_SEC;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 86400)
+    return DEFAULT_ADVICE_COOLDOWN_SEC;
+  return parsed;
+}
+function resolveStateDir(homeDir) {
+  const override = process.env.BUDGET_STATE_DIR;
+  if (override && override.trim() !== "")
+    return override.trim();
+  return join5(homeDir, ".budget-guard");
+}
+
+class AdviceCooldown {
+  path;
+  cooldownSec;
+  log;
+  constructor(options) {
+    this.path = join5(resolveStateDir(options.homeDir), COOLDOWN_FILENAME);
+    this.cooldownSec = options.cooldownSec ?? DEFAULT_ADVICE_COOLDOWN_SEC;
+    this.log = options.log ?? (() => {});
+  }
+  tryAcquire(direction, now) {
+    const file = this.read();
+    const last = file[direction]?.lastEmittedEpoch;
+    if (this.cooldownSec > 0 && typeof last === "number" && Number.isFinite(last) && now - last < this.cooldownSec && last <= now) {
+      return false;
+    }
+    this.write({ ...file, [direction]: { lastEmittedEpoch: now } });
+    return true;
+  }
+  read() {
+    let raw;
+    try {
+      raw = readFileSync5(this.path, "utf-8");
+    } catch {
+      return {};
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return {};
+      return parsed;
+    } catch {
+      this.log(`advice-cooldown: ignoring malformed ${this.path}`);
+      return {};
+    }
+  }
+  write(file) {
+    try {
+      atomicWriteJson(this.path, file);
+    } catch (error) {
+      this.log(`advice-cooldown: write failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+
 // src/budget/budget-fingerprint.ts
 var RESET_FINGERPRINT_BUCKET_SEC = 600;
-var AGENT_LABEL2 = {
+var AGENT_LABEL3 = {
   claude: "Claude",
   codex: "Codex"
 };
-function pct2(value) {
+function pct3(value) {
   return `${Math.round(value * 10) / 10}%`;
 }
 function formatEpoch2(epoch) {
@@ -3926,46 +4301,38 @@ function agentsToSide(agents) {
     return "codex";
   return null;
 }
-function shouldEnter(usage, cfg, now) {
-  if (!isDecisionGrade(usage, now))
-    return false;
-  return usage.gateUtil >= cfg.pauseAt;
-}
-function canAgentResume(usage, cfg, now) {
-  if (!isDecisionGrade(usage, now))
-    return false;
-  if (usage.rateLimitedUntil > now)
-    return false;
-  return usage.gateUtil < cfg.resumeBelow;
-}
 function nextActiveSide(prevSide, state, cfg) {
   const active = new Set(sideToAgents(prevSide));
   for (const agent of ["claude", "codex"]) {
     const usage = state.perAgent[agent];
-    if (shouldEnter(usage, cfg, state.now)) {
+    if (agentShouldPause(agent, usage, cfg, state.now).pause) {
       active.add(agent);
-    } else if (active.has(agent) && canAgentResume(usage, cfg, state.now)) {
+    } else if (active.has(agent) && agentCanResume(usage, cfg, state.now)) {
       active.delete(agent);
     }
   }
   return agentsToSide(active);
 }
+function removedAgents(prevSide, currentSide) {
+  const current = new Set(sideToAgents(currentSide));
+  return sideToAgents(prevSide).filter((agent) => !current.has(agent));
+}
 function activeSideReason(agent, usage, cfg, now) {
   if (!usage)
-    return `${AGENT_LABEL2[agent]} \u63A2\u6D4B\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u4FDD\u6301\u4E0A\u4E00\u8F6E\u9884\u7B97\u5E72\u9884`;
+    return `${AGENT_LABEL3[agent]} \u63A2\u6D4B\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u4FDD\u6301\u4E0A\u4E00\u8F6E\u9884\u7B97\u5E72\u9884`;
   if (usage.rateLimitedUntil > now) {
-    return `${AGENT_LABEL2[agent]} \u63A2\u9488\u88AB\u9650\u6D41\u81F3 ${formatEpoch2(usage.rateLimitedUntil)}`;
+    return `${AGENT_LABEL3[agent]} \u63A2\u9488\u88AB\u9650\u6D41\u81F3 ${formatEpoch2(usage.rateLimitedUntil)}`;
   }
-  if (usage.gateUtil >= cfg.pauseAt) {
-    return `${AGENT_LABEL2[agent]} gateUtil ${pct2(usage.gateUtil)} \u2265 pauseAt ${pct2(cfg.pauseAt)}`;
-  }
-  return `${AGENT_LABEL2[agent]} gateUtil ${pct2(usage.gateUtil)} \u5C1A\u672A\u4F4E\u4E8E resumeBelow ${pct2(cfg.resumeBelow)}`;
+  const decision = agentShouldPause(agent, usage, cfg, now);
+  if (decision.pause)
+    return decision.reason;
+  return `${AGENT_LABEL3[agent]} gateUtil ${pct3(usage.gateUtil)} \u5C1A\u672A\u6EE1\u8DB3\u51FA\u95F8\u6761\u4EF6`;
 }
 function interventionReason(side, state, cfg) {
   return sideToAgents(side).map((agent) => activeSideReason(agent, state.perAgent[agent], cfg, state.now)).join("\uFF1B");
 }
 function resumeAfterEpoch2(side, state, cfg) {
-  const epochs = sideToAgents(side).map((agent) => resumeBlockingEpoch(state.perAgent[agent], cfg, state.now)).filter((epoch) => epoch > 0);
+  const epochs = sideToAgents(side).map((agent) => resumeBlockingEpochFor(state.perAgent[agent], cfg, state.now)).filter((epoch) => epoch > 0);
   if (epochs.length === 0)
     return null;
   return Math.max(...epochs);
@@ -3999,6 +4366,7 @@ function directiveFingerprint(state, activeSide) {
 function classifyPoll(prev, state, cfg) {
   const previousSide = prev.side;
   const currentSide = nextActiveSide(previousSide, state, cfg);
+  const recoveredSides = removedAgents(previousSide, currentSide);
   if (currentSide) {
     const reason = interventionReason(currentSide, state, cfg);
     const nextResumeRaw = resumeAfterEpoch2(currentSide, state, cfg);
@@ -4015,33 +4383,67 @@ function classifyPoll(prev, state, cfg) {
         reason,
         resumeEpoch,
         emit,
-        pauseChanged
+        pauseChanged,
+        recoveredSides
       }
     };
   }
   if (previousSide) {
     return {
       next: { side: null, fingerprint: null, resumeEpoch: null, reason: null },
-      effect: { kind: "exit", previousSide }
+      effect: { kind: "exit", previousSide, recoveredSides }
     };
   }
   if (!isDecisionGrade(state.perAgent.claude, state.now) || !isDecisionGrade(state.perAgent.codex, state.now)) {
-    return { next: prev, effect: { kind: "none" } };
+    return { next: prev, effect: { kind: "none", recoveredSides: [] } };
   }
   if (!state.directiveToClaude) {
     return {
       next: { side: null, fingerprint: null, resumeEpoch: null, reason: null },
-      effect: { kind: "none" }
+      effect: { kind: "none", recoveredSides: [] }
     };
   }
   const fingerprint = directiveFingerprint(state);
   if (fingerprint !== prev.fingerprint) {
     return {
       next: { side: null, fingerprint, resumeEpoch: null, reason: null },
-      effect: { kind: "advise", phase: state.phase }
+      effect: { kind: "advise", phase: state.phase, recoveredSides: [] }
+    };
+  }
+  return { next: prev, effect: { kind: "none", recoveredSides: [] } };
+}
+function resumeCandidateSides(effect) {
+  if (effect.recoveredSides.length > 0) {
+    return effect.recoveredSides;
+  }
+  switch (effect.kind) {
+    case "exit":
+      return sideToAgents(effect.previousSide);
+    case "enter":
+    case "hold-uncertain":
+      return sideToAgents(effect.side);
+    case "advise":
+    case "none":
+      return [];
+  }
+}
+function computeResumeCandidate(sides, state, cfg, signals) {
+  const candidate = {};
+  const detail = {};
+  for (const agent of sides) {
+    const windowRefreshed = agentCanResume(state.perAgent[agent], cfg, state.now);
+    const ready = windowRefreshed && signals.pendingExists[agent] && signals.tuiReady[agent] && signals.checkpointExists;
+    candidate[agent] = ready;
+    const pending = signals.pending?.[agent];
+    detail[agent] = {
+      ready,
+      ...pending ? { pending } : {},
+      ...signals.checkpointPath ? { checkpointPath: signals.checkpointPath } : {}
     };
   }
-  return { next: prev, effect: { kind: "none" } };
+  if (sides.length > 0)
+    candidate.detail = detail;
+  return candidate;
 }
 
 // src/budget/burn-view.ts
@@ -4110,17 +4512,17 @@ var REAL_BUDGET_POLL_SCHEDULER = {
     clearTimeout(timer);
   }
 };
-var AGENT_LABEL3 = {
+var AGENT_LABEL4 = {
   claude: "Claude",
   codex: "Codex"
 };
-function pct3(value) {
+function pct4(value) {
   return `${Math.round(value * 10) / 10}%`;
 }
 function usageLine(agent, usage) {
   if (!usage)
-    return `${AGENT_LABEL3[agent]} \u672A\u77E5`;
-  return `${AGENT_LABEL3[agent]} gate=${pct3(usage.gateUtil)} warn=${pct3(usage.warnUtil)}`;
+    return `${AGENT_LABEL4[agent]} \u672A\u77E5`;
+  return `${AGENT_LABEL4[agent]} gate=${pct4(usage.gateUtil)} warn=${pct4(usage.warnUtil)}`;
 }
 function maxPollDelayMs(config) {
   return Math.max(0, config.pollSeconds * 1000);
@@ -4181,9 +4583,13 @@ class BudgetCoordinator {
   now;
   scheduler;
   log;
+  onResume;
+  resumeSignals;
+  adviceCooldown;
   timer = null;
   running = false;
   fpState = INITIAL_FINGERPRINT_STATE;
+  resumeCandidate = {};
   latestSnapshot = null;
   pendingOverrideTier = null;
   pendingOverrides = null;
@@ -4199,6 +4605,13 @@ class BudgetCoordinator {
     this.now = options.now ?? (() => Math.floor(Date.now() / 1000));
     this.scheduler = options.scheduler ?? REAL_BUDGET_POLL_SCHEDULER;
     this.log = options.log ?? (() => {});
+    this.onResume = options.onResume ?? (() => {});
+    this.resumeSignals = options.resumeSignals ?? null;
+    this.adviceCooldown = options.adviceCooldown ?? new AdviceCooldown({
+      homeDir: homedir2(),
+      cooldownSec: resolveAdviceCooldownSec(),
+      log: this.log
+    });
   }
   async start() {
     if (this.running || !this.config.enabled)
@@ -4224,6 +4637,19 @@ class BudgetCoordinator {
   getSnapshot() {
     return this.latestSnapshot;
   }
+  getResumeCandidate() {
+    const { detail, ...rest } = this.resumeCandidate;
+    return detail ? {
+      ...rest,
+      detail: Object.fromEntries(Object.entries(detail).map(([side, value]) => [
+        side,
+        {
+          ...value,
+          ...value.pending ? { pending: { ...value.pending } } : {}
+        }
+      ]))
+    } : { ...rest };
+  }
   getCodexTurnOverrides() {
     if (!this.tierControlEnabled())
       return null;
@@ -4279,10 +4705,15 @@ class BudgetCoordinator {
     if (!this.running) {
       return;
     }
-    const state = computeBudgetState(usage.claude, usage.codex, this.config, this.now());
+    const now = this.now();
+    const runway = {
+      claude: agentRunway(usage.claude, now),
+      codex: agentRunway(usage.codex, now)
+    };
+    const state = computeBudgetState(usage.claude, usage.codex, this.config, now, runway);
     this.updatePendingOverrides(state.effort.codexTier);
     this.applyState(state);
-    this.setSnapshot(this.toSnapshot(state));
+    this.setSnapshot(this.toSnapshot(state, runway));
   }
   setSnapshot(snapshot) {
     this.latestSnapshot = snapshot;
@@ -4291,6 +4722,11 @@ class BudgetCoordinator {
   applyState(state) {
     const { next, effect } = classifyPoll(this.fpState, state, this.config);
     this.fpState = next;
+    this.resumeCandidate = this.resumeSignals ? computeResumeCandidate(resumeCandidateSides(effect), state, this.config, this.resumeSignals()) : {};
+    for (const side of effect.recoveredSides) {
+      const { id, directive } = this.emitRecovery(side, state);
+      this.onResume(side, directive, id);
+    }
     switch (effect.kind) {
       case "enter":
       case "hold-uncertain": {
@@ -4303,12 +4739,16 @@ class BudgetCoordinator {
       }
       case "exit": {
         this.onPauseChange(false);
-        this.emitDirective(this.recoveryPrefix(effect.previousSide), this.recoveryDirective(state, effect.previousSide));
         return;
       }
       case "advise": {
-        const prefix = effect.phase === "balance" ? "system_budget_balance" : "system_budget_parallel";
-        this.emitDirective(prefix, state.directiveToClaude);
+        if (effect.phase === "underutilized") {
+          if (!this.adviceCooldown.tryAcquire("underutilization", state.now))
+            return;
+          this.emitDirective("system_budget_underutilized", state.directiveToClaude);
+          return;
+        }
+        this.emitDirective("system_budget_balance", state.directiveToClaude);
         return;
       }
       case "none":
@@ -4349,45 +4789,44 @@ class BudgetCoordinator {
     this.pendingOverrides = { ...overrides };
   }
   emitDirective(prefix, content) {
-    this.emit(`${prefix}_${this.sequence++}`, content);
+    const id = `${prefix}_${this.sequence++}`;
+    this.emit(id, content);
+    return id;
   }
   interventionPrefix(side) {
     return side === "claude" ? "system_budget_handoff" : "system_budget_pause";
   }
-  recoveryPrefix(previousSide) {
-    return previousSide === "claude" ? "system_budget_claude_recovered" : "system_budget_resume";
+  recoveryPrefix(side) {
+    return side === "claude" ? "system_budget_claude_recovered" : "system_budget_resume";
+  }
+  emitRecovery(side, state) {
+    const directive = this.recoveryDirective(state, side);
+    const id = this.emitDirective(this.recoveryPrefix(side), directive);
+    return { id, directive };
   }
   interventionDirective(state, side, reason, resumeEpoch) {
     return renderBudgetInterventionDirective(state.perAgent.claude, state.perAgent.codex, side, reason || "\u9884\u7B97\u63A5\u8FD1\u8017\u5C3D", resumeEpoch, this.config);
   }
-  recoveryDirective(state, previousSide) {
-    if (previousSide === "claude") {
+  recoveryDirective(state, side) {
+    const recoveredText = `\u5404\u7A97\u53E3 util \u5DF2\u56DE\u843D\u81F3\u52A8\u6001\u6682\u505C\u7EBF \u2212 ${pct4(this.config.maximize.resumeHysteresisPct)} \u4EE5\u4E0B\u6216\u5BF9\u5E94\u7A97\u53E3\u5DF2\u5237\u65B0`;
+    if (side === "claude") {
       return [
         "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011Claude \u4FA7\u9884\u7B97\u5DF2\u6062\u590D\u3002",
         `${usageLine("claude", state.perAgent.claude)}\uFF1B${usageLine("codex", state.perAgent.codex)}\u3002`,
-        `Claude gateUtil \u5DF2\u4F4E\u4E8E ${pct3(this.config.resumeBelow)}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\u3002`,
+        `Claude ${recoveredText}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\u3002`,
         "Claude \u53EF\u6062\u590D orchestrator \u89D2\u8272\uFF1B\u540E\u7EED\u5206\u914D\u524D\u8BF7\u91CD\u65B0\u67E5\u8BE2\u5B9E\u65F6\u989D\u5EA6\uFF0C\u4E0D\u8981\u4F9D\u8D56\u65E7\u6570\u5B57\u3002"
       ].join(`
-`);
-    }
-    if (previousSide === "codex") {
-      return [
-        "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011Codex \u4FA7\u9884\u7B97\u95F8\u95E8\u89E3\u9664\u3002",
-        `${usageLine("claude", state.perAgent.claude)}\uFF1B${usageLine("codex", state.perAgent.codex)}\u3002`,
-        `\u95F8\u95E8\u5DF2\u653E\u5F00\uFF1ACodex gateUtil \u4F4E\u4E8E ${pct3(this.config.resumeBelow)}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\u3002`,
-        "\u5EFA\u8BAE Claude \u7528 reply \u5E26\u4E0A\u5F53\u524D\u76EE\u6807\u3001checkpoint \u548C\u4E0B\u4E00\u6B65\uFF0C\u5524\u9192 Codex \u63A5\u7EED\u6267\u884C\u3002"
-      ].join(`
 `);
     }
     return [
-      "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011\u8054\u5408\u6682\u505C\u89E3\u9664\u3002",
+      "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011Codex \u4FA7\u9884\u7B97\u95F8\u95E8\u89E3\u9664\u3002",
       `${usageLine("claude", state.perAgent.claude)}\uFF1B${usageLine("codex", state.perAgent.codex)}\u3002`,
-      `\u95F8\u95E8\u5DF2\u653E\u5F00\uFF1A\u53CC\u65B9 gateUtil \u5747\u4F4E\u4E8E ${pct3(this.config.resumeBelow)}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\u3002`,
+      `\u95F8\u95E8\u5DF2\u653E\u5F00\uFF1ACodex ${recoveredText}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\u3002`,
       "\u5EFA\u8BAE Claude \u7528 reply \u5E26\u4E0A\u5F53\u524D\u76EE\u6807\u3001checkpoint \u548C\u4E0B\u4E00\u6B65\uFF0C\u5524\u9192 Codex \u63A5\u7EED\u6267\u884C\u3002"
     ].join(`
 `);
   }
-  toSnapshot(state) {
+  toSnapshot(state, runway) {
     const paused = this.isPaused();
     return {
       phase: paused ? "paused" : state.phase,
@@ -4403,18 +4842,23 @@ class BudgetCoordinator {
       parallelRecommended: paused ? false : state.parallel.recommended,
       codexTier: state.effort.codexTier,
       claudeAdvice: state.effort.claudeAdvice,
-      ...this.burnRateSnapshotFields(state)
+      ...this.burnRateSnapshotFields(state, runway),
+      ...this.dynamicLineSnapshotFields(state)
+    };
+  }
+  dynamicLineSnapshotFields(state) {
+    return {
+      dynamicPauseLine: {
+        claude: effectiveDynamicLine(state.perAgent.claude, this.config, state.now),
+        codex: effectiveDynamicLine(state.perAgent.codex, this.config, state.now)
+      }
     };
   }
-  burnRateSnapshotFields(state) {
+  burnRateSnapshotFields(state, runway) {
     const rates = {
       claude: agentBurnRates(state.perAgent.claude),
       codex: agentBurnRates(state.perAgent.codex)
     };
-    const runway = {
-      claude: agentRunway(state.perAgent.claude, state.now),
-      codex: agentRunway(state.perAgent.codex, state.now)
-    };
     if (!hasAnyBurnSignal(rates, runway))
       return {};
     return { burnRate: rates, runway };
@@ -4424,8 +4868,8 @@ class BudgetCoordinator {
 // src/budget/quota-source.ts
 import { execFile } from "child_process";
 import { existsSync as existsSync5 } from "fs";
-import { homedir as homedir2 } from "os";
-import { basename, join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+import { basename, join as join6 } from "path";
 function parseBurnFields(record) {
   const group = {};
   let any = false;
@@ -4515,7 +4959,7 @@ function asFiniteNumber(value) {
 function numberOr(value, fallback) {
   return asFiniteNumber(value) ?? fallback;
 }
-function clamp(value, min, max) {
+function clamp2(value, min, max) {
   return Math.min(max, Math.max(min, value));
 }
 function asRecord(value) {
@@ -4536,7 +4980,7 @@ function normalizeBucket(value, fetchedAt) {
   }
   return {
     id,
-    util: clamp(util, 0, 100),
+    util: clamp2(util, 0, 100),
     resetEpoch: Math.max(0, resetEpoch),
     resetAfterSeconds: resetAfter === null ? null : Math.max(0, resetAfter),
     burn: parseBurnFields(bucket)
@@ -4550,7 +4994,7 @@ function normalizeTopLevelBucket(record, util, fetchedAt) {
   }
   return {
     id: "top_level",
-    util: clamp(util, 0, 100),
+    util: clamp2(util, 0, 100),
     resetEpoch: Math.max(0, resetEpoch),
     resetAfterSeconds: resetAfter === null ? null : Math.max(0, resetAfter),
     burn: parseBurnFields(record)
@@ -4617,8 +5061,8 @@ function identifyWindows(buckets) {
 function normalizeTolerantProbeRecord(record) {
   const fetchedAt = numberOr(record.fetched_at ?? record.fetchedAt ?? record.now_epoch ?? record.nowEpoch, 0);
   const hasFiniteUtil = asFiniteNumber(record.util ?? record.hard_util ?? record.hardUtil) !== null || asFiniteNumber(record.warn_util ?? record.warnUtil) !== null;
-  const gateUtil = clamp(numberOr(record.util ?? record.hard_util ?? record.hardUtil, 0), 0, 100);
-  const warnUtil = clamp(numberOr(record.warn_util ?? record.warnUtil, gateUtil), 0, 100);
+  const gateUtil = clamp2(numberOr(record.util ?? record.hard_util ?? record.hardUtil, 0), 0, 100);
+  const warnUtil = clamp2(numberOr(record.warn_util ?? record.warnUtil, gateUtil), 0, 100);
   const rawBuckets = Array.isArray(record.buckets) ? record.buckets : [];
   const buckets = rawBuckets.map((bucket) => normalizeBucket(bucket, fetchedAt)).filter((bucket) => bucket !== null);
   let parsedVia = "id-match";
@@ -4645,7 +5089,7 @@ function normalizeTolerantProbeRecord(record) {
     warnUtil,
     fiveHour,
     weekly,
-    remaining: clamp(100 - gateUtil, 0, 100),
+    remaining: clamp2(100 - gateUtil, 0, 100),
     rateLimitedUntil,
     fetchedAt,
     parsedVia
@@ -4693,7 +5137,11 @@ function isDegradedUsage(usage, now = Math.floor(Date.now() / 1000)) {
   if (usage.stale || !usage.ok)
     return true;
   const hasFreshWindow = usage.fiveHour !== null && usage.fiveHour.resetEpoch > now || usage.weekly !== null && usage.weekly.resetEpoch > now;
-  return !hasFreshWindow;
+  if (!hasFreshWindow)
+    return true;
+  if (usage.fetchedAt > 0 && now - usage.fetchedAt > STALE_MAX_AGE_SEC)
+    return true;
+  return false;
 }
 
 class QuotaSource {
@@ -4708,7 +5156,7 @@ class QuotaSource {
   unknownSchemaVersionsLogged = new Set;
   constructor(options = {}) {
     this.env = options.env ?? process.env;
-    this.homeDir = options.homeDir ?? homedir2();
+    this.homeDir = options.homeDir ?? homedir3();
     this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     this.runner = options.runner ?? defaultRunner;
     this.log = options.log ?? (() => {});
@@ -4740,11 +5188,11 @@ class QuotaSource {
       add(command, commandKind(command));
       return candidates;
     }
-    const binDir = join5(this.homeDir, ".budget-guard/bin");
-    const installedProbeMjs = join5(binDir, "probe.mjs");
+    const binDir = join6(this.homeDir, ".budget-guard/bin");
+    const installedProbeMjs = join6(binDir, "probe.mjs");
     if (existsSync5(installedProbeMjs))
       add(installedProbeMjs, "probe-mjs");
-    const installedBudgetProbe = join5(binDir, "budget-probe");
+    const installedBudgetProbe = join6(binDir, "budget-probe");
     if (existsSync5(installedBudgetProbe))
       add(installedBudgetProbe, "budget-probe");
     return candidates;
@@ -4807,9 +5255,603 @@ function createQuotaSource(options) {
   return new QuotaSource(options);
 }
 
+// src/budget/pending-reader.ts
+import { createHash } from "crypto";
+import { join as join7 } from "path";
+function nodeFs() {
+  return __require("fs");
+}
+function cwdMatches(entryCwd, optsCwd) {
+  if (entryCwd === optsCwd)
+    return true;
+  try {
+    const fs2 = nodeFs();
+    return fs2.realpathSync(entryCwd) === fs2.realpathSync(optsCwd);
+  } catch {
+    return false;
+  }
+}
+function parsePendingPayload(value) {
+  const record = asRecord(value);
+  if (!record)
+    return null;
+  const sessionId = record.session_id;
+  if (typeof sessionId !== "string" || sessionId === "")
+    return null;
+  const util = asFiniteNumber(record.util);
+  if (util === null)
+    return null;
+  const warnUtil = numberOr(record.warn_util, util);
+  const resetEpoch = numberOr(record.reset_epoch ?? record.reset, 0);
+  const at = numberOr(record.at, 0);
+  const cwd = typeof record.cwd === "string" ? record.cwd : "";
+  const status = typeof record.status === "string" ? record.status : "";
+  const agent = record.agent === "claude" || record.agent === "codex" ? record.agent : null;
+  if (agent === null)
+    return null;
+  return { status, agent, sessionId, cwd, resetEpoch, util, warnUtil, at, sourcePath: "", contentHash: "" };
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function resolveStateDir2(homeDir) {
+  const override = process.env.BUDGET_STATE_DIR;
+  if (override && override.trim() !== "")
+    return override.trim();
+  return join7(homeDir, ".budget-guard");
+}
+function readPendingFile(path, log) {
+  let raw;
+  try {
+    raw = nodeFs().readFileSync(path, "utf-8");
+  } catch (error) {
+    log(`pending reader: skip unreadable ${path}: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+  const text = String(raw).trim();
+  if (text === "")
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    log(`pending reader: skip malformed JSON ${path}`);
+    return null;
+  }
+  const entry = parsePendingPayload(parsed);
+  if (!entry)
+    return null;
+  return { ...entry, sourcePath: path, contentHash: sha256(text) };
+}
+function listScopeFiles(stateDir, agent, log) {
+  const pendingDir = join7(stateDir, "pending");
+  let names;
+  try {
+    names = nodeFs().readdirSync(pendingDir);
+  } catch {
+    return [];
+  }
+  const prefix = `${agent}_`;
+  return names.filter((name) => name.startsWith(prefix) && name.endsWith(".json")).map((name) => join7(pendingDir, name));
+}
+function readGuardPending(opts) {
+  const log = opts.log ?? (() => {});
+  const stateDir = resolveStateDir2(opts.homeDir);
+  const paths = [
+    ...listScopeFiles(stateDir, opts.agent, log),
+    join7(stateDir, `pending_${opts.agent}.json`)
+  ];
+  const bySession = new Map;
+  for (const path of paths) {
+    const entry = readPendingFile(path, log);
+    if (!entry)
+      continue;
+    if (entry.agent !== opts.agent)
+      continue;
+    if (entry.status !== "paused")
+      continue;
+    if (opts.cwd !== undefined && !cwdMatches(entry.cwd, opts.cwd))
+      continue;
+    if (!bySession.has(entry.sessionId)) {
+      bySession.set(entry.sessionId, entry);
+    }
+  }
+  return [...bySession.values()];
+}
+
+// src/budget/resume-injection-queue.ts
+import { createHash as createHash2 } from "crypto";
+import { closeSync as closeSync3, existsSync as existsSync6, mkdirSync as mkdirSync5, openSync as openSync3, readdirSync, readFileSync as readFileSync6, realpathSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join8 } from "path";
+
+// src/budget/resume-prompt.ts
+var RESUME_PROMPT = "\u989D\u5EA6\u7A97\u53E3\u5DF2\u5237\u65B0\uFF0C\u7EE7\u7EED\u4E0A\u6B21\u672A\u5B8C\u6210\u7684\u4EFB\u52A1\uFF1A\u4ECE .agent/checkpoint.md \u7684\u300C\u4E0B\u4E00\u6B65\u300D\u63A5\u7740\u505A\uFF1B\u5B8C\u6210\u540E\u505C\u4E0B\u5E76\u6807 DONE\u3002";
+function claudeResumePrompt(resumeId) {
+  return "\u989D\u5EA6\u7A97\u53E3\u5DF2\u5237\u65B0\u3002" + `\u8BF7\u5148\u8C03\u7528 ack_resume(resume_id="${resumeId}", status="resumed") \u786E\u8BA4\u5DF2\u6536\u5230\u672C\u901A\u77E5\uFF08ACK = \u5DF2\u63A5\u6536\uFF0C\u4E0D\u662F\u5B8C\u6210\uFF0C\u8BF7\u7ACB\u5373\u8C03\u7528\uFF0C\u4E0D\u8981\u7B49\u4EFB\u52A1\u505A\u5B8C\uFF09\uFF0C` + "\u518D\u4ECE .agent/checkpoint.md \u7684\u300C\u4E0B\u4E00\u6B65\u300D\u63A5\u7740\u505A\uFF1B\u5B8C\u6210\u540E\u505C\u4E0B\u5E76\u6807 DONE\u3002";
+}
+
+// src/budget/resume-injection-queue.ts
+var DEFAULT_RETRY_MS = 5000;
+var DEFAULT_CONFIRM_TIMEOUT_MS = 60000;
+var DEFAULT_MAX_ATTEMPTS = 5;
+var DEFAULT_STALE_CLAIM_TTL_SEC = 300;
+var DEFAULT_CONSUMED_TTL_SEC = 7 * 24 * 3600;
+function finitePositive(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+
+class ResumeInjectionQueue {
+  inject;
+  scheduler;
+  retryMs;
+  confirmTimeoutMs;
+  maxAttempts;
+  log;
+  onInjectionAccepted;
+  onInjectionSuperseded;
+  onConfirmed;
+  onAbandoned;
+  entries = new Map;
+  resetSweepDepth = 0;
+  constructor(options) {
+    this.inject = options.inject;
+    this.scheduler = options.scheduler ?? globalThis;
+    this.retryMs = finitePositive(options.retryMs, DEFAULT_RETRY_MS);
+    this.confirmTimeoutMs = finitePositive(options.confirmTimeoutMs, DEFAULT_CONFIRM_TIMEOUT_MS);
+    this.maxAttempts = finitePositive(options.maxAttempts, DEFAULT_MAX_ATTEMPTS);
+    this.log = options.log ?? (() => {});
+    this.onInjectionAccepted = options.onInjectionAccepted ?? (() => {});
+    this.onInjectionSuperseded = options.onInjectionSuperseded ?? (() => {});
+    this.onConfirmed = options.onConfirmed ?? (() => {});
+    this.onAbandoned = options.onAbandoned ?? (() => {});
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get(resumeId) {
+    const entry = this.entries.get(resumeId);
+    if (!entry)
+      return;
+    const { retryTimer: _retryTimer, confirmTimer: _confirmTimer, claim: _claim, ...publicEntry } = entry;
+    return { ...publicEntry };
+  }
+  enqueue(input) {
+    if (this.entries.has(input.resumeId)) {
+      this.log(`resume injection deduped: ${input.resumeId}`);
+      try {
+        input.claim?.release();
+      } catch (error) {
+        this.log(`resume claim release failed (${input.resumeId} dedup): ${error instanceof Error ? error.message : String(error)}`);
+      }
+      return;
+    }
+    if (input.claim) {
+      const identity = input.claim.identity;
+      for (const existing of this.entries.values()) {
+        if (existing.claim && existing.claim.identity === identity) {
+          this.log(`resume injection identity-deduped: ${input.resumeId} ~ existing ${existing.resumeId} (identity ${identity})`);
+          existing.claim = input.claim;
+          return;
+        }
+      }
+    }
+    this.entries.set(input.resumeId, {
+      resumeId: input.resumeId,
+      prompt: input.prompt ?? RESUME_PROMPT,
+      state: "pending",
+      attempts: 0,
+      ...input.claim ? { claim: input.claim } : {}
+    });
+    this.tryInjectNext();
+  }
+  onTurnDrained() {
+    this.tryInjectNext();
+  }
+  stop() {
+    for (const entry of this.entries.values()) {
+      const requestId = entry.injectionId;
+      this.clearRetryTimer(entry);
+      this.clearConfirmTimer(entry);
+      if (requestId !== undefined) {
+        this.onInjectionSuperseded({ resumeId: entry.resumeId, requestId, reason: "stop" });
+      }
+      try {
+        entry.claim?.release();
+      } catch (error) {
+        this.log(`resume claim release failed (${entry.resumeId}): ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    this.entries.clear();
+  }
+  onTurnTrackingReset() {
+    this.resetSweepDepth++;
+    try {
+      for (const entry of [...this.entries.values()]) {
+        if (entry.state === "awaiting_confirm") {
+          this.supersedeAwaiting(entry, "turn_tracking_reset");
+          this.countRealAttemptOrAbandon(entry, "turn tracking reset before turn/start confirmation");
+        } else if (entry.state === "pending") {
+          this.clearRetryTimer(entry);
+          this.scheduleRetry(entry);
+        }
+      }
+    } finally {
+      this.resetSweepDepth--;
+    }
+  }
+  onBridgeTurnStarted(event) {
+    const entry = this.entries.get(event.resumeId);
+    if (!entry || entry.state !== "awaiting_confirm" || entry.injectionId !== event.requestId)
+      return;
+    this.clearConfirmTimer(entry);
+    try {
+      entry.claim?.consume();
+    } catch (error) {
+      this.log(`resume claim consume failed (${event.resumeId}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+    this.entries.delete(event.resumeId);
+    this.onConfirmed({ resumeId: event.resumeId, requestId: event.requestId, turnId: event.turnId });
+  }
+  onBridgeTurnRejected(event) {
+    const entry = this.entries.get(event.resumeId);
+    if (!entry || entry.state !== "awaiting_confirm" || entry.injectionId !== event.requestId)
+      return;
+    this.supersedeAwaiting(entry, "bridge_rejected");
+    this.countRealAttemptOrAbandon(entry, event.error);
+  }
+  tryInjectNext() {
+    if (this.resetSweepDepth > 0)
+      return;
+    for (const entry of this.entries.values()) {
+      if (entry.state === "awaiting_confirm")
+        return;
+    }
+    for (const entry of this.entries.values()) {
+      if (entry.state !== "pending")
+        continue;
+      this.clearRetryTimer(entry);
+      let requestId;
+      try {
+        requestId = this.inject(entry.prompt);
+      } catch (error) {
+        this.countRealAttemptOrAbandon(entry, error instanceof Error ? error.message : String(error));
+        return;
+      }
+      if (requestId === null) {
+        this.scheduleRetry(entry);
+        return;
+      }
+      entry.state = "awaiting_confirm";
+      entry.injectionId = requestId;
+      this.onInjectionAccepted({ resumeId: entry.resumeId, requestId });
+      this.scheduleConfirmTimeout(entry);
+      return;
+    }
+  }
+  countRealAttemptOrAbandon(entry, reason) {
+    entry.attempts += 1;
+    if (entry.attempts >= this.maxAttempts) {
+      this.abandon(entry, reason);
+      return;
+    }
+    this.scheduleRetry(entry);
+  }
+  abandon(entry, reason) {
+    this.clearRetryTimer(entry);
+    this.clearConfirmTimer(entry);
+    this.entries.delete(entry.resumeId);
+    try {
+      entry.claim?.release();
+    } catch (error) {
+      this.log(`resume claim release failed (${entry.resumeId}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+    this.onAbandoned({ resumeId: entry.resumeId, reason });
+    this.tryInjectNext();
+  }
+  supersedeAwaiting(entry, reason) {
+    this.clearConfirmTimer(entry);
+    const requestId = entry.injectionId;
+    delete entry.injectionId;
+    entry.state = "pending";
+    if (requestId !== undefined) {
+      this.onInjectionSuperseded({ resumeId: entry.resumeId, requestId, reason });
+    }
+  }
+  scheduleRetry(entry) {
+    if (!this.entries.has(entry.resumeId))
+      return;
+    this.clearRetryTimer(entry);
+    entry.retryTimer = this.scheduler.setTimeout(() => {
+      delete entry.retryTimer;
+      this.tryInjectNext();
+    }, this.retryMs);
+    entry.retryTimer?.unref?.();
+  }
+  scheduleConfirmTimeout(entry) {
+    this.clearConfirmTimer(entry);
+    entry.confirmTimer = this.scheduler.setTimeout(() => {
+      delete entry.confirmTimer;
+      if (entry.state !== "awaiting_confirm")
+        return;
+      this.supersedeAwaiting(entry, "confirm_timeout");
+      this.countRealAttemptOrAbandon(entry, "turn/start confirmation timed out");
+    }, this.confirmTimeoutMs);
+    entry.confirmTimer?.unref?.();
+  }
+  clearRetryTimer(entry) {
+    if (entry.retryTimer === undefined)
+      return;
+    this.scheduler.clearTimeout(entry.retryTimer);
+    delete entry.retryTimer;
+  }
+  clearConfirmTimer(entry) {
+    if (entry.confirmTimer === undefined)
+      return;
+    this.scheduler.clearTimeout(entry.confirmTimer);
+    delete entry.confirmTimer;
+  }
+}
+function realpathOrRaw(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function sha2562(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function writeJsonWx(path, value) {
+  let fd;
+  try {
+    fd = openSync3(path, "wx", 384);
+  } catch (error) {
+    if (error?.code === "EEXIST")
+      return false;
+    throw error;
+  }
+  try {
+    writeFileSync3(fd, JSON.stringify(value, null, 2));
+  } finally {
+    closeSync3(fd);
+  }
+  return true;
+}
+function unlinkIfExists(path) {
+  try {
+    unlinkSync4(path);
+  } catch (error) {
+    if (error?.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function readClaimedAt(path) {
+  try {
+    const parsed = JSON.parse(readFileSync6(path, "utf-8"));
+    const claimedAt = parsed?.claimed_at;
+    return typeof claimedAt === "number" && Number.isFinite(claimedAt) ? claimedAt : null;
+  } catch {
+    return null;
+  }
+}
+function pruneStaleResumeArtifacts(dir, tsField, ttlSec, nowSec, log) {
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json"))
+      continue;
+    const p = join8(dir, name);
+    try {
+      const parsed = JSON.parse(readFileSync6(p, "utf-8"));
+      const ts = parsed?.[tsField];
+      if (typeof ts === "number" && Number.isFinite(ts) && nowSec - ts > ttlSec) {
+        unlinkIfExists(p);
+      }
+    } catch (error) {
+      log?.(`resume artifact prune skipped ${p}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+function tryClaimPendingResume(opts) {
+  const now = opts.now ?? (() => Math.floor(Date.now() / 1000));
+  const claimTtlSec = finitePositive(opts.claimTtlSec, DEFAULT_STALE_CLAIM_TTL_SEC);
+  const consumedTtlSec = finitePositive(opts.consumedTtlSec, DEFAULT_CONSUMED_TTL_SEC);
+  const cwd = realpathOrRaw(opts.pending.cwd);
+  const sourcePath = opts.pending.sourcePath ?? "";
+  const contentHash = opts.pending.contentHash ?? "";
+  const identity = sha2562([
+    opts.agent,
+    opts.pending.sessionId,
+    cwd,
+    contentHash
+  ].join("\x00"));
+  const claimsDir = join8(opts.stateDir, "claims");
+  const consumedDir = join8(opts.stateDir, "consumed");
+  const claimPath = join8(claimsDir, `${identity}.json`);
+  const consumedPath = join8(consumedDir, `${identity}.json`);
+  mkdirSync5(claimsDir, { recursive: true });
+  mkdirSync5(consumedDir, { recursive: true });
+  const nowSec = now();
+  pruneStaleResumeArtifacts(consumedDir, "consumed_at", consumedTtlSec, nowSec, opts.log);
+  pruneStaleResumeArtifacts(claimsDir, "claimed_at", claimTtlSec, nowSec, opts.log);
+  if (existsSync6(consumedPath))
+    return { ok: false, reason: "consumed" };
+  if (existsSync6(claimPath)) {
+    const claimedAt = readClaimedAt(claimPath);
+    if (claimedAt !== null && nowSec - claimedAt > claimTtlSec) {
+      try {
+        unlinkIfExists(claimPath);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        opts.log?.(`stale resume claim cleanup failed: ${message}`);
+        return { ok: false, reason: "error", error: message };
+      }
+    } else {
+      return { ok: false, reason: "claimed" };
+    }
+  }
+  const payload = {
+    identity,
+    agent: opts.agent,
+    session_id: opts.pending.sessionId,
+    cwd,
+    pending_path: sourcePath,
+    pending_hash: contentHash,
+    checkpoint_path: opts.checkpointPath,
+    claimed_at: nowSec
+  };
+  try {
+    if (!writeJsonWx(claimPath, payload))
+      return { ok: false, reason: "claimed" };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    opts.log?.(`resume claim failed: ${message}`);
+    return { ok: false, reason: "error", error: message };
+  }
+  return {
+    ok: true,
+    claim: {
+      identity,
+      claimPath,
+      consumedPath,
+      consume: () => {
+        mkdirSync5(consumedDir, { recursive: true });
+        writeFileSync3(consumedPath, JSON.stringify({ ...payload, consumed_at: now() }, null, 2));
+        unlinkIfExists(claimPath);
+      },
+      release: () => {
+        unlinkIfExists(claimPath);
+      }
+    }
+  };
+}
+
+// src/budget/resume-ack-tracker.ts
+function finitePositive2(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+
+class ResumeAckTracker {
+  push;
+  scheduler;
+  timeoutMs;
+  retries;
+  onDegraded;
+  entries = new Map;
+  deliverySeq = 0;
+  constructor(options) {
+    this.push = options.push;
+    this.scheduler = options.scheduler;
+    this.timeoutMs = finitePositive2(options.timeoutMs, 60000);
+    this.retries = finitePositive2(options.retries, 3);
+    this.onDegraded = options.onDegraded ?? (() => {});
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get(resumeId) {
+    const entry = this.entries.get(resumeId);
+    if (!entry)
+      return;
+    const { timer: _timer, ...publicEntry } = entry;
+    return { ...publicEntry };
+  }
+  start(resumeId) {
+    if (this.entries.has(resumeId))
+      return;
+    const entry = { resumeId, attempts: 0, state: "awaiting_ack" };
+    this.entries.set(resumeId, entry);
+    this.pushAttempt(entry);
+    this.armTimer(entry);
+  }
+  ack(resumeId) {
+    const entry = this.entries.get(resumeId);
+    if (!entry)
+      return;
+    this.clearTimer(entry);
+    entry.state = "resumed";
+    this.entries.delete(resumeId);
+  }
+  stop() {
+    for (const entry of this.entries.values()) {
+      this.clearTimer(entry);
+    }
+    this.entries.clear();
+  }
+  pushAttempt(entry) {
+    const deliveryId = `${entry.resumeId}_retry${entry.attempts}_${++this.deliverySeq}`;
+    this.push({ resumeId: entry.resumeId, deliveryId, attempt: entry.attempts });
+  }
+  armTimer(entry) {
+    this.clearTimer(entry);
+    entry.timer = this.scheduler.setTimeout(() => {
+      delete entry.timer;
+      this.onTimeout(entry);
+    }, this.timeoutMs);
+    entry.timer?.unref?.();
+  }
+  onTimeout(entry) {
+    if (entry.state !== "awaiting_ack" || !this.entries.has(entry.resumeId))
+      return;
+    entry.attempts += 1;
+    if (entry.attempts >= this.retries) {
+      entry.state = "degraded";
+      this.entries.delete(entry.resumeId);
+      this.onDegraded(entry.resumeId);
+      return;
+    }
+    this.pushAttempt(entry);
+    this.armTimer(entry);
+  }
+  clearTimer(entry) {
+    if (entry.timer === undefined)
+      return;
+    this.scheduler.clearTimeout(entry.timer);
+    delete entry.timer;
+  }
+}
+
+// src/budget/route-resume.ts
+function routeResume(side, resumeId, deps) {
+  if (side === "codex") {
+    deps.enqueueCodex(resumeId);
+    return;
+  }
+  deps.claudeTracker.start(resumeId);
+}
+
+// src/budget/resume-ack-sentinel.ts
+import { renameSync as renameSync3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join9 } from "path";
+var RESUME_ACK_DEGRADED_SENTINEL = "resume-ack-degraded.json";
+function resumeAckSentinelPath(stateDir) {
+  return join9(stateDir, RESUME_ACK_DEGRADED_SENTINEL);
+}
+function writeResumeAckDegradedSentinel(opts) {
+  const now = opts.now ?? (() => Date.now());
+  const payload = {
+    resumeId: opts.resumeId,
+    degradedAt: now()
+  };
+  const target = resumeAckSentinelPath(opts.stateDir);
+  const tmp = `${target}.${process.pid}.tmp`;
+  try {
+    writeFileSync4(tmp, JSON.stringify(payload, null, 2), { mode: 384 });
+    renameSync3(tmp, target);
+    opts.log?.(`Resume-ack degraded sentinel written: ${opts.resumeId}`);
+  } catch (err) {
+    opts.log?.(`Resume-ack degraded sentinel write failed (${opts.resumeId}): ${err?.message ?? err}`);
+  }
+}
+
 // src/daemon-identity-ownership.ts
-import { readFileSync as readFileSync5 } from "fs";
-var defaultRead2 = (path) => readFileSync5(path, "utf-8");
+import { readFileSync as readFileSync7 } from "fs";
+var defaultRead2 = (path) => readFileSync7(path, "utf-8");
 function pidFileOwnedByUs(pidFilePath, ourPid, read = defaultRead2) {
   let raw;
   try {
@@ -4977,12 +6019,12 @@ class ReplyRequiredTracker {
 
 // src/thread-state.ts
 import {
-  existsSync as existsSync6,
-  readdirSync,
-  readFileSync as readFileSync6
+  existsSync as existsSync7,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync8
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { basename as basename2, join as join6 } from "path";
+import { homedir as homedir4 } from "os";
+import { basename as basename2, join as join10 } from "path";
 function nowIso() {
   return new Date().toISOString();
 }
@@ -4991,11 +6033,11 @@ function threadTag(identity) {
   return `abg:${name}:${identity.cwd}`;
 }
 function codexHome(env = process.env) {
-  return env.CODEX_HOME && env.CODEX_HOME.length > 0 ? env.CODEX_HOME : join6(homedir3(), ".codex");
+  return env.CODEX_HOME && env.CODEX_HOME.length > 0 ? env.CODEX_HOME : join10(homedir4(), ".codex");
 }
 function readRawCurrentThread(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync6(stateDir.currentThreadFile, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(stateDir.currentThreadFile, "utf-8"));
     if (parsed?.version === 1 && typeof parsed.threadId === "string" && parsed.threadId.length > 0 && (parsed.status === "pending" || parsed.status === "current") && typeof parsed.cwd === "string") {
       return parsed;
     }
@@ -5003,8 +6045,8 @@ function readRawCurrentThread(stateDir) {
   return null;
 }
 function findCodexRolloutFile(threadId, env = process.env, maxEntries = 20000) {
-  const sessionsDir = join6(codexHome(env), "sessions");
-  if (!threadId || !existsSync6(sessionsDir))
+  const sessionsDir = join10(codexHome(env), "sessions");
+  if (!threadId || !existsSync7(sessionsDir))
     return null;
   const exactName = `rollout-${threadId}.jsonl`;
   const stack = [sessionsDir];
@@ -5013,13 +6055,13 @@ function findCodexRolloutFile(threadId, env = process.env, maxEntries = 20000) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true });
+      entries = readdirSync2(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       visited++;
-      const path = join6(dir, entry.name);
+      const path = join10(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(path);
         continue;
@@ -5208,6 +6250,11 @@ var BOOTSTRAP_TIMEOUT_MS = parsePositiveIntEnv("AGENTBRIDGE_BOOTSTRAP_TIMEOUT_MS
 var CODEX_BOOT_RETRIES = parsePositiveIntEnv("AGENTBRIDGE_CODEX_BOOT_RETRIES", 2);
 var ALLOW_IDENTITYLESS_CLIENT = process.env.AGENTBRIDGE_COMPAT_IDENTITYLESS === "1";
 var BUDGET_CONFIG = applyBudgetEnvOverrides(config.budget);
+var RESUME_INJECT_RETRY_MS = parsePositiveIntEnv("AGENTBRIDGE_RESUME_INJECT_RETRY_MS", 5000, log);
+var RESUME_CONFIRM_TIMEOUT_MS = parsePositiveIntEnv("AGENTBRIDGE_RESUME_CONFIRM_TIMEOUT_MS", 60000, log);
+var RESUME_INJECT_MAX_ATTEMPTS = parsePositiveIntEnv("AGENTBRIDGE_RESUME_INJECT_MAX_ATTEMPTS", 5, log);
+var RESUME_ACK_TIMEOUT_MS = parsePositiveIntEnv("AGENTBRIDGE_RESUME_ACK_TIMEOUT_MS", 60000, log);
+var RESUME_ACK_RETRIES = parsePositiveIntEnv("AGENTBRIDGE_RESUME_ACK_RETRIES", 3, log);
 var daemonLifecycle = new DaemonLifecycle({ stateDir, controlPort: CONTROL_PORT, log });
 var DAEMON_NONCE = randomUUID4();
 var DAEMON_STARTED_AT = Date.now();
@@ -5225,6 +6272,52 @@ var inAttentionWindow = false;
 var replyTracker = new ReplyRequiredTracker;
 var idempotencyTracker = new IdempotencyTracker;
 var pendingTurnStarts = new Map;
+var pendingResumeTurnStarts = new Map;
+var resumeInjectionQueue = new ResumeInjectionQueue({
+  inject: (prompt) => codex.injectMessage(prompt),
+  retryMs: RESUME_INJECT_RETRY_MS,
+  confirmTimeoutMs: RESUME_CONFIRM_TIMEOUT_MS,
+  maxAttempts: RESUME_INJECT_MAX_ATTEMPTS,
+  log,
+  onInjectionAccepted: ({ resumeId, requestId }) => {
+    pendingResumeTurnStarts.set(requestId, { resumeId });
+    log(`Budget resume injection accepted: ${resumeId} \u2192 request ${requestId}`);
+  },
+  onInjectionSuperseded: ({ resumeId, requestId, reason }) => {
+    pendingResumeTurnStarts.delete(requestId);
+    log(`Budget resume injection superseded: ${resumeId} request ${requestId} (${reason})`);
+  },
+  onConfirmed: ({ resumeId, requestId, turnId }) => {
+    log(`Budget resume injection confirmed: ${resumeId} request ${requestId} \u2192 turn ${turnId}`);
+  },
+  onAbandoned: ({ resumeId, reason }) => {
+    log(`Budget resume injection abandoned: ${resumeId}: ${reason}`);
+  }
+});
+var claudeResumeTracker = new ResumeAckTracker({
+  push: ({ resumeId, deliveryId, attempt }) => {
+    const message = {
+      id: `system_budget_resume_${SYSTEM_MSG_SALT}_${deliveryId}`,
+      source: "codex",
+      content: claudeResumePrompt(resumeId),
+      timestamp: Date.now(),
+      resumeId
+    };
+    log(`Budget resume push to Claude: ${resumeId} (attempt ${attempt}, delivery ${deliveryId})`);
+    emitToClaude(message);
+  },
+  scheduler: globalThis,
+  timeoutMs: RESUME_ACK_TIMEOUT_MS,
+  retries: RESUME_ACK_RETRIES,
+  onDegraded: (resumeId) => {
+    log(`Budget resume ${resumeId} degraded: no ack from Claude after ${RESUME_ACK_RETRIES} attempts`);
+    try {
+      writeResumeAckDegradedSentinel({ stateDir: stateDir.dir, resumeId, log });
+    } catch (err) {
+      log(`Resume degraded sentinel write failed (${resumeId}): ${err?.message ?? err}`);
+    }
+  }
+});
 var pendingSteerDispatches = new Map;
 var BUSY_RETRY_ADVISORY_MS = 15000;
 var shuttingDown = false;
@@ -5250,11 +6343,105 @@ function createPendingBackpressureBuffer() {
   });
 }
 var budgetCoordinator = null;
+function pairCwd() {
+  const raw = process.cwd();
+  try {
+    return realpathSync2(raw);
+  } catch {
+    return raw;
+  }
+}
+function budgetGuardStateDir() {
+  const override = process.env.BUDGET_STATE_DIR;
+  if (override && override.trim() !== "")
+    return override.trim();
+  return join11(homedir5(), ".budget-guard");
+}
+function resumeClaimTtlSec() {
+  const totalMs = RESUME_CONFIRM_TIMEOUT_MS * RESUME_INJECT_MAX_ATTEMPTS + RESUME_INJECT_RETRY_MS * Math.max(0, RESUME_INJECT_MAX_ATTEMPTS - 1);
+  return Math.max(1, Math.ceil(totalMs / 1000));
+}
+function readResumeSignals() {
+  let tuiReadyCodex = false;
+  let tuiReadyClaude = false;
+  try {
+    tuiReadyCodex = tuiConnectionState.canReply();
+  } catch (error) {
+    log(`resume signal: codex tuiReady failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  try {
+    tuiReadyClaude = attachedClaude !== null;
+  } catch (error) {
+    log(`resume signal: claude tuiReady failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let pendingCodex = false;
+  let pendingClaude = false;
+  let pendingCodexEntry;
+  let pendingClaudeEntry;
+  try {
+    const home = homedir5();
+    const cwd = pairCwd();
+    pendingCodexEntry = readGuardPending({ homeDir: home, agent: "codex", cwd, log })[0];
+    pendingClaudeEntry = readGuardPending({ homeDir: home, agent: "claude", cwd, log })[0];
+    pendingCodex = pendingCodexEntry !== undefined;
+    pendingClaude = pendingClaudeEntry !== undefined;
+  } catch (error) {
+    log(`resume signal: pending read failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let checkpointExists = false;
+  let checkpointPath;
+  try {
+    checkpointPath = join11(pairCwd(), ".agent", "checkpoint.md");
+    checkpointExists = existsSync8(checkpointPath);
+  } catch (error) {
+    log(`resume signal: checkpoint stat failed: ${error instanceof Error ? error.message : String(error)}`);
+    checkpointPath = undefined;
+  }
+  return {
+    tuiReady: { codex: tuiReadyCodex, claude: tuiReadyClaude },
+    pendingExists: { codex: pendingCodex, claude: pendingClaude },
+    pending: {
+      ...pendingCodexEntry ? { codex: pendingCodexEntry } : {},
+      ...pendingClaudeEntry ? { claude: pendingClaudeEntry } : {}
+    },
+    checkpointExists,
+    ...checkpointPath ? { checkpointPath } : {}
+  };
+}
+function enqueueCodexBudgetResume(resumeId) {
+  const candidate = budgetCoordinator?.getResumeCandidate();
+  const detail = candidate?.detail?.codex;
+  if (candidate?.codex !== true || detail?.ready !== true) {
+    log(`Budget resume ${resumeId} ignored: Codex resume candidate is not ready`);
+    return;
+  }
+  if (!detail.pending) {
+    log(`Budget resume ${resumeId} ignored: missing Codex guard pending entry`);
+    return;
+  }
+  if (!detail.checkpointPath) {
+    log(`Budget resume ${resumeId} ignored: missing checkpoint path`);
+    return;
+  }
+  const claim = tryClaimPendingResume({
+    stateDir: budgetGuardStateDir(),
+    agent: "codex",
+    pending: detail.pending,
+    checkpointPath: detail.checkpointPath,
+    claimTtlSec: resumeClaimTtlSec(),
+    log
+  });
+  if (!claim.ok) {
+    log(`Budget resume ${resumeId} not enqueued: pending claim ${claim.reason}${claim.error ? ` (${claim.error})` : ""}`);
+    return;
+  }
+  resumeInjectionQueue.enqueue({ resumeId, prompt: RESUME_PROMPT, claim: claim.claim });
+}
 function ensureBudgetCoordinatorStarted() {
   if (!BUDGET_CONFIG.enabled)
     return;
   if (!budgetCoordinator) {
-    log(`Budget coordinator config: pollSeconds=${BUDGET_CONFIG.pollSeconds} pauseAt=${BUDGET_CONFIG.pauseAt} ` + `resumeBelow=${BUDGET_CONFIG.resumeBelow} syncDriftPct=${BUDGET_CONFIG.syncDriftPct} ` + `parallel=${BUDGET_CONFIG.parallel.minRemainingPct}%/${BUDGET_CONFIG.parallel.timeWindowSec}s ` + `codexTierControl=${BUDGET_CONFIG.codexTierControl} ` + `codexTiersFull=${BUDGET_CONFIG.codexTiers.full ? "configured" : "missing"} ` + `strategy=${BUDGET_CONFIG.strategy}`);
+    log(`Budget coordinator config: pollSeconds=${BUDGET_CONFIG.pollSeconds} pauseAt=${BUDGET_CONFIG.pauseAt} ` + `resumeBelow=${BUDGET_CONFIG.resumeBelow} syncDriftPct=${BUDGET_CONFIG.syncDriftPct} ` + `parallel=${BUDGET_CONFIG.parallel.minRemainingPct}%/${BUDGET_CONFIG.parallel.timeWindowSec}s ` + `codexTierControl=${BUDGET_CONFIG.codexTierControl} ` + `codexTiersFull=${BUDGET_CONFIG.codexTiers.full ? "configured" : "missing"} ` + `targetUtil=${BUDGET_CONFIG.maximize.targetUtil} fallback=${BUDGET_CONFIG.pauseAt}/${BUDGET_CONFIG.resumeBelow}`);
     budgetCoordinator = new BudgetCoordinator({
       source: createQuotaSource({ log }),
       config: BUDGET_CONFIG,
@@ -5265,7 +6452,17 @@ function ensureBudgetCoordinatorStarted() {
         log(`Budget intervention ${paused ? "ACTIVE" : "CLEARED"} ` + `(gate ${budgetCoordinator?.isGateClosed() ? "CLOSED" : "OPEN"})`);
       },
       onSnapshot: () => broadcastStatus(),
-      log
+      log,
+      onResume: (side, _directive, resumeId) => {
+        if (side === "claude") {
+          log(`Budget resume ${resumeId} for Claude side \u2192 arming ack tracker`);
+        }
+        routeResume(side, resumeId, {
+          claudeTracker: claudeResumeTracker,
+          enqueueCodex: enqueueCodexBudgetResume
+        });
+      },
+      resumeSignals: readResumeSignals
     });
   }
   budgetCoordinator.start();
@@ -5278,7 +6475,8 @@ function budgetPauseGateError() {
   const reason = snapshot?.pauseReason ?? "Codex \u4FA7\u989D\u5EA6\u63A5\u8FD1\u8017\u5C3D";
   const resumeAt = snapshot?.resumeAfterEpoch ? new Date(snapshot.resumeAfterEpoch * 1000).toISOString().replace("T", " ").replace(/\.\d+Z$/, "Z") : null;
   const sideHint = snapshot?.pauseSide === "both" ? "\u53CC\u4FA7\u989D\u5EA6\u5747\u5DF2\u8017\u5C3D\uFF0C\u8BF7\u5199 checkpoint \u7B49\u5F85\u5237\u65B0" : "\u4F60\u53EF\u7EE7\u7EED solo \u63A8\u8FDB\u53EF\u72EC\u7ACB\u90E8\u5206\uFF0C\u5E76\u5199 checkpoint \u6807\u6CE8\u5206\u5DE5\u65AD\u70B9";
-  return `\u9884\u7B97\u6682\u505C\uFF08\u95F8\u95E8\u5173\u95ED\uFF09\uFF0C\u5DF2\u62D2\u7EDD\u8F6C\u53D1\uFF1A${reason}\u3002` + `Codex \u4FA7 gateUtil \u4F4E\u4E8E ${BUDGET_CONFIG.resumeBelow}% \u540E\u95F8\u95E8\u81EA\u52A8\u653E\u5F00` + (resumeAt ? `\uFF08\u9884\u8BA1\u6062\u590D ${resumeAt}\uFF0C\u4EE5\u5B9E\u6D4B\u4E3A\u51C6\uFF1B\u63D0\u524D\u5237\u65B0\u4F1A\u66F4\u65E9\u89E3\u9664\uFF09` : "") + `\u3002\u6536\u5230 RESUME \u901A\u77E5\u524D\u8BF7\u52FF\u91CD\u8BD5\u5411 Codex \u53D1\u9001 reply\uFF1B${sideHint}\u3002`;
+  const reopenText = `Codex \u4FA7\u5404\u7A97\u53E3 util \u56DE\u843D\u81F3\u52A8\u6001\u6682\u505C\u7EBF \u2212 ${BUDGET_CONFIG.maximize.resumeHysteresisPct}% \u4EE5\u4E0B\u6216\u5BF9\u5E94\u7A97\u53E3\u5237\u65B0\u540E\u95F8\u95E8\u81EA\u52A8\u653E\u5F00`;
+  return `\u9884\u7B97\u6682\u505C\uFF08\u95F8\u95E8\u5173\u95ED\uFF09\uFF0C\u5DF2\u62D2\u7EDD\u8F6C\u53D1\uFF1A${reason}\u3002` + reopenText + (resumeAt ? `\uFF08\u9884\u8BA1\u6062\u590D ${resumeAt}\uFF0C\u4EE5\u5B9E\u6D4B\u4E3A\u51C6\uFF1B\u63D0\u524D\u5237\u65B0\u4F1A\u66F4\u65E9\u89E3\u9664\uFF09` : "") + `\u3002\u6536\u5230 RESUME \u901A\u77E5\u524D\u8BF7\u52FF\u91CD\u8BD5\u5411 Codex \u53D1\u9001 reply\uFF1B${sideHint}\u3002`;
 }
 var tuiConnectionState = new TuiConnectionState({
   disconnectGraceMs: TUI_DISCONNECT_GRACE_MS,
@@ -5324,6 +6522,12 @@ codex.on("steerAccepted", ({ requestId }) => {
   }
 });
 codex.on("bridgeTurnStarted", ({ requestId, turnId }) => {
+  const pendingResume = pendingResumeTurnStarts.get(requestId);
+  if (pendingResume) {
+    pendingResumeTurnStarts.delete(requestId);
+    resumeInjectionQueue.onBridgeTurnStarted({ resumeId: pendingResume.resumeId, requestId, turnId });
+    return;
+  }
   const pending = pendingTurnStarts.get(requestId);
   if (!pending) {
     log(`bridgeTurnStarted for unknown injection ${requestId} (turn ${turnId}) \u2014 correlation dropped`);
@@ -5345,6 +6549,12 @@ codex.on("bridgeTurnStarted", ({ requestId, turnId }) => {
   }
 });
 codex.on("bridgeTurnRejected", ({ requestId, error }) => {
+  const pendingResume = pendingResumeTurnStarts.get(requestId);
+  if (pendingResume) {
+    pendingResumeTurnStarts.delete(requestId);
+    resumeInjectionQueue.onBridgeTurnRejected({ resumeId: pendingResume.resumeId, requestId, error });
+    return;
+  }
   const pending = pendingTurnStarts.get(requestId);
   if (!pending)
     return;
@@ -5362,11 +6572,16 @@ codex.on("turnTrackingReset", (reason) => {
   if (pendingTurnStarts.size > 0) {
     log(`Cleared ${pendingTurnStarts.size} pending turn-start correlation(s) on turn tracking reset (${reason})`);
   }
+  if (pendingResumeTurnStarts.size > 0) {
+    log(`Cleared ${pendingResumeTurnStarts.size} pending resume turn-start correlation(s) on turn tracking reset (${reason})`);
+  }
   if (pendingSteerDispatches.size > 0) {
     log(`Cleared ${pendingSteerDispatches.size} pending steer dispatch(es) on turn tracking reset (${reason})`);
   }
   pendingTurnStarts.clear();
+  pendingResumeTurnStarts.clear();
   pendingSteerDispatches.clear();
+  resumeInjectionQueue.onTurnTrackingReset();
 });
 codex.on("turnStarted", () => {
   log("Codex turn started");
@@ -5411,6 +6626,7 @@ codex.on("turnCompleted", () => {
   }
   emitToClaude(systemMessage("system_turn_completed", "\u2705 Codex finished the current turn. You can reply now if needed."));
   startAttentionWindow();
+  resumeInjectionQueue.onTurnDrained();
 });
 codex.on("turnAborted", (reason) => {
   log(`Codex turn aborted (${reason}) \u2014 clearing reply-required state`);
@@ -5470,7 +6686,9 @@ codex.on("exit", (code) => {
   replyTracker.reset();
   idempotencyTracker.terminateAll("aborted");
   pendingTurnStarts.clear();
+  pendingResumeTurnStarts.clear();
   pendingSteerDispatches.clear();
+  resumeInjectionQueue.onTurnTrackingReset();
   statusBuffer.flush("codex exited");
   tuiConnectionState.handleCodexExit();
   clearPendingClaudeDisconnect("Codex process exited");
@@ -5580,6 +6798,10 @@ function handleControlMessage(ws, raw) {
     case "status":
       sendStatus(ws);
       return;
+    case "ack_resume":
+      log(`Received ack_resume from Claude #${ws.data.clientId}: ${message.resumeId} (${message.status})`);
+      claudeResumeTracker.ack(message.resumeId);
+      return;
     case "probe_incumbent":
       handleProbeIncumbent(ws).catch((err) => {
         log(`handleProbeIncumbent threw for #${ws.data.clientId}: ${err?.message ?? err}`);
@@ -5685,7 +6907,7 @@ async function handleClaudeToCodex(ws, message) {
     const reason = budgetPauseGateError();
     log(`Injection rejected by budget pause gate`);
     const resumeAfterEpoch3 = budgetCoordinator?.getSnapshot()?.resumeAfterEpoch ?? null;
-    const retryAfterMs = resumeAfterEpoch3 !== null ? Math.max(0, resumeAfterEpoch3 * 1000 - Date.now()) : undefined;
+    const retryAfterMs = retryAfterMsForResume(resumeAfterEpoch3, Date.now());
     sendClaudeToCodexResult(ws, message.requestId, {
       success: false,
       code: "budget_paused",
@@ -6233,6 +7455,8 @@ function shutdown(reason, exitCode = 0) {
   shuttingDown = true;
   log(`Shutting down daemon (${reason})...`);
   clearBootDeadline();
+  resumeInjectionQueue.stop();
+  claudeResumeTracker.stop();
   stopBudgetCoordinator();
   idempotencyTracker.dispose();
   tuiConnectionState.dispose(`daemon shutdown (${reason})`);