@raysonmeng/agentbridge 0.1.16 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raysonmeng/agentbridge",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Bridge between Claude Code and Codex — bidirectional agent communication via MCP Channel + JSON-RPC",
   "type": "module",
   "packageManager": "bun@1.3.11",

package/plugins/agentbridge/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbridge",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Bridge Claude Code and Codex with a shared daemon, push channel delivery, and bidirectional reply tooling.",
   "author": {
     "name": "AgentBridge Contributors",

package/plugins/agentbridge/scripts/health-check.sh

@@ -19,6 +19,89 @@ if printf '%s' "$pair_id" | grep -Eq '^[A-Za-z0-9._-]+$'; then
   pair_arg=" --pair ${pair_id}"
 fi
 
+# ── PR4 §6: resume-ack degraded escape hatch ─────────────────────────────────
+# When the daemon's Claude-side ResumeAckTracker exhausts retries with no ack, it
+# drops a sentinel in the state dir. Surface it here BEFORE the cooldown gate so
+# a fresh session within the cooldown window still sees it (else it'd be eaten),
+# then CONSUME (delete) the sentinel so the notice shows exactly once.
+resolve_state_dir() {
+  if [ -n "${AGENTBRIDGE_STATE_DIR:-}" ]; then
+    printf '%s' "${AGENTBRIDGE_STATE_DIR}"
+    return
+  fi
+  case "$(uname -s 2>/dev/null)" in
+    Darwin)
+      printf '%s' "${HOME}/Library/Application Support/AgentBridge"
+      ;;
+    *)
+      local xdg="${XDG_STATE_HOME:-}"
+      if [ -n "$xdg" ]; then
+        printf '%s' "${xdg}/agentbridge"
+      else
+        printf '%s' "${HOME}/.local/state/agentbridge"
+      fi
+      ;;
+  esac
+}
+
+state_dir="$(resolve_state_dir)"
+resume_sentinel="${state_dir}/resume-ack-degraded.json"
+if [ -f "$resume_sentinel" ]; then
+  resume_id="$(grep -o '"resumeId"[[:space:]]*:[[:space:]]*"[^"]*"' "$resume_sentinel" 2>/dev/null | head -n1 | sed 's/.*"resumeId"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')"
+  # Staleness gate: the sentinel carries degradedAt (epoch MILLISECONDS, written by
+  # writeResumeAckDegradedSentinel). A degrade that happened long ago points at a
+  # checkpoint that is probably already handled, so surfacing "continue from
+  # checkpoint" would mislead. Drop (still consuming) a sentinel older than the TTL.
+  # Default 24h survives an overnight away-window (the core use case — wake up and
+  # the recovery notice is still there) yet suppresses multi-day-stale notices;
+  # configurable via AGENTBRIDGE_RESUME_SENTINEL_TTL_SEC. Fail-open: a missing,
+  # non-numeric, or implausibly-long (>16-digit) degradedAt / TTL is treated as
+  # FRESH so a possibly-real recovery is never silently suppressed. (A parseable
+  # but genuinely old timestamp is still aged normally → stale.)
+  degraded_at_ms="$(grep -o '"degradedAt"[[:space:]]*:[[:space:]]*[0-9][0-9]*' "$resume_sentinel" 2>/dev/null | head -n1 | grep -o '[0-9][0-9]*$')"
+  resume_ttl_sec="${AGENTBRIDGE_RESUME_SENTINEL_TTL_SEC:-86400}"
+  resume_stale=0
+  # Accept only a plausible 1–16 digit integer for BOTH operands: 16 digits keeps
+  # every value (epoch-ms ~13 digits, any sane TTL ≤ ~9.99e15) far under bash's
+  # signed 64-bit ceiling, so the subtraction below can never overflow; anything
+  # longer / non-numeric / missing is rejected here → FRESH (fail-open).
+  if printf '%s' "$degraded_at_ms" | grep -Eq '^[0-9]{1,16}$' && printf '%s' "$resume_ttl_sec" | grep -Eq '^[0-9]{1,16}$'; then
+    # Compare in SECONDS (degradedAt is epoch ms → integer-divide by 1000) and never
+    # multiply the user TTL by 1000, so the comparison can't overflow. `10#` forces
+    # base-10 so a leading-zero value (e.g. 0888…) parses decimally instead of as
+    # octal — an octal-invalid operand would otherwise make the $(( )) arithmetic
+    # fail, and in bash a failed arithmetic assignment terminates the enclosing
+    # if-block (regardless of set flags), skipping the consume (rm) below and leaking
+    # the sentinel. The ^[0-9]{1,16}$ guard above + `10#` together make this
+    # arithmetic TOTAL for every accepted input (no octal abort, no int64 overflow),
+    # so age_sec is always assigned and the unconditional rm below always runs
+    # (consume-once holds).
+    now_sec="$(date +%s 2>/dev/null)"
+    age_sec=$(( ${now_sec:-0} - 10#${degraded_at_ms} / 1000 ))
+    if [ "$age_sec" -gt "$resume_ttl_sec" ]; then
+      resume_stale=1
+    fi
+  fi
+  rm -f "$resume_sentinel" 2>/dev/null || true  # consume once, whether surfaced or dropped-as-stale
+  if [ "$resume_stale" -eq 0 ]; then
+    # Defense-in-depth (resume_id is daemon-controlled, but harden anyway): only
+    # interpolate it into the JSON heredoc if it matches the known-safe id charset
+    # (system_budget_claude_recovered_<seq> — a plain monotonic sequence, no salt;
+    # the salt lives in BridgeMessage.id, not in the resumeId the sentinel stores).
+    # Anything else (a corrupted or
+    # tampered sentinel carrying " or \) collapses to "unknown" so the emitted hook
+    # JSON can never be broken by the value — mirrors the pair_id guard above.
+    if ! printf '%s' "$resume_id" | grep -Eq '^[A-Za-z0-9._-]+$'; then
+      resume_id="unknown"
+    fi
+    cat <<EOF
+{"hookSpecificOutput":{"hookEventName":"SessionStart","additionalContext":"AgentBridge: 上次额度刷新后的续接通知未被确认（resume_id=${resume_id:-unknown}），可能上一个会话已空闲或退出。请从 .agent/checkpoint.md 的「下一步」继续未完成的任务。"}}
+EOF
+    exit 0
+  fi
+  # stale → sentinel consumed above; fall through to the normal health check below.
+fi
+
 if ! command -v curl >/dev/null 2>&1; then
   exit 0
 fi

package/plugins/agentbridge/server/bridge-server.js

@@ -13866,7 +13866,8 @@ class StateDirResolver {
 // src/budget/types.ts
 var STALE_MAX_AGE_SEC = 600;
 
-// src/budget/budget-state.ts
+// src/budget/budget-decision.ts
+var MAX_TIME_TO_RESET_HOURS = 7 * 24;
 function isDecisionGrade(usage, now) {
   if (!usage)
     return false;
@@ -13877,7 +13878,6 @@ function isDecisionGrade(usage, now) {
     return false;
   return true;
 }
-
 // src/budget/burn-view.ts
 function agentWeeklyFiveHourWindowsLeft(usage, now) {
   if (!usage || usage.stale || !usage.ok)
@@ -13895,7 +13895,7 @@ function agentWeeklyFiveHourWindowsLeft(usage, now) {
 }
 
 // src/budget/render.ts
-var DEFAULT_GUARD_HARD_PCT = 92;
+var DEFAULT_GUARD_HARD_PCT = 99;
 function resolveGuardHardHint(env = process.env) {
   const raw = env.AGENTBRIDGE_GUARD_HARD_HINT;
   if (raw === undefined || raw.trim() === "")
@@ -14007,16 +14007,59 @@ function formatFiveHourWindowsLeftLine(snapshot) {
   const byAgent = values.map(([name, value]) => `${name} ~${value.toFixed(1)}`).join(" / ");
   return `\u6309\u5F53\u524D\u8282\u594F\uFF0C\u5468\u989D\u5EA6\u8FD8\u591F ${byAgent} \u4E2A 5h \u7A97\u53E3`;
 }
+var FIVE_HOUR_WINDOW_SEC = 5 * 3600;
+function clockWindowsLeft(usage, snapshotAt) {
+  const weekly = usage?.weekly;
+  if (!weekly || weekly.resetEpoch <= snapshotAt)
+    return null;
+  return (weekly.resetEpoch - snapshotAt) / FIVE_HOUR_WINDOW_SEC;
+}
+function formatClockWindowsLine(snapshot) {
+  const values = [];
+  const claude = clockWindowsLeft(snapshot.claude, snapshot.updatedAt);
+  const codex = clockWindowsLeft(snapshot.codex, snapshot.updatedAt);
+  if (claude !== null)
+    values.push(["Claude", claude]);
+  if (codex !== null)
+    values.push(["Codex", codex]);
+  if (values.length === 0)
+    return null;
+  const unique = [...new Set(values.map(([, value]) => value.toFixed(1)))];
+  if (unique.length === 1)
+    return `\u8DDD\u5468\u5237\u65B0\u8FD8\u80FD\u5BB9\u7EB3 ~${unique[0]} \u4E2A 5h \u7A97\u53E3\uFF08\u65F6\u949F\uFF09`;
+  const byAgent = values.map(([name, value]) => `${name} ~${value.toFixed(1)}`).join(" / ");
+  return `\u8DDD\u5468\u5237\u65B0\u8FD8\u80FD\u5BB9\u7EB3 ${byAgent} \u4E2A 5h \u7A97\u53E3\uFF08\u65F6\u949F\uFF09`;
+}
+function formatDynamicLineLine(snapshot) {
+  const lines = snapshot.dynamicPauseLine;
+  if (!lines)
+    return null;
+  const parts = [];
+  const entries = [
+    ["Claude", lines.claude, snapshot.claude],
+    ["Codex", lines.codex, snapshot.codex]
+  ];
+  for (const [name, line, usage] of entries) {
+    if (line === null)
+      continue;
+    const headroom = usage ? `\uFF08util ${usage.gateUtil}%\uFF0C\u4F59\u91CF ${(line - usage.gateUtil).toFixed(1)}\uFF09` : "";
+    parts.push(`${name} ${line.toFixed(1)}%${headroom}`);
+  }
+  if (parts.length === 0)
+    return null;
+  return `\u52A8\u6001\u6682\u505C\u7EBF\uFF1A${parts.join(" \xB7 ")}`;
+}
 var PHASE_LABELS = {
   normal: "normal\uFF08\u6B63\u5E38\uFF09",
   balance: "balance\uFF08\u9700\u5747\u8861\uFF09",
-  parallel: "parallel\uFF08\u5EFA\u8BAE\u5E76\u884C\u63D0\u901F\uFF09",
+  parallel: "parallel\uFF08\u5DF2\u9000\u5F79\uFF09",
+  underutilized: "underutilized\uFF08\u989D\u5EA6\u6B20\u8F7D\uFF0C\u5EFA\u8BAE\u63D0\u901F\uFF09",
   paused: "paused\uFF08\u9884\u7B97\u5E72\u9884\u4E2D\uFF09"
 };
 function renderBudgetSnapshot(snapshot, options = {}) {
   const guardHardPct = options.guardHardPct ?? resolveGuardHardHint();
   const lines = [];
-  lines.push(`\u3010\u9884\u7B97\u5FEB\u7167 \xB7 \u8D26\u53F7\u7EA7\u3011\u9636\u6BB5\uFF1A${PHASE_LABELS[snapshot.phase]} \xB7 \u66F4\u65B0\u4E8E ${formatEpoch(snapshot.updatedAt)}`);
+  lines.push(`\u3010\u9884\u7B97\u5FEB\u7167 \xB7 \u8D26\u53F7\u7EA7\u3011\u9636\u6BB5\uFF1A${PHASE_LABELS[snapshot.phase] ?? snapshot.phase} \xB7 \u66F4\u65B0\u4E8E ${formatEpoch(snapshot.updatedAt)}`);
   lines.push(formatAgent("Claude", snapshot.claude, snapshot.updatedAt));
   lines.push(formatAgent("Codex", snapshot.codex, snapshot.updatedAt));
   if (snapshot.burnRate) {
@@ -14030,6 +14073,12 @@ function renderBudgetSnapshot(snapshot, options = {}) {
   const fiveHourWindowsLeftLine = formatFiveHourWindowsLeftLine(snapshot);
   if (fiveHourWindowsLeftLine)
     lines.push(fiveHourWindowsLeftLine);
+  const clockWindowsLine = formatClockWindowsLine(snapshot);
+  if (clockWindowsLine)
+    lines.push(clockWindowsLine);
+  const dynamicLineLine = formatDynamicLineLine(snapshot);
+  if (dynamicLineLine)
+    lines.push(dynamicLineLine);
   if (snapshot.claude && snapshot.codex) {
     const abs = Math.abs(snapshot.driftPct);
     if (abs > 0) {
@@ -14118,6 +14167,7 @@ class ClaudeAdapter extends EventEmitter {
   notificationIdPrefix;
   instanceId;
   replySender = null;
+  resumeAckHandler = null;
   logFile;
   logger;
   pendingMessages = [];
@@ -14168,6 +14218,9 @@ class ClaudeAdapter extends EventEmitter {
   setReplySender(sender) {
     this.replySender = sender;
   }
+  setResumeAckHandler(handler) {
+    this.resumeAckHandler = handler;
+  }
   getPendingMessageCount() {
     return this.pendingMessages.length;
   }
@@ -14195,7 +14248,8 @@ class ClaudeAdapter extends EventEmitter {
             user: "Codex",
             user_id: "codex",
             ts,
-            source_type: "codex"
+            source_type: "codex",
+            ...message.resumeId ? { resume_id: message.resumeId } : {}
           }
         }
       });
@@ -14368,6 +14422,25 @@ chat_id: ${this.sessionId}`);
             properties: {},
             required: []
           }
+        },
+        {
+          name: "ack_resume",
+          description: "ONLY for acknowledging a system_budget_resume directive (the budget window refreshed). NOT a general channel to Codex (use reply for that). This is an acknowledgement that you RECEIVED the resume directive \u2014 call it as soon as you see the notice, then continue the work; do NOT wait until the task is finished.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              resume_id: {
+                type: "string",
+                description: "The resume_id from the system_budget_resume notice (meta.resume_id)."
+              },
+              status: {
+                type: "string",
+                enum: ["resumed", "declined", "already_running"],
+                description: 'Acknowledgement outcome, recorded for observability only \u2014 all three values stop the resume re-push identically (the bridge takes no different downstream action for "declined"). "resumed" (default): you are resuming the task. "declined": you are not resuming. "already_running": you were already working and need no resume.'
+              }
+            },
+            required: ["resume_id"]
+          }
         }
       ]
     }));
@@ -14382,12 +14455,50 @@ chat_id: ${this.sessionId}`);
       if (name === "get_budget") {
         return this.handleGetBudget();
       }
+      if (name === "ack_resume") {
+        return this.handleAckResume(args);
+      }
       return {
         content: [{ type: "text", text: `Unknown tool: ${name}` }],
         isError: true
       };
     });
   }
+  async handleAckResume(args) {
+    const resumeIdRaw = args?.resume_id;
+    if (typeof resumeIdRaw !== "string" || resumeIdRaw.length === 0) {
+      return {
+        content: [{ type: "text", text: "Error: missing required parameter 'resume_id'" }],
+        isError: true
+      };
+    }
+    if (resumeIdRaw.length > 128) {
+      return {
+        content: [{ type: "text", text: `Error: resume_id is too long (${resumeIdRaw.length} chars, max 128).` }],
+        isError: true
+      };
+    }
+    const statusRaw = args?.status;
+    if (statusRaw !== undefined && statusRaw !== "resumed" && statusRaw !== "declined" && statusRaw !== "already_running") {
+      return {
+        content: [{ type: "text", text: `Error: invalid status value ${JSON.stringify(statusRaw)} \u2014 use "resumed", "declined" or "already_running".` }],
+        isError: true
+      };
+    }
+    const status = typeof statusRaw === "string" ? statusRaw : "resumed";
+    if (!this.resumeAckHandler) {
+      this.log("No resume ack handler registered");
+      return {
+        content: [{ type: "text", text: "Error: bridge not initialized, cannot acknowledge resume." }],
+        isError: true
+      };
+    }
+    this.log(`ack_resume received (resume_id=${resumeIdRaw}, status=${status}, instance=${this.instanceId})`);
+    this.resumeAckHandler(resumeIdRaw, status);
+    return {
+      content: [{ type: "text", text: `Resume acknowledged (resume_id=${resumeIdRaw}, status=${status}).` }]
+    };
+  }
   handleGetBudget() {
     this.log(`get_budget called (instance=${this.instanceId}, hasSnapshot=${this.budgetSnapshot !== null})`);
     const text = this.budgetSnapshot ? renderBudgetSnapshot(this.budgetSnapshot) : BUDGET_UNAVAILABLE_TEXT;
@@ -14511,11 +14622,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.18", "0.0.0-source"),
+  commit: defineString("9db0aa3", "source"),
   bundle: defineBundle("plugin"),
   contractVersion: defineNumber(1, CONTRACT_VERSION),
-  codeHash: defineString("1fc975838e46", "source")
+  codeHash: defineString("46a6407023f0", "source")
 });
 function sameRuntimeContract(a, b) {
   if (!a || !b)
@@ -14781,6 +14892,9 @@ class DaemonClient extends EventEmitter2 {
     });
     return pending;
   }
+  sendAckResume(resumeId, status) {
+    this.send({ type: "ack_resume", resumeId, status });
+  }
   attachSocketHandlers(ws, socketId) {
     ws.onmessage = (event) => {
       const raw = typeof event.data === "string" ? event.data : event.data.toString();
@@ -15547,7 +15661,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",
@@ -15600,6 +15724,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;
 }
@@ -15607,7 +15759,7 @@ function hasCustomDecisionValues(config2) {
   const d = DEFAULT_CONFIG;
   const b = config2.budget;
   const db = d.budget;
-  return config2.idleShutdownSeconds !== d.idleShutdownSeconds || config2.turnCoordination.attentionWindowSeconds !== d.turnCoordination.attentionWindowSeconds || config2.codex.appPort !== d.codex.appPort || config2.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 config2.idleShutdownSeconds !== d.idleShutdownSeconds || config2.turnCoordination.attentionWindowSeconds !== d.turnCoordination.attentionWindowSeconds || config2.codex.appPort !== d.codex.appPort || config2.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))
@@ -15625,8 +15777,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")
@@ -15677,7 +15862,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 normalizeConfig(raw) {
@@ -16209,6 +16395,17 @@ claude.setReplySender(async (msg, requireReply, onBusy, idempotencyKey) => {
   }
   return daemonClient.sendReply(msg, requireReply, onBusy, idempotencyKey);
 });
+claude.setResumeAckHandler((resumeId, status) => {
+  if (daemonDisabled) {
+    log(`Resume ack ${resumeId} (${status}) dropped \u2014 daemon disabled (${daemonDisabledReason ?? "killed"})`);
+    return;
+  }
+  try {
+    daemonClient.sendAckResume(resumeId, status);
+  } catch (err) {
+    log(`Resume ack ${resumeId} (${status}) send failed: ${err?.message ?? err}`);
+  }
+});
 daemonClient.on("turnStarted", ({ requestId, idempotencyKey, threadId, turnId }) => {
   log(`Codex turn started for reply ${requestId} (turn=${turnId}, thread=${threadId}` + `${idempotencyKey ? `, idempotencyKey=${idempotencyKey}` : ""})`);
 });