@adhd/agent-plugin-budget 0.1.0 → 0.2.1

package/index.js

@@ -1,14 +1,15 @@
-import { z as p } from "zod";
-function S(f) {
-  const e = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/, t = f.match(e);
-  if (!t)
-    throw new Error(`invalid ISO 8601 duration: ${f}`);
-  const [, o, s, a, n, i, c] = t;
-  let r = 0;
-  return o && (r += parseInt(o) * 365.25 * 864e5), s && (r += parseInt(s) * 30.44 * 864e5), a && (r += parseInt(a) * 864e5), n && (r += parseInt(n) * 36e5), i && (r += parseInt(i) * 6e4), c && (r += parseFloat(c) * 1e3), Math.round(r);
+import { z as u } from "zod";
+import { contextWindowFor as S } from "@adhd/agent-base-types";
+function E(c) {
+  const t = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/, e = c.match(t);
+  if (!e)
+    throw new Error(`invalid ISO 8601 duration: ${c}`);
+  const [, o, s, n, i, r, a] = e;
+  let l = 0;
+  return o && (l += parseInt(o) * 365.25 * 864e5), s && (l += parseInt(s) * 30.44 * 864e5), n && (l += parseInt(n) * 864e5), i && (l += parseInt(i) * 36e5), r && (l += parseInt(r) * 6e4), a && (l += parseFloat(a) * 1e3), Math.round(l);
 }
-const E = [
-  "tokens",
+const M = [
+  "context",
   "inputTokens",
   "outputTokens",
   "calls",
@@ -16,268 +17,417 @@ const E = [
   "modelMs",
   "cost",
   "toolCalls",
+  "errors",
+  "consecutiveErrors",
   "responseSize"
-], M = p.object({
-  field: p.enum(E),
-  maximum: p.number().min(0),
-  window: p.string().optional(),
-  scope: p.enum(["task", "session", "agent", "global"]).optional(),
-  mode: p.enum(["warning", "block"]).optional(),
-  message: p.string().optional()
-}), g = p.object({
-  caps: p.array(M).optional(),
-  mode: p.enum(["warning", "block"]).optional(),
-  costPerInputToken: p.number().min(0).optional(),
-  costPerOutputToken: p.number().min(0).optional(),
-  scope: p.enum(["task", "session", "agent", "global"]).optional()
-}), w = p.object({
+], b = /* @__PURE__ */ new Set(["toolCalls", "errors", "consecutiveErrors"]), y = u.object({
+  field: u.enum(M),
+  maximum: u.number().min(0).optional(),
+  contextWindowFraction: u.number().min(0).max(1).optional(),
+  window: u.string().optional(),
+  scope: u.enum(["task", "session", "agent", "global"]).optional(),
+  mode: u.enum(["warning", "block"]).optional(),
+  message: u.string().optional()
+}).superRefine((c, t) => {
+  if (c.field === "context") {
+    const e = c.maximum !== void 0, o = c.contextWindowFraction !== void 0;
+    e === o && t.addIssue({
+      code: u.ZodIssueCode.custom,
+      path: ["contextWindowFraction"],
+      message: "cap field 'context' requires exactly one of 'maximum' or 'contextWindowFraction'"
+    }), c.window !== void 0 && t.addIssue({
+      code: u.ZodIssueCode.custom,
+      path: ["window"],
+      message: "cap field 'context' rejects 'window' — a windowed peak is meaningless; windowed cumulative volume is expressible via 'inputTokens'/'outputTokens' + 'window'"
+    });
+  } else
+    (c.field === "errors" || c.field === "consecutiveErrors") && (c.window !== void 0 && t.addIssue({
+      code: u.ZodIssueCode.custom,
+      path: ["window"],
+      message: `cap field '${c.field}' rejects 'window' — windowed error budgets are not expressible this wave`
+    }), c.scope !== void 0 && c.scope !== "task" && t.addIssue({
+      code: u.ZodIssueCode.custom,
+      path: ["scope"],
+      message: `cap field '${c.field}' is counted per-task in memory (no task_usage column) — only 'task' scope is expressible this wave`
+    })), c.window !== void 0 && (c.scope === void 0 || c.scope === "task") && t.addIssue({
+      code: u.ZodIssueCode.custom,
+      path: ["scope"],
+      message: `cap field '${c.field}' carries 'window' but resolves to 'task' scope, where windowed caps are a silent no-op (no task-level window query); set an explicit 'scope': 'session' | 'agent' | 'global'`
+    }), c.contextWindowFraction !== void 0 && t.addIssue({
+      code: u.ZodIssueCode.custom,
+      path: ["contextWindowFraction"],
+      message: `'contextWindowFraction' is only valid on cap field 'context' (got '${c.field}')`
+    }), c.maximum === void 0 && t.addIssue({
+      code: u.ZodIssueCode.custom,
+      path: ["maximum"],
+      message: `cap field '${c.field}' requires a 'maximum'`
+    });
+}), g = u.object({
+  caps: u.array(y).optional(),
+  mode: u.enum(["warning", "block"]).optional(),
+  costPerInputToken: u.number().min(0).optional(),
+  costPerOutputToken: u.number().min(0).optional(),
+  // Cache-weighted cost rates (BUG-AGENTMCP-008). Default = costPerInputToken when
+  // unset, so a config without them bills every input token at the flat input rate —
+  // byte-for-byte identical to the pre-fix behavior.
+  costPerCacheReadToken: u.number().min(0).optional(),
+  costPerCacheWriteToken: u.number().min(0).optional(),
+  scope: u.enum(["task", "session", "agent", "global"]).optional()
+}), x = g.partial().superRefine((c, t) => {
+  const e = c.caps ?? [];
+  for (const [o, s] of e.entries())
+    s.field === "context" && t.addIssue({
+      code: u.ZodIssueCode.custom,
+      path: ["caps", o, "field"],
+      message: "cap field 'context' is only valid at model scope — a tool-scoped 'context' cap is a silent no-op (enforced on the model path, invisible to tool overrides); place it in 'defaults'/'agent'/'provider' instead"
+    });
+}), _ = u.object({
   defaults: g.optional(),
-  agent: p.object({
+  agent: u.object({
     default: g.optional(),
-    overrides: p.record(p.string(), g.partial()).optional().default({})
+    overrides: u.record(u.string(), g.partial()).optional().default({})
   }).optional(),
-  provider: p.object({
+  provider: u.object({
     default: g.optional(),
-    overrides: p.record(p.string(), g.partial()).optional().default({})
+    overrides: u.record(u.string(), g.partial()).optional().default({})
   }).optional(),
-  tool: p.object({
-    default: g.optional(),
-    overrides: p.record(p.string(), g.partial()).optional().default({})
+  tool: u.object({
+    default: x.optional(),
+    overrides: u.record(u.string(), x).optional().default({})
   }).optional()
-}), y = p.object({}).passthrough(), x = {
+}), N = u.object({}).passthrough(), A = {
   maxInputTokens: { field: "inputTokens" },
   maxOutputTokens: { field: "outputTokens" },
-  maxTotalTokens: { field: "tokens" },
   maxModelCalls: { field: "calls" },
   maxWallClockMs: { field: "wallClock" },
   maxModelMs: { field: "modelMs" },
   maxCostUSD: { field: "cost" },
-  maxTokensPer24h: { field: "tokens", window: "PT24H" },
+  maxTokensPer24h: { field: "inputTokens", window: "PT24H" },
   maxCalls: { field: "toolCalls" }
 };
-function b(f) {
-  const e = [], t = {};
-  for (const [o, s] of Object.entries(f)) {
-    const a = x[o];
-    if (a && typeof s == "number") {
-      const n = { field: a.field, maximum: s };
-      a.window && (n.window = a.window), e.push(n);
+function O(c) {
+  const t = [], e = {};
+  for (const [n, i] of Object.entries(c)) {
+    const r = A[n];
+    if (r && typeof i == "number") {
+      const a = { field: r.field, maximum: i };
+      r.window && (a.window = r.window), t.push(a);
     } else
-      (o === "scope" || o === "mode" || o === "costPerInputToken" || o === "costPerOutputToken" || o === "message") && (t[o] = s);
+      (n === "scope" || n === "mode" || n === "costPerInputToken" || n === "costPerOutputToken" || n === "costPerCacheReadToken" || n === "costPerCacheWriteToken" || n === "message") && (e[n] = i);
   }
-  return e.length > 0 && (t.caps = e), g.parse(t);
+  t.length > 0 && (e.caps = t);
+  const o = e.scope, s = o === "task" || o === "session" || o === "agent" || o === "global" ? o : void 0;
+  for (const n of t)
+    n.window !== void 0 && n.scope === void 0 && (n.scope = s ?? "global");
+  return g.parse(e);
 }
-function _(f) {
-  const e = f;
-  if (e.defaults !== void 0 || e.agent !== void 0 || e.provider !== void 0 || e.tool !== void 0) {
-    const t = w.parse(f);
+const w = (c) => `legacy 'tokens' budget cap detected (${c}): cap field 'tokens' is removed; use 'context' (peak request input) or 'inputTokens'/'outputTokens' (windowed volume)`;
+function P(c) {
+  const t = c ?? {};
+  if (typeof t.maxTotalTokens == "number")
+    throw new Error(w("flat 'maxTotalTokens'"));
+  const e = (s) => {
+    if (typeof s != "object" || s === null)
+      return;
+    const n = s;
+    if (typeof n.maxTotalTokens == "number")
+      throw new Error(w("structured 'maxTotalTokens'"));
+    const i = n.caps;
+    if (Array.isArray(i)) {
+      for (const r of i)
+        if (typeof r == "object" && r !== null && r.field === "tokens")
+          throw new Error(w("caps[].field === 'tokens'"));
+    }
+  }, o = (s) => {
+    if (typeof s != "object" || s === null)
+      return;
+    const n = s;
+    e(n), "default" in n && e(n.default);
+    const i = n.overrides;
+    if (typeof i == "object" && i !== null)
+      for (const r of Object.values(i))
+        e(r);
+  };
+  e(t.defaults), o(t.agent), o(t.provider), o(t.tool);
+}
+function I(c) {
+  P(c);
+  const t = c;
+  if (t.defaults !== void 0 || t.agent !== void 0 || t.provider !== void 0 || t.tool !== void 0) {
+    const e = _.parse(c);
     return {
-      defaults: t.defaults ?? g.parse({}),
-      agent: t.agent ?? { overrides: {} },
-      provider: t.provider ?? { overrides: {} },
-      tool: t.tool ?? { overrides: {} }
+      defaults: e.defaults ?? g.parse({}),
+      agent: e.agent ?? { overrides: {} },
+      provider: e.provider ?? { overrides: {} },
+      tool: e.tool ?? { overrides: {} }
     };
   }
   return {
-    defaults: b(e),
+    defaults: O(t),
     agent: { overrides: {} },
     provider: { overrides: {} },
     tool: { overrides: {} }
   };
 }
-function T(f, e, t, o) {
+function v(c, t, e, o) {
   return {
     isEnforcementError: !0,
     code: "BUDGET_EXCEEDED",
-    message: o ?? `${f} limit is ${e}, current value is ${Math.round(t)}`
+    message: o ?? `${c} limit is ${t}, current value is ${Math.round(e)}`
   };
 }
-function v(f, e, t) {
-  return { isToolWarning: !0, toolName: f, callId: e, message: t };
+function $(c, t, e) {
+  return { isToolWarning: !0, toolName: c, callId: t, message: e };
+}
+function R(c, t) {
+  var o;
+  let e = 0;
+  for (const s of c) {
+    e += ((o = s.content) == null ? void 0 : o.length) ?? 0;
+    for (const n of s.toolCalls ?? [])
+      e += JSON.stringify(n.arguments ?? {}).length;
+    for (const n of s.toolResults ?? [])
+      e += JSON.stringify(n.result ?? null).length;
+  }
+  for (const s of t)
+    e += JSON.stringify({
+      name: s.name,
+      description: s.description,
+      inputSchema: s.inputSchema
+    }).length;
+  return Math.ceil(e / 4);
 }
-class O {
-  constructor(e, t, o = 0, s = 0) {
-    this.db = e, this.cfg = t, this.costPerInput = o, this.costPerOutput = s, this.name = "agent-mcp-budget", this.accumulators = /* @__PURE__ */ new Map();
+class L {
+  constructor(t, e, o = 0, s = 0, n = 0, i = 0) {
+    this.db = t, this.cfg = e, this.costPerInput = o, this.costPerOutput = s, this.costPerCacheRead = n, this.costPerCacheWrite = i, this.name = "agent-mcp-budget", this.accumulators = /* @__PURE__ */ new Map();
   }
-  install(e) {
-    e.register("task:start", (t) => {
+  install(t) {
+    this.hooks = t, t.register("task:start", (e) => {
+      try {
+        this.onTaskStart(e);
+      } catch {
+      }
+    }), t.register("pre:model_request", (e) => {
       try {
-        this.onTaskStart(t);
+        this.onPreModelRequest(e);
       } catch {
       }
-    }), e.register("pre:model_request", (t) => {
+    }), t.register("post:model_response", (e) => {
       try {
-        this.onPreModelRequest(t);
+        this.onPostModelResponse(e);
       } catch {
       }
-    }), e.register("post:model_response", (t) => {
+    }), t.register("post:tool_call", (e) => {
       try {
-        this.onPostModelResponse(t);
+        this.onPostToolCall(e);
       } catch {
       }
-    }), e.register("task:completed", (t) => {
+    }), t.register("task:completed", (e) => {
       try {
-        this.onTerminal(t.executionContext.taskId);
+        this.onTerminal(e.executionContext.taskId);
       } catch {
       }
-    }), e.register("task:failed", (t) => {
+    }), t.register("task:failed", (e) => {
       try {
-        this.onTerminal(t.executionContext.taskId);
+        this.onTerminal(e.executionContext.taskId);
       } catch {
       }
-    }), e.register("task:cancelled", (t) => {
+    }), t.register("task:cancelled", (e) => {
       try {
-        this.onTerminal(t.executionContext.taskId);
+        this.onTerminal(e.executionContext.taskId);
       } catch {
       }
-    }), e.registerEnforcement(
+    }), t.registerEnforcement(
       "pre:model_request",
-      (t) => this.enforcePreModel(t)
-    ), e.registerEnforcement("pre:tool_call", (t) => this.enforcePreTool(t)), e.register("transform:tool_result", (t) => {
+      (e) => this.enforcePreModel(e)
+    ), t.registerEnforcement("pre:tool_call", (e) => this.enforcePreTool(e)), t.register("transform:tool_result", (e) => {
       try {
-        this.enforceResponseSize(t);
+        this.enforceResponseSize(e);
       } catch {
       }
     });
   }
   // ── Observational handlers ────────────────────────────────────────────────
-  onTaskStart(e) {
-    var n, i;
-    const { taskId: t, sessionId: o, agentName: s } = e.executionContext, a = ((i = (n = e.executionContext.agentDefinition) == null ? void 0 : n.provider) == null ? void 0 : i.type) ?? "unknown";
-    this.accumulators.set(t, {
-      taskId: t,
+  onTaskStart(t) {
+    var i, r;
+    const { taskId: e, sessionId: o, agentName: s } = t.executionContext, n = ((r = (i = t.executionContext.agentDefinition) == null ? void 0 : i.provider) == null ? void 0 : r.type) ?? "unknown";
+    this.accumulators.set(e, {
+      taskId: e,
       sessionId: o ?? void 0,
       agentName: s,
-      providerType: a,
+      providerType: n,
       startedAtMs: Date.now(),
+      uncachedInputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
       inputTokens: 0,
       outputTokens: 0,
+      peakContextTokens: 0,
       modelCalls: 0,
       totalModelMs: 0,
-      toolCalls: /* @__PURE__ */ new Map()
+      toolCalls: /* @__PURE__ */ new Map(),
+      errors: 0,
+      consecutiveErrors: 0
     });
   }
-  onPreModelRequest(e) {
-    const t = this.accumulators.get(e.executionContext.taskId);
-    t && (t.modelCallStartMs = Date.now());
+  onPreModelRequest(t) {
+    const e = this.accumulators.get(t.executionContext.taskId);
+    e && (e.modelCallStartMs = Date.now());
   }
-  onPostModelResponse(e) {
-    const t = this.accumulators.get(e.executionContext.taskId);
-    if (!t)
+  onPostModelResponse(t) {
+    const e = this.accumulators.get(t.executionContext.taskId);
+    if (!e)
       return;
-    const o = e.tokenUsage;
-    o && (t.inputTokens += o.inputTokens ?? 0, t.outputTokens += o.outputTokens ?? 0), t.modelCalls += 1, t.modelCallStartMs !== void 0 && (t.totalModelMs += Date.now() - t.modelCallStartMs, t.modelCallStartMs = void 0);
+    const o = t.tokenUsage;
+    if (o) {
+      const s = o.inputTokens ?? 0, n = o.cacheReadTokens ?? 0, i = o.cacheCreationTokens ?? 0, a = o.uncachedInputTokens !== void 0 || o.cacheReadTokens !== void 0 || o.cacheCreationTokens !== void 0 ? o.uncachedInputTokens ?? Math.max(0, s - n - i) : s;
+      e.uncachedInputTokens += a, e.cacheReadTokens += n, e.cacheCreationTokens += i, e.inputTokens += a + n + i, e.outputTokens += o.outputTokens ?? 0, e.peakContextTokens = Math.max(e.peakContextTokens, s);
+    }
+    e.modelCalls += 1, e.modelCallStartMs !== void 0 && (e.totalModelMs += Date.now() - e.modelCallStartMs, e.modelCallStartMs = void 0);
+  }
+  onTerminal(t) {
+    this.accumulators.delete(t);
   }
-  onTerminal(e) {
-    this.accumulators.delete(e);
+  /**
+   * Packet C — error counters (plan §3): the ONLY place the error budget
+   * changes. Fires at post:tool_call, which the orchestrator emits exclusively
+   * for EXECUTED tools (orchestrator.ts Phase 2 map, post:tool_call emit). A
+   * call soft-blocked by an IToolWarning at pre:tool_call is injected as a
+   * warningResult and SKIPPED (orchestrator.ts:619-626, filter at 645-647) —
+   * it never reaches Phase 2 and never emits post:tool_call. That is the
+   * non-self-amplifying guarantee: a warning-mode errors cap's own warnings are
+   * never counted, so the counter cannot feed itself.
+   *
+   * Thrown-errors-only (owner lean, plan §3): `isError` is true at this
+   * boundary only when the tool's callTool THREW (orchestrator.ts:718);
+   * error-shaped non-throwing results are indistinguishable from success here.
+   */
+  onPostToolCall(t) {
+    const e = this.accumulators.get(t.executionContext.taskId);
+    e && (t.isError ? (e.errors += 1, e.consecutiveErrors += 1) : e.consecutiveErrors = 0);
   }
   // ── Config resolution ─────────────────────────────────────────────────────
-  mergeDim(e) {
-    let t = { caps: [] };
-    for (const o of e)
-      o && (t = {
-        caps: [...t.caps ?? [], ...o.caps ?? []],
-        mode: o.mode ?? t.mode,
-        costPerInputToken: o.costPerInputToken ?? t.costPerInputToken,
-        costPerOutputToken: o.costPerOutputToken ?? t.costPerOutputToken,
-        scope: o.scope ?? t.scope
+  mergeDim(t) {
+    let e = { caps: [] };
+    for (const o of t)
+      o && (e = {
+        caps: [...e.caps ?? [], ...o.caps ?? []],
+        mode: o.mode ?? e.mode,
+        costPerInputToken: o.costPerInputToken ?? e.costPerInputToken,
+        costPerOutputToken: o.costPerOutputToken ?? e.costPerOutputToken,
+        costPerCacheReadToken: o.costPerCacheReadToken ?? e.costPerCacheReadToken,
+        costPerCacheWriteToken: o.costPerCacheWriteToken ?? e.costPerCacheWriteToken,
+        scope: o.scope ?? e.scope
       });
-    return t;
+    return e;
   }
-  resolveCaps(e, t, o) {
-    var u, m, d;
-    const s = this.cfg.defaults, a = this.cfg.agent, n = this.cfg.provider, i = this.cfg.tool;
+  resolveCaps(t, e, o) {
+    var f, d, k;
+    const s = this.cfg.defaults, n = this.cfg.agent, i = this.cfg.provider, r = this.cfg.tool;
     if (o) {
-      const k = (u = i == null ? void 0 : i.overrides) == null ? void 0 : u[o], h = this.mergeDim([s, i == null ? void 0 : i.default, k]);
+      const m = (f = r == null ? void 0 : r.overrides) == null ? void 0 : f[o], h = this.mergeDim([s, r == null ? void 0 : r.default, m]);
       return {
         caps: h.caps ?? [],
         mode: h.mode,
         scope: h.scope
       };
     }
-    const c = (m = a == null ? void 0 : a.overrides) == null ? void 0 : m[e], r = (d = n == null ? void 0 : n.overrides) == null ? void 0 : d[t], l = this.mergeDim([
+    const a = (d = n == null ? void 0 : n.overrides) == null ? void 0 : d[t], l = (k = i == null ? void 0 : i.overrides) == null ? void 0 : k[e], p = this.mergeDim([
       s,
-      a == null ? void 0 : a.default,
-      c,
       n == null ? void 0 : n.default,
-      r
+      a,
+      i == null ? void 0 : i.default,
+      l
     ]);
-    return { caps: l.caps ?? [], mode: l.mode, scope: l.scope };
+    return { caps: p.caps ?? [], mode: p.mode, scope: p.scope };
   }
   // ── Scope-aware DB queries ────────────────────────────────────────────────
-  queryScopeTotals(e, t, o, s) {
-    const a = this.accumulators.get(e), n = a ? {
-      inputTokens: a.inputTokens,
-      outputTokens: a.outputTokens,
-      modelCalls: a.modelCalls
-    } : { inputTokens: 0, outputTokens: 0, modelCalls: 0 };
+  queryScopeTotals(t, e, o, s) {
+    const n = this.accumulators.get(t), i = n ? {
+      inputTokens: n.inputTokens,
+      outputTokens: n.outputTokens,
+      modelCalls: n.modelCalls,
+      peakContextTokens: n.peakContextTokens
+    } : {
+      inputTokens: 0,
+      outputTokens: 0,
+      modelCalls: 0,
+      peakContextTokens: 0
+    };
     if (s === "task" || !this.db)
-      return n;
+      return i;
     try {
-      const i = this.db;
-      let c;
-      if (s === "session" && t ? c = i.prepare(
+      const r = this.db;
+      let a;
+      if (s === "session" && e ? a = r.prepare(
         `SELECT
                COALESCE(SUM(tu.input_tokens), 0) AS input,
                COALESCE(SUM(tu.output_tokens), 0) AS output,
-               COALESCE(SUM(tu.model_calls), 0) AS calls
+               COALESCE(SUM(tu.model_calls), 0) AS calls,
+               COALESCE(MAX(tu.peak_context_tokens), 0) AS peak
              FROM task_usage tu
              JOIN tasks t ON tu.task_id = t.id
              WHERE t.session_id = ? AND tu.task_id != ?`
-      ).get(t, e) : s === "agent" ? c = i.prepare(
+      ).get(e, t) : s === "agent" ? a = r.prepare(
         `SELECT
                COALESCE(SUM(input_tokens), 0) AS input,
                COALESCE(SUM(output_tokens), 0) AS output,
-               COALESCE(SUM(model_calls), 0) AS calls
+               COALESCE(SUM(model_calls), 0) AS calls,
+               COALESCE(MAX(peak_context_tokens), 0) AS peak
              FROM task_usage
              WHERE agent_name = ? AND task_id != ?`
-      ).get(o, e) : s === "global" && (c = i.prepare(
+      ).get(o, t) : s === "global" && (a = r.prepare(
         `SELECT
                COALESCE(SUM(input_tokens), 0) AS input,
                COALESCE(SUM(output_tokens), 0) AS output,
-               COALESCE(SUM(model_calls), 0) AS calls
+               COALESCE(SUM(model_calls), 0) AS calls,
+               COALESCE(MAX(peak_context_tokens), 0) AS peak
              FROM task_usage
              WHERE task_id != ?`
-      ).get(e)), c)
+      ).get(t)), a)
         return {
-          inputTokens: (c.input ?? 0) + n.inputTokens,
-          outputTokens: (c.output ?? 0) + n.outputTokens,
-          modelCalls: (c.calls ?? 0) + n.modelCalls
+          inputTokens: (a.input ?? 0) + i.inputTokens,
+          outputTokens: (a.output ?? 0) + i.outputTokens,
+          modelCalls: (a.calls ?? 0) + i.modelCalls,
+          // Scoped context = MAX over the scope's task set of peak_context_tokens,
+          // with the current task's in-memory peak folded in (it is a member of the
+          // set; the queries above exclude it by `task_id != ?`).
+          peakContextTokens: Math.max(a.peak ?? 0, i.peakContextTokens)
         };
     } catch {
     }
-    return n;
+    return i;
   }
-  queryWindowTokens(e, t, o, s) {
+  queryWindowTokens(t, e, o, s) {
     if (!this.db)
       return 0;
     try {
-      const a = this.db, n = new Date(Date.now() - o).toISOString();
-      let i;
-      if (e === "session") {
-        const c = s ? " AND tu.task_id != ?" : "", r = [t, n];
-        s && r.push(s), i = a.prepare(
+      const n = this.db, i = new Date(Date.now() - o).toISOString();
+      let r;
+      if (t === "session") {
+        const a = s ? " AND tu.task_id != ?" : "", l = [e, i];
+        s && l.push(s), r = n.prepare(
           `SELECT COALESCE(SUM(tu.input_tokens + tu.output_tokens), 0) AS total
              FROM task_usage tu
              JOIN tasks t ON tu.task_id = t.id
-             WHERE t.session_id = ? AND tu.created_at >= ?${c}`
-        ).get(...r);
-      } else if (e === "agent") {
-        const c = s ? " AND task_id != ?" : "", r = [t, n];
-        s && r.push(s), i = a.prepare(
+             WHERE t.session_id = ? AND tu.created_at >= ?${a}`
+        ).get(...l);
+      } else if (t === "agent") {
+        const a = s ? " AND task_id != ?" : "", l = [e, i];
+        s && l.push(s), r = n.prepare(
           `SELECT COALESCE(SUM(input_tokens + output_tokens), 0) AS total
              FROM task_usage
-             WHERE agent_name = ? AND created_at >= ?${c}`
-        ).get(...r);
-      } else if (e === "global") {
-        const c = s ? " AND task_id != ?" : "", r = [n];
-        s && r.push(s), i = a.prepare(
+             WHERE agent_name = ? AND created_at >= ?${a}`
+        ).get(...l);
+      } else if (t === "global") {
+        const a = s ? " AND task_id != ?" : "", l = [i];
+        s && l.push(s), r = n.prepare(
           `SELECT COALESCE(SUM(input_tokens + output_tokens), 0) AS total
              FROM task_usage
-             WHERE created_at >= ?${c}`
-        ).get(...r);
+             WHERE created_at >= ?${a}`
+        ).get(...l);
       }
-      return (i == null ? void 0 : i.total) ?? 0;
+      return (r == null ? void 0 : r.total) ?? 0;
     } catch {
       return 0;
     }
@@ -292,189 +442,275 @@ class O {
    *   W = number of unique (scope, window) pairs across all caps
    *
    * Independent of cap count, agent count, session count, or history depth.
+   *
+   * `requestEstimate` (tokens) is the tools-aware estimate of the PENDING
+   * request, computed on the model path; it feeds the 'context' enforcement
+   * value = max(provider-reported peak, estimate) per owner ruling 4.
    */
-  buildSnapshot(e, t, o, s, a, n) {
-    const i = {};
-    i.inputTokens = t.inputTokens, i.outputTokens = t.outputTokens, i.calls = t.modelCalls, i.wallClock = Date.now() - t.startedAtMs, i.modelMs = t.totalModelMs, i.cost = t.inputTokens * this.costPerInput + t.outputTokens * this.costPerOutput;
-    const c = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Map();
-    for (const l of e) {
-      const u = l.scope ?? n ?? "task";
-      if (u !== "task" && c.add(u), l.window) {
-        const m = `${u}:${l.window}`;
-        r.has(m) || r.set(m, {
-          scope: u,
-          windowMs: S(l.window)
+  buildSnapshot(t, e, o, s, n, i, r = 0) {
+    const a = {};
+    a.inputTokens = e.inputTokens, a.outputTokens = e.outputTokens, a.calls = e.modelCalls, a.wallClock = Date.now() - e.startedAtMs, a.modelMs = e.totalModelMs, a.context = Math.max(e.peakContextTokens, r), a.errors = e.errors, a.consecutiveErrors = e.consecutiveErrors, a.cost = e.uncachedInputTokens * this.costPerInput + e.cacheReadTokens * this.costPerCacheRead + e.cacheCreationTokens * this.costPerCacheWrite + e.outputTokens * this.costPerOutput;
+    const l = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Map();
+    for (const f of t) {
+      const d = f.scope ?? i ?? "task";
+      if (d !== "task" && l.add(d), f.window) {
+        const k = `${d}:${f.window}`;
+        p.has(k) || p.set(k, {
+          scope: d,
+          windowMs: E(f.window)
         });
       }
     }
-    for (const l of c) {
-      const u = this.queryScopeTotals(o, s, a, l);
-      i[`${l}:inputTokens`] = u.inputTokens, i[`${l}:outputTokens`] = u.outputTokens, i[`${l}:calls`] = u.modelCalls;
+    for (const f of l) {
+      const d = this.queryScopeTotals(o, s, n, f);
+      a[`${f}:inputTokens`] = d.inputTokens, a[`${f}:outputTokens`] = d.outputTokens, a[`${f}:calls`] = d.modelCalls, a[`${f}:context`] = Math.max(
+        d.peakContextTokens,
+        r
+      );
     }
-    for (const [l, { scope: u, windowMs: m }] of r) {
-      let d = "";
-      u === "session" ? d = s ?? "" : u === "agent" && (d = a ?? ""), i[l] = this.queryWindowTokens(u, d, m, o);
+    for (const [f, { scope: d, windowMs: k }] of p) {
+      let m = "";
+      d === "session" ? m = s ?? "" : d === "agent" && (m = n ?? ""), a[f] = this.queryWindowTokens(d, m, k, o);
     }
-    return i;
+    return a;
   }
-  getSnapshotValue(e, t, o) {
-    const s = t.scope ?? o ?? "task";
-    let a;
-    t.window ? a = "" : a = s !== "task" ? `${s}:` : "";
+  getSnapshotValue(t, e, o) {
+    const s = e.scope ?? o ?? "task";
     let n;
-    switch (t.field) {
+    e.window ? n = "" : n = s !== "task" ? `${s}:` : "";
+    let i;
+    switch (e.field) {
       case "inputTokens":
-        n = e[`${a}inputTokens`] ?? e.inputTokens;
+        i = t[`${n}inputTokens`] ?? t.inputTokens;
         break;
       case "outputTokens":
-        n = e[`${a}outputTokens`] ?? e.outputTokens;
+        i = t[`${n}outputTokens`] ?? t.outputTokens;
         break;
-      case "tokens":
-        n = (e[`${a}inputTokens`] ?? e.inputTokens) + (e[`${a}outputTokens`] ?? e.outputTokens);
+      case "context":
+        i = t[`${n}context`] ?? t.context;
         break;
       case "calls":
-        n = e[`${a}calls`] ?? e.calls;
+        i = t[`${n}calls`] ?? t.calls;
         break;
       case "wallClock":
-        n = e.wallClock;
+        i = t.wallClock;
         break;
       case "modelMs":
-        n = e.modelMs;
+        i = t.modelMs;
         break;
       case "cost":
-        n = e.cost;
+        i = t.cost;
         break;
       case "toolCalls":
-        n = 0;
+        i = 0;
+        break;
+      case "errors":
+        i = t.errors;
+        break;
+      case "consecutiveErrors":
+        i = t.consecutiveErrors;
         break;
       default:
-        n = 0;
+        i = 0;
     }
-    return t.window && (n += e[`${s}:${t.window}`] ?? 0), n;
+    return e.window && (i += t[`${s}:${e.window}`] ?? 0), i;
   }
-  evaluateCap(e, t, o) {
-    const s = this.getSnapshotValue(t, e, o);
-    if (s >= e.maximum)
-      throw T(e.field, e.maximum, s, e.message);
+  /**
+   * Emit a `budget:*` notification event for an exceeded cap. Pure notification
+   * layer (owner ruling 7): HookRegistry.emit swallows handler errors and is a
+   * no-op when no handler is registered, so emission can never affect
+   * enforcement. `message` defaults to cap.message, then the standard
+   * `"<field> limit is <limit>, current value is <current>"` string — the
+   * same resolution `makeEnforcementError` uses, so the block event's message
+   * always matches the error the orchestrator sees.
+   *
+   * `limit` is the RESOLVED cap limit (`maximum`, or the context-window-derived
+   * limit for `contextWindowFraction` caps) — the payload must report the real
+   * number the cap trips at, not an undefined `maximum`.
+   */
+  async emitBudgetEvent(t, e, o, s, n, i) {
+    this.hooks && await this.hooks.emit(t, {
+      executionContext: e,
+      field: o.field,
+      maximum: n,
+      current: s,
+      message: i ?? o.message ?? `${o.field} limit is ${n}, current value is ${Math.round(
+        s
+      )}`
+    });
+  }
+  /**
+   * Resolve a cap's numeric limit. A `context` cap configured via
+   * `contextWindowFraction` has no `maximum`: the limit is
+   * `contextWindowFor(modelId) * fraction` (128K fallback for unknown models).
+   * Every other cap carries an explicit `maximum` (schema-enforced).
+   */
+  resolveCapLimit(t, e) {
+    if (t.maximum !== void 0)
+      return t.maximum;
+    const o = e.agentDefinition.provider;
+    return Math.floor(
+      S(o.model) * (t.contextWindowFraction ?? 0)
+    );
+  }
+  /**
+   * Evaluate a single cap against the snapshot. Mode resolution matches the
+   * tool path (`cap.mode ?? dimMode ?? 'warning'`, owner ruling 5): warning
+   * (the default) emits `budget:warning` and resolves — the run continues;
+   * block emits `budget:block` BEFORE throwing the enforcement error.
+   */
+  async evaluateCap(t, e, o, s, n) {
+    const i = this.resolveCapLimit(t, o), r = this.getSnapshotValue(e, t, n);
+    if (r < i)
+      return;
+    if ((t.mode ?? s ?? "warning") === "warning") {
+      await this.emitBudgetEvent("budget:warning", o, t, r, i);
+      return;
+    }
+    throw await this.emitBudgetEvent("budget:block", o, t, r, i), v(t.field, i, r, t.message);
   }
   // ── Enforcement: pre:model_request ────────────────────────────────────────
-  enforcePreModel(e) {
-    var u, m;
-    const { taskId: t, sessionId: o, agentName: s } = e.executionContext, a = ((m = (u = e.executionContext.agentDefinition) == null ? void 0 : u.provider) == null ? void 0 : m.type) ?? "unknown", n = this.accumulators.get(t);
-    if (!n)
+  async enforcePreModel(t) {
+    var d, k;
+    const { taskId: e, sessionId: o, agentName: s } = t.executionContext, n = ((k = (d = t.executionContext.agentDefinition) == null ? void 0 : d.provider) == null ? void 0 : k.type) ?? "unknown", i = this.accumulators.get(e);
+    if (!i)
       return;
-    const { caps: i, scope: c } = this.resolveCaps(s, a), r = i.filter((d) => d.field !== "toolCalls");
-    if (r.length === 0)
+    const { caps: r, mode: a, scope: l } = this.resolveCaps(
+      s,
+      n
+    ), p = r.filter(
+      (m) => !b.has(m.field)
+    );
+    if (p.length === 0)
       return;
-    const l = this.buildSnapshot(
-      r,
-      n,
-      t,
+    const f = this.buildSnapshot(
+      p,
+      i,
+      e,
       o,
       s,
-      c
+      l,
+      R(t.messages, t.tools)
     );
-    for (const d of r)
-      this.evaluateCap(d, l);
+    for (const m of p)
+      await this.evaluateCap(m, f, t.executionContext, a, l);
   }
   // ── Enforcement: pre:tool_call ────────────────────────────────────────────
-  enforcePreTool(e) {
-    const { toolName: t, callId: o, executionContext: s } = e, {
-      caps: a,
-      mode: n,
-      scope: i
-    } = this.resolveCaps(s.agentName, "", t), c = this.accumulators.get(s.taskId);
-    if (!c || a.length === 0)
+  async enforcePreTool(t) {
+    const { toolName: e, callId: o, executionContext: s } = t, {
+      caps: n,
+      mode: i,
+      scope: r
+    } = this.resolveCaps(s.agentName, "", e), a = this.accumulators.get(s.taskId);
+    if (!a)
+      return;
+    const l = n.filter((d) => d.field !== "context");
+    if (l.length === 0)
       return;
-    const r = c.toolCalls.get(t) ?? 0, l = this.buildSnapshot(
+    const p = a.toolCalls.get(e) ?? 0, f = this.buildSnapshot(
+      l,
       a,
-      c,
       s.taskId,
       s.sessionId,
       s.agentName,
-      i
+      r
     );
-    for (const u of a) {
-      const m = u.field === "toolCalls" ? r : this.getSnapshotValue(l, u, i);
-      if (m >= u.maximum) {
-        const d = u.message ?? `tool "${t}": ${u.field} limit is ${u.maximum}, current value is ${Math.round(m)}`;
-        throw (u.mode ?? n ?? "warning") === "warning" ? v(t, o, d) : T(
-          `tool:${t}:${u.field}`,
-          u.maximum,
+    for (const d of l) {
+      const k = this.resolveCapLimit(d, s), m = d.field === "toolCalls" ? p : this.getSnapshotValue(f, d, r);
+      if (m >= k) {
+        const h = d.message ?? `tool "${e}": ${d.field} limit is ${k}, current value is ${Math.round(m)}`;
+        throw (d.mode ?? i ?? "warning") === "warning" ? (await this.emitBudgetEvent(
+          "budget:warning",
+          s,
+          d,
+          m,
+          k,
+          h
+        ), $(e, o, h)) : (await this.emitBudgetEvent(
+          "budget:block",
+          s,
+          d,
+          m,
+          k,
+          h
+        ), v(
+          `tool:${e}:${d.field}`,
+          k,
           m,
-          u.message
-        );
+          d.message
+        ));
       }
     }
-    c.toolCalls.set(t, r + 1);
+    a.toolCalls.set(e, p + 1);
   }
   // ── Enforcement: transform:tool_result (response size) ────────────────────
-  enforceResponseSize(e) {
-    const { toolName: t, result: o } = e;
+  enforceResponseSize(t) {
+    const { toolName: e, result: o } = t;
     if (typeof o != "object" || o === null)
       return;
-    const { caps: s, mode: a } = this.resolveCaps("", "", t), n = s.filter((l) => l.field === "responseSize");
-    if (n.length === 0)
+    const { caps: s, mode: n } = this.resolveCaps("", "", e), i = s.filter((p) => p.field === "responseSize");
+    if (i.length === 0)
       return;
-    const i = o, c = i.content;
-    if (!Array.isArray(c))
+    const r = o, a = r.content;
+    if (!Array.isArray(a))
       return;
-    let r = 0;
-    for (const l of c)
-      if (typeof l == "object" && l !== null) {
-        const u = l;
-        u.type === "text" && (r += (u.text ?? "").length);
+    let l = 0;
+    for (const p of a)
+      if (typeof p == "object" && p !== null) {
+        const f = p;
+        f.type === "text" && (l += (f.text ?? "").length);
       }
-    for (const l of n) {
-      if (r <= l.maximum)
+    for (const p of i) {
+      const f = this.resolveCapLimit(p, t.executionContext);
+      if (l <= f)
         continue;
-      if ((l.mode ?? a ?? "warning") === "block")
-        i.content = [
+      if ((p.mode ?? n ?? "warning") === "block")
+        r.content = [
           {
             type: "text",
-            text: l.message ?? `Response size (${r} chars) exceeds limit of ${l.maximum}. Use offset/limit or shell paging tools instead.`
+            text: p.message ?? `Response size (${l} chars) exceeds limit of ${f}. Use offset/limit or shell paging tools instead.`
           }
-        ], e.isError = !0;
+        ], t.isError = !0;
       else {
-        let m = l.maximum;
-        const d = [];
-        for (const k of c) {
-          if (typeof k != "object" || k === null) {
-            d.push(k);
+        let k = f;
+        const m = [];
+        for (const h of a) {
+          if (typeof h != "object" || h === null) {
+            m.push(h);
             continue;
           }
-          const h = k;
-          if (h.type !== "text") {
-            d.push(k);
+          const C = h;
+          if (C.type !== "text") {
+            m.push(h);
             continue;
           }
-          const C = h.text ?? "";
-          if (C.length <= m)
-            d.push(k), m -= C.length;
+          const T = C.text ?? "";
+          if (T.length <= k)
+            m.push(h), k -= T.length;
           else {
-            d.push({ type: "text", text: C.slice(0, m) });
+            m.push({ type: "text", text: T.slice(0, k) });
             break;
           }
         }
-        d.push({
+        m.push({
           type: "text",
           text: `
 
-[truncated: response was ${r} chars, limited to ${l.maximum}. ${l.message ?? "Use offset/limit or shell paging tools for full content."}]`
-        }), i.content = d;
+[truncated: response was ${l} chars, limited to ${p.maximum}. ${p.message ?? "Use offset/limit or shell paging tools for full content."}]`
+        }), r.content = m;
       }
       break;
     }
   }
 }
-const $ = ({ db: f, config: e }) => {
-  var a, n;
-  const t = _(e), o = ((a = t.defaults) == null ? void 0 : a.costPerInputToken) ?? 0, s = ((n = t.defaults) == null ? void 0 : n.costPerOutputToken) ?? 0;
-  return new O(f, t, o, s);
+const j = ({ db: c, config: t }) => {
+  var r, a, l, p;
+  const e = I(t), o = ((r = e.defaults) == null ? void 0 : r.costPerInputToken) ?? 0, s = ((a = e.defaults) == null ? void 0 : a.costPerOutputToken) ?? 0, n = ((l = e.defaults) == null ? void 0 : l.costPerCacheReadToken) ?? o, i = ((p = e.defaults) == null ? void 0 : p.costPerCacheWriteToken) ?? o;
+  return new L(c, e, o, s, n, i);
 };
 export {
-  y as configSchema,
-  $ as createPlugin,
-  $ as default,
-  w as pluginConfigSchema
+  N as configSchema,
+  j as createPlugin,
+  j as default,
+  _ as pluginConfigSchema
 };