@khalilgharbaoui/opencode-claude-code-plugin 0.54.2 → 0.56.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/claude-code-language-model.ts
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 
 // src/ids.ts
 import { randomInt } from "crypto";
@@ -151,7 +151,7 @@ function translateStreamForHost(stream, dialect = "v1") {
 }
 
 // src/account-failover.ts
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 
 // src/accounts.ts
 import {
@@ -705,6 +705,198 @@ ${ACCOUNT_GROUP_MARKER} this conversation was running on the Claude account "${s
 `;
 }
 
+// src/account-usage.ts
+import { mkdirSync as mkdirSync2, readFileSync, renameSync as renameSync2, statSync as statSync2, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var DEFAULT_USAGE_WARN_THRESHOLDS = [50, 75, 90, 95];
+var DEFAULT_USAGE_SWITCH_AT = 90;
+var UNTIMED_READING_TTL_MS = 5 * 60 * 60 * 1e3;
+var USAGE_READING_MAX_AGE_MS = 8 * 24 * 60 * 60 * 1e3;
+var MAX_USAGE_ACCOUNTS = 32;
+var MAX_USAGE_WINDOWS = 8;
+var NAME = /^[a-z0-9_-]{1,64}$/;
+var STATUS = /^[a-z_]{1,32}$/;
+var MAX_RESETS_TEXT = 80;
+var pathOverride = null;
+var cache = null;
+function accountUsageStorePath() {
+  if (pathOverride) return pathOverride;
+  const stateRoot = process.env.XDG_STATE_HOME || join2(homedir2(), ".local", "state");
+  return join2(stateRoot, "opencode-claude-code-plugin", "account-usage.json");
+}
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function validEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const entry = value;
+  if (!finite(entry.observedAt)) return null;
+  if (typeof entry.status !== "string" || !STATUS.test(entry.status)) return null;
+  if (entry.utilization !== null && !finite(entry.utilization)) return null;
+  if (entry.resetsAt !== void 0 && !finite(entry.resetsAt)) return null;
+  if (entry.resetsText !== void 0 && (typeof entry.resetsText !== "string" || entry.resetsText.length > MAX_RESETS_TEXT)) {
+    return null;
+  }
+  const noted = Array.isArray(entry.noted) ? [...new Set(entry.noted.filter((t) => finite(t) && t > 0 && t <= 100))].sort(
+    (a, b) => a - b
+  ) : [];
+  return {
+    utilization: entry.utilization,
+    ...entry.resetsAt === void 0 ? {} : { resetsAt: entry.resetsAt },
+    ...entry.resetsText === void 0 ? {} : { resetsText: entry.resetsText },
+    status: entry.status,
+    observedAt: entry.observedAt,
+    noted
+  };
+}
+function readStore(file, now) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    const accounts = parsed && typeof parsed === "object" ? parsed.accounts : null;
+    if (!accounts || typeof accounts !== "object" || Array.isArray(accounts)) return out;
+    const cutoff = now - USAGE_READING_MAX_AGE_MS;
+    for (const [account, windows] of Object.entries(accounts)) {
+      if (!NAME.test(account) || !windows || typeof windows !== "object") continue;
+      const kept = /* @__PURE__ */ new Map();
+      for (const [window, raw] of Object.entries(windows)) {
+        if (!NAME.test(window)) continue;
+        const entry = validEntry(raw);
+        if (entry && entry.observedAt >= cutoff) kept.set(window, entry);
+      }
+      if (kept.size > 0) out.set(account, kept);
+    }
+  } catch {
+  }
+  return out;
+}
+function newestObserved(windows) {
+  let newest = 0;
+  for (const entry of windows.values()) newest = Math.max(newest, entry.observedAt);
+  return newest;
+}
+function bounded(usage, now) {
+  const cutoff = now - USAGE_READING_MAX_AGE_MS;
+  const accounts = [...usage.entries()].map(([account, windows]) => {
+    const kept = [...windows.entries()].filter(([, entry]) => entry.observedAt >= cutoff).sort((a, b) => a[1].observedAt - b[1].observedAt).slice(-MAX_USAGE_WINDOWS);
+    return [account, new Map(kept)];
+  }).filter(([, windows]) => windows.size > 0).sort((a, b) => newestObserved(a[1]) - newestObserved(b[1])).slice(-MAX_USAGE_ACCOUNTS);
+  return new Map(accounts);
+}
+function writeStore(file, usage) {
+  const accounts = {};
+  for (const [account, windows] of usage) accounts[account] = Object.fromEntries(windows);
+  try {
+    mkdirSync2(join2(file, ".."), { recursive: true, mode: 448 });
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ version: 1, accounts }), { mode: 384 });
+    renameSync2(tmp, file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cached(now) {
+  const file = accountUsageStorePath();
+  if (!cache || cache.path !== file) cache = { path: file, usage: readStore(file, now) };
+  return cache.usage;
+}
+function refreshed(now) {
+  const file = accountUsageStorePath();
+  cache = { path: file, usage: readStore(file, now) };
+  return cache.usage;
+}
+function isReadingCurrent(entry, now = Date.now()) {
+  if (entry.resetsAt !== void 0) return entry.resetsAt > now;
+  return now - entry.observedAt < UNTIMED_READING_TTL_MS;
+}
+function applyReading(previous, reading, now = Date.now()) {
+  const carried = previous && isReadingCurrent(previous, now) ? previous.noted : [];
+  return {
+    utilization: finite(reading.utilization) ? reading.utilization : null,
+    ...finite(reading.resetsAt) ? { resetsAt: reading.resetsAt } : {},
+    ...reading.resetsText && !finite(reading.resetsAt) ? { resetsText: reading.resetsText.slice(0, MAX_RESETS_TEXT) } : {},
+    status: STATUS.test(reading.status) ? reading.status : "unknown",
+    observedAt: now,
+    noted: [...carried]
+  };
+}
+function usagePercent(utilization) {
+  return Math.round(utilization * 1e3) / 10;
+}
+function pendingCrossings(entry, thresholds, now = Date.now()) {
+  if (!isReadingCurrent(entry, now)) return [];
+  if (entry.utilization === null || entry.status === "rejected") return [];
+  const percent = usagePercent(entry.utilization);
+  return [...new Set(thresholds)].filter((threshold) => percent >= threshold && !entry.noted.includes(threshold)).sort((a, b) => a - b);
+}
+function resolveUsageWarnThresholds(value) {
+  if (!Array.isArray(value)) return [...DEFAULT_USAGE_WARN_THRESHOLDS];
+  return [...new Set(value.filter((t) => finite(t) && t > 0 && t <= 100))].sort(
+    (a, b) => a - b
+  );
+}
+function resolveUsageSwitchAt(value) {
+  if (value === false || value === 0) return null;
+  if (finite(value) && value > 0 && value <= 100) return value;
+  return DEFAULT_USAGE_SWITCH_AT;
+}
+function recordUsageReading(account, window, reading, now = Date.now()) {
+  if (!NAME.test(account) || !NAME.test(window)) return null;
+  const file = accountUsageStorePath();
+  const merged = readStore(file, now);
+  const previous = merged.get(account)?.get(window) ?? cached(now).get(account)?.get(window);
+  const entry = applyReading(previous, reading, now);
+  const windows = merged.get(account) ?? /* @__PURE__ */ new Map();
+  windows.set(window, entry);
+  merged.set(account, windows);
+  const kept = bounded(merged, now);
+  cache = { path: file, usage: kept };
+  return writeStore(file, kept) ? entry : null;
+}
+function markUsageNoted(account, window, thresholds, now = Date.now()) {
+  if (!NAME.test(account) || !NAME.test(window) || thresholds.length === 0) return false;
+  const file = accountUsageStorePath();
+  const merged = readStore(file, now);
+  const entry = merged.get(account)?.get(window) ?? cached(now).get(account)?.get(window);
+  if (!entry) return false;
+  const updated = {
+    ...entry,
+    noted: [.../* @__PURE__ */ new Set([...entry.noted, ...thresholds])].sort((a, b) => a - b)
+  };
+  const windows = merged.get(account) ?? /* @__PURE__ */ new Map();
+  windows.set(window, updated);
+  merged.set(account, windows);
+  const kept = bounded(merged, now);
+  cache = { path: file, usage: kept };
+  return writeStore(file, kept);
+}
+function usageCrossings(account, thresholds, now = Date.now()) {
+  if (thresholds.length === 0) return [];
+  const collect = (usage) => {
+    const out = [];
+    for (const [window, entry] of usage.get(account) ?? []) {
+      const crossed = pendingCrossings(entry, thresholds, now);
+      if (crossed.length > 0) out.push({ window, entry, crossed });
+    }
+    return out;
+  };
+  if (collect(cached(now)).length === 0) return [];
+  return collect(refreshed(now));
+}
+function accountUsageAtOrOver(account, percent, now = Date.now()) {
+  for (const entry of cached(now).get(account)?.values() ?? []) {
+    if (!isReadingCurrent(entry, now)) continue;
+    if (entry.status === "rejected") return true;
+    if (entry.utilization !== null && usagePercent(entry.utilization) >= percent) return true;
+  }
+  return false;
+}
+function snapshotAccountUsage(now = Date.now()) {
+  return refreshed(now);
+}
+
 // src/types.ts
 var READ_ONLY_PERMISSION_MODE = "read-only";
 var DEFAULT_PROXY_TOOL_NAMES = [
@@ -1079,9 +1271,9 @@ function reportConversationReset(msg) {
 }
 var RESULT_ERROR_MARKER = "\u258C **claude code error:**";
 var RESULT_SUBTYPES = {
-  error_max_turns: "it hit its internal turn limit before finishing",
+  error_max_turns: "it reached its `--max-turns` cap (the agent's `maxTurns`) before finishing this message",
   error_during_execution: "it failed while running the turn",
-  error_max_budget_usd: "it hit the configured spend limit for the turn",
+  error_max_budget_usd: "it reached its `--max-budget-usd` cap (the agent's `maxBudgetUsd`), which counts this process's whole life",
   error_max_structured_output_retries: "it could not produce valid structured output"
 };
 function describeResultFailure(msg) {
@@ -1529,7 +1721,7 @@ function accountBlockKind(msg) {
 function describeAccountBlock(kind) {
   return ACCOUNT_BLOCKS[kind].what;
 }
-function loginCommandFor(configDir, home = homedir2()) {
+function loginCommandFor(configDir, home = homedir3()) {
   if (!configDir) return "claude auth login";
   const shown = configDir === home || configDir.startsWith(`${home}/`) ? `~${configDir.slice(home.length)}` : configDir;
   return `CLAUDE_CONFIG_DIR=${shown} claude auth login`;
@@ -1560,6 +1752,28 @@ function formatUsageLimitNote(input) {
 ${USAGE_LIMIT_MARKER} ${what} ${advice}
 `;
 }
+var USAGE_MARKER = "\u258C **usage:**";
+function formatUsageNote(input) {
+  const account = normalizeAccountName(input.account || DEFAULT_ACCOUNT);
+  const clauses = input.windows.map((entry) => {
+    const window = describeRateLimitWindow(entry.window) ?? "a usage window";
+    const resets = formatResetsAtLocal(entry.resetsAt);
+    const when = resets ? `, which resets at ${resets}` : entry.resetsText ? `, which resets ${entry.resetsText}` : "";
+    return `${entry.percent}% of ${window}${when}`;
+  });
+  const used = clauses.length <= 1 ? clauses.join("") : `${clauses.slice(0, -1).join("; ")}; and ${clauses[clauses.length - 1]}`;
+  let then = "";
+  if (input.movedTo) {
+    const until = formatResetsAtLocal(input.movedTo.until);
+    then = ` New turns move to the "${normalizeAccountName(input.movedTo.target)}" account ${until ? `until ${until}` : "until opencode restarts"}.`;
+  } else {
+    const others = describeOtherAccounts(input.candidates ?? []);
+    if (others) then = ` To keep working past the limit, pick a model from ${others}.`;
+  }
+  return `
+${USAGE_MARKER} the Claude account "${account}" has used ${used}.${then}
+`;
+}
 function isAccountLimitError(input) {
   if (input.rateLimit && isRateLimitRejected(input.rateLimit)) return true;
   const text = input.resultText;
@@ -1591,7 +1805,7 @@ function recallAccountLimit(account, now = Date.now()) {
   };
 }
 var accountOverrides = /* @__PURE__ */ new Map();
-function setAccountOverride(source, target, until, now = Date.now()) {
+function setAccountOverride(source, target, until, now = Date.now(), cause = "usage-limit") {
   const from = normalizeAccountName(source || DEFAULT_ACCOUNT);
   const to = normalizeAccountName(target);
   if (!to || to === from) return;
@@ -1604,6 +1818,14 @@ function setAccountOverride(source, target, until, now = Date.now()) {
     until = void 0;
   }
   accountOverrides.set(from, { target: to, until });
+  if (cause === "usage-threshold") {
+    log.warn("claude account is near its usage limit; new turns move to another account until the window resets", {
+      source: from,
+      target: to,
+      until: until ?? null
+    });
+    return;
+  }
   log.warn(
     `Claude account "${from}" is out of usage; this and every other session on it now runs on "${to}"${until ? ` until ${new Date(until).toISOString()}` : " until opencode restarts"}.`,
     { source: from, target: to, until: until ?? null }
@@ -1623,6 +1845,9 @@ function resolveAccountOverride(source, now = Date.now()) {
   }
   return entry.target;
 }
+function clearAccountOverride(source) {
+  accountOverrides.delete(normalizeAccountName(source || DEFAULT_ACCOUNT));
+}
 function stripAccountSuffix(modelId) {
   const at = modelId.indexOf("@");
   return at === -1 ? modelId : modelId.slice(0, at);
@@ -1671,6 +1896,20 @@ function failoverCandidates(accounts, source, groups) {
   }
   return out;
 }
+function isAccountKnownUnavailable(account, now = Date.now()) {
+  if (resolveAccountOverride(account, now) !== void 0) return true;
+  return recallAccountLimit(account, now).resetsAt !== void 0;
+}
+function nextAutoFailoverAccount(candidates, tried, now = Date.now()) {
+  return candidates.find(
+    (account) => !tried.has(account) && !isAccountKnownUnavailable(account, now)
+  );
+}
+function nextUsageSwitchAccount(candidates, exclude, switchAt, now = Date.now()) {
+  return candidates.find(
+    (account) => !exclude.has(account) && !isAccountKnownUnavailable(account, now) && !accountUsageAtOrOver(account, switchAt, now)
+  );
+}
 var pendingQuestions2 = /* @__PURE__ */ new Map();
 function pendingKey2(sessionKey2, toolCallId) {
   return `${sessionKey2}${KEY_SEPARATOR2}${toolCallId}`;
@@ -1797,6 +2036,13 @@ function formatFailoverNote(input) {
 ${FAILOVER_MARKER} "${input.sourceAccount}" is out of usage, so this conversation continues on "${input.target}" ${resets ? `until ${resets}` : "until opencode restarts"}. Claude cannot resume a session across accounts, so the thread is being replayed into a fresh one.
 `;
 }
+function formatAutoFailoverNote(input) {
+  const resets = describeReset(input.resetsAt);
+  const arrival = input.carried ? "The conversation continues where it stopped." : "The conversation is replayed into a fresh Claude session there.";
+  return `
+${FAILOVER_MARKER} "${input.failedAccount}" ${input.reason ?? "is out of usage"}, so this turn moved to "${input.target}" automatically and stays there until ${resets ?? "opencode restarts"}. ${arrival}
+`;
+}
 function formatFailoverStopNote(reason) {
   return `
 ${FAILOVER_MARKER} Staying on this account (${reason}). The turn ends here; the usage limit is unchanged.
@@ -1845,7 +2091,7 @@ function failoverUntil(resetsAt) {
 }
 
 // src/subagent-dispatch.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/agent-models.ts
 import { readFile, readdir } from "fs/promises";
@@ -2253,6 +2499,7 @@ var REASONING_EFFORTS = [
 var registry = {};
 var defaultSubagentModel;
 var defaultSubagentCacheTtl;
+var defaultSubagentCliCaps = {};
 var providerFallbackModels = [];
 function setAgentRegistry(records2) {
   registry = records2;
@@ -2269,6 +2516,15 @@ function getDefaultSubagentModel() {
 function setDefaultSubagentCacheTtl(ttl) {
   defaultSubagentCacheTtl = ttl?.trim() || void 0;
 }
+function setDefaultSubagentCliCaps(caps) {
+  defaultSubagentCliCaps = {
+    ...caps.maxTurns !== void 0 ? { maxTurns: caps.maxTurns } : {},
+    ...caps.maxBudgetUsd !== void 0 ? { maxBudgetUsd: caps.maxBudgetUsd } : {}
+  };
+}
+function getDefaultSubagentCliCaps() {
+  return { ...defaultSubagentCliCaps };
+}
 function setProviderFallbackModels(models) {
   providerFallbackModels = models ?? [];
 }
@@ -2352,6 +2608,45 @@ function resolveAgentCacheTtl(agent, overrides) {
   log.debug("agent prompt cache ttl", { agent, ttl: wanted });
   return wanted;
 }
+var refusedMainAgentBudgets = /* @__PURE__ */ new Set();
+function resolveAgentCliCaps(agent, overrides) {
+  if (!agent) return {};
+  const record = (overrides?.records ?? registry)[agent];
+  if (!record) return {};
+  const defaults = overrides?.defaults ?? defaultSubagentCliCaps;
+  const isSubagent = record.mode === "subagent";
+  const caps = {};
+  const turns = parseCap(record.maxTurns, true);
+  if (record.maxTurns !== void 0 && turns === void 0) {
+    log.warn("agent maxTurns refused: not a positive whole number", { agent });
+  }
+  const maxTurns = turns ?? (isSubagent ? defaults.maxTurns : void 0);
+  if (maxTurns !== void 0) caps.maxTurns = maxTurns;
+  const budget = parseCap(record.maxBudgetUsd, false);
+  if (record.maxBudgetUsd !== void 0 && budget === void 0) {
+    log.warn("agent maxBudgetUsd refused: not a positive number of dollars", { agent });
+  }
+  if (budget !== void 0 && !isSubagent) {
+    if (!refusedMainAgentBudgets.has(agent)) {
+      refusedMainAgentBudgets.add(agent);
+      log.warn(
+        "agent maxBudgetUsd ignored: the CLI counts it over a reused process's whole life, so it applies to subagents only",
+        { agent }
+      );
+    }
+  } else {
+    const maxBudgetUsd = budget ?? (isSubagent ? defaults.maxBudgetUsd : void 0);
+    if (maxBudgetUsd !== void 0) caps.maxBudgetUsd = maxBudgetUsd;
+  }
+  return caps;
+}
+function parseCap(value, integer) {
+  if (value === void 0) return void 0;
+  const parsed = typeof value === "string" ? value.trim() ? Number(value) : NaN : value;
+  if (!Number.isFinite(parsed) || parsed <= 0) return void 0;
+  if (integer && !Number.isInteger(parsed)) return void 0;
+  return parsed;
+}
 function parseAgentFrontmatter(text) {
   const record = {};
   if (!text.startsWith("---")) return record;
@@ -2384,6 +2679,8 @@ function parseAgentFrontmatter(text) {
     else if (key === "forceModel") record.forceModel = value;
     else if (key === "reasoningEffort") record.reasoningEffort = value;
     else if (key === "cacheTtl") record.cacheTtl = value;
+    else if (key === "maxTurns") record.maxTurns = value;
+    else if (key === "maxBudgetUsd") record.maxBudgetUsd = value;
   }
   return record;
 }
@@ -2445,18 +2742,18 @@ function agentDirectories(home, projectDirectory) {
 }
 
 // src/dispatch-choice-store.ts
-import { mkdirSync as mkdirSync2, readFileSync, renameSync as renameSync2, writeFileSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join2 } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, renameSync as renameSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join3 } from "path";
 var MAX_DISPATCH_CHOICE_SESSIONS = 128;
 var MAX_DISPATCH_CHOICES_PER_SESSION = 32;
 var DISPATCH_CHOICE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
 var sessions = null;
-var pathOverride = null;
+var pathOverride2 = null;
 function dispatchChoiceStorePath() {
-  if (pathOverride) return pathOverride;
-  const stateRoot = process.env.XDG_STATE_HOME || join2(homedir3(), ".local", "state");
-  return join2(stateRoot, "opencode-claude-code-plugin", "subagent-dispatch.json");
+  if (pathOverride2) return pathOverride2;
+  const stateRoot = process.env.XDG_STATE_HOME || join3(homedir4(), ".local", "state");
+  return join3(stateRoot, "opencode-claude-code-plugin", "subagent-dispatch.json");
 }
 function isChoice(value) {
   const choice = value;
@@ -2482,7 +2779,7 @@ function trimChoices(choices) {
 function readFile2(file) {
   const out = /* @__PURE__ */ new Map();
   try {
-    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    const parsed = JSON.parse(readFileSync2(file, "utf8"));
     const entries = parsed && typeof parsed === "object" ? parsed.sessions : null;
     if (!entries || typeof entries !== "object") return out;
     const cutoff = Date.now() - DISPATCH_CHOICE_MAX_AGE_MS;
@@ -2504,12 +2801,12 @@ function save(update) {
   const kept = [...merged.entries()].filter(([, record]) => record.updatedAt >= cutoff).filter(([, record]) => Object.keys(record.choices).length > 0).sort((a, b) => a[1].updatedAt - b[1].updatedAt).slice(-MAX_DISPATCH_CHOICE_SESSIONS);
   sessions = new Map(kept);
   try {
-    mkdirSync2(join2(file, ".."), { recursive: true, mode: 448 });
+    mkdirSync3(join3(file, ".."), { recursive: true, mode: 448 });
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
+    writeFileSync2(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
       mode: 384
     });
-    renameSync2(tmp, file);
+    renameSync3(tmp, file);
   } catch (err) {
     log.debug("could not write the subagent dispatch choice store", {
       error: err instanceof Error ? err.message : String(err)
@@ -3419,97 +3716,404 @@ function stripSubagentDispatchParts(prompt) {
   return changed ? out : prompt;
 }
 
-// src/cli-version.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-
-// src/windows-spawn.ts
-import * as fs2 from "fs";
-import * as path4 from "path";
-var DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
-function envValue(env, name) {
-  const direct = env[name];
-  if (direct !== void 0) return direct;
-  const match = Object.keys(env).find((key) => key.toLowerCase() === name.toLowerCase());
-  return match === void 0 ? void 0 : env[match];
+// src/session-fork.ts
+import { createHash } from "crypto";
+var fingerprints = /* @__PURE__ */ new Map();
+var fingerprintSeq = 0;
+var MAX_FORK_FINGERPRINTS = 64;
+function hashPart(hash, part) {
+  const p = part;
+  const type = typeof p?.type === "string" ? p.type : "unknown";
+  switch (type) {
+    case "text":
+      hash.update("text\0");
+      hash.update(String(p?.text ?? ""));
+      break;
+    case "tool-call":
+      hash.update("call\0");
+      hash.update(String(p?.toolName ?? ""));
+      hash.update("\0");
+      hash.update(stableJson(p?.input));
+      break;
+    case "tool-result":
+      hash.update("result\0");
+      hash.update(String(p?.toolName ?? ""));
+      hash.update("\0");
+      hash.update(stableJson(p?.output));
+      break;
+    case "file":
+    case "image": {
+      hash.update(type);
+      hash.update("\0");
+      hash.update(String(p?.mediaType ?? ""));
+      hash.update("\0");
+      const data = p?.data ?? p?.image;
+      if (typeof data === "string") hash.update(data);
+      else if (data instanceof Uint8Array) hash.update(data);
+      else if (data instanceof URL) hash.update(data.href);
+      else hash.update(stableJson(data));
+      break;
+    }
+    default:
+      hash.update("other\0");
+      hash.update(type);
+      break;
+  }
+  hash.update("");
 }
-function defaultIsFile(candidate) {
+function stableJson(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (node) => {
+    if (node === null || typeof node !== "object") return node;
+    if (seen.has(node)) return "[circular]";
+    seen.add(node);
+    if (Array.isArray(node)) return node.map(walk);
+    const out = {};
+    for (const key of Object.keys(node).sort()) {
+      out[key] = walk(node[key]);
+    }
+    return out;
+  };
   try {
-    return fs2.statSync(candidate).isFile();
+    return JSON.stringify(walk(value)) ?? "null";
   } catch {
-    return false;
+    return "[unserializable]";
   }
 }
-function executableExtensions(env = process.env) {
-  const raw = envValue(env, "PATHEXT") ?? DEFAULT_PATHEXT;
-  return raw.split(";").map((ext) => ext.trim().toLowerCase()).filter(Boolean).map((ext) => ext.startsWith(".") ? ext : `.${ext}`);
-}
-function isBatchFile(file) {
-  const ext = path4.win32.extname(file).toLowerCase();
-  return ext === ".cmd" || ext === ".bat";
-}
-function resolveWindowsCommand(command, deps = {}) {
-  const env = deps.env ?? process.env;
-  const isFile = deps.isFile ?? defaultIsFile;
-  const extensions = executableExtensions(env);
-  const candidatesFor = (base) => {
-    const ext = path4.win32.extname(base).toLowerCase();
-    if (ext && extensions.includes(ext)) return [base];
-    return [...extensions.map((candidate) => base + candidate), base];
-  };
-  if (command.includes("\\") || command.includes("/")) {
-    for (const candidate of candidatesFor(command)) {
-      if (isFile(candidate)) return candidate;
-    }
-    return null;
-  }
-  const pathValue = envValue(env, "PATH") ?? "";
-  for (const entry of pathValue.split(path4.win32.delimiter)) {
-    const directory = entry.trim().replace(/^"(.*)"$/, "$1");
-    if (!directory) continue;
-    for (const candidate of candidatesFor(path4.win32.join(directory, command))) {
-      if (isFile(candidate)) return candidate;
-    }
+function messageDigest(msg) {
+  const hash = createHash("sha256");
+  hash.update(msg.role);
+  hash.update("\0");
+  if (typeof msg.content === "string") {
+    hash.update("text\0");
+    hash.update(msg.content);
+    hash.update("");
+  } else if (Array.isArray(msg.content)) {
+    for (const part of msg.content) hashPart(hash, part);
   }
-  return null;
+  return hash.digest("hex").slice(0, 32);
 }
-function quoteBatchArgument(arg) {
-  if (/[\r\n]/.test(arg)) {
-    throw new Error("cmd.exe cannot carry a newline in an argument");
-  }
-  let out = '"';
-  let backslashes = 0;
-  for (const char of arg) {
-    if (char === "\\") {
-      backslashes += 1;
-      continue;
-    }
-    if (char === '"') {
-      out += "\\".repeat(backslashes * 2) + '""';
-      backslashes = 0;
+var ASSISTANT_TURN_DIGEST = "assistant-turn";
+function conversationDigests(prompt, opts) {
+  const out = [];
+  for (const msg of prompt) {
+    if (msg.role !== "user" && msg.role !== "assistant" && msg.role !== "tool") {
       continue;
     }
-    out += "\\".repeat(backslashes) + char;
-    backslashes = 0;
+    out.push({
+      role: msg.role,
+      digest: opts?.assistantContent === false && msg.role === "assistant" ? ASSISTANT_TURN_DIGEST : messageDigest(msg)
+    });
   }
-  return `${out}${"\\".repeat(backslashes * 2)}"`;
-}
-function planCmdInvocation(file, args, env = process.env) {
-  const comspec = envValue(env, "ComSpec") ?? "cmd.exe";
-  const line = [`"${path4.win32.normalize(file)}"`, ...args.map(quoteBatchArgument)];
-  return {
-    file: comspec,
-    args: ["/d", "/s", "/c", `"${line.join(" ")}"`],
-    windowsVerbatimArguments: true
-  };
-}
-function planClaudeSpawn(command, args, deps = {}) {
-  const platform2 = deps.platform ?? process.platform;
-  if (platform2 !== "win32") return { file: command, args: [...args] };
-  const env = deps.env ?? process.env;
-  const resolved = resolveWindowsCommand(command, deps) ?? command;
-  if (isBatchFile(resolved)) return planCmdInvocation(resolved, args, env);
-  return { file: resolved, args: [...args] };
+  return out;
+}
+function recordForkFingerprint(sessionKey2, prompt, cliPath) {
+  const entries = conversationDigests(prompt);
+  if (entries.length === 0) return;
+  fingerprints.delete(sessionKey2);
+  fingerprints.set(sessionKey2, { entries, cliPath, seq: ++fingerprintSeq });
+  while (fingerprints.size > MAX_FORK_FINGERPRINTS) {
+    const oldest = fingerprints.keys().next();
+    if (oldest.done) break;
+    fingerprints.delete(oldest.value);
+  }
+}
+function forgetForkFingerprint(sessionKey2) {
+  fingerprints.delete(sessionKey2);
+}
+function forkSiblingSignature(sessionKey2) {
+  const parts = sessionKey2.split("::");
+  if (parts.length < 5) return null;
+  if (parts[2] === "compaction") return null;
+  const blanked = [...parts];
+  blanked[3] = "*";
+  return blanked.join("::");
+}
+function modelSiblingSignature(sessionKey2, accountProviders) {
+  const parts = sessionKey2.split("::");
+  if (parts.length < 5) return null;
+  if (parts[2] === "compaction") return null;
+  const withoutEffort = parts[parts.length - 1].startsWith("effort=") ? parts.slice(0, -1) : parts;
+  if (withoutEffort.length < 5) return null;
+  const blanked = [...withoutEffort];
+  blanked[1] = "*";
+  const signature = blanked.join("::");
+  return accountProviders && accountProviders.size > 0 ? blankAccountProvider(signature, accountProviders) : signature;
+}
+function moveForkFingerprint(fromKey, toKey) {
+  const record = fingerprints.get(fromKey);
+  if (!record) return;
+  fingerprints.delete(fromKey);
+  fingerprints.delete(toKey);
+  fingerprints.set(toKey, { ...record, seq: ++fingerprintSeq });
+}
+function splitForkHistory(prompt, opts) {
+  const messages = prompt;
+  let lastAssistant = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "assistant") {
+      lastAssistant = i;
+      break;
+    }
+  }
+  if (lastAssistant < 0) return { history: [], forkable: false };
+  for (let i = lastAssistant + 1; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === "tool") return { history: [], forkable: false };
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part?.type === "tool-result") return { history: [], forkable: false };
+    }
+  }
+  return {
+    history: conversationDigests(messages.slice(0, lastAssistant + 1), opts),
+    forkable: true
+  };
+}
+function findForkParent(opts) {
+  const signature = forkSiblingSignature(opts.sessionKey);
+  if (!signature) return null;
+  const { history, forkable } = splitForkHistory(opts.prompt);
+  if (!forkable || history.length === 0) return null;
+  let best = null;
+  let bestLength = 0;
+  let bestSeq = -1;
+  for (const [key, fingerprint] of fingerprints) {
+    if (key === opts.sessionKey) continue;
+    if (fingerprint.cliPath !== opts.cliPath) continue;
+    if (forkSiblingSignature(key) !== signature) continue;
+    const recorded = fingerprint.entries;
+    if (recorded.length === 0 || recorded.length > history.length) continue;
+    if (!isPrefix(recorded, history)) continue;
+    if (!tailIsReplyOnly(history, recorded.length)) continue;
+    const claudeSessionId = opts.lookupClaudeSessionId(key);
+    if (!claudeSessionId) continue;
+    if (opts.isBusy(key)) continue;
+    if (recorded.length > bestLength || recorded.length === bestLength && fingerprint.seq > bestSeq) {
+      best = { parentKey: key, claudeSessionId, matched: recorded.length };
+      bestLength = recorded.length;
+      bestSeq = fingerprint.seq;
+    }
+  }
+  if (best) {
+    log.info("found a fork parent for this conversation", {
+      sessionKey: opts.sessionKey,
+      parentKey: best.parentKey,
+      matchedMessages: best.matched,
+      historyMessages: history.length
+    });
+  }
+  return best;
+}
+function continuesRecordedConversation(recorded, prompt, opts) {
+  const { history, forkable } = splitForkHistory(prompt, opts);
+  if (!forkable || recorded.length === 0 || recorded.length > history.length) return false;
+  return isPrefix(recorded, history) && tailIsReplyOnly(history, recorded.length);
+}
+function isPrefix(recorded, history) {
+  for (let i = 0; i < recorded.length; i++) {
+    if (recorded[i].role !== history[i].role) return false;
+    if (recorded[i].digest !== history[i].digest) return false;
+  }
+  return true;
+}
+function tailIsReplyOnly(history, from) {
+  for (let i = from; i < history.length; i++) {
+    if (history[i].role === "user") return false;
+  }
+  return true;
+}
+
+// src/conversation-gap.ts
+var served = /* @__PURE__ */ new Map();
+var servedSeq = 0;
+var MAX_SERVED_CONVERSATIONS = 64;
+function recordServedConversation(sessionKey2, prompt) {
+  const chain = conversationDigests(prompt, { assistantContent: false });
+  if (chain.length === 0) return;
+  served.delete(sessionKey2);
+  served.set(sessionKey2, { chain, seq: ++servedSeq });
+  while (served.size > MAX_SERVED_CONVERSATIONS) {
+    const oldest = served.keys().next();
+    if (oldest.done) break;
+    served.delete(oldest.value);
+  }
+}
+function forgetServedConversation(sessionKey2) {
+  served.delete(sessionKey2);
+}
+function moveServedConversation(fromKey, toKey) {
+  const record = served.get(fromKey);
+  if (!record) return;
+  served.delete(fromKey);
+  served.delete(toKey);
+  served.set(toKey, { ...record, seq: ++servedSeq });
+}
+function classifyConversationChange(sessionKey2, prompt) {
+  const record = served.get(sessionKey2);
+  if (!record) return null;
+  const recorded = record.chain;
+  if (recorded.length === 0) return null;
+  const messages = prompt;
+  let lastAssistant = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "assistant") {
+      lastAssistant = i;
+      break;
+    }
+  }
+  if (lastAssistant < 0) return null;
+  const history = [];
+  for (let i = 0; i <= lastAssistant; i++) {
+    const msg = messages[i];
+    if (msg.role !== "user" && msg.role !== "assistant" && msg.role !== "tool") continue;
+    const [entry] = conversationDigests([msg], { assistantContent: false });
+    history.push({ index: i, role: entry.role, digest: entry.digest });
+  }
+  let shared = 0;
+  while (shared < recorded.length && shared < history.length && recorded[shared].role === history[shared].role && recorded[shared].digest === history[shared].digest) {
+    shared++;
+  }
+  if (shared < recorded.length) {
+    if (shared === 0) return null;
+    let removedUserMessages = 0;
+    for (let i = shared; i < recorded.length; i++) {
+      if (recorded[i].role === "user") removedUserMessages++;
+    }
+    if (removedUserMessages === 0) return null;
+    log.debug("this claude session holds turns the conversation no longer has", {
+      sessionKey: sessionKey2,
+      recorded: recorded.length,
+      shared,
+      removedUserMessages
+    });
+    return {
+      kind: "rewound",
+      sharedMessages: shared,
+      removedMessages: recorded.length - shared,
+      removedUserMessages
+    };
+  }
+  let firstUser = -1;
+  for (let i = recorded.length; i < history.length; i++) {
+    if (history[i].role === "user") {
+      firstUser = i;
+      break;
+    }
+  }
+  if (firstUser < 0) return null;
+  const from = history[firstUser].index;
+  const missed = messages.slice(from, lastAssistant + 1);
+  let userMessages = 0;
+  for (let i = firstUser; i < history.length; i++) {
+    if (history[i].role === "user") userMessages++;
+  }
+  log.debug("this claude session missed part of the conversation", {
+    sessionKey: sessionKey2,
+    recorded: recorded.length,
+    missed: missed.length,
+    userMessages
+  });
+  return { kind: "missed", messages: missed, userMessages };
+}
+var CONVERSATION_REWOUND_MARKER = "\u258C **conversation rewound:**";
+function formatConversationRewoundNote() {
+  return `
+${CONVERSATION_REWOUND_MARKER} this conversation was edited or undone, so the Claude session answering it still held the turns that were removed. This turn replays the thread as it stands now into a fresh Claude session, which no longer has them.
+`;
+}
+
+// src/cli-version.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/windows-spawn.ts
+import * as fs2 from "fs";
+import * as path4 from "path";
+var DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
+function envValue(env, name) {
+  const direct = env[name];
+  if (direct !== void 0) return direct;
+  const match = Object.keys(env).find((key) => key.toLowerCase() === name.toLowerCase());
+  return match === void 0 ? void 0 : env[match];
+}
+function defaultIsFile(candidate) {
+  try {
+    return fs2.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+function executableExtensions(env = process.env) {
+  const raw = envValue(env, "PATHEXT") ?? DEFAULT_PATHEXT;
+  return raw.split(";").map((ext) => ext.trim().toLowerCase()).filter(Boolean).map((ext) => ext.startsWith(".") ? ext : `.${ext}`);
+}
+function isBatchFile(file) {
+  const ext = path4.win32.extname(file).toLowerCase();
+  return ext === ".cmd" || ext === ".bat";
+}
+function resolveWindowsCommand(command, deps = {}) {
+  const env = deps.env ?? process.env;
+  const isFile = deps.isFile ?? defaultIsFile;
+  const extensions = executableExtensions(env);
+  const candidatesFor = (base) => {
+    const ext = path4.win32.extname(base).toLowerCase();
+    if (ext && extensions.includes(ext)) return [base];
+    return [...extensions.map((candidate) => base + candidate), base];
+  };
+  if (command.includes("\\") || command.includes("/")) {
+    for (const candidate of candidatesFor(command)) {
+      if (isFile(candidate)) return candidate;
+    }
+    return null;
+  }
+  const pathValue = envValue(env, "PATH") ?? "";
+  for (const entry of pathValue.split(path4.win32.delimiter)) {
+    const directory = entry.trim().replace(/^"(.*)"$/, "$1");
+    if (!directory) continue;
+    for (const candidate of candidatesFor(path4.win32.join(directory, command))) {
+      if (isFile(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function quoteBatchArgument(arg) {
+  if (/[\r\n]/.test(arg)) {
+    throw new Error("cmd.exe cannot carry a newline in an argument");
+  }
+  let out = '"';
+  let backslashes = 0;
+  for (const char of arg) {
+    if (char === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    if (char === '"') {
+      out += "\\".repeat(backslashes * 2) + '""';
+      backslashes = 0;
+      continue;
+    }
+    out += "\\".repeat(backslashes) + char;
+    backslashes = 0;
+  }
+  return `${out}${"\\".repeat(backslashes * 2)}"`;
+}
+function planCmdInvocation(file, args, env = process.env) {
+  const comspec = envValue(env, "ComSpec") ?? "cmd.exe";
+  const line = [`"${path4.win32.normalize(file)}"`, ...args.map(quoteBatchArgument)];
+  return {
+    file: comspec,
+    args: ["/d", "/s", "/c", `"${line.join(" ")}"`],
+    windowsVerbatimArguments: true
+  };
+}
+function planClaudeSpawn(command, args, deps = {}) {
+  const platform2 = deps.platform ?? process.platform;
+  if (platform2 !== "win32") return { file: command, args: [...args] };
+  const env = deps.env ?? process.env;
+  const resolved = resolveWindowsCommand(command, deps) ?? command;
+  if (isBatchFile(resolved)) return planCmdInvocation(resolved, args, env);
+  return { file: resolved, args: [...args] };
 }
 
 // src/cli-version.ts
@@ -3524,7 +4128,7 @@ function probeExec(cliPath, args, options) {
     windowsVerbatimArguments: plan.windowsVerbatimArguments
   });
 }
-var cache = /* @__PURE__ */ new Map();
+var cache2 = /* @__PURE__ */ new Map();
 var PROBE_TIMEOUT_MS = 5e3;
 var probeTimeoutMs = PROBE_TIMEOUT_MS;
 var MAX_DEADLINE_REPROBES = 2;
@@ -3569,8 +4173,8 @@ function spawnMcpTimeoutEnv(inherited = process.env) {
   return inherited.MCP_TIMEOUT === void 0 ? { MCP_TIMEOUT: String(SPAWN_MCP_TIMEOUT_MS) } : {};
 }
 function detectCliVersion(cliPath) {
-  const cached = cache.get(cliPath);
-  if (cached) return cached;
+  const cached2 = cache2.get(cliPath);
+  if (cached2) return cached2;
   let deadlineKill = false;
   const promise = (async () => {
     try {
@@ -3606,8 +4210,8 @@ function detectCliVersion(cliPath) {
       return null;
     }
   })();
-  cache.set(cliPath, promise);
-  forgetDeadlineKill(cache, cliPath, promise, () => deadlineKill);
+  cache2.set(cliPath, promise);
+  forgetDeadlineKill(cache2, cliPath, promise, () => deadlineKill);
   return promise;
 }
 function gte(v, target) {
@@ -3639,6 +4243,10 @@ function cliSupportsInteractiveBypass(v) {
   if (!v) return false;
   return gte(v, { major: 2, minor: 1, patch: 263 });
 }
+function cliSupportsMaxTurns(v) {
+  if (!v) return false;
+  return gte(v, { major: 2, minor: 1, patch: 280 });
+}
 var INTERACTIVE_MEASURED_CLI = "2.1.293";
 var INTERACTIVE_MEASURED = { major: 2, minor: 1, patch: 293 };
 function isUnmeasuredInteractiveCli(v) {
@@ -3666,8 +4274,8 @@ var flagSupport = /* @__PURE__ */ new Map();
 var headlessSupport = /* @__PURE__ */ new Map();
 function detectHeadlessSupport(cliPath) {
   const key = `${cliPath}\0headless`;
-  const cached = headlessSupport.get(key);
-  if (cached) return cached;
+  const cached2 = headlessSupport.get(key);
+  if (cached2) return cached2;
   let deadlineKill = false;
   const promise = (async () => {
     try {
@@ -3702,8 +4310,8 @@ function detectHeadlessSupport(cliPath) {
 }
 function detectCliSupportsFlag(cliPath, flag) {
   const key = `${cliPath}\0${flag}`;
-  const cached = flagSupport.get(key);
-  if (cached) return cached;
+  const cached2 = flagSupport.get(key);
+  if (cached2) return cached2;
   let deadlineKill = false;
   const promise = (async () => {
     try {
@@ -4383,6 +4991,21 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
           writeToolCallResult(res, requestId, intercepted);
           return;
         }
+        if (options.admit) {
+          let refusal = null;
+          try {
+            refusal = await options.admit(toolName, input);
+          } catch (admitError) {
+            log.warn("proxy-mcp admission check failed; letting the call through", {
+              toolName,
+              error: admitError instanceof Error ? admitError.message : String(admitError)
+            });
+          }
+          if (refusal) {
+            writeToolCallResult(res, requestId, refusal);
+            return;
+          }
+        }
         const callId = crypto.randomUUID();
         log.info("proxy-mcp tool call received", {
           callId,
@@ -4403,12 +5026,12 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
         });
         let timer = null;
         const result = await new Promise(
-          (resolve6, reject2) => {
+          (resolve7, reject2) => {
             const entry = {
               id: callId,
               toolName,
               input,
-              resolve: resolve6,
+              resolve: resolve7,
               reject: reject2,
               channel
             };
@@ -4497,11 +5120,11 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
       }
     }
   });
-  await new Promise((resolve6, reject2) => {
+  await new Promise((resolve7, reject2) => {
     server2.once("error", reject2);
     server2.listen(0, "127.0.0.1", () => {
       server2.off("error", reject2);
-      resolve6();
+      resolve7();
     });
   });
   const addr = server2.address();
@@ -4558,8 +5181,8 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
         entry.reject(new Error(SERVER_CLOSED_MESSAGE));
       }
       pending2.clear();
-      await new Promise((resolve6) => {
-        server2.close(() => resolve6());
+      await new Promise((resolve7) => {
+        server2.close(() => resolve7());
       });
       if (configFilePath) {
         try {
@@ -4615,6 +5238,7 @@ function resolveDisallowedTools(options) {
   for (const name of disallowedToolFlags(options.proxyTools ?? [])) push(name);
   for (const name of options.extraDisallowedTools ?? []) push(String(name));
   if (options.disableWebSearch) push("WebSearch");
+  for (const rule of options.readRules ?? []) push(String(rule));
   return out;
 }
 function resolveProxyOpencodeToolDefs(options) {
@@ -4731,10 +5355,10 @@ function resolveMcpProxyToolDefs(options) {
   return { defs, coveredServers, matchedServers };
 }
 function readBody(req) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve6(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve7(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -5623,6 +6247,7 @@ var opencodeClient = null;
 function setOpencodeClient(client) {
   if (client && typeof client === "object") {
     opencodeClient = client;
+    childSessionAnswers.clear();
   }
 }
 function getOpencodeClient() {
@@ -5690,6 +6315,20 @@ async function fetchSessionParentId(sessionID) {
     return void 0;
   }
 }
+var childSessionAnswers = /* @__PURE__ */ new Map();
+var MAX_CHILD_SESSION_ANSWERS = 256;
+function watchChildSession(sessionID) {
+  if (!sessionID || sessionID === "default") return () => false;
+  const known = childSessionAnswers.get(sessionID);
+  if (known !== void 0) return () => known;
+  let answer;
+  void fetchSessionParentId(sessionID).then((parentID) => {
+    answer = !!parentID;
+    if (childSessionAnswers.size >= MAX_CHILD_SESSION_ANSWERS) childSessionAnswers.clear();
+    childSessionAnswers.set(sessionID, answer);
+  });
+  return () => answer;
+}
 async function fetchSessionRunState(sessionID, directory) {
   if (!sessionID || sessionID === "default") return "unknown";
   const status = opencodeClient?.session?.status;
@@ -5726,7 +6365,7 @@ async function settleSessionRunState(sessionID, options = {}) {
     if (state === "busy") return "busy";
     if (state !== "unknown") last = state;
     if (Date.now() - started2 >= windowMs) return last;
-    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
+    await new Promise((resolve7) => setTimeout(resolve7, pollMs));
   }
 }
 var DEFAULT_MCP_CONNECT_WAIT_MS = 3e3;
@@ -5779,7 +6418,7 @@ async function waitForPendingMcpServers(first, budgetMs, signal) {
   for (; ; ) {
     if (Date.now() - started2 >= budgetMs) break;
     if (signal?.aborted) break;
-    await new Promise((resolve6) => setTimeout(resolve6, MCP_CONNECT_POLL_MS));
+    await new Promise((resolve7) => setTimeout(resolve7, MCP_CONNECT_POLL_MS));
     if (signal?.aborted) break;
     const next = await fetchRuntimeMcpStatus();
     if (!next) break;
@@ -6008,8 +6647,8 @@ async function countOtherRunningWithin(exclude, budgetMs) {
     worker
   );
   let timer;
-  const deadline = new Promise((resolve6) => {
-    timer = setTimeout(() => resolve6("over"), budgetMs);
+  const deadline = new Promise((resolve7) => {
+    timer = setTimeout(() => resolve7("over"), budgetMs);
     timer.unref?.();
   });
   try {
@@ -6040,6 +6679,41 @@ async function withBackgroundRunningCount(result, budgetMs = BACKGROUND_COUNT_BU
   }
   return { ...result, text: result.text + formatBackgroundRunningLine(others, dispatched.length) };
 }
+var BACKGROUND_CAP_BUDGET_MS = 2e3;
+function requestedBackgroundChildren(toolName, input) {
+  const isBackground = (value) => value === true || value === "true";
+  if (toolName === "task") return isBackground(input.background) ? 1 : 0;
+  if (toolName === "task_batch" && Array.isArray(input.tasks)) {
+    return input.tasks.filter(
+      (task) => !!task && typeof task === "object" && isBackground(task.background)
+    ).length;
+  }
+  return 0;
+}
+async function admitBackgroundDispatch(toolName, input, cap, budgetMs = BACKGROUND_CAP_BUDGET_MS) {
+  const requested = requestedBackgroundChildren(toolName, input);
+  if (requested === 0) return null;
+  const running = await countOtherRunningWithin(/* @__PURE__ */ new Set(), budgetMs);
+  if (running !== void 0 && running + requested <= cap) return null;
+  log.notice("background dispatch refused by maxBackgroundSubagents", {
+    toolName,
+    cap,
+    requested,
+    ...running === void 0 ? { countUnreadable: true } : { running }
+  });
+  return {
+    kind: "error",
+    message: formatBackgroundCapRefusal({ toolName, cap, running, requested, budgetMs })
+  };
+}
+function formatBackgroundCapRefusal(opts) {
+  const batch = opts.toolName === "task_batch";
+  const what = batch ? `This task_batch was not started, none of its tasks: a batch is refused whole.` : `This background task was not started.`;
+  const why = opts.running === void 0 ? `\`maxBackgroundSubagents\` allows ${opts.cap} background subagent${opts.cap === 1 ? "" : "s"} at once, and the running count could not be read within ${Math.round(
+    (opts.budgetMs ?? BACKGROUND_CAP_BUDGET_MS) / 1e3
+  )} s, so the cap could not be checked.` : `\`maxBackgroundSubagents\` allows ${opts.cap} background subagent${opts.cap === 1 ? "" : "s"} at once, ${opts.running} ${opts.running === 1 ? "is" : "are"} running now, and this ${batch ? "batch" : "dispatch"} would start ${opts.requested} more.`;
+  return `Background dispatch refused. ${why} ${what} Run this work in the foreground instead (omit \`background\`), which is never capped, or keep working and dispatch it later: a running subagent's result arrives as a new message when it finishes. Do not sleep or poll for room.`;
+}
 function formatBackgroundRunningLine(others, dispatched) {
   const total = others + dispatched;
   const including = dispatched === 1 ? "this one" : `the ${dispatched} just started`;
@@ -6121,288 +6795,80 @@ opencode has no assistant reply for this task yet and it is not running. It may
     };
   }
   if (reply.error) {
-    markCollected(options.sessionKey, taskId);
-    return {
-      kind: "text",
-      isError: true,
-      text: `<task id="${taskId}" state="error">
-${reply.error}
-</task>`
-    };
-  }
-  if (hasCollectedBackgroundTask(options.sessionKey, taskId)) {
-    return {
-      kind: "text",
-      text: `<task id="${taskId}" state="completed">
-Already delivered to this conversation earlier (by this tool or by opencode's completion notification). Scroll back for the result rather than collecting it again.
-</task>`
-    };
-  }
-  markCollected(options.sessionKey, taskId);
-  log.info("collected background subagent result", {
-    sessionKey: options.sessionKey,
-    taskId,
-    textLength: reply.text.length
-  });
-  return {
-    kind: "text",
-    text: `<task id="${taskId}" state="completed">
-<task_result>
-${reply.text || "(the subagent produced no text)"}
-</task_result>
-</task>`
-  };
-}
-async function cancelBackgroundTask(input, options) {
-  const taskId = readTaskId(input);
-  if (!taskId) return { kind: "error", message: MISSING_TASK_ID };
-  const refused = await guardParent(taskId, options.callerSessionId);
-  if (refused) return { kind: "error", message: refused };
-  const running = isBackgroundTaskRunning(
-    await fetchSessionRunState(taskId),
-    await fetchSessionReplies(taskId) ?? []
-  );
-  const aborted = await abortSession(taskId);
-  if (!aborted) {
-    return {
-      kind: "error",
-      message: `Could not cancel background task ${taskId}: opencode did not accept the abort. It may have already finished, or this opencode build does not expose session abort.`
-    };
-  }
-  collected.get(options.sessionKey)?.delete(taskId);
-  mark(cancelled, options.sessionKey, taskId);
-  log.info("cancelled background subagent", {
-    sessionKey: options.sessionKey,
-    taskId,
-    wasRunning: running
-  });
-  return {
-    kind: "text",
-    text: `<task id="${taskId}" state="cancelled">
-` + (running ? "Stopped. No completion notification will arrive for it." : "It was not running when the cancel was sent, so nothing was interrupted. No completion notification will arrive for it.") + "\n</task>"
-  };
-}
-
-// src/session-fork.ts
-import { createHash as createHash3 } from "crypto";
-var fingerprints = /* @__PURE__ */ new Map();
-var fingerprintSeq = 0;
-var MAX_FORK_FINGERPRINTS = 64;
-function hashPart(hash, part) {
-  const p = part;
-  const type = typeof p?.type === "string" ? p.type : "unknown";
-  switch (type) {
-    case "text":
-      hash.update("text\0");
-      hash.update(String(p?.text ?? ""));
-      break;
-    case "tool-call":
-      hash.update("call\0");
-      hash.update(String(p?.toolName ?? ""));
-      hash.update("\0");
-      hash.update(stableJson(p?.input));
-      break;
-    case "tool-result":
-      hash.update("result\0");
-      hash.update(String(p?.toolName ?? ""));
-      hash.update("\0");
-      hash.update(stableJson(p?.output));
-      break;
-    case "file":
-    case "image": {
-      hash.update(type);
-      hash.update("\0");
-      hash.update(String(p?.mediaType ?? ""));
-      hash.update("\0");
-      const data = p?.data ?? p?.image;
-      if (typeof data === "string") hash.update(data);
-      else if (data instanceof Uint8Array) hash.update(data);
-      else if (data instanceof URL) hash.update(data.href);
-      else hash.update(stableJson(data));
-      break;
-    }
-    default:
-      hash.update("other\0");
-      hash.update(type);
-      break;
-  }
-  hash.update("");
-}
-function stableJson(value) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  const walk = (node) => {
-    if (node === null || typeof node !== "object") return node;
-    if (seen.has(node)) return "[circular]";
-    seen.add(node);
-    if (Array.isArray(node)) return node.map(walk);
-    const out = {};
-    for (const key of Object.keys(node).sort()) {
-      out[key] = walk(node[key]);
-    }
-    return out;
-  };
-  try {
-    return JSON.stringify(walk(value)) ?? "null";
-  } catch {
-    return "[unserializable]";
-  }
-}
-function messageDigest(msg) {
-  const hash = createHash3("sha256");
-  hash.update(msg.role);
-  hash.update("\0");
-  if (typeof msg.content === "string") {
-    hash.update("text\0");
-    hash.update(msg.content);
-    hash.update("");
-  } else if (Array.isArray(msg.content)) {
-    for (const part of msg.content) hashPart(hash, part);
-  }
-  return hash.digest("hex").slice(0, 32);
-}
-var ASSISTANT_TURN_DIGEST = "assistant-turn";
-function conversationDigests(prompt, opts) {
-  const out = [];
-  for (const msg of prompt) {
-    if (msg.role !== "user" && msg.role !== "assistant" && msg.role !== "tool") {
-      continue;
-    }
-    out.push({
-      role: msg.role,
-      digest: opts?.assistantContent === false && msg.role === "assistant" ? ASSISTANT_TURN_DIGEST : messageDigest(msg)
-    });
-  }
-  return out;
-}
-function recordForkFingerprint(sessionKey2, prompt, cliPath) {
-  const entries = conversationDigests(prompt);
-  if (entries.length === 0) return;
-  fingerprints.delete(sessionKey2);
-  fingerprints.set(sessionKey2, { entries, cliPath, seq: ++fingerprintSeq });
-  while (fingerprints.size > MAX_FORK_FINGERPRINTS) {
-    const oldest = fingerprints.keys().next();
-    if (oldest.done) break;
-    fingerprints.delete(oldest.value);
-  }
-}
-function forgetForkFingerprint(sessionKey2) {
-  fingerprints.delete(sessionKey2);
-}
-function forkSiblingSignature(sessionKey2) {
-  const parts = sessionKey2.split("::");
-  if (parts.length < 5) return null;
-  if (parts[2] === "compaction") return null;
-  const blanked = [...parts];
-  blanked[3] = "*";
-  return blanked.join("::");
-}
-function modelSiblingSignature(sessionKey2, accountProviders) {
-  const parts = sessionKey2.split("::");
-  if (parts.length < 5) return null;
-  if (parts[2] === "compaction") return null;
-  const withoutEffort = parts[parts.length - 1].startsWith("effort=") ? parts.slice(0, -1) : parts;
-  if (withoutEffort.length < 5) return null;
-  const blanked = [...withoutEffort];
-  blanked[1] = "*";
-  const signature = blanked.join("::");
-  return accountProviders && accountProviders.size > 0 ? blankAccountProvider(signature, accountProviders) : signature;
-}
-function moveForkFingerprint(fromKey, toKey) {
-  const record = fingerprints.get(fromKey);
-  if (!record) return;
-  fingerprints.delete(fromKey);
-  fingerprints.delete(toKey);
-  fingerprints.set(toKey, { ...record, seq: ++fingerprintSeq });
-}
-function splitForkHistory(prompt, opts) {
-  const messages = prompt;
-  let lastAssistant = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === "assistant") {
-      lastAssistant = i;
-      break;
-    }
+    markCollected(options.sessionKey, taskId);
+    return {
+      kind: "text",
+      isError: true,
+      text: `<task id="${taskId}" state="error">
+${reply.error}
+</task>`
+    };
   }
-  if (lastAssistant < 0) return { history: [], forkable: false };
-  for (let i = lastAssistant + 1; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg.role === "tool") return { history: [], forkable: false };
-    if (!Array.isArray(msg.content)) continue;
-    for (const part of msg.content) {
-      if (part?.type === "tool-result") return { history: [], forkable: false };
-    }
+  if (hasCollectedBackgroundTask(options.sessionKey, taskId)) {
+    return {
+      kind: "text",
+      text: `<task id="${taskId}" state="completed">
+Already delivered to this conversation earlier (by this tool or by opencode's completion notification). Scroll back for the result rather than collecting it again.
+</task>`
+    };
   }
+  markCollected(options.sessionKey, taskId);
+  log.info("collected background subagent result", {
+    sessionKey: options.sessionKey,
+    taskId,
+    textLength: reply.text.length
+  });
   return {
-    history: conversationDigests(messages.slice(0, lastAssistant + 1), opts),
-    forkable: true
+    kind: "text",
+    text: `<task id="${taskId}" state="completed">
+<task_result>
+${reply.text || "(the subagent produced no text)"}
+</task_result>
+</task>`
   };
 }
-function findForkParent(opts) {
-  const signature = forkSiblingSignature(opts.sessionKey);
-  if (!signature) return null;
-  const { history, forkable } = splitForkHistory(opts.prompt);
-  if (!forkable || history.length === 0) return null;
-  let best = null;
-  let bestLength = 0;
-  let bestSeq = -1;
-  for (const [key, fingerprint] of fingerprints) {
-    if (key === opts.sessionKey) continue;
-    if (fingerprint.cliPath !== opts.cliPath) continue;
-    if (forkSiblingSignature(key) !== signature) continue;
-    const recorded = fingerprint.entries;
-    if (recorded.length === 0 || recorded.length > history.length) continue;
-    if (!isPrefix(recorded, history)) continue;
-    if (!tailIsReplyOnly(history, recorded.length)) continue;
-    const claudeSessionId = opts.lookupClaudeSessionId(key);
-    if (!claudeSessionId) continue;
-    if (opts.isBusy(key)) continue;
-    if (recorded.length > bestLength || recorded.length === bestLength && fingerprint.seq > bestSeq) {
-      best = { parentKey: key, claudeSessionId, matched: recorded.length };
-      bestLength = recorded.length;
-      bestSeq = fingerprint.seq;
-    }
-  }
-  if (best) {
-    log.info("found a fork parent for this conversation", {
-      sessionKey: opts.sessionKey,
-      parentKey: best.parentKey,
-      matchedMessages: best.matched,
-      historyMessages: history.length
-    });
-  }
-  return best;
-}
-function continuesRecordedConversation(recorded, prompt, opts) {
-  const { history, forkable } = splitForkHistory(prompt, opts);
-  if (!forkable || recorded.length === 0 || recorded.length > history.length) return false;
-  return isPrefix(recorded, history) && tailIsReplyOnly(history, recorded.length);
-}
-function isPrefix(recorded, history) {
-  for (let i = 0; i < recorded.length; i++) {
-    if (recorded[i].role !== history[i].role) return false;
-    if (recorded[i].digest !== history[i].digest) return false;
-  }
-  return true;
-}
-function tailIsReplyOnly(history, from) {
-  for (let i = from; i < history.length; i++) {
-    if (history[i].role === "user") return false;
+async function cancelBackgroundTask(input, options) {
+  const taskId = readTaskId(input);
+  if (!taskId) return { kind: "error", message: MISSING_TASK_ID };
+  const refused = await guardParent(taskId, options.callerSessionId);
+  if (refused) return { kind: "error", message: refused };
+  const running = isBackgroundTaskRunning(
+    await fetchSessionRunState(taskId),
+    await fetchSessionReplies(taskId) ?? []
+  );
+  const aborted = await abortSession(taskId);
+  if (!aborted) {
+    return {
+      kind: "error",
+      message: `Could not cancel background task ${taskId}: opencode did not accept the abort. It may have already finished, or this opencode build does not expose session abort.`
+    };
   }
-  return true;
+  collected.get(options.sessionKey)?.delete(taskId);
+  mark(cancelled, options.sessionKey, taskId);
+  log.info("cancelled background subagent", {
+    sessionKey: options.sessionKey,
+    taskId,
+    wasRunning: running
+  });
+  return {
+    kind: "text",
+    text: `<task id="${taskId}" state="cancelled">
+` + (running ? "Stopped. No completion notification will arrive for it." : "It was not running when the cancel was sent, so nothing was interrupted. No completion notification will arrive for it.") + "\n</task>"
+  };
 }
 
 // src/session-resume-store.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync3, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join8 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync4, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join9 } from "path";
 var MAX_RESUME_RECORDS = 256;
 var RESUME_RECORD_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
 var records = null;
-var pathOverride2 = null;
+var pathOverride3 = null;
 function resumeStorePath() {
-  if (pathOverride2) return pathOverride2;
-  const stateRoot = process.env.XDG_STATE_HOME || join8(homedir6(), ".local", "state");
-  return join8(stateRoot, "opencode-claude-code-plugin", "claude-sessions.json");
+  if (pathOverride3) return pathOverride3;
+  const stateRoot = process.env.XDG_STATE_HOME || join9(homedir7(), ".local", "state");
+  return join9(stateRoot, "opencode-claude-code-plugin", "claude-sessions.json");
 }
 function isDigest(value) {
   const entry = value;
@@ -6416,7 +6882,7 @@ function load2() {
   if (records) return records;
   records = /* @__PURE__ */ new Map();
   try {
-    const parsed = JSON.parse(readFileSync4(resumeStorePath(), "utf8"));
+    const parsed = JSON.parse(readFileSync5(resumeStorePath(), "utf8"));
     const entries = parsed && typeof parsed === "object" ? parsed.sessions : null;
     if (entries && typeof entries === "object") {
       const cutoff = Date.now() - RESUME_RECORD_MAX_AGE_MS;
@@ -6431,7 +6897,7 @@ function save2(update) {
   const file = resumeStorePath();
   const merged = /* @__PURE__ */ new Map();
   try {
-    const onDisk = JSON.parse(readFileSync4(file, "utf8"))?.sessions;
+    const onDisk = JSON.parse(readFileSync5(file, "utf8"))?.sessions;
     if (onDisk && typeof onDisk === "object") {
       for (const [key, record] of Object.entries(onDisk)) {
         if (isRecord2(record)) merged.set(key, record);
@@ -6444,12 +6910,12 @@ function save2(update) {
   const kept = [...merged.entries()].filter(([, record]) => record.updatedAt >= cutoff).sort((a, b) => a[1].updatedAt - b[1].updatedAt).slice(-MAX_RESUME_RECORDS);
   records = new Map(kept);
   try {
-    mkdirSync4(join8(file, ".."), { recursive: true, mode: 448 });
+    mkdirSync5(join9(file, ".."), { recursive: true, mode: 448 });
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync4(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
+    writeFileSync5(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
       mode: 384
     });
-    renameSync3(tmp, file);
+    renameSync4(tmp, file);
   } catch (err) {
     log.debug("could not write the claude session resume store", {
       error: err instanceof Error ? err.message : String(err)
@@ -6867,7 +7333,7 @@ async function requestSideQuestion(activeProcess, question, options) {
     }
   });
   pendingProcesses.add(proc);
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const event = `side-question:${requestId}`;
     let settled = false;
     let sent = false;
@@ -6922,7 +7388,7 @@ async function requestSideQuestion(activeProcess, question, options) {
       }
       settled = true;
       cleanup();
-      resolve6({ response: result.response, synthetic: result.synthetic });
+      resolve7({ response: result.response, synthetic: result.synthetic });
     };
     const timer = setTimeout(() => {
       fail(new Error(`/btw timed out after ${timeoutMs}ms.`), true);
@@ -7097,16 +7563,16 @@ function isTurnInFlight(ap) {
 }
 function awaitTurnIdle(ap, timeoutMs) {
   if (!ap.turnInFlight) return Promise.resolve(true);
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const wake = () => {
       clearTimeout(timer);
-      resolve6(true);
+      resolve7(true);
     };
     const timer = setTimeout(() => {
       const waiters = ap.turnIdleWaiters ?? [];
       const at = waiters.indexOf(wake);
       if (at >= 0) waiters.splice(at, 1);
-      resolve6(false);
+      resolve7(false);
     }, timeoutMs);
     (ap.turnIdleWaiters ??= []).push(wake);
   });
@@ -7247,14 +7713,14 @@ function hasProcessExited(proc) {
 }
 function waitForProcessExit(proc, timeoutMs) {
   if (hasProcessExited(proc)) return Promise.resolve(true);
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const onExit = () => {
       clearTimeout(timer);
-      resolve6(true);
+      resolve7(true);
     };
     const timer = setTimeout(() => {
       proc.off("exit", onExit);
-      resolve6(hasProcessExited(proc));
+      resolve7(hasProcessExited(proc));
     }, timeoutMs);
     proc.once("exit", onExit);
   });
@@ -7321,6 +7787,7 @@ function deleteClaudeSessionId(key) {
   if (claudeSessionId) clearLedger(claudeSessionId);
   claudeSessions.delete(key);
   forgetForkFingerprint(key);
+  forgetServedConversation(key);
   forgetResumePoint(key);
 }
 function transferClaudeSession(fromKey, toKey) {
@@ -7332,6 +7799,7 @@ function transferClaudeSession(fromKey, toKey) {
   setClaudeSessionId(toKey, claudeSessionId);
   moveResumePoint(fromKey, toKey);
   moveForkFingerprint(fromKey, toKey);
+  moveServedConversation(fromKey, toKey);
   clearExitPlanModeQuestions(fromKey);
   clearAccountFailoverQuestions(fromKey);
   clearSubagentDispatchQuestions(fromKey);
@@ -7557,7 +8025,9 @@ function buildCliArgs(opts) {
     thinking,
     thinkingDisplay,
     fastMode,
-    cliVersion
+    cliVersion,
+    maxTurns,
+    maxBudgetUsd
   } = opts;
   const args = [
     "--print",
@@ -7628,6 +8098,8 @@ function buildCliArgs(opts) {
   if (fastMode && cliSupportsFastMode(cliVersion ?? null)) {
     args.push("--settings", JSON.stringify({ fastMode: true }));
   }
+  if (maxTurns !== void 0) args.push("--max-turns", String(maxTurns));
+  if (maxBudgetUsd !== void 0) args.push("--max-budget-usd", String(maxBudgetUsd));
   if (skipPermissions && permissionMode !== "plan" && !readOnly) {
     args.push("--dangerously-skip-permissions");
   }
@@ -7781,7 +8253,7 @@ async function waitForSessionIdle(client, sessionID, options = {}) {
     if (options.stop?.()) return true;
     if (await sessionStatus(client, sessionID) !== "busy") return true;
     if (Date.now() - started2 >= timeoutMs) return false;
-    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
+    await new Promise((resolve7) => setTimeout(resolve7, pollMs));
   }
 }
 async function deliverAsideInline(client, sessionID, text, options = {}) {
@@ -7792,7 +8264,7 @@ async function deliverAsideInline(client, sessionID, text, options = {}) {
     if (emitAsideInline(sessionID, text)) return true;
     if (Date.now() - started2 >= timeoutMs) return false;
     if (await sessionStatus(client, sessionID) !== "busy") return false;
-    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
+    await new Promise((resolve7) => setTimeout(resolve7, pollMs));
   }
 }
 async function waitForAsideProcess(client, sessionID, options = {}) {
@@ -7813,7 +8285,7 @@ async function waitForAsideProcess(client, sessionID, options = {}) {
       log.warn("btw: a turn is running but no claude process appeared for it", { sessionID, waitedMs });
       return void 0;
     }
-    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
+    await new Promise((resolve7) => setTimeout(resolve7, pollMs));
   }
 }
 async function settleSessionBusy(client, sessionID, active, options = {}) {
@@ -7825,7 +8297,7 @@ async function settleSessionBusy(client, sessionID, active, options = {}) {
     if (status === "busy") return true;
     if (status === "unknown") return isProcessBusy(active);
     if (Date.now() - started2 >= settleMs) return false;
-    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
+    await new Promise((resolve7) => setTimeout(resolve7, pollMs));
   }
 }
 function errorText(error) {
@@ -7872,10 +8344,10 @@ async function handleBtwCommand(client, input, options = {}) {
   let inlineDone = false;
   let markInlineDelivered = () => {
   };
-  const inlineDelivered = new Promise((resolve6) => {
+  const inlineDelivered = new Promise((resolve7) => {
     markInlineDelivered = () => {
       inlineDone = true;
-      resolve6("inline");
+      resolve7("inline");
     };
   });
   if (isSideQuestionPending(active)) {
@@ -7953,10 +8425,147 @@ async function handleBtwCommand(client, input, options = {}) {
   }
 }
 
+// src/budget-ledger.ts
+var BUDGET_MARKER = "\u258C **budget:**";
+var DEFAULT_BUDGET_WARN_AT = [50, 80];
+var MAX_SESSIONS = 256;
+var MAX_CLAUDE_SESSIONS = 512;
+var sessions2 = /* @__PURE__ */ new Map();
+var lastTotals = /* @__PURE__ */ new Map();
+function touch2(session) {
+  let entry = sessions2.get(session);
+  if (entry) {
+    sessions2.delete(session);
+  } else {
+    entry = { own: 0, notedPercent: 0 };
+  }
+  sessions2.set(session, entry);
+  while (sessions2.size > MAX_SESSIONS) {
+    const oldest = sessions2.keys().next();
+    if (oldest.done) break;
+    sessions2.delete(oldest.value);
+  }
+  return entry;
+}
+function resolveBudgetUsd(value, option) {
+  if (value === void 0 || value === null) return void 0;
+  const parsed = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+  if (typeof parsed === "number" && Number.isFinite(parsed) && parsed > 0) return parsed;
+  log.warn("budget option refused: not a positive number of dollars", { option });
+  return void 0;
+}
+function resolvePositiveInteger(value, option) {
+  if (value === void 0 || value === null) return void 0;
+  const parsed = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+  if (typeof parsed === "number" && Number.isInteger(parsed) && parsed > 0) return parsed;
+  log.warn("cap option refused: not a positive whole number", { option });
+  return void 0;
+}
+function resolveBudgetWarnAt(value) {
+  if (value === void 0 || value === null) return [...DEFAULT_BUDGET_WARN_AT];
+  if (!Array.isArray(value) || !value.every((entry) => typeof entry === "number" && Number.isFinite(entry) && entry > 0 && entry < 100)) {
+    log.warn("budgetWarnAt refused: expected percentages between 0 and 100", {
+      option: "budgetWarnAt"
+    });
+    return [...DEFAULT_BUDGET_WARN_AT];
+  }
+  return [...new Set(value)].sort((a, b) => a - b);
+}
+function costDelta(claudeSessionId, totalCostUsd, cumulative) {
+  if (!Number.isFinite(totalCostUsd) || totalCostUsd <= 0) return 0;
+  if (!cumulative || !claudeSessionId) return totalCostUsd;
+  const previous = lastTotals.get(claudeSessionId);
+  lastTotals.delete(claudeSessionId);
+  lastTotals.set(claudeSessionId, totalCostUsd);
+  while (lastTotals.size > MAX_CLAUDE_SESSIONS) {
+    const oldest = lastTotals.keys().next();
+    if (oldest.done) break;
+    lastTotals.delete(oldest.value);
+  }
+  if (previous === void 0 || totalCostUsd < previous) return totalCostUsd;
+  return totalCostUsd - previous;
+}
+function recordSessionCost(session, deltaUsd) {
+  if (!(deltaUsd > 0)) return;
+  touch2(session).own += deltaUsd;
+}
+function sessionParentKnown(session) {
+  return sessions2.get(session)?.parent !== void 0;
+}
+function noteSessionParent(session, parent) {
+  touch2(session).parent = parent && parent !== session ? parent : null;
+}
+function isChildSession(session) {
+  return typeof sessions2.get(session)?.parent === "string";
+}
+function budgetRoot(session) {
+  let current = session;
+  const seen = /* @__PURE__ */ new Set([current]);
+  for (; ; ) {
+    const parent = sessions2.get(current)?.parent;
+    if (typeof parent !== "string" || seen.has(parent)) return current;
+    seen.add(parent);
+    current = parent;
+  }
+}
+function sessionSpend(root) {
+  let total = 0;
+  for (const [session, entry] of sessions2) {
+    if (entry.own > 0 && budgetRoot(session) === root) total += entry.own;
+  }
+  return total;
+}
+function takeCrossedThreshold(root, capUsd, warnAt) {
+  const spentUsd = sessionSpend(root);
+  const percentSpent = spentUsd / capUsd * 100;
+  const entry = touch2(root);
+  const crossed = [...warnAt, 100].filter(
+    (threshold) => threshold <= percentSpent && threshold > entry.notedPercent
+  );
+  if (crossed.length === 0) return null;
+  const percent = Math.max(...crossed);
+  entry.notedPercent = percent;
+  return { percent, spentUsd };
+}
+function formatUsd(value) {
+  if (value >= 100) return `$${value.toFixed(0)}`;
+  if (value >= 1) return `$${value.toFixed(2)}`;
+  return `$${value.toFixed(4)}`;
+}
+function formatBudgetWarnNote(percent, spentUsd, capUsd) {
+  if (percent >= 100) {
+    return `${BUDGET_MARKER} this conversation has spent ${formatUsd(spentUsd)} of its ${formatUsd(capUsd)} \`maxBudgetUsd\`, so the next message will not start a turn. Raise \`maxBudgetUsd\` and relaunch opencode, or start a new session.`;
+  }
+  return `${BUDGET_MARKER} this conversation has spent ${formatUsd(spentUsd)}, ${percent}% of its ${formatUsd(capUsd)} \`maxBudgetUsd\`, counting the subagents it started.`;
+}
+function formatBudgetStopNote(spentUsd, capUsd) {
+  return `${BUDGET_MARKER} this conversation has spent ${formatUsd(spentUsd)} against its ${formatUsd(capUsd)} \`maxBudgetUsd\`, so this turn was not started and nothing was sent to Claude. Raise \`maxBudgetUsd\` in the provider options and relaunch opencode (plugin options are read once at startup), or start a new session.`;
+}
+function recordResultCost(budget, claudeSessionId, totalCostUsd) {
+  if (typeof totalCostUsd !== "number") return;
+  recordSessionCost(budget.session, costDelta(claudeSessionId, totalCostUsd, budget.cumulative));
+}
+function takeBudgetNote(budget) {
+  if (!budget.notes) return null;
+  const crossed = takeCrossedThreshold(budgetRoot(budget.session), budget.capUsd, budget.warnAt);
+  return crossed ? formatBudgetWarnNote(crossed.percent, crossed.spentUsd, budget.capUsd) : null;
+}
+function snapshotBudgets() {
+  const roots = /* @__PURE__ */ new Map();
+  for (const [session, entry] of sessions2) {
+    const root = budgetRoot(session);
+    const row = roots.get(root) ?? { session: root, spentUsd: 0, children: 0 };
+    row.spentUsd += entry.own;
+    if (root !== session && entry.own > 0) row.children++;
+    roots.set(root, row);
+  }
+  return [...roots.values()].filter((row) => row.spentUsd > 0).sort((a, b) => b.spentUsd - a.spentUsd);
+}
+
 // src/diagnostic-bundle.ts
 import { createHash as createHash4, randomBytes as randomBytes2 } from "crypto";
 import { openSync, readSync, closeSync, fstatSync, realpathSync } from "fs";
-import { homedir as homedir7 } from "os";
+import { homedir as homedir8 } from "os";
 
 // src/log-messages.ts
 var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
@@ -7970,18 +8579,32 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "account failover declined; ending the turn",
   "accountGroups must be an object mapping an account name to a group name; ignoring it",
   "accountGroups names an account that is not configured; ignoring it",
+  "agent cap not applied: this claude CLI does not take the flag",
   "agent effort override refused: unknown level",
+  "agent maxBudgetUsd ignored: the CLI counts it over a reused process's whole life, so it applies to subagents only",
+  "agent maxBudgetUsd refused: not a positive number of dollars",
+  "agent maxTurns / maxBudgetUsd not applied: the interactive transport cannot pass print-only flags",
+  "agent maxTurns refused: not a positive whole number",
   "agent model override refused: unknown model",
   "agent prompt cache ttl refused: unknown value",
+  "an opencode read deny rule could not be mapped onto Claude's own Read; that path stays readable by the CLI's own file tools",
   "auto-continuation stopped",
   "auto-continuing incomplete claude result",
+  "automatic account switch skipped an account whose runtime could not be prepared",
+  "background dispatch refused by maxBackgroundSubagents",
   "btw: a turn is running but no claude process appeared for it",
   "btw: early aside failed; the message will ask again",
+  "budget option refused: not a positive number of dollars",
+  "budgetWarnAt refused: expected percentages between 0 and 100",
   "cannot interrupt this transport; waiting for the turn to end",
+  "cap option refused: not a positive whole number",
   "carried this conversation's claude transcript to the other account",
   "carrying the claude conversation over to the new session key",
   "claude --version output unparseable",
+  "claude account cannot serve this turn; continuing it on the next account automatically",
+  "claude account is near its usage limit; new turns move to another account until the window resets",
   "claude account is out of usage; the turn ends with a note",
+  "claude account usage crossed a warning threshold",
   "claude already registers a different skill under this name; not bridging ours",
   "claude cli < 2.1.142 detected; Opus 4.7 thinking summaries unavailable. Run `npm i -g @anthropic-ai/claude-code` to upgrade.",
   "claude cli does not support --plugin-dir; opencode skills will not be bridged. Run `npm i -g @anthropic-ai/claude-code` to upgrade.",
@@ -8004,6 +8627,8 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "cleanup-stale: error processing cache root",
   "cleanup-stale: rmSync failed",
   "continuing this conversation's claude session under the new model or effort instead of replaying it",
+  "conversation budget reached; turn not started",
+  "conversation budget threshold crossed",
   "copied a shared Claude capability into the account config dir instead of linking it; later edits to the original will not be picked up",
   "could not share a Claude capability with the account",
   "delivering proxy results after interrupted continuation",
@@ -8054,6 +8679,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "interactiveBypass is ignored: skipPermissions governs the interactive transport too",
   "malformed data URI, skipping file part",
   "no active process to respawn (start watchdog); ending turn",
+  "no configured account could take this turn; it ends here",
   "no proxyTools entry was recognised; nothing will be proxied this turn",
   "no stdout after envelope write; respawning claude process to resume conversation",
   "opencode 2 event subscription ended; deleted sessions keep their claude process until idle eviction",
@@ -8069,6 +8695,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "proxy call past its deadline, but opencode is still serving it; waiting",
   "proxy call still waiting, deadline approaching",
   "proxy call still waiting, no deadline",
+  "proxy-mcp admission check failed; letting the call through",
   "proxy-mcp client closed a tool call before its result",
   "proxy-mcp dropping result for a closed tool call",
   "proxy-mcp interceptor failed",
@@ -8083,6 +8710,8 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "remote URL images are not supported by Claude CLI, skipping",
   "replaying stdout the child emitted between turns",
   "replaying the conversation as text: no claude session was available to continue",
+  "replaying the conversation as text: the thread was edited or undone",
+  "replaying the messages this claude session missed: the conversation continued under another session key",
   "replaying this conversation as text on the other account",
   "replaying this conversation rather than carrying it across accounts",
   "result fallback timer fired \u2014 closing stream without result event",
@@ -8153,6 +8782,20 @@ var BUNDLE_DATA_ALLOWLIST = {
   isError: "flag",
   planModeQuestion: "flag",
   subagentDispatchCrossGroup: "flag",
+  // Whether opencode's read deny rules are carried onto Claude's own Read,
+  // and how many were. A count and a flag only: the patterns themselves are
+  // the operator's config text and are never logged (h #g243).
+  mapReadRules: "flag",
+  readRuleDenies: "count",
+  // Budgets and caps (h #g245): numbers and option names only, never spend
+  // per conversation beyond what the doctor table already prints.
+  child: "flag",
+  countUnreadable: "flag",
+  cap: "count",
+  requested: "count",
+  running: "count",
+  option: "name",
+  cliFlag: "name",
   kept: "flag",
   listsAgentTypes: "flag",
   opencodeHasQuestion: "flag",
@@ -8160,6 +8803,8 @@ var BUNDLE_DATA_ALLOWLIST = {
   sse: "flag",
   strictMcpConfig: "flag",
   supported: "flag",
+  // Whether a usage threshold moved new turns to another account (h #g244).
+  switched: "flag",
   turnStats: "flag",
   // counts and sizes: a length is a shape, never content
   attempts: "count",
@@ -8185,12 +8830,22 @@ var BUNDLE_DATA_ALLOWLIST = {
   preTokens: "count",
   released: "count",
   removed: "count",
+  // The three counts of a rewound thread: how much of what this key's Claude
+  // session was answering is still in the conversation, and how much of it is
+  // not (h #g242).
+  sharedMessages: "count",
+  removedMessages: "count",
+  removedUserMessages: "count",
   // The three counts of a released subagent dispatch: how many subagents, how
   // many of them carried a choice, and which task a refused answer was for.
   claims: "count",
   tasks: "count",
   taskIndex: "count",
   skills: "count",
+  // A usage reading crossing a warning threshold (h #g244): the percent used
+  // and the thresholds it crossed, numbers only.
+  utilization: "count",
+  crossed: "count",
   stderrBytes: "count",
   textLength: "count",
   tools: "count",
@@ -8349,7 +9004,7 @@ function createIdHasher(salt = randomBytes2(16).toString("hex")) {
   return (raw) => createHash4("sha256").update(salt).update("\0").update(raw).digest("hex").slice(0, 8);
 }
 function createRedactionContext(options = {}) {
-  const home = options.home ?? homedir7();
+  const home = options.home ?? homedir8();
   const homes = /* @__PURE__ */ new Set();
   if (home) homes.add(home);
   if (home) {
@@ -8643,6 +9298,202 @@ function buildLogBundleSection(input) {
   return lines.join("\n");
 }
 
+// src/read-rules.ts
+import * as path8 from "path";
+import * as os4 from "os";
+var OPENCODE_DEFAULT_READ_RULES = [
+  { pattern: "*", effect: "allow", source: "default" },
+  { pattern: "*.env", effect: "ask", source: "default" },
+  { pattern: "*.env.*", effect: "ask", source: "default" },
+  { pattern: "*.env.example", effect: "allow", source: "default" }
+];
+var READ_PERMISSION = "read";
+function wildcardMatch(input, pattern) {
+  const normalized = input.replaceAll("\\", "/");
+  let escaped = pattern.replaceAll("\\", "/").replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  if (escaped.endsWith(" .*")) escaped = `${escaped.slice(0, -3)}( .*)?`;
+  return new RegExp(`^${escaped}$`, process.platform === "win32" ? "si" : "s").test(normalized);
+}
+function expandHome2(pattern, home) {
+  if (pattern === "~" || pattern === "$HOME") return home;
+  if (pattern.startsWith("~/")) return home + pattern.slice(1);
+  if (pattern.startsWith("$HOME/") || pattern.startsWith("$HOME\\")) return home + pattern.slice(5);
+  return pattern;
+}
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isEffect(value) {
+  return value === "allow" || value === "ask" || value === "deny";
+}
+function mergePermissionBlock(base, incoming) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(incoming)) {
+    const existing = out[key];
+    out[key] = isPlainObject2(existing) && isPlainObject2(value) ? mergePermissionBlock(existing, value) : value;
+  }
+  return out;
+}
+function v1PermissionBlock(layers) {
+  let permission = {};
+  let tools = {};
+  for (const layer of layers) {
+    const block = layer.permission;
+    if (typeof block === "string") permission = mergePermissionBlock(permission, { "*": block });
+    else if (isPlainObject2(block)) permission = mergePermissionBlock(permission, block);
+    if (isPlainObject2(layer.tools)) tools = { ...tools, ...layer.tools };
+  }
+  const fromEnv = process.env.OPENCODE_PERMISSION;
+  if (fromEnv) {
+    try {
+      const parsed = JSON.parse(fromEnv);
+      if (isPlainObject2(parsed)) permission = mergePermissionBlock(permission, parsed);
+    } catch {
+    }
+  }
+  const derived = {};
+  if (tools.read === false) derived[READ_PERMISSION] = "deny";
+  else if (tools.read === true) derived[READ_PERMISSION] = "allow";
+  return mergePermissionBlock(derived, permission);
+}
+function rulesFromV1Block(block, home) {
+  const rules = [];
+  for (const [key, value] of Object.entries(block)) {
+    if (!wildcardMatch(READ_PERMISSION, key)) continue;
+    if (isEffect(value)) {
+      rules.push({ pattern: "*", effect: value, source: "config" });
+      continue;
+    }
+    if (!isPlainObject2(value)) continue;
+    for (const [pattern, effect] of Object.entries(value)) {
+      if (!isEffect(effect)) continue;
+      rules.push({ pattern: expandHome2(String(pattern), home), effect, source: "config" });
+    }
+  }
+  return rules;
+}
+function rulesFromV2Array(value, home) {
+  if (!Array.isArray(value)) return [];
+  const rules = [];
+  for (const entry of value) {
+    if (!isPlainObject2(entry)) continue;
+    const { action, resource, effect } = entry;
+    if (typeof action !== "string" || !wildcardMatch(READ_PERMISSION, action)) continue;
+    if (!isEffect(effect)) continue;
+    const pattern = typeof resource === "string" && resource.length > 0 ? resource : "*";
+    rules.push({ pattern: expandHome2(pattern, home), effect, source: "config" });
+  }
+  return rules;
+}
+function resolveReadRules(layers, hostApi = "v1", options = {}) {
+  const home = options.home ?? os4.homedir();
+  const rules = options.includeDefaults === false ? [] : [...OPENCODE_DEFAULT_READ_RULES];
+  if (hostApi === "v2") {
+    for (const layer of layers) {
+      const block = typeof layer.permission === "string" ? { "*": layer.permission } : isPlainObject2(layer.permission) ? layer.permission : null;
+      if (block) rules.push(...rulesFromV1Block(block, home));
+      rules.push(...rulesFromV2Array(layer.permissions, home));
+    }
+    return rules;
+  }
+  rules.push(...rulesFromV1Block(v1PermissionBlock(layers), home));
+  for (const layer of layers) rules.push(...rulesFromV2Array(layer.permissions, home));
+  return rules;
+}
+function describeReadPatternRefusal(reason) {
+  switch (reason) {
+    case "empty-pattern":
+      return "the pattern is empty";
+    case "contains-dotdot":
+      return "it contains `..`, which leaves the worktree the two matchers agree on";
+  }
+}
+function translateReadPattern(pattern, options = {}) {
+  const raw = pattern.replaceAll("\\", "/").trim();
+  if (raw.length === 0) return { refused: "empty-pattern" };
+  if (raw.split("/").includes("..")) return { refused: "contains-dotdot" };
+  if (/^\*+$/.test(raw)) return { rule: "**" };
+  const widenSubtree = (value) => value.endsWith("/*") ? `${value}*` : value;
+  if (path8.posix.isAbsolute(raw)) {
+    return { rule: `/${widenSubtree(raw)}` };
+  }
+  if (!raw.includes("/")) return { rule: raw };
+  const { worktree, cwd } = options;
+  if (worktree && cwd && path8.resolve(worktree) !== path8.resolve(cwd)) {
+    const anchored = path8.posix.join(path8.resolve(worktree).replaceAll("\\", "/"), widenSubtree(raw));
+    return { rule: `/${anchored}` };
+  }
+  return { rule: widenSubtree(raw) };
+}
+function emptyMapping(enabled) {
+  return { enabled, deny: [], ask: [], unmapped: [], shadowedAllows: [] };
+}
+function mapReadRules(rules, options = {}) {
+  const deny = [];
+  const ask = [];
+  const unmapped = [];
+  const shadowedAllows = [];
+  const seen = /* @__PURE__ */ new Set();
+  const supersededBy = (index, pattern, by) => rules.slice(index + 1).some((later) => by(later) && wildcardMatch(pattern, later.pattern));
+  rules.forEach((rule, index) => {
+    if (rule.effect === "ask") {
+      if (supersededBy(index, rule.pattern, () => true)) return;
+      if (!ask.includes(rule.pattern)) ask.push(rule.pattern);
+      return;
+    }
+    if (rule.effect !== "deny") return;
+    if (supersededBy(index, rule.pattern, (later) => later.effect !== "deny")) return;
+    const translated = translateReadPattern(rule.pattern, options);
+    if ("refused" in translated) {
+      unmapped.push({ pattern: rule.pattern, reason: translated.refused });
+      return;
+    }
+    const entry = `Read(${translated.rule})`;
+    if (!seen.has(entry)) {
+      seen.add(entry);
+      deny.push(entry);
+    }
+    for (const later of rules.slice(index + 1)) {
+      if (later.effect !== "allow") continue;
+      if (!wildcardMatch(later.pattern, rule.pattern)) continue;
+      if (!shadowedAllows.includes(later.pattern)) shadowedAllows.push(later.pattern);
+    }
+  });
+  return { deny, ask, unmapped, shadowedAllows };
+}
+function resolveReadRuleMapping(input) {
+  if (input.enabled === false) return emptyMapping(false);
+  try {
+    const rules = resolveReadRules(input.layers, input.hostApi ?? "v1", { home: input.home });
+    const mapped = mapReadRules(rules, { worktree: input.worktree, cwd: input.cwd });
+    for (const refused of mapped.unmapped) {
+      log.warn(
+        "an opencode read deny rule could not be mapped onto Claude's own Read; that path stays readable by the CLI's own file tools",
+        { reason: refused.reason }
+      );
+    }
+    if (mapped.deny.length > 0) {
+      log.info("mapped opencode read deny rules onto the claude spawn", {
+        rules: mapped.deny,
+        askNotEnforced: mapped.ask.length
+      });
+    }
+    return { enabled: true, ...mapped };
+  } catch (err) {
+    log.debug("could not resolve opencode read rules", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return emptyMapping(true);
+  }
+}
+var lastReadRuleMapping;
+function recordReadRuleMapping(mapping) {
+  lastReadRuleMapping = mapping;
+}
+function snapshotReadRuleMapping() {
+  return lastReadRuleMapping;
+}
+
 // src/plan-usage.ts
 import { execFile as execFile2 } from "child_process";
 var PLAN_USAGE_ARGUMENTS = /* @__PURE__ */ new Set(["usage", "cost", "stats", "limits"]);
@@ -8686,7 +9537,7 @@ function parsePlanUsage(stdout) {
 }
 function runCli(cliPath, args, timeoutMs, env) {
   const plan = planClaudeSpawn(cliPath, args);
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     execFile2(
       plan.file,
       plan.args,
@@ -8700,9 +9551,9 @@ function runCli(cliPath, args, timeoutMs, env) {
         windowsVerbatimArguments: plan.windowsVerbatimArguments
       },
       (error, stdout) => {
-        if (stdout && stdout.trim()) return resolve6(stdout);
+        if (stdout && stdout.trim()) return resolve7(stdout);
         if (error) return reject(error);
-        resolve6(stdout ?? "");
+        resolve7(stdout ?? "");
       }
     );
   });
@@ -8741,13 +9592,13 @@ async function fetchPlanUsage(cliPath, options = {}) {
 
 // src/stale-build.ts
 import * as fs7 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/startup-diagnostics.ts
 import { execFile as execFile3 } from "child_process";
 import * as fs6 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 import { promisify as promisify2 } from "util";
 import { fileURLToPath } from "url";
 
@@ -8782,8 +9633,8 @@ var cachedPluginVersion;
 function pluginVersion() {
   if (cachedPluginVersion) return cachedPluginVersion;
   try {
-    const here = path8.dirname(fileURLToPath(import.meta.url));
-    const raw = fs6.readFileSync(path8.join(here, "..", "package.json"), "utf8");
+    const here = path9.dirname(fileURLToPath(import.meta.url));
+    const raw = fs6.readFileSync(path9.join(here, "..", "package.json"), "utf8");
     const version = JSON.parse(raw).version;
     cachedPluginVersion = typeof version === "string" ? version : "unknown";
   } catch {
@@ -8807,7 +9658,7 @@ var opencodeVersionProbe;
 function detectOpencodeVersion(execPath = process.execPath) {
   if (opencodeVersionProbe) return opencodeVersionProbe;
   opencodeVersionProbe = (async () => {
-    if (!path8.basename(execPath).toLowerCase().includes("opencode")) {
+    if (!path9.basename(execPath).toLowerCase().includes("opencode")) {
       log.debug("skipping opencode version probe: execPath is not opencode", { execPath });
       return void 0;
     }
@@ -8860,6 +9711,23 @@ function collectStartupDiagnostics(providers, opencodeVersion) {
       error: err instanceof Error ? err.message : String(err)
     });
   }
+  const mapReadRules2 = firstOption(providers, "mapReadRules") !== false;
+  let readRuleDenies = 0;
+  if (mapReadRules2) {
+    try {
+      const hostApi = firstOption(providers, "hostApi") === "v2" ? "v2" : "v1";
+      readRuleDenies = resolveReadRuleMapping({
+        layers: opencodeConfigLayers(cwd.resolved, hostApi),
+        hostApi,
+        worktree: detectWorktree(cwd.resolved),
+        cwd: cwd.resolved
+      }).deny.length;
+    } catch (err) {
+      log.debug("startup diagnostics could not resolve opencode read rules", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
   let transport;
   try {
     transport = requestedTransport({
@@ -8895,6 +9763,8 @@ function collectStartupDiagnostics(providers, opencodeVersion) {
     planModeQuestion: firstOption(providers, "planModeQuestion") === true,
     subagentDispatch: firstOption(providers, "subagentDispatch") === "ask" ? "ask" : "off",
     subagentDispatchCrossGroup: firstOption(providers, "subagentDispatchCrossGroup") === true,
+    mapReadRules: mapReadRules2,
+    readRuleDenies,
     anthropicApiKeyInEnv: Boolean(
       process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN
     )
@@ -8988,7 +9858,7 @@ function createStaleBuildWatch(io) {
   const claimed = /* @__PURE__ */ new Set();
   const warned = /* @__PURE__ */ new Set();
   let checkedAt;
-  let cached = null;
+  let cached2 = null;
   const read = () => {
     let onDisk;
     try {
@@ -9006,10 +9876,10 @@ function createStaleBuildWatch(io) {
     },
     check() {
       const now = io.now();
-      if (checkedAt !== void 0 && now - checkedAt < throttleMs) return cached;
+      if (checkedAt !== void 0 && now - checkedAt < throttleMs) return cached2;
       checkedAt = now;
       const status = read();
-      cached = status.stale;
+      cached2 = status.stale;
       if (status.stale && status.onDisk) {
         const identity = `${status.stale.kind}:${status.onDisk.version}:${status.onDisk.mtimeMs}:${status.onDisk.size}`;
         if (!warned.has(identity)) {
@@ -9022,7 +9892,7 @@ function createStaleBuildWatch(io) {
           });
         }
       }
-      return cached;
+      return cached2;
     },
     describe() {
       return read();
@@ -9047,7 +9917,7 @@ function defaultEntryPath() {
 }
 function readOnDiskBuild(entryPath) {
   try {
-    const raw = fs7.readFileSync(path9.join(path9.dirname(entryPath), "..", "package.json"), "utf8");
+    const raw = fs7.readFileSync(path10.join(path10.dirname(entryPath), "..", "package.json"), "utf8");
     const version = JSON.parse(raw).version;
     if (typeof version !== "string" || version.length === 0) return void 0;
     const stat = fs7.statSync(entryPath);
@@ -9272,10 +10142,24 @@ function formatDoctorReport(report) {
     );
   }
   lines.push("");
+  lines.push("**opencode read rules on Claude's own Read**");
+  lines.push("");
+  lines.push(...formatReadRules(report.readRules));
+  if (report.accountUsage) {
+    lines.push("");
+    lines.push("**Account usage**");
+    lines.push("");
+    lines.push(...formatAccountUsage(report.accountUsage));
+  }
+  lines.push("");
   lines.push("**Background subagents**");
   lines.push("");
   lines.push(...formatBackgroundSubagents(report.backgroundSubagents));
   lines.push("");
+  lines.push("**Budgets and caps**");
+  lines.push("");
+  lines.push(...formatBudgets(report.budgets));
+  lines.push("");
   lines.push("**Plan usage**");
   lines.push("");
   switch (report.planUsage.status) {
@@ -9306,7 +10190,82 @@ function formatDoctorReport(report) {
       lines.push("```");
     }
   }
-  return lines.join("\n");
+  return lines.join("\n");
+}
+function formatReadRules(mapping) {
+  const lines = [];
+  if (!mapping) {
+    lines.push(
+      "Not mapped yet: no `claude` spawn has been planned in this process. The next message in a Claude Code session resolves them."
+    );
+    return lines;
+  }
+  if (!mapping.enabled) {
+    lines.push(
+      "Off (`mapReadRules: false`). opencode's `read` rules reach its own tools only, so a file opencode would refuse is still readable by the Read the CLI runs itself."
+    );
+    return lines;
+  }
+  if (mapping.deny.length === 0) {
+    lines.push(
+      "No `deny` rule to map. opencode's defaults only `ask` for `.env` files, and an ask cannot be carried onto a spawn that has nobody to ask (see below)."
+    );
+  } else {
+    lines.push(`Denied on Claude's own Read (${mapping.deny.length}):`);
+    lines.push("");
+    for (const rule of mapping.deny) lines.push(`- \`${rule}\``);
+  }
+  if (mapping.ask.length > 0) {
+    lines.push("");
+    lines.push(`Not enforced, because they are \`ask\` rules (${mapping.ask.length}):`);
+    lines.push("");
+    for (const pattern of mapping.ask) lines.push(`- \`${pattern}\``);
+    lines.push("");
+    lines.push(
+      "A headless spawn runs with the skip flag and there is no one for the CLI to ask, so an `ask` is reported rather than silently promoted to a deny. To close one, make it `deny` in opencode's `permission.read`, or add `Read` to `proxyTools` so the read runs in opencode and its own prompt applies."
+    );
+  }
+  if (mapping.unmapped.length > 0) {
+    lines.push("");
+    lines.push(`Deny rules that could NOT be mapped (${mapping.unmapped.length}):`);
+    lines.push("");
+    for (const refused of mapping.unmapped) {
+      lines.push(`- \`${refused.pattern}\`: ${describeReadPatternRefusal(refused.reason)}`);
+    }
+  }
+  if (mapping.shadowedAllows.length > 0) {
+    lines.push("");
+    lines.push(`Allow rules a mapped deny now shadows (${mapping.shadowedAllows.length}):`);
+    lines.push("");
+    for (const pattern of mapping.shadowedAllows) lines.push(`- \`${pattern}\``);
+    lines.push("");
+    lines.push(
+      "Claude Code's deny beats its allow, so an exception opencode would carve out of a deny cannot be expressed: Claude refuses these where opencode would allow them."
+    );
+  }
+  return lines;
+}
+function formatAccountUsage(usage, now = Date.now()) {
+  const rows = [];
+  for (const account of [...usage.keys()].sort()) {
+    for (const [window, entry] of usage.get(account)) {
+      const used = entry.status === "rejected" && entry.utilization === null ? "out" : entry.utilization === null ? "unknown" : `${usagePercent(entry.utilization)}%`;
+      const resets = entry.resetsAt !== void 0 ? formatResetsAtLocal(entry.resetsAt) ?? "unknown" : entry.resetsText ? tableCell(entry.resetsText) : "unknown";
+      rows.push(
+        `| ${account} | ${window} | ${used} | ${entry.status} | ${resets}${isReadingCurrent(entry, now) ? "" : " (window over)"} | ${formatAge(Math.max(0, now - entry.observedAt))} ago | ${entry.noted.length > 0 ? entry.noted.map((t) => `${t}%`).join(", ") : "none"} |`
+      );
+    }
+  }
+  if (rows.length === 0) {
+    return [
+      "No reading yet. Claude Code reports an account's usage on the stream when its view of the limits changes, usually on the first turn of a process; the interactive transport reports nothing until a limit."
+    ];
+  }
+  return [
+    "| account | window | used | status | resets | observed | noted at |",
+    "|---|---|---|---|---|---|---|",
+    ...rows
+  ];
 }
 function formatBackgroundSubagents(state) {
   const lines = [];
@@ -9314,6 +10273,10 @@ function formatBackgroundSubagents(state) {
     lines.push(...formatRunningCount(state.running));
     lines.push("");
   }
+  lines.push(
+    state.cap === void 0 ? "maxBackgroundSubagents: off (no cap)" : `maxBackgroundSubagents: ${state.cap} at once; a background dispatch over it is refused whole`
+  );
+  lines.push("");
   const gate = state.gate;
   if (!gate) {
     lines.push(
@@ -9372,6 +10335,39 @@ function formatRunningCount(count) {
   }
   return lines;
 }
+function formatBudgets(budgets) {
+  const lines = [];
+  lines.push("| Field | Value |");
+  lines.push("|---|---|");
+  lines.push(
+    `| maxBudgetUsd | ${budgets.maxBudgetUsd === void 0 ? "off (no cap)" : formatUsd(budgets.maxBudgetUsd)} |`
+  );
+  if (budgets.maxBudgetUsd !== void 0) {
+    const warnAt = budgets.warnAt.map((percent) => `${percent}%`).join(", ");
+    lines.push(`| budgetWarnAt | ${warnAt || "none"} |`);
+  }
+  lines.push(`| defaultSubagentMaxTurns | ${budgets.subagentDefaults.maxTurns ?? "unset"} |`);
+  lines.push(
+    `| defaultSubagentMaxBudgetUsd | ${budgets.subagentDefaults.maxBudgetUsd === void 0 ? "unset" : formatUsd(budgets.subagentDefaults.maxBudgetUsd)} |`
+  );
+  if (budgets.maxBudgetUsd === void 0) return lines;
+  lines.push("");
+  if (budgets.sessions.length === 0) {
+    lines.push("No spend recorded by this process yet.");
+  } else {
+    lines.push("| session | spent | of cap | subagents counted |");
+    lines.push("|---|---|---|---|");
+    for (const row of budgets.sessions) {
+      const percent = Math.round(row.spentUsd / budgets.maxBudgetUsd * 100);
+      lines.push(`| ${row.session} | ${formatUsd(row.spentUsd)} | ${percent}% | ${row.children} |`);
+    }
+  }
+  lines.push("");
+  lines.push(
+    "In memory only: an opencode restart starts every conversation's ledger again (a resumed Claude session's first result restores its own earlier total). A conversation at its cap ends each new turn before anything is spawned."
+  );
+  return lines;
+}
 function describeBackgroundGateSource(gate) {
   if (gate.hostApi === "v2") {
     return "opencode 2 offers `background` unconditionally, so the registry is not consulted";
@@ -9450,14 +10446,23 @@ async function gatherDoctorReport(options) {
     processes,
     pendingCalls: snapshotPendingProxyCalls(),
     proxyServers,
+    readRules: snapshotReadRuleMapping(),
     mcpServerErrors: snapshotMcpServerErrors(),
     pluginLoadFailures: snapshotPluginLoadFailures(),
     hookFailures: snapshotHookFailures(),
     planUsage,
+    accountUsage: snapshotAccountUsage(),
     backgroundSubagents: {
       gate: snapshotBackgroundSubagentGate(),
       ledgers: snapshotBackgroundTasks(),
-      running: await countRunningBackgroundTasks().catch(() => void 0)
+      running: await countRunningBackgroundTasks().catch(() => void 0),
+      cap: options.maxBackgroundSubagents
+    },
+    budgets: {
+      maxBudgetUsd: options.maxBudgetUsd,
+      warnAt: options.budgetWarnAt ?? [],
+      subagentDefaults: getDefaultSubagentCliCaps(),
+      sessions: snapshotBudgets()
     }
   };
 }
@@ -9490,7 +10495,32 @@ function withholdFreeText(report) {
     hookFailures: report.hookFailures.map((failure) => ({
       ...failure,
       stderr: withhold(failure.stderr)
-    }))
+    })),
+    // The reset phrase the TUI printed is Claude Code's text, not the plugin's.
+    accountUsage: report.accountUsage && new Map(
+      [...report.accountUsage].map(([account, windows]) => [
+        account,
+        new Map(
+          [...windows].map(([window, entry]) => [
+            window,
+            entry.resetsText ? { ...entry, resetsText: withhold(entry.resetsText) } : entry
+          ])
+        )
+      ])
+    ),
+    // The operator's own glob patterns. Not plugin-authored, so they follow
+    // the same rule as a hook's stderr: the shape and the counts survive a
+    // bundle, the text does not.
+    readRules: report.readRules && {
+      ...report.readRules,
+      deny: report.readRules.deny.map(withhold),
+      ask: report.readRules.ask.map(withhold),
+      unmapped: report.readRules.unmapped.map((refused) => ({
+        ...refused,
+        pattern: withhold(refused.pattern)
+      })),
+      shadowedAllows: report.readRules.shadowedAllows.map(withhold)
+    }
   };
 }
 function renderDoctorReport(report, options) {
@@ -9687,11 +10717,14 @@ var PLUGIN_NOTE_MARKERS = [
   FAILOVER_MARKER,
   ACCOUNT_BLOCK_MARKER,
   ACCOUNT_GROUP_MARKER,
+  CONVERSATION_REWOUND_MARKER,
   USAGE_LIMIT_MARKER,
+  USAGE_MARKER,
   MODEL_FALLBACK_MARKER,
   UNATTENDED_REPLAY_MARKER,
   STALE_BUILD_MARKER,
-  SUBAGENT_DISPATCH_MARKER
+  SUBAGENT_DISPATCH_MARKER,
+  BUDGET_MARKER
 ];
 function isPluginNote(part) {
   if (!part || part.type !== "text" || typeof part.text !== "string") return false;
@@ -9837,8 +10870,10 @@ function clipWithMarker(text, max) {
 \u2026[truncated ${text.length - max} chars]`;
 }
 var MAX_REPLAY_MESSAGE_CHARS = 2e3;
-var MAX_REPLAY_LAST_REPLY_CHARS = 12e3;
 var MAX_REPLAY_HEAD_CHARS = 1e3;
+var MAX_REPLAY_RECENT_MESSAGES = 6;
+var MAX_REPLAY_RECENT_MESSAGE_CHARS = 12e3;
+var MAX_REPLAY_TOTAL_CHARS = 18e4;
 function clipMiddle(text, max) {
   if (text.length <= max) return text;
   const head = Math.min(Math.floor(max / 4), MAX_REPLAY_HEAD_CHARS);
@@ -9902,39 +10937,58 @@ ${clipWithMarker(
   }
   return { text: lines.join("\n"), toolResultCount };
 }
+function isConversationMessage(msg) {
+  return msg.role === "user" || msg.role === "assistant" || msg.role === "tool";
+}
 function compactConversationHistory(prompt, opts = {}) {
   const mode = opts.mode ?? "fresh-session";
   prompt = filterSideQuestionHistory(prompt);
   if (mode === "compaction") {
     return buildCompactionHistory(prompt);
   }
-  const conversationMessages = prompt.filter(
-    (m) => m.role === "user" || m.role === "assistant" || m.role === "tool"
-  );
+  if (opts.messages) {
+    const run = filterSideQuestionHistory(opts.messages).filter(isConversationMessage);
+    return run.length === 0 ? null : renderReplay(run);
+  }
+  const conversationMessages = prompt.filter(isConversationMessage);
   if (conversationMessages.length <= 1) {
     return null;
   }
-  const historyParts = [];
-  let lastAssistant = -1;
-  for (let i = conversationMessages.length - 2; i >= 0; i--) {
-    if (conversationMessages[i].role === "assistant") {
-      lastAssistant = i;
-      break;
-    }
-  }
-  for (let i = 0; i < conversationMessages.length - 1; i++) {
-    const msg = conversationMessages[i];
+  return renderReplay(conversationMessages.slice(0, -1));
+}
+function renderReplay(messages) {
+  const entries = [];
+  let total = 0;
+  let rank = 0;
+  let omitted = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
     const role = msg.role === "user" ? "User" : msg.role === "assistant" ? "Assistant" : "Tool";
     const { text } = renderMessageContentForCompaction(msg);
-    if (text.trim()) {
-      const max = i === lastAssistant ? MAX_REPLAY_LAST_REPLY_CHARS : MAX_REPLAY_MESSAGE_CHARS;
-      historyParts.push(`${role}: ${clipMiddle(text, max)}`);
+    if (!text.trim()) continue;
+    const max = rank < MAX_REPLAY_RECENT_MESSAGES ? MAX_REPLAY_RECENT_MESSAGE_CHARS : MAX_REPLAY_MESSAGE_CHARS;
+    rank++;
+    const entry = `${role}: ${clipMiddle(text, max)}`;
+    if (total + entry.length > MAX_REPLAY_TOTAL_CHARS) {
+      omitted = i + 1;
+      break;
     }
+    entries.push(entry);
+    total += entry.length + 2;
   }
-  if (historyParts.length === 0) {
-    return null;
+  if (entries.length === 0) return null;
+  entries.reverse();
+  if (omitted > 0) {
+    log.info("replay bounded: the oldest messages were dropped", {
+      omitted,
+      kept: entries.length,
+      chars: total
+    });
+    entries.unshift(
+      `[${omitted} earlier message${omitted === 1 ? "" : "s"} omitted: the replay is capped at ${MAX_REPLAY_TOTAL_CHARS} characters]`
+    );
   }
-  return historyParts.join("\n\n");
+  return entries.join("\n\n");
 }
 function buildCompactionHistory(prompt) {
   const entries = [];
@@ -10038,6 +11092,27 @@ ${historyContext}
 
 Now continuing with the current message:
 
+`
+      });
+    }
+  } else if (opts.missed && opts.missed.length > 0) {
+    const missed = compactConversationHistory(prompt, { messages: opts.missed });
+    if (missed) {
+      log.info("including the messages this claude session missed", {
+        messages: opts.missed.length,
+        chars: missed.length
+      });
+      content.push({
+        type: "text",
+        text: `<missed_conversation>
+The conversation continued under another opencode agent or model while this session was not asked. These are the messages exchanged since your last reply, replayed as text. They are part of this conversation: decisions and plans made there stand, and work done there is done.
+
+${missed}
+
+</missed_conversation>
+
+Now continuing with the current message:
+
 `
       });
     }
@@ -10139,13 +11214,13 @@ function getTrailingUserMessages(prompt, opts = {}) {
 // src/skill-bridge.ts
 import * as crypto3 from "crypto";
 import * as fs8 from "fs";
-import * as os4 from "os";
-import * as path10 from "path";
+import * as os5 from "os";
+import * as path11 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function bundledSkillsDir() {
   try {
     const here = fileURLToPath3(import.meta.url);
-    const dir = path10.resolve(path10.dirname(here), "..", "skills");
+    const dir = path11.resolve(path11.dirname(here), "..", "skills");
     return dirExists2(dir) ? dir : null;
   } catch {
     return null;
@@ -10162,7 +11237,7 @@ function realPath(p) {
   try {
     return fs8.realpathSync(p);
   } catch {
-    return path10.resolve(p);
+    return path11.resolve(p);
   }
 }
 function envEnabled(name) {
@@ -10183,10 +11258,10 @@ function declaredSkillName(source) {
   return SAFE_SKILL_NAME.test(name) ? name : null;
 }
 function readSkill(root, entry) {
-  const dir = path10.join(root, entry);
+  const dir = path11.join(root, entry);
   let source;
   try {
-    source = fs8.readFileSync(path10.join(dir, "SKILL.md"), "utf8");
+    source = fs8.readFileSync(path11.join(dir, "SKILL.md"), "utf8");
   } catch {
     return null;
   }
@@ -10204,40 +11279,40 @@ function skillRoots(cwd) {
   const roots = [];
   const seen = /* @__PURE__ */ new Set();
   const push = (p) => {
-    const abs = path10.resolve(p);
+    const abs = path11.resolve(p);
     if (seen.has(abs)) return;
     seen.add(abs);
     if (dirExists2(abs)) roots.push(abs);
   };
-  const home = os4.homedir();
-  const homeDir = home ? path10.resolve(home) : null;
-  let current = path10.resolve(cwd);
+  const home = os5.homedir();
+  const homeDir = home ? path11.resolve(home) : null;
+  let current = path11.resolve(cwd);
   while (true) {
-    push(path10.join(current, ".opencode", "skills"));
+    push(path11.join(current, ".opencode", "skills"));
     if (current !== homeDir) {
-      push(path10.join(current, ".claude", "skills"));
-      push(path10.join(current, ".agents", "skills"));
+      push(path11.join(current, ".claude", "skills"));
+      push(path11.join(current, ".agents", "skills"));
     }
-    const parent = path10.dirname(current);
+    const parent = path11.dirname(current);
     if (parent === current) break;
     current = parent;
   }
-  if (homeDir) push(path10.join(homeDir, ".opencode", "skills"));
+  if (homeDir) push(path11.join(homeDir, ".opencode", "skills"));
   const envDir = process.env.OPENCODE_CONFIG_DIR;
   if (envDir) {
-    push(path10.join(envDir, "skills"));
-    push(path10.join(envDir, "skill"));
+    push(path11.join(envDir, "skills"));
+    push(path11.join(envDir, "skill"));
   }
-  const xdg = process.env.XDG_CONFIG_HOME ?? (homeDir ? path10.join(homeDir, ".config") : null);
+  const xdg = process.env.XDG_CONFIG_HOME ?? (homeDir ? path11.join(homeDir, ".config") : null);
   if (xdg) {
-    push(path10.join(xdg, "opencode", "skills"));
-    push(path10.join(xdg, "opencode", "skill"));
+    push(path11.join(xdg, "opencode", "skills"));
+    push(path11.join(xdg, "opencode", "skill"));
   }
   if (homeDir && !envEnabled("OPENCODE_DISABLE_EXTERNAL_SKILLS")) {
     if (!envEnabled("OPENCODE_DISABLE_CLAUDE_CODE_SKILLS")) {
-      push(path10.join(homeDir, ".claude", "skills"));
+      push(path11.join(homeDir, ".claude", "skills"));
     }
-    push(path10.join(homeDir, ".agents", "skills"));
+    push(path11.join(homeDir, ".agents", "skills"));
   }
   return roots;
 }
@@ -10284,23 +11359,23 @@ function discoverBundledSkills() {
 }
 function claudeConfigDir(configDir) {
   const explicit = configDir ?? process.env.CLAUDE_CONFIG_DIR;
-  if (explicit) return path10.resolve(expandHome(explicit));
-  const home = os4.homedir();
-  return home ? path10.resolve(home, ".claude") : null;
+  if (explicit) return path11.resolve(expandHome(explicit));
+  const home = os5.homedir();
+  return home ? path11.resolve(home, ".claude") : null;
 }
 function installedPluginSkillRoots(configDir, cwd) {
   if (!configDir) return [];
   let parsed;
   try {
     parsed = JSON.parse(
-      fs8.readFileSync(path10.join(configDir, "plugins", "installed_plugins.json"), "utf8")
+      fs8.readFileSync(path11.join(configDir, "plugins", "installed_plugins.json"), "utf8")
     );
   } catch {
     return [];
   }
   const plugins = parsed?.plugins;
   if (!plugins || typeof plugins !== "object") return [];
-  const workspace = path10.resolve(cwd);
+  const workspace = path11.resolve(cwd);
   const roots = [];
   for (const installs of Object.values(plugins)) {
     if (!Array.isArray(installs)) continue;
@@ -10308,23 +11383,23 @@ function installedPluginSkillRoots(configDir, cwd) {
       const entry = install;
       if (typeof entry?.installPath !== "string" || !entry.installPath) continue;
       if (entry.scope !== "user" && !coversWorkspace(entry.projectPath, workspace)) continue;
-      roots.push(path10.join(entry.installPath, "skills"));
+      roots.push(path11.join(entry.installPath, "skills"));
     }
   }
   return roots;
 }
 function coversWorkspace(projectPath, workspace) {
   if (typeof projectPath !== "string" || !projectPath) return false;
-  const root = path10.resolve(projectPath);
+  const root = path11.resolve(projectPath);
   if (root === workspace) return true;
-  const rel = path10.relative(root, workspace);
-  return rel !== "" && !rel.startsWith("..") && !path10.isAbsolute(rel);
+  const rel = path11.relative(root, workspace);
+  return rel !== "" && !rel.startsWith("..") && !path11.isAbsolute(rel);
 }
 function discoverNativeClaudeSkills(opts) {
   const found = [];
   const scanned = /* @__PURE__ */ new Set();
   const scan = (root, scope) => {
-    const abs = path10.resolve(root);
+    const abs = path11.resolve(root);
     if (scanned.has(abs)) return;
     scanned.add(abs);
     let entries;
@@ -10341,13 +11416,13 @@ function discoverNativeClaudeSkills(opts) {
     }
   };
   const configDir = claudeConfigDir(opts.configDir);
-  if (configDir) scan(path10.join(configDir, "skills"), "user");
-  const home = os4.homedir();
-  const homeDir = home ? path10.resolve(home) : null;
-  let current = path10.resolve(opts.cwd);
+  if (configDir) scan(path11.join(configDir, "skills"), "user");
+  const home = os5.homedir();
+  const homeDir = home ? path11.resolve(home) : null;
+  let current = path11.resolve(opts.cwd);
   while (true) {
-    if (current !== homeDir) scan(path10.join(current, ".claude", "skills"), "project");
-    const parent = path10.dirname(current);
+    if (current !== homeDir) scan(path11.join(current, ".claude", "skills"), "project");
+    const parent = path11.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -10381,7 +11456,7 @@ function dropNativelyLoadedSkills(skills, native) {
 }
 function readBundledSkillInfos() {
   return discoverBundledSkills().flatMap((skill) => {
-    const file = path10.join(skill.dir, "SKILL.md");
+    const file = path11.join(skill.dir, "SKILL.md");
     let text;
     try {
       text = fs8.readFileSync(file, "utf8");
@@ -10425,13 +11500,13 @@ function buildSkillPluginDir(skills) {
   if (skills.length === 0) return null;
   const fingerprint = skills.map((s) => `${s.name}\0${s.dir}`).join("\n");
   const hash = crypto3.createHash("sha256").update(fingerprint).digest("hex").slice(0, 12);
-  const root = path10.join(pluginTmpDir(), `skills-${hash}`);
-  const manifest = path10.join(root, ".claude-plugin", "plugin.json");
+  const root = path11.join(pluginTmpDir(), `skills-${hash}`);
+  const manifest = path11.join(root, ".claude-plugin", "plugin.json");
   if (fileExists2(manifest)) return root;
   try {
     fs8.rmSync(root, { recursive: true, force: true });
-    fs8.mkdirSync(path10.join(root, ".claude-plugin"), { recursive: true });
-    fs8.mkdirSync(path10.join(root, "skills"), { recursive: true });
+    fs8.mkdirSync(path11.join(root, ".claude-plugin"), { recursive: true });
+    fs8.mkdirSync(path11.join(root, "skills"), { recursive: true });
     fs8.writeFileSync(
       manifest,
       JSON.stringify(
@@ -10445,7 +11520,7 @@ function buildSkillPluginDir(skills) {
       { encoding: "utf8", mode: 384 }
     );
     for (const skill of skills) {
-      linkSkill(skill.dir, path10.join(root, "skills", skill.name));
+      linkSkill(skill.dir, path11.join(root, "skills", skill.name));
     }
   } catch (err) {
     log.warn("failed to stage opencode skill plugin dir", {
@@ -10461,7 +11536,7 @@ function registerBundledSkillPath(config) {
   if (!dir) return false;
   config.skills ??= {};
   const paths = config.skills.paths ??= [];
-  if (paths.some((p) => path10.resolve(p) === dir)) return false;
+  if (paths.some((p) => path11.resolve(p) === dir)) return false;
   paths.push(dir);
   return true;
 }
@@ -10509,22 +11584,22 @@ async function resolveSkillPluginDirs(opts) {
 // src/claude-session-wrapper.ts
 import { EventEmitter as EventEmitter4 } from "events";
 import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync4, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync4, writeFileSync as writeFileSync7 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 
 // src/claude-session-bun.ts
-import * as os5 from "os";
+import * as os6 from "os";
 import * as fs9 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 import { execFileSync } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
 import { StringDecoder } from "string_decoder";
 function resolveClaude(cmd = "claude") {
-  if (path11.isAbsolute(cmd) && fs9.existsSync(cmd)) return cmd;
+  if (path12.isAbsolute(cmd) && fs9.existsSync(cmd)) return cmd;
   const viaBun = Bun.which(cmd);
   if (viaBun) return viaBun;
-  const isWin = os5.platform() === "win32";
+  const isWin = os6.platform() === "win32";
   try {
     const out = execFileSync(isWin ? "where" : "which", [cmd], {
       encoding: "utf8",
@@ -10537,7 +11612,7 @@ function resolveClaude(cmd = "claude") {
   throw new Error(`Could not resolve command on PATH: ${cmd}`);
 }
 function encodeCwd(cwd) {
-  const resolved = path11.resolve(cwd);
+  const resolved = path12.resolve(cwd);
   let real = resolved;
   try {
     real = fs9.realpathSync.native(resolved);
@@ -10548,7 +11623,7 @@ function encodeCwd(cwd) {
 var bunPtySpawner = (argv, opts) => {
   const [command, ...args] = argv;
   const resolved = resolveClaude(command ?? "claude");
-  if (os5.platform() === "win32" && isBatchFile(resolved)) {
+  if (os6.platform() === "win32" && isBatchFile(resolved)) {
     throw new Error(
       `The interactive transport cannot run a Windows batch shim (${resolved}). Point \`cliPath\` at claude.exe, or use the default headless transport.`
     );
@@ -10656,10 +11731,10 @@ function classifyScreen(text) {
   return null;
 }
 function interactiveTranscriptPath(opts) {
-  return path11.join(
+  return path12.join(
     resolveConfigDir(opts.configDir),
     "projects",
-    encodeCwd(path11.resolve(opts.cwd)),
+    encodeCwd(path12.resolve(opts.cwd)),
     `${opts.sessionId}.jsonl`
   );
 }
@@ -10901,12 +11976,12 @@ function isOwnPromptRecord(rec, normalized) {
 }
 function resolveConfigDir(configDir) {
   const value = configDir ?? process.env.CLAUDE_CONFIG_DIR;
-  if (!value) return path11.join(os5.homedir(), ".claude");
-  if (value === "~") return os5.homedir();
+  if (!value) return path12.join(os6.homedir(), ".claude");
+  if (value === "~") return os6.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path11.join(os5.homedir(), value.slice(2));
+    return path12.join(os6.homedir(), value.slice(2));
   }
-  return path11.resolve(value);
+  return path12.resolve(value);
 }
 function fatalScreenMessage(kind, configDir, cwd) {
   if (kind === "trust") {
@@ -10970,7 +12045,7 @@ var ClaudeSession = class {
   abandonTurn = false;
   o;
   constructor(opts = {}) {
-    this.cwd = path11.resolve(opts.cwd ?? process.cwd());
+    this.cwd = path12.resolve(opts.cwd ?? process.cwd());
     this.configDir = resolveConfigDir(opts.configDir);
     this.explicitConfigDir = opts.configDir ? this.configDir : void 0;
     this.signal = opts.signal;
@@ -10982,7 +12057,7 @@ var ClaudeSession = class {
     this.onExit = opts.onExit;
     this.spawnPty = opts.spawnPty ?? bunPtySpawner;
     this.sessionId = opts.resumeSessionId ?? randomUUID4();
-    this.jsonlPath = path11.join(
+    this.jsonlPath = path12.join(
       this.configDir,
       "projects",
       encodeCwd(this.cwd),
@@ -11278,7 +12353,7 @@ var ClaudeSession = class {
       throw new Error("session not started or already exited");
     if (this.turn) throw new Error("a turn is already running in this session");
     let settle;
-    this.turn = new Promise((resolve6) => settle = resolve6);
+    this.turn = new Promise((resolve7) => settle = resolve7);
     this.turnDenied = [];
     this.abandonTurn = false;
     this.transcript.skipToEnd();
@@ -11693,8 +12768,8 @@ ${text2}`
 }
 function stageImage(data, extension) {
   try {
-    const file = join13(pluginTmpDir(), `attachment-${randomUUID5()}.${extension}`);
-    writeFileSync6(file, data, { mode: 384, flag: "wx" });
+    const file = join14(pluginTmpDir(), `attachment-${randomUUID5()}.${extension}`);
+    writeFileSync7(file, data, { mode: 384, flag: "wx" });
     return file;
   } catch (err) {
     log.warn("interactive transport could not stage an image", {
@@ -12175,17 +13250,17 @@ function spawnInteractiveProcess(opts) {
 }
 
 // src/spawn-record-store.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync8, renameSync as renameSync4, statSync as statSync7, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join14 } from "path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync9, renameSync as renameSync5, statSync as statSync8, writeFileSync as writeFileSync8 } from "fs";
+import { homedir as homedir12 } from "os";
+import { join as join15 } from "path";
 var MAX_SPAWN_RECORDS = 256;
 var SPAWN_RECORD_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
-var pathOverride3 = null;
+var pathOverride4 = null;
 var lastWritten = /* @__PURE__ */ new Map();
 function spawnRecordStorePath() {
-  if (pathOverride3) return pathOverride3;
-  const stateRoot = process.env.XDG_STATE_HOME || join14(homedir10(), ".local", "state");
-  return join14(stateRoot, "opencode-claude-code-plugin", "session-spawns.json");
+  if (pathOverride4) return pathOverride4;
+  const stateRoot = process.env.XDG_STATE_HOME || join15(homedir12(), ".local", "state");
+  return join15(stateRoot, "opencode-claude-code-plugin", "session-spawns.json");
 }
 function isRecord5(value) {
   const record = value;
@@ -12198,7 +13273,7 @@ function isRecord5(value) {
 function readEntries(file) {
   const out = /* @__PURE__ */ new Map();
   try {
-    const parsed = JSON.parse(readFileSync8(file, "utf8"));
+    const parsed = JSON.parse(readFileSync9(file, "utf8"));
     const entries = parsed && typeof parsed === "object" ? parsed.sessions : null;
     if (!entries || typeof entries !== "object") return out;
     const cutoff = Date.now() - SPAWN_RECORD_MAX_AGE_MS;
@@ -12234,12 +13309,12 @@ ${record.account ?? ""}`;
   const cutoff = now - SPAWN_RECORD_MAX_AGE_MS;
   const kept = [...merged.entries()].filter(([, entry]) => entry.at >= cutoff).sort((a, b) => a[1].at - b[1].at).slice(-MAX_SPAWN_RECORDS);
   try {
-    mkdirSync6(join14(file, ".."), { recursive: true, mode: 448 });
+    mkdirSync7(join15(file, ".."), { recursive: true, mode: 448 });
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync7(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
+    writeFileSync8(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
       mode: 384
     });
-    renameSync4(tmp, file);
+    renameSync5(tmp, file);
   } catch {
     return false;
   }
@@ -12252,7 +13327,7 @@ ${record.account ?? ""}`;
 import { randomUUID as randomUUID6 } from "crypto";
 import { constants as fsConstants } from "fs";
 import { chmod as chmod2, copyFile as copyFile2, lstat as lstat2, mkdir as mkdir2 } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 var transcriptPath = interactiveTranscriptPath;
 function configDirForAccount(account) {
   const normalized = normalizeAccountName(account || DEFAULT_ACCOUNT);
@@ -12280,7 +13355,7 @@ async function carryTranscriptToAccount(input) {
   const carriedId = renamed ? (input.newSessionId ?? randomUUID6)() : sessionId;
   const target = renamed ? transcriptPath({ configDir: targetConfigDir, cwd, sessionId: carriedId }) : targetOwn;
   try {
-    await mkdir2(path12.dirname(target), { recursive: true, mode: 448 });
+    await mkdir2(path13.dirname(target), { recursive: true, mode: 448 });
     await copyFile2(live.file, target, fsConstants.COPYFILE_EXCL);
     await chmod2(target, 384);
   } catch (err) {
@@ -12300,7 +13375,7 @@ function dedupe2(dirs) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const dir of dirs) {
-    const resolved = path12.resolve(dir);
+    const resolved = path13.resolve(dir);
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     out.push(resolved);
@@ -12309,13 +13384,13 @@ function dedupe2(dirs) {
 }
 
 // src/prompts.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir11 } from "os";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
+import { homedir as homedir13 } from "os";
 import { randomUUID as randomUUID7 } from "crypto";
-import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join15 } from "path";
+import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join16 } from "path";
 function readPromptFileIfPresent(path15) {
   try {
-    const content = readFileSync9(path15, "utf8").trim();
+    const content = readFileSync10(path15, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -12324,7 +13399,7 @@ function readPromptFileIfPresent(path15) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join15(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join16(dir, "AGENTS.md"));
     if (content) return content;
     const parent = dirname6(dir);
     if (parent === dir) return void 0;
@@ -12435,7 +13510,7 @@ var CLAUDE_NATIVE_INSTRUCTION_FILES = /* @__PURE__ */ new Set(["CLAUDE.md", "CLA
 function userAuthoredInstructions(forwarded, opts = {}) {
   const readFile3 = opts.readFile ?? ((path15) => {
     try {
-      return readFileSync9(path15, "utf8");
+      return readFileSync10(path15, "utf8");
     } catch {
       return null;
     }
@@ -12476,8 +13551,8 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join15(homedir11(), ".config");
-  const globalAgents = readPromptFileIfPresent(join15(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join16(homedir13(), ".config");
+  const globalAgents = readPromptFileIfPresent(join16(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   const forwarded = extraSystemContent.join("\n\n");
   const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
@@ -12493,9 +13568,9 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path15 = join15(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
+  const path15 = join16(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
   try {
-    writeFileSync8(path15, content, { encoding: "utf8", mode: 384 });
+    writeFileSync9(path15, content, { encoding: "utf8", mode: 384 });
     return path15;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
@@ -13113,12 +14188,43 @@ async function ensureProxyServer(config, tools, sessionKeyForCalls, interceptCom
       };
     });
   }
-  const srv = await createProxyMcpServer(tools, timeoutOverrides, interceptors);
+  const cap = config.maxBackgroundSubagents;
+  const admit = cap !== void 0 && tools.some((t) => t.name === "task" || t.name === TASK_BATCH_TOOL_NAME) ? (toolName, input) => admitBackgroundDispatch(toolName, input, cap) : void 0;
+  const srv = await createProxyMcpServer(tools, timeoutOverrides, interceptors, { admit });
   srv.calls.on("call", (call) => {
     queuePendingProxyCall(sessionKeyForCalls, call, timeoutOverrides);
   });
   return srv;
 }
+async function resolveSpawnCliCaps(caps, cliPath, cliVersion, whenAborted) {
+  const result = {};
+  if (caps.maxTurns !== void 0) {
+    if (cliSupportsMaxTurns(cliVersion)) result.maxTurns = caps.maxTurns;
+    else warnCapDropped("max-turns");
+  }
+  if (caps.maxBudgetUsd !== void 0) {
+    const probe = detectCliSupportsFlag(cliPath, "--max-budget-usd");
+    const supported = whenAborted ? await Promise.race([probe, whenAborted.then(() => false)]) : await probe;
+    if (supported) result.maxBudgetUsd = caps.maxBudgetUsd;
+    else warnCapDropped("max-budget-usd");
+  }
+  return result;
+}
+var droppedCapWarnings = /* @__PURE__ */ new Set();
+function warnCapDropped(cliFlag) {
+  if (droppedCapWarnings.has(cliFlag)) return;
+  droppedCapWarnings.add(cliFlag);
+  log.warn("agent cap not applied: this claude CLI does not take the flag", { cliFlag });
+}
+var interactiveCapsWarned = false;
+function warnCliCapsOnInteractive(caps) {
+  if (interactiveCapsWarned) return;
+  if (caps.maxTurns === void 0 && caps.maxBudgetUsd === void 0) return;
+  interactiveCapsWarned = true;
+  log.warn(
+    "agent maxTurns / maxBudgetUsd not applied: the interactive transport cannot pass print-only flags"
+  );
+}
 
 // src/mcp-hot-reload.ts
 var DEFAULT_MCP_HOT_RELOAD_COOLDOWN_MS = 6e4;
@@ -13437,8 +14543,8 @@ function watchTurnAbort(signal) {
   let aborted = signal?.aborted === true;
   let listeners = [];
   let settle;
-  const whenAborted = new Promise((resolve6) => {
-    settle = resolve6;
+  const whenAborted = new Promise((resolve7) => {
+    settle = resolve7;
   });
   const fire = () => {
     if (aborted && listeners === null) return;
@@ -14227,6 +15333,13 @@ function createLineHandler(state, ctx) {
           };
           rememberAccountLimit(ctx.sourceAccount, state.accountLimitHit);
         }
+        if (info?.rateLimitType && info.status) {
+          recordUsageReading(ctx.usageAccount, info.rateLimitType, {
+            utilization: info.utilization ?? null,
+            resetsAt: resetsAtToMs(info.resetsAt),
+            status: info.status
+          });
+        }
         const note = reportRateLimitEvent(msg);
         if (note) {
           state.controller.enqueue({ type: "text-delta", id: state.startTextBlock(), delta: note });
@@ -14514,6 +15627,7 @@ ${plan}
           resultText: msg.message.content.filter((b) => b.type === "text" && b.text).map((b) => String(b.text)).join("\n")
         }));
         const limitErrorReply = limitFromReply && ctx.usageLimitNoteActive;
+        const autoFailoverReply = (limitFromReply || accountBlockKind(msg) !== null) && ctx.autoFailoverTarget() !== void 0;
         const compactionApiError = ctx.compactionMode && (apiErrorReply || typeof msg.error === "string");
         if (limitFromReply) {
           state.accountLimitHit ??= recallAccountLimit(ctx.sourceAccount);
@@ -14526,6 +15640,15 @@ ${plan}
             window: known.window ?? said.window,
             ...known.resetsAt === void 0 && said.resetsText ? { resetsText: said.resetsText } : {}
           };
+          if (ctx.interactive) {
+            const hit = state.accountLimitHit;
+            recordUsageReading(ctx.usageAccount, hit.window ?? "unknown", {
+              utilization: null,
+              resetsAt: resetsAtToMs(hit.resetsAt),
+              resetsText: hit.resetsText,
+              status: "rejected"
+            });
+          }
         }
         if (hasText && !hasToolUse) {
           startResultFallback(state);
@@ -14535,7 +15658,7 @@ ${plan}
         }
         for (const block2 of msg.message.content) {
           if (block2.type === "text" && block2.text) {
-            if (limitErrorReply) continue;
+            if (limitErrorReply || autoFailoverReply) continue;
             if (compactionApiError) {
               state.compactionFailureText ??= block2.text;
               continue;
@@ -14755,6 +15878,7 @@ ${plan}
         if (msg.session_id) {
           setClaudeSessionId(state.sessionKey, msg.session_id);
         }
+        if (ctx.budget) recordResultCost(ctx.budget, msg.session_id, msg.total_cost_usd);
         if (deliverPendingCompletions(state)) {
           return;
         }
@@ -14763,9 +15887,11 @@ ${plan}
         })) {
           state.accountLimitHit = recallAccountLimit(ctx.sourceAccount);
         }
+        const autoFailoverResult = msg.is_error === true && (!!state.accountLimitHit || !!state.accountBlock) && ctx.autoFailoverTarget() !== void 0;
         state.usageLimitNote = ctx.usageLimitNoteActive && !!state.accountLimitHit && // An expired login or a billing hold writes its own note just below
         // and says what to run; two notes about one failure is one too many.
-        !state.accountBlock && msg.is_error === true;
+        !state.accountBlock && msg.is_error === true && // Moved to another account: that account's answer is this turn's.
+        !autoFailoverResult;
         const compactionFailure = ctx.compactionMode && (msg.is_error === true || typeof msg.subtype === "string" && msg.subtype !== "success");
         if (compactionFailure) {
           if (typeof msg.result === "string" && msg.result.trim()) {
@@ -14774,7 +15900,7 @@ ${plan}
           state.resultFailure ??= state.accountBlock ?? (state.accountLimitHit ? "usage_limit" : void 0) ?? (typeof msg.subtype === "string" && msg.subtype !== "success" ? msg.subtype : "error");
         }
         if (!state.currentTextId && msg.is_error && !compactionFailure && // Already on screen from the reply frame, word for word.
-        !(typeof msg.result === "string" && state.apiErrorTextShown !== null && msg.result.trim() === state.apiErrorTextShown.trim()) && !state.usageLimitNote && typeof msg.result === "string" && msg.result.trim().length > 0) {
+        !(typeof msg.result === "string" && state.apiErrorTextShown !== null && msg.result.trim() === state.apiErrorTextShown.trim()) && !state.usageLimitNote && !autoFailoverResult && typeof msg.result === "string" && msg.result.trim().length > 0) {
           const errId = state.startTextBlock();
           state.controller.enqueue({
             type: "text-delta",
@@ -14788,14 +15914,14 @@ ${plan}
         if (state.accountBlock && msg.is_error) {
           state.resultFailure ??= state.accountBlock;
           const offeringSwitch = ctx.failoverAskActive;
-          if (!compactionFailure) {
+          if (!compactionFailure && !autoFailoverResult) {
             state.controller.enqueue({
               type: "text-delta",
               id: state.startTextBlock(),
               delta: formatAccountBlockNote({
                 kind: state.accountBlock,
                 account: ctx.sourceAccount,
-                configDir: ctx.config.configDir,
+                configDir: ctx.accountConfigDir,
                 offeringSwitch,
                 // Read only when the form is not taking the turn, which is the
                 // default: moving the work by hand is then the operator's only
@@ -14814,7 +15940,7 @@ ${plan}
         const failure = describeResultFailure(msg);
         if (failure) {
           state.resultFailure = msg.subtype;
-          if (!compactionFailure) {
+          if (!compactionFailure && !autoFailoverResult) {
             state.controller.enqueue({
               type: "text-delta",
               id: state.startTextBlock(),
@@ -14857,6 +15983,19 @@ ${plan}
             });
           }
         }
+        if (ctx.budget && !autoFailoverResult && !state.modelRefusal) {
+          const note = takeBudgetNote(ctx.budget);
+          if (note) {
+            state.controller.enqueue({
+              type: "text-delta",
+              id: state.startTextBlock(),
+              delta: note
+            });
+            log.notice("conversation budget threshold crossed", {
+              sessionId: msg.session_id
+            });
+          }
+        }
         state.turnCompleted = true;
         state.endTextBlock();
         const shouldDeferResult = !msg.is_error && !state.autoContinueState.aborted && !state.autoContinueState.sawAskUserQuestion;
@@ -15023,6 +16162,66 @@ var ClaudeCodeLanguageModel = class {
   async resolvePlanModeQuestion(compactionMode, loadLiveToolInfo = () => this.fetchLiveToolInfo()) {
     return resolvePlanModeQuestion(this.config, compactionMode, loadLiveToolInfo);
   }
+  /**
+   * The ledger this turn keeps under `maxBudgetUsd` (h #g245), or null for
+   * none. The parent lookup runs once per session per process and only with a
+   * cap set, so a default install never pays for it. A lookup that cannot
+   * answer reads as "no parent", which makes the session its own conversation:
+   * its spend is still counted, against its own budget.
+   */
+  async resolveTurnBudget(affinity, compactionMode, mode, interactive) {
+    const capUsd = this.config.maxBudgetUsd;
+    if (capUsd === void 0 || !affinity || affinity === "default") return null;
+    if (!sessionParentKnown(affinity)) {
+      noteSessionParent(affinity, await fetchSessionParentId(affinity) ?? null);
+    }
+    return {
+      session: affinity,
+      capUsd,
+      warnAt: this.config.budgetWarnAt ?? [],
+      notes: !compactionMode && mode !== "generate" && !isChildSession(affinity),
+      // The interactive transport synthesizes a per-turn `result` (h #g208);
+      // headless reports the Claude session's running total.
+      cumulative: !interactive
+    };
+  }
+  /**
+   * A turn the session budget stopped before anything was spawned: one
+   * `▌ **budget:**` note (when the turn may write one) and an error finish,
+   * the shape a usage limit has had since h #g214. A child session gets an
+   * `error` part instead of the note, so the parent's `task` result says why
+   * without the note becoming the subagent's answer.
+   */
+  budgetStopStream(opts) {
+    log.notice("conversation budget reached; turn not started", {
+      child: opts.child
+    });
+    const toUsage2 = this.toUsage.bind(this);
+    const text = formatBudgetStopNote(opts.spentUsd, opts.capUsd);
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue({ type: "stream-start", warnings: opts.warnings });
+        if (opts.note) {
+          const id = generateId();
+          controller.enqueue({ type: "text-start", id });
+          controller.enqueue({ type: "text-delta", id, delta: text });
+          controller.enqueue({ type: "text-end", id });
+        } else if (opts.child) {
+          controller.enqueue({ type: "error", error: new Error(text) });
+        }
+        controller.enqueue({
+          type: "finish",
+          finishReason: { unified: "error", raw: "budget_exceeded" },
+          usage: toUsage2({ input_tokens: 0, output_tokens: 0 }),
+          providerMetadata: {
+            "claude-code": { path: "budget-stop", synthetic: true, usageUnavailable: true }
+          }
+        });
+        controller.close();
+      }
+    });
+    return { stream, request: { body: { text: "" } } };
+  }
   /**
    * A dispatch form, as a turn: one synthetic `question` tool call and a
    * `tool-calls` finish, which is how the operator's answer comes back on the
@@ -15312,12 +16511,93 @@ var ClaudeCodeLanguageModel = class {
    * because which method opencode used is not in them.
    */
   async streamTurn(options, mode) {
-    const result = await this.runModelChain(options, mode);
+    const result = await this.runAccountFailover(options, mode);
     return {
       ...result,
       stream: translateStreamForHost(result.stream, this.config.hostApi ?? "v1")
     };
   }
+  /**
+   * Run the turn, moving the same request to the next eligible configured
+   * account when the one it ran on is out of usage or cannot serve
+   * (`accountFailover: "auto"`). The single wiring point for the automatic
+   * switch, and outside `runModelChain` on purpose: an account switch starts
+   * that account's own model chain from the top.
+   *
+   * Anything but `"auto"` is `runModelChain` and one `await`, so `"off"` and
+   * `"ask"` are exactly what they were. With `"auto"`, the attempt that failed
+   * decides the switch itself (`completeResult` sets `run.switchTo` and closes
+   * its stream without a `finish`), and the next attempt's prologue makes the
+   * switch the form's pick would have made. This only splices the attempts
+   * into one caller turn: one `stream-start`, and the `finish` of whichever
+   * attempt did not switch.
+   *
+   * The bound is `run.tried`, as it is `tried` for the model chain: every
+   * account spawned or switched to goes in, and none in it is picked again.
+   *
+   * Cancelling the returned stream is a stop, for every attempt: this loop is
+   * the plugin starting more work on the caller's behalf, so a caller that
+   * has gone away must reach all of it. Each attempt gets a signal that the
+   * caller's own `abortSignal` and a `cancel()` both abort, and the loop
+   * starts no further account once either has happened.
+   */
+  async runAccountFailover(options, mode) {
+    if (this.config.accountFailover !== "auto") return this.runModelChain(options, mode);
+    const self = this;
+    const run = { tried: /* @__PURE__ */ new Set() };
+    const cancelled2 = new AbortController();
+    const attemptOptions = {
+      ...options,
+      abortSignal: options.abortSignal ? AbortSignal.any([options.abortSignal, cancelled2.signal]) : cancelled2.signal
+    };
+    const stopped = () => attemptOptions.abortSignal.aborted;
+    let inner = await this.runModelChain(attemptOptions, mode, run);
+    const request = inner.request;
+    let reader;
+    const stream = new ReadableStream({
+      async start(controller) {
+        let started2 = false;
+        try {
+          for (; ; ) {
+            reader = inner.stream.getReader();
+            try {
+              for (; ; ) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                if (value.type === "stream-start") {
+                  if (started2) continue;
+                  started2 = true;
+                }
+                controller.enqueue(value);
+              }
+            } finally {
+              reader.releaseLock();
+            }
+            if (!run.switchTo) break;
+            if (stopped()) {
+              log.info("turn stopped before the automatic account switch; not switching", {
+                target: run.switchTo.target
+              });
+              break;
+            }
+            inner = await self.runModelChain(attemptOptions, mode, run);
+          }
+        } catch (error) {
+          if (!stopped()) controller.enqueue({ type: "error", error });
+        } finally {
+          try {
+            controller.close();
+          } catch {
+          }
+        }
+      },
+      async cancel(reason) {
+        cancelled2.abort(reason);
+        await reader?.cancel(reason).catch(() => void 0);
+      }
+    });
+    return { stream, request };
+  }
   /**
    * Run the turn, moving to the next model in the fallback chain if the one
    * it started on is refused. The single wiring point for `src/model-fallback.ts`.
@@ -15336,14 +16616,14 @@ var ClaudeCodeLanguageModel = class {
    * and an exhausted chain leaves the last attempt un-armed so its error
    * surfaces exactly as it does today.
    */
-  async runModelChain(options, mode) {
+  async runModelChain(options, mode, accountRun) {
     const agent = this.getOpencodeAgent(options);
     const chain = this.isCompactionCall(options) ? [] : resolveFallbackChain(agent, resolveAgentModel(agent, this.modelId));
-    if (chain.length === 0) return this.doStreamForHost(options, void 0, mode);
+    if (chain.length === 0) return this.doStreamForHost(options, void 0, mode, accountRun);
     const self = this;
     const tried = /* @__PURE__ */ new Set();
     let attempt = { armed: true };
-    let inner = await this.doStreamForHost(options, attempt, mode);
+    let inner = await this.doStreamForHost(options, attempt, mode, accountRun);
     const request = inner.request;
     const stream = new ReadableStream({
       async start(controller) {
@@ -15413,7 +16693,7 @@ var ClaudeCodeLanguageModel = class {
               modelOverride: next,
               armed: nextFallbackModel(chain, tried) !== void 0
             };
-            inner = await self.doStreamForHost(options, attempt, mode);
+            inner = await self.doStreamForHost(options, attempt, mode, accountRun);
           }
         } catch (error) {
           controller.enqueue({ type: "error", error });
@@ -15427,8 +16707,10 @@ var ClaudeCodeLanguageModel = class {
     });
     return { stream, request };
   }
-  async doStreamForHost(options, attempt, mode = "stream") {
+  async doStreamForHost(options, attempt, mode = "stream", accountRun) {
     const warnings = [];
+    const autoSwitch = accountRun?.switchTo;
+    if (accountRun) accountRun.switchTo = void 0;
     const turnAbort = watchTurnAbort(options.abortSignal);
     const abortedBeforeWork = (stage) => {
       log.info("abort before the turn asked claude for work; nothing spawned", {
@@ -15466,6 +16748,11 @@ var ClaudeCodeLanguageModel = class {
       this.getOpencodeAgent(options) ?? null
     ];
     if (promptCacheTtl) context.push(promptCacheTtl);
+    const agentCliCaps = compactionMode ? {} : resolveAgentCliCaps(this.getOpencodeAgent(options));
+    if (agentCliCaps.maxTurns !== void 0) context.push(`maxTurns=${agentCliCaps.maxTurns}`);
+    if (agentCliCaps.maxBudgetUsd !== void 0) {
+      context.push(`maxBudgetUsd=${agentCliCaps.maxBudgetUsd}`);
+    }
     const baseKey = sessionKey(
       cwd,
       `${effectiveModelId}::${scope}::${affinity}::context=${JSON.stringify(context)}`
@@ -15523,7 +16810,10 @@ var ClaudeCodeLanguageModel = class {
         configDir: this.config.accountInProcess ? this.config.configDir : void 0,
         // `/claude-code-doctor usage` opts into the CLI's own plan-usage
         // report; anything else here is ignored, as it always has been.
-        argument: doctor.rest
+        argument: doctor.rest,
+        maxBudgetUsd: this.config.maxBudgetUsd,
+        budgetWarnAt: this.config.budgetWarnAt,
+        maxBackgroundSubagents: this.config.maxBackgroundSubagents
       };
       const stream2 = new ReadableStream({
         async start(controller) {
@@ -15659,6 +16949,23 @@ var ClaudeCodeLanguageModel = class {
     if (dispatchStep?.kind === "release") {
       return this.subagentDispatchReleaseStream(dispatchStep, sk, warnings);
     }
+    const budget = await this.resolveTurnBudget(affinity, compactionMode, mode, useInteractive);
+    if (budget && !compactionMode) {
+      const root = budgetRoot(budget.session);
+      const spentUsd = sessionSpend(root);
+      if (spentUsd >= budget.capUsd && getPendingProxyCalls(sk).length === 0) {
+        turnAbort.dispose();
+        return this.budgetStopStream({
+          spentUsd,
+          capUsd: budget.capUsd,
+          // The note is the operator's; a `doGenerate` turn's text is a return
+          // value and a child's can become its parent's `task` result.
+          note: mode !== "generate" && !isChildSession(budget.session),
+          child: isChildSession(budget.session),
+          warnings
+        });
+      }
+    }
     if (!compactionMode) invalidateOtherEffortSessions(baseKey, reasoningEffort);
     if (!compactionMode && affinity !== "default") {
       recordSessionSpawn(affinity, {
@@ -15668,12 +16975,17 @@ var ClaudeCodeLanguageModel = class {
       });
     }
     const hasPriorConversation = options.prompt.filter((m) => m.role === "user" || m.role === "assistant").length > 1;
-    if (!hasPriorConversation) {
+    if (!hasPriorConversation && !autoSwitch) {
       deleteClaudeSessionId(sk);
       deleteActiveProcess(sk);
       clearCompression(sk);
     }
-    const failoverAnswer = compactionMode || mode === "generate" ? null : consumeAccountFailoverAnswer(sk, options.prompt, {
+    const failoverAnswer = autoSwitch ? {
+      kind: "switch",
+      target: autoSwitch.target,
+      sourceAccount: autoSwitch.sourceAccount,
+      resetsAt: autoSwitch.resetsAt
+    } : compactionMode || mode === "generate" ? null : consumeAccountFailoverAnswer(sk, options.prompt, {
       sourceAccount,
       candidates: failoverCandidates(
         this.config.failoverAccounts,
@@ -15731,13 +17043,84 @@ var ClaudeCodeLanguageModel = class {
         cliPath: this.config.cliPath,
         modelId: effectiveModelId
       });
+      while (autoSwitch && accountRun && failover.target !== failoverAnswer.target) {
+        log.notice("automatic account switch skipped an account whose runtime could not be prepared", {
+          sessionKey: sk,
+          target: failoverAnswer.target
+        });
+        const next = nextAutoFailoverAccount(
+          failoverCandidates(this.config.failoverAccounts, sourceAccount, groups),
+          accountRun.tried
+        );
+        if (!next) {
+          clearAccountOverride(failoverAnswer.sourceAccount);
+          log.warn("no configured account could take this turn; it ends here", {
+            sessionKey: sk,
+            account: autoSwitch.failedAccount,
+            cause: autoSwitch.cause
+          });
+          const note = mode === "generate" ? null : autoSwitch.cause === "usage_limit" ? formatUsageLimitNote({
+            sourceAccount: autoSwitch.failedAccount,
+            candidates: [],
+            resetsAt: autoSwitch.resetsAt,
+            window: autoSwitch.window
+          }) : formatAccountBlockNote({
+            kind: autoSwitch.cause,
+            account: autoSwitch.failedAccount,
+            configDir: autoSwitch.failedConfigDir,
+            offeringSwitch: false,
+            candidates: []
+          });
+          const cause = autoSwitch.cause;
+          const exhausted = new ReadableStream({
+            start(controller) {
+              controller.enqueue({ type: "stream-start", warnings });
+              if (note) {
+                const id = generateId();
+                controller.enqueue({ type: "text-start", id });
+                controller.enqueue({ type: "text-delta", id, delta: note });
+                controller.enqueue({ type: "text-end", id });
+              }
+              controller.enqueue({
+                type: "finish",
+                finishReason: { unified: "error", raw: cause },
+                usage: toUsage2({ input_tokens: 0, output_tokens: 0 }),
+                providerMetadata: {
+                  "claude-code": {
+                    path: "account-failover-exhausted",
+                    synthetic: true,
+                    usageUnavailable: true
+                  }
+                }
+              });
+              controller.close();
+            }
+          });
+          return { stream: exhausted, request: { body: { text: "" } } };
+        }
+        accountRun.tried.add(next);
+        failoverAnswer.target = next;
+        setAccountOverride(
+          failoverAnswer.sourceAccount,
+          next,
+          failoverUntil(failoverAnswer.resetsAt)
+        );
+        failover = await resolveFailoverSpawn({
+          account: sourceAccount,
+          baseCliPath,
+          cliPath: this.config.cliPath,
+          modelId: effectiveModelId
+        });
+      }
       cliPath = failover.cliPath;
       asideTransportRef.cliPath = cliPath;
-      failoverNote = formatFailoverNote({
-        sourceAccount: failoverAnswer.sourceAccount,
-        target: failoverAnswer.target,
-        resetsAt: failoverAnswer.resetsAt
-      });
+      if (!autoSwitch) {
+        failoverNote = formatFailoverNote({
+          sourceAccount: failoverAnswer.sourceAccount,
+          target: failoverAnswer.target,
+          resetsAt: failoverAnswer.resetsAt
+        });
+      }
     }
     const spawnConfigDir = this.config.accountInProcess ? this.skillBridgeSpawn(failover).configDir : void 0;
     const processForAccount = getActiveProcess(sk);
@@ -15801,6 +17184,15 @@ var ClaudeCodeLanguageModel = class {
     if (failoverAnswer?.kind === "switch" && hasPriorConversation && !conversationOnTarget) {
       includeHistoryContext = true;
     }
+    if (autoSwitch && failoverAnswer?.kind === "switch" && mode !== "generate") {
+      failoverNote = formatAutoFailoverNote({
+        failedAccount: autoSwitch.failedAccount,
+        target: failoverAnswer.target,
+        resetsAt: autoSwitch.resetsAt,
+        reason: autoSwitch.reason,
+        carried: conversationOnTarget
+      });
+    }
     let accountGroupNote = null;
     if (!compactionMode && groups && accountProviders.size > 0 && includeHistoryContext && failoverAnswer?.kind !== "switch") {
       const foreign = findForeignAccountSibling({
@@ -15870,7 +17262,7 @@ var ClaudeCodeLanguageModel = class {
     let replayReason = "no-session-for-key";
     if (this.config.resumeAfterRestart !== false && includeHistoryContext && !compactionMode && !forkFromClaudeSessionId && failoverAnswer?.kind !== "switch") {
       const configDir = resolveConfigDir(this.config.configDir);
-      const transcriptPath2 = (id, dir) => join16(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
+      const transcriptPath2 = (id, dir) => join17(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
       const resumePoint = findResumePoint({
         sessionKey: sk,
         prompt: options.prompt,
@@ -15973,6 +17365,30 @@ var ClaudeCodeLanguageModel = class {
         messages: options.prompt.length
       });
     }
+    const conversationChange = !compactionMode && !includeHistoryContext && failoverAnswer?.kind !== "switch" && !accountGroupNote && (!!getClaudeSessionId(sk) || !!getActiveProcess(sk)) ? classifyConversationChange(sk, filterSideQuestionHistory(options.prompt)) : null;
+    const missed = conversationChange?.kind === "missed" ? conversationChange : null;
+    if (missed) {
+      log.notice("replaying the messages this claude session missed: the conversation continued under another session key", {
+        sessionKey: sk,
+        messages: missed.messages.length,
+        userMessages: missed.userMessages
+      });
+    }
+    let rewoundNote = null;
+    if (conversationChange?.kind === "rewound") {
+      await deleteActiveProcessAndWait(sk);
+      deleteClaudeSessionId(sk);
+      includeHistoryContext = true;
+      replayReason = "history-rewound";
+      log.notice("replaying the conversation as text: the thread was edited or undone", {
+        sessionKey: sk,
+        reason: "history-rewound",
+        sharedMessages: conversationChange.sharedMessages,
+        removedMessages: conversationChange.removedMessages,
+        removedUserMessages: conversationChange.removedUserMessages
+      });
+      if (mode !== "generate") rewoundNote = formatConversationRewoundNote();
+    }
     if (this.config.forkSessions === true && !compactionMode) {
       recordForkFingerprint(sk, options.prompt, cliPath);
     }
@@ -15993,7 +17409,8 @@ var ClaudeCodeLanguageModel = class {
       compactionMode,
       compactionInstructions: useInteractive && compactionMode ? extractSystemMessages(effectivePrompt).join("\n\n") : void 0,
       cliToolCallIds: new Set(previousPendingProxyCalls.map((c) => c.toolCallId)),
-      stripContextReminders: this.stripContextRemindersEnabled()
+      stripContextReminders: this.stripContextRemindersEnabled(),
+      missed: missed?.messages
     });
     const ptyPlanMode = useInteractive && !compactionMode && this.config.permissionMode === "plan";
     const resolvedProxy = compactionMode ? null : ptyPlanMode ? this.resolvedProxyTools()?.filter((def) => def.name !== "write" && def.name !== "edit") ?? null : this.resolvedProxyTools();
@@ -16058,7 +17475,24 @@ var ClaudeCodeLanguageModel = class {
       // the operator is usually not even looking at.
       childSession: !!await fetchSessionParentId(affinity)
     });
+    const spawnedAccount = failover.target ?? sourceAccount;
+    accountRun?.tried.add(spawnedAccount);
+    let autoFailoverChoice;
+    const autoFailoverTarget = () => {
+      if (autoFailoverChoice === void 0) {
+        autoFailoverChoice = accountRun && !compactionMode ? nextAutoFailoverAccount(failoverAccounts, accountRun.tried) ?? null : null;
+      }
+      return autoFailoverChoice ?? void 0;
+    };
+    const limitAccount = accountRun ? spawnedAccount : sourceAccount;
     const usageLimitNoteActive = !compactionMode && mode !== "generate" && !failoverAskActive;
+    const usageWarnThresholds = resolveUsageWarnThresholds(this.config.usageWarnThresholds);
+    const usageSwitchAt = this.config.usageSwitchAt === null ? null : resolveUsageSwitchAt(this.config.usageSwitchAt);
+    const usageNoteThresholds = [
+      .../* @__PURE__ */ new Set([...usageWarnThresholds, ...usageSwitchAt === null ? [] : [usageSwitchAt]])
+    ];
+    const usageNotesPossible = usageNoteThresholds.length > 0 && !compactionMode && mode !== "generate";
+    const usageChildSession = usageNotesPossible ? watchChildSession(affinity) : () => true;
     let staleBuild = null;
     if (!compactionMode && mode !== "generate" && affinity !== "default") {
       staleBuild = staleBuildWatch().check();
@@ -16385,11 +17819,20 @@ var ClaudeCodeLanguageModel = class {
               );
             }
             const questionProxyActive = enrichedProxy?.some((t) => t.name === "question") ?? false;
+            const readRules = resolveReadRuleMapping({
+              layers: opencodeConfigLayers(cwd, self.config.hostApi === "v2" ? "v2" : "v1"),
+              hostApi: self.config.hostApi === "v2" ? "v2" : "v1",
+              enabled: self.config.mapReadRules !== false,
+              worktree: detectWorktree(cwd),
+              cwd
+            });
             const allDisallowed = resolveDisallowedTools({
               proxyTools: enrichedProxy,
               extraDisallowedTools: self.config.extraDisallowedTools,
-              disableWebSearch: self.config.webSearch === "disabled"
+              disableWebSearch: self.config.webSearch === "disabled",
+              readRules: readRules.deny
             });
+            recordReadRuleMapping(readRules);
             return {
               excludeServers,
               taskProxyEnabled,
@@ -16500,6 +17943,7 @@ var ClaudeCodeLanguageModel = class {
                 supportsBypass: ptyBypassSupported
               });
               if (!posture) throw new Error("the interactive transport cannot hold this permission posture");
+              warnCliCapsOnInteractive(agentCliCaps);
               const ap = spawnInteractiveProcess({
                 cwd,
                 cliPath,
@@ -16623,7 +18067,8 @@ var ClaudeCodeLanguageModel = class {
                 pluginDirs: skillPluginDirs,
                 ...self.thinkingCliOptions(),
                 fastMode,
-                cliVersion
+                cliVersion,
+                ...await resolveSpawnCliCaps(agentCliCaps, cliPath, cliVersion, turnAbort.whenAborted)
               });
               spawnSystemPromptFile = systemPromptFile;
               spawnProxyServer = state.proxyServer;
@@ -16673,6 +18118,14 @@ var ClaudeCodeLanguageModel = class {
             });
             state.endTextBlock();
           }
+          if (rewoundNote) {
+            controller.enqueue({
+              type: "text-delta",
+              id: state.startTextBlock(),
+              delta: rewoundNote
+            });
+            state.endTextBlock();
+          }
           if (accountGroupNote) {
             controller.enqueue({
               type: "text-delta",
@@ -16690,6 +18143,56 @@ var ClaudeCodeLanguageModel = class {
             state.endTextBlock();
           }
           state.autoContinueState.startedAt = Date.now();
+          const writeUsageNote = () => {
+            const crossings = usageCrossings(spawnedAccount, usageNoteThresholds);
+            if (crossings.length === 0) return;
+            const switching = usageSwitchAt !== null && crossings.some((crossing) => crossing.crossed.includes(usageSwitchAt));
+            let movedTo;
+            let candidates = [];
+            if (switching && usageSwitchAt !== null) {
+              if (accountRun) {
+                const target = nextUsageSwitchAccount(
+                  failoverAccounts,
+                  /* @__PURE__ */ new Set([spawnedAccount, sourceAccount]),
+                  usageSwitchAt
+                );
+                if (target) {
+                  const until = Math.max(
+                    ...crossings.filter((crossing) => crossing.crossed.includes(usageSwitchAt)).map((crossing) => crossing.entry.resetsAt ?? 0)
+                  );
+                  movedTo = { target, ...until > 0 ? { until } : {} };
+                  setAccountOverride(sourceAccount, target, movedTo.until, Date.now(), "usage-threshold");
+                }
+              } else {
+                candidates = failoverAccounts.filter(
+                  (account) => account !== spawnedAccount && !accountUsageAtOrOver(account, usageSwitchAt)
+                );
+              }
+            }
+            const windows = crossings.map((crossing) => ({
+              window: crossing.window,
+              percent: usagePercent(crossing.entry.utilization ?? 0),
+              resetsAt: crossing.entry.resetsAt,
+              resetsText: crossing.entry.resetsText
+            }));
+            for (const crossing of crossings) {
+              log.notice("claude account usage crossed a warning threshold", {
+                sessionKey: sk,
+                account: spawnedAccount,
+                rateLimitType: crossing.window,
+                utilization: usagePercent(crossing.entry.utilization ?? 0),
+                crossed: crossing.crossed,
+                switched: movedTo !== void 0
+              });
+              markUsageNoted(spawnedAccount, crossing.window, crossing.crossed);
+            }
+            controller.enqueue({
+              type: "text-delta",
+              id: state.startTextBlock(),
+              delta: formatUsageNote({ account: spawnedAccount, windows, movedTo, candidates })
+            });
+            state.endTextBlock();
+          };
           const completeResult = (msg) => {
             if (state.controllerClosed) return;
             if (self.config.resumeAfterRestart !== false && !compactionMode && msg.is_error !== true && typeof msg.session_id === "string") {
@@ -16698,6 +18201,9 @@ var ClaudeCodeLanguageModel = class {
                 account: failover.target ?? sourceAccount
               });
             }
+            if (!compactionMode) {
+              recordServedConversation(sk, filterSideQuestionHistory(options.prompt));
+            }
             if (deliverPendingCompletions(state)) {
               if (state.drainBuffer.length > 0) drainNow(state);
               return;
@@ -16735,6 +18241,36 @@ var ClaudeCodeLanguageModel = class {
               finishWithQuestionCall(state, call);
               return;
             }
+            const autoTarget = (state.accountLimitHit || state.accountBlock) && msg.is_error === true ? autoFailoverTarget() : void 0;
+            if (autoTarget && accountRun) {
+              const target = autoTarget;
+              accountRun.tried.add(target);
+              accountRun.switchTo = {
+                target,
+                sourceAccount,
+                failedAccount: limitAccount,
+                cause: state.accountLimitHit ? "usage_limit" : state.accountBlock,
+                resetsAt: state.accountLimitHit?.resetsAt,
+                window: state.accountLimitHit?.window,
+                failedConfigDir: self.skillBridgeSpawn(failover).configDir,
+                reason: state.accountLimitHit || !state.accountBlock ? void 0 : describeAccountBlock(state.accountBlock)
+              };
+              log.warn("claude account cannot serve this turn; continuing it on the next account automatically", {
+                sessionKey: sk,
+                account: limitAccount,
+                target,
+                cause: state.accountLimitHit ? "usage_limit" : state.accountBlock,
+                resetsAt: state.accountLimitHit?.resetsAt ?? null
+              });
+              state.endTextBlock();
+              state.controllerClosed = true;
+              cleanupTurn();
+              try {
+                controller.close();
+              } catch {
+              }
+              return;
+            }
             if (modelFallbackArmed && attempt && msg.is_error === true) {
               const refusal = state.modelRefusal ?? (state.accountLimitHit && !failoverAskActive && !state.accountBlock ? { kind: "account_limit" } : null);
               if (refusal) {
@@ -16763,19 +18299,20 @@ var ClaudeCodeLanguageModel = class {
               }
             }
             if (state.usageLimitNote) {
+              const noteCandidates = accountRun ? [] : failoverAccounts;
               log.warn("claude account is out of usage; the turn ends with a note", {
                 sessionKey: sk,
-                account: sourceAccount,
+                account: limitAccount,
                 window: state.accountLimitHit?.window ?? null,
                 resetsAt: state.accountLimitHit?.resetsAt ?? null,
-                candidates: failoverAccounts
+                candidates: noteCandidates
               });
               controller.enqueue({
                 type: "text-delta",
                 id: state.startTextBlock(),
                 delta: formatUsageLimitNote({
-                  sourceAccount,
-                  candidates: failoverAccounts,
+                  sourceAccount: limitAccount,
+                  candidates: noteCandidates,
                   resetsAt: state.accountLimitHit?.resetsAt,
                   window: state.accountLimitHit?.window,
                   resetsText: state.accountLimitHit?.resetsText
@@ -16784,6 +18321,9 @@ var ClaudeCodeLanguageModel = class {
               state.endTextBlock();
               state.resultFailure ??= "usage_limit";
             }
+            if (accountRun && state.accountLimitHit && msg.is_error === true) {
+              state.resultFailure ??= "usage_limit";
+            }
             if (runAutoContinue(state, msg)) return;
             for (const [idx, reasoningId] of state.reasoningIds) {
               if (state.reasoningStarted.get(idx)) {
@@ -16816,6 +18356,9 @@ var ClaudeCodeLanguageModel = class {
               });
               state.endTextBlock();
             }
+            if (usageNotesPossible && msg.is_error !== true && !state.resultFailure && usageChildSession() === false) {
+              writeUsageNote();
+            }
             if (compactionMode && state.resultFailure) {
               log.warn("claude could not compact the conversation; no summary was stored", {
                 sessionKey: sk,
@@ -16868,10 +18411,16 @@ var ClaudeCodeLanguageModel = class {
             fastMode,
             planModeQuestionActive,
             interactive: useInteractive,
-            sourceAccount,
+            sourceAccount: limitAccount,
+            usageAccount: spawnedAccount,
+            accountConfigDir: accountRun ? self.skillBridgeSpawn(failover).configDir : self.config.configDir,
             failoverAskActive,
+            autoFailoverTarget,
             usageLimitNoteActive,
-            failoverAccounts,
+            // Read only when no switch takes the turn, which under `"auto"`
+            // means no account is left to offer.
+            failoverAccounts: accountRun ? [] : failoverAccounts,
+            budget,
             modelFallbackArmed,
             attempt,
             handleControlRequest: handleControlRequest2,
@@ -17122,7 +18671,7 @@ var ClaudeCodeLanguageModel = class {
               return fresh.length;
             };
             if (!state.unattendedTurnEnded && await forwardTrailingUserMessages() > 0) {
-              await new Promise((resolve6) => setTimeout(resolve6, FORWARD_SETTLE_MS));
+              await new Promise((resolve7) => setTimeout(resolve7, FORWARD_SETTLE_MS));
               if (state.controllerClosed) return;
             }
             for (const { call, result: opencodeResult } of previousPendingProxyMatches) {
@@ -17226,8 +18775,8 @@ var ClaudeCodeLanguageModel = class {
 };
 
 // src/account-tier.ts
-import { readFileSync as readFileSync10 } from "fs";
-import path13 from "path";
+import { readFileSync as readFileSync11 } from "fs";
+import path14 from "path";
 var ORGANIZATION_TYPE_LABELS = {
   claude_max: "Max",
   claude_pro: "Pro",
@@ -17249,14 +18798,14 @@ function accountTierConfigDir(account) {
 function readAccountTier(account) {
   const normalized = normalizeAccountName(account) || DEFAULT_ACCOUNT;
   const configDir = accountTierConfigDir(normalized);
-  const cached = tierCache.get(configDir);
-  if (cached !== void 0) return cached ?? void 0;
+  const cached2 = tierCache.get(configDir);
+  if (cached2 !== void 0) return cached2 ?? void 0;
   const label = readTierFromConfigDir(configDir, normalized === DEFAULT_ACCOUNT);
   tierCache.set(configDir, label ?? null);
   return label;
 }
 function readTierFromConfigDir(configDir, allowLegacyFallback) {
-  const candidates = [path13.join(configDir, ".claude.json")];
+  const candidates = [path14.join(configDir, ".claude.json")];
   if (allowLegacyFallback) candidates.push(expandHome("~/.claude.json"));
   for (const candidate of candidates) {
     const oauth = readOauthAccount(candidate);
@@ -17269,7 +18818,7 @@ function readTierFromConfigDir(configDir, allowLegacyFallback) {
 function readOauthAccount(file) {
   let raw;
   try {
-    raw = readFileSync10(file, "utf8");
+    raw = readFileSync11(file, "utf8");
   } catch {
     return void 0;
   }
@@ -17297,14 +18846,14 @@ function tierLabel(oauthAccount) {
 // src/cleanup-stale.ts
 import {
   existsSync as existsSync5,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync11,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync12,
   realpathSync as realpathSync4,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "fs";
-import { homedir as homedir12 } from "os";
-import { dirname as dirname7, join as join17, resolve as resolve5 } from "path";
+import { homedir as homedir14 } from "os";
+import { dirname as dirname7, join as join18, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -17312,20 +18861,20 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join17(xdg, "opencode") : null,
-    join17(homedir12(), ".cache", "opencode"),
-    join17(homedir12(), "Library", "Caches", "opencode")
+    xdg ? join18(xdg, "opencode") : null,
+    join18(homedir14(), ".cache", "opencode"),
+    join18(homedir14(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join17(homedir12(), ".config");
-  return join17(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join18(homedir14(), ".config");
+  return join18(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
   if (!existsSync5(cfg)) return false;
   try {
-    const json = JSON.parse(readFileSync11(cfg, "utf8"));
+    const json = JSON.parse(readFileSync12(cfg, "utf8"));
     const plugins = json.plugin;
     if (!Array.isArray(plugins)) return false;
     return plugins.some(
@@ -17338,7 +18887,7 @@ function userIntendsToUseUnscoped() {
 function ourLoadedDir() {
   try {
     const filePath = fileURLToPath4(import.meta.url);
-    return realpathSync4(resolve5(filePath, "..", ".."));
+    return realpathSync4(resolve6(filePath, "..", ".."));
   } catch {
     return null;
   }
@@ -17346,19 +18895,19 @@ function ourLoadedDir() {
 function ourVersion(dir) {
   if (!dir) return null;
   try {
-    const pkg = JSON.parse(readFileSync11(join17(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync12(join18(dir, "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
   } catch {
     return null;
   }
 }
 function markerPath() {
-  const stateRoot = process.env.XDG_STATE_HOME ?? join17(homedir12(), ".local", "state");
-  return join17(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
+  const stateRoot = process.env.XDG_STATE_HOME ?? join18(homedir14(), ".local", "state");
+  return join18(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
 }
 function markerVersion() {
   try {
-    const marker = JSON.parse(readFileSync11(markerPath(), "utf8"));
+    const marker = JSON.parse(readFileSync12(markerPath(), "utf8"));
     return typeof marker.version === "string" ? marker.version : null;
   } catch {
     return null;
@@ -17367,8 +18916,8 @@ function markerVersion() {
 function writeMarker(version) {
   const file = markerPath();
   try {
-    mkdirSync7(dirname7(file), { recursive: true });
-    writeFileSync9(
+    mkdirSync8(dirname7(file), { recursive: true, mode: 448 });
+    writeFileSync10(
       file,
       JSON.stringify({ version, at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n",
       "utf8"
@@ -17403,7 +18952,7 @@ function cleanupStaleUnscopedInstall() {
 }
 function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync5(cacheRoot)) return;
-  const stalePath = join17(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  const stalePath = join18(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
   if (!existsSync5(stalePath)) return;
   let realStalePath = stalePath;
   try {
@@ -17411,11 +18960,11 @@ function cleanupOne(cacheRoot, ourDir) {
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join17(stalePath, "package.json");
+  const pkgJsonPath = join18(stalePath, "package.json");
   if (!existsSync5(pkgJsonPath)) return;
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync11(pkgJsonPath, "utf8"));
+    pkg = JSON.parse(readFileSync12(pkgJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -17431,13 +18980,13 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join17(cacheRoot, "package.json");
+  const cachePkgJson = join18(cacheRoot, "package.json");
   if (!existsSync5(cachePkgJson)) return;
   try {
-    const cfg = JSON.parse(readFileSync11(cachePkgJson, "utf8"));
+    const cfg = JSON.parse(readFileSync12(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
-      writeFileSync9(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
+      writeFileSync10(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
       log.info("cleanup-stale: pruned dep from cache package.json");
     }
   } catch (err) {
@@ -17514,7 +19063,6 @@ function registerOpencodeLogSink(client) {
 }
 
 // src/v2-client.ts
-import path14 from "path";
 function formatAgentTypeList(agents) {
   const lines = agents.flatMap((agent) => {
     if (agent.hidden === true || agent.mode === "primary") return [];
@@ -17542,8 +19090,7 @@ function describe(value) {
 function toV1Session(info) {
   if (!info || typeof info !== "object") return void 0;
   const session = info;
-  const root = session.location?.directory;
-  const directory = typeof root === "string" ? typeof session.subpath === "string" && session.subpath.length > 0 ? path14.resolve(root, session.subpath) : root : void 0;
+  const directory = typeof session.location?.directory === "string" ? session.location.directory : void 0;
   return { ...info, directory, parentID: session.parentID };
 }
 function toV1Messages(messages) {
@@ -18062,6 +19609,12 @@ function createClaudeCode(settings = {}) {
   const cliPath = settings.cliPath ?? process.env.CLAUDE_CLI_PATH ?? "claude";
   const providerName = settings.providerID ?? settings.name ?? "claude-code";
   const proxyTools = preset?.proxyTools ?? settings.proxyTools ?? [...DEFAULT_PROXY_TOOL_NAMES];
+  const maxBudgetUsd = resolveBudgetUsd(settings.maxBudgetUsd, "maxBudgetUsd");
+  const budgetWarnAt = maxBudgetUsd === void 0 ? void 0 : resolveBudgetWarnAt(settings.budgetWarnAt);
+  const maxBackgroundSubagents = resolvePositiveInteger(
+    settings.maxBackgroundSubagents,
+    "maxBackgroundSubagents"
+  );
   const createModel = (modelId) => {
     return new ClaudeCodeLanguageModel(modelId, {
       provider: providerName,
@@ -18104,6 +19657,7 @@ function createClaudeCode(settings = {}) {
       proxyOpencodeTools: settings.proxyOpencodeTools,
       stripContextReminders: settings.stripContextReminders === true,
       extraDisallowedTools: preset?.extraDisallowedTools ?? settings.extraDisallowedTools,
+      mapReadRules: settings.mapReadRules,
       proxyToolTimeoutMs: settings.proxyToolTimeoutMs,
       planModeQuestion: settings.planModeQuestion ?? false,
       webSearch: settings.webSearch,
@@ -18122,6 +19676,13 @@ function createClaudeCode(settings = {}) {
       resumeAfterRestart: settings.resumeAfterRestart !== false,
       resumeAcrossModelChanges: settings.resumeAcrossModelChanges !== false,
       crossAccountResume: settings.crossAccountResume !== false,
+      // Resolved once per model, not per turn, for the reason `accountGroups`
+      // is: an invalid value WARNs at creation and a turn reads a checked one.
+      maxBudgetUsd,
+      budgetWarnAt,
+      maxBackgroundSubagents,
+      usageWarnThresholds: resolveUsageWarnThresholds(settings.usageWarnThresholds),
+      usageSwitchAt: resolveUsageSwitchAt(settings.usageSwitchAt),
       transport: settings.transport,
       interactive: settings.interactive,
       interactiveBypass: settings.interactiveBypass,
@@ -18325,6 +19886,13 @@ async function buildAgentRegistry(config) {
     typeof configuredTtl === "string" ? configuredTtl : void 0
   );
   setProviderFallbackModels(parseFallbackModelList(options?.fallbackModels));
+  setDefaultSubagentCliCaps({
+    maxTurns: resolvePositiveInteger(options?.defaultSubagentMaxTurns, "defaultSubagentMaxTurns"),
+    maxBudgetUsd: resolveBudgetUsd(
+      options?.defaultSubagentMaxBudgetUsd,
+      "defaultSubagentMaxBudgetUsd"
+    )
+  });
   const records2 = await readAgentMarkdownRecords(
     agentDirectories(
       process.env.HOME ?? process.env.USERPROFILE,
@@ -18337,6 +19905,10 @@ async function buildAgentRegistry(config) {
       const value = agent[key] ?? bag[key];
       return typeof value === "string" ? value : void 0;
     };
+    const pickNumber = (key) => {
+      const value = agent[key] ?? bag[key];
+      return typeof value === "number" || typeof value === "string" ? value : void 0;
+    };
     const declaredChain = parseFallbackModelList(
       agent.fallbackModels ?? bag.fallbackModels
     );
@@ -18346,6 +19918,8 @@ async function buildAgentRegistry(config) {
       forceModel: pick("forceModel") ?? records2[name]?.forceModel,
       reasoningEffort: pick("reasoningEffort") ?? records2[name]?.reasoningEffort,
       cacheTtl: pick("cacheTtl") ?? records2[name]?.cacheTtl,
+      maxTurns: pickNumber("maxTurns") ?? records2[name]?.maxTurns,
+      maxBudgetUsd: pickNumber("maxBudgetUsd") ?? records2[name]?.maxBudgetUsd,
       fallbackModels: declaredChain.length ? declaredChain : records2[name]?.fallbackModels,
       prompt: pick("prompt") ?? records2[name]?.prompt
     };