@wrongstack/core 0.289.0 → 0.291.1

package/dist/coordination/index.js

@@ -542,14 +542,28 @@ function mapContent(msg, fn) {
   }
   return { ...msg, content: next };
 }
+function hasMeaningfulContent(content) {
+  if (typeof content === "string") return content.trim().length > 0;
+  for (const block of content) {
+    if (block.type === "text") {
+      if (block.text.trim().length > 0) return true;
+      continue;
+    }
+    if (block.type === "thinking") {
+      if (block.thinking.trim().length > 0 || block.signature) return true;
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
 function isEmptyMessage(msg) {
-  if (typeof msg.content === "string") return msg.content.trim().length === 0;
-  return msg.content.length === 0;
+  return !hasMeaningfulContent(msg.content);
 }
 
 // src/utils/safe-json.ts
 function safeParse(input, maxBytes = 5e6) {
-  if (input.length > maxBytes) {
+  if (Buffer.byteLength(input, "utf8") > maxBytes) {
     return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
   }
   try {
@@ -605,6 +619,11 @@ function invalid(sessionId) {
   });
 }
 
+// src/utils/string.ts
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+
 // src/utils/ulid.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
@@ -633,11 +652,6 @@ function ulid(seedTime = Date.now()) {
   return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN);
 }
 
-// src/utils/string.ts
-function truncate(s, max) {
-  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
-}
-
 // src/utils/wstack-paths.ts
 import { createHash } from "node:crypto";
 import * as fs2 from "node:fs";
@@ -1643,8 +1657,34 @@ function makeAgentSubagentRunner(opts) {
     const taskStartedAt = Date.now();
     const factoryResult = await opts.factory(ctx.config, task);
     const { agent, events } = factoryResult;
+    const taskContext = task.context ?? {};
+    const hasExplicitTelemetryTask = typeof taskContext["telemetryTaskId"] === "string";
+    const telemetryTaskId = hasExplicitTelemetryTask ? taskContext["telemetryTaskId"] : task.id;
+    const telemetryRunId = typeof taskContext["telemetryRunId"] === "string" ? taskContext["telemetryRunId"] : void 0;
+    const telemetryBoardId = typeof taskContext["telemetryBoardId"] === "string" ? taskContext["telemetryBoardId"] : void 0;
     const agentContext = agent.ctx;
-    if (agentContext?.meta) agentContext.meta["subagentTaskId"] = task.id;
+    if (agentContext?.meta) {
+      agentContext.meta["subagentTaskId"] = task.id;
+      const kanbanContext = taskContext["kanban"];
+      if (kanbanContext && typeof kanbanContext === "object") {
+        agentContext.meta["kanban"] = kanbanContext;
+      }
+      if (hasExplicitTelemetryTask) {
+        agentContext.meta["telemetryTaskId"] = telemetryTaskId;
+        if (telemetryRunId) agentContext.meta["telemetryRunId"] = telemetryRunId;
+      }
+    }
+    if (hasExplicitTelemetryTask) {
+      agentContext?.setCurrentKanbanTask?.(telemetryTaskId, telemetryBoardId);
+    } else {
+      const kanbanContext = taskContext["kanban"];
+      if (kanbanContext && typeof kanbanContext === "object") {
+        const kanban = kanbanContext;
+        const boardId = typeof kanban["boardId"] === "string" ? kanban["boardId"] : void 0;
+        const taskId = typeof kanban["taskId"] === "string" ? kanban["taskId"] : void 0;
+        if (taskId) agentContext?.setCurrentKanbanTask?.(taskId, boardId);
+      }
+    }
     const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
     ctx.budget._events = events;
@@ -1669,6 +1709,27 @@ function makeAgentSubagentRunner(opts) {
     const unsub = [];
     unsub.push(
       events.on("tool.executed", (e) => {
+        if (hasExplicitTelemetryTask) {
+          opts.hostEvents?.emit("subagent.tool_executed", {
+            sessionId: e.sessionId,
+            subagentId: ctx.subagentId,
+            agentSessionId: e.sessionId,
+            agentName: e.agentName ?? ctx.config.name,
+            taskId: telemetryTaskId,
+            runId: telemetryRunId,
+            traceId: e.traceId,
+            id: e.id,
+            name: e.name,
+            durationMs: e.durationMs,
+            ok: e.ok,
+            // Raw tool inputs may contain credentials or sensitive arguments.
+            // Task telemetry crosses from the isolated worker bus to the shared
+            // host bus, so expose only execution metadata at this boundary.
+            outputBytes: e.outputBytes,
+            outputTokens: e.outputTokens,
+            outputLines: e.outputLines
+          });
+        }
         try {
           ctx.budget.recordToolCall();
         } catch (eb) {
@@ -1680,6 +1741,17 @@ function makeAgentSubagentRunner(opts) {
           lastToolFailed = null;
         }
       }),
+      events.on("file.event", (e) => {
+        if (!hasExplicitTelemetryTask) return;
+        if (e.runId === telemetryRunId && e.taskId === telemetryTaskId) return;
+        opts.hostEvents?.emit("file.event", {
+          ...e,
+          scope: "task",
+          taskId: telemetryTaskId,
+          boardId: telemetryBoardId,
+          runId: telemetryRunId
+        });
+      }),
       events.on("provider.response", (e) => {
         try {
           ctx.budget.recordUsage(e.usage);
@@ -2973,6 +3045,40 @@ var DOMAIN_AGENTS = [
         "information architecture"
       ]
     }
+  },
+  {
+    config: {
+      id: "ios",
+      name: "iOS",
+      role: "ios",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: agentPrompt("ios")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Apple-platform app development in Swift against the latest Xcode/iOS-SDK line: SwiftUI, UIKit, SwiftData, concurrency, accessibility, and App Store submission.",
+      keywords: [
+        "ios",
+        "iphone",
+        "ipad",
+        "ipados",
+        "watchos",
+        "tvos",
+        "visionos",
+        "macos",
+        "swift",
+        "swiftui",
+        "uikit",
+        "xcode",
+        "swiftdata",
+        "app store",
+        "app intents",
+        "swift package manager",
+        "cocoapods",
+        "foundation models"
+      ]
+    }
   }
 ];
 
@@ -6218,6 +6324,8 @@ function rosterSummaryFromConfigs(roster) {
 import { randomUUID as randomUUID5 } from "node:crypto";
 import {
   claimReadyTask,
+  describeKanbanBoundary,
+  heartbeatTaskAssignment,
   listReadyTasks,
   updateTaskAssignment
 } from "@wrongstack/kanban";
@@ -6972,13 +7080,19 @@ function makeKanbanQueueTool(director, roster) {
       const projectRoot = ctx.projectRoot;
       if (!projectRoot) return { error: "kanban_queue requires ctx.projectRoot." };
       const maxTasks = Math.max(1, Math.min(20, Math.floor(i.maxTasks ?? 1)));
-      const leaseTtlMs = Math.max(1e3, Math.floor(i.leaseTtlMs ?? 5 * 60 * 1e3));
+      const baseLeaseTtlMs = Math.max(1e3, Math.floor(i.leaseTtlMs ?? 5 * 60 * 1e3));
+      const leaseTtlMs = i.awaitCompletion === true && i.timeoutMs !== void 0 ? Math.max(baseLeaseTtlMs, i.timeoutMs + 6e4) : baseLeaseTtlMs;
+      const heartbeatIntervalMs = Math.max(
+        5e3,
+        i.heartbeatIntervalMs ?? Math.floor(leaseTtlMs / 2)
+      );
+      const effectiveLeaseTtlMs = Math.max(leaseTtlMs, heartbeatIntervalMs * 2);
       const claimedAt = nowIso();
       const leaseSeeding = {
         leaseId: randomUUID5(),
         claimedAt,
         heartbeatAt: claimedAt,
-        leaseExpiresAt: new Date(Date.now() + leaseTtlMs).toISOString()
+        leaseExpiresAt: new Date(Date.now() + effectiveLeaseTtlMs).toISOString()
       };
       const candidateTaskIds = i.taskId !== void 0 ? [i.taskId] : i.query ? (await listReadyTasks(projectRoot, {
         ...i.boardId !== void 0 ? { boardId: i.boardId } : {}
@@ -6986,9 +7100,11 @@ function makeKanbanQueueTool(director, roster) {
       const dispatches = [];
       const errors = [];
       const resultFailures = [];
+      const budgetRejectedTaskIds = /* @__PURE__ */ new Set();
       for (let index = 0; index < maxTasks; index++) {
         const candidateTaskId = candidateTaskIds?.[index];
         if (candidateTaskIds && !candidateTaskId) break;
+        if (candidateTaskId && budgetRejectedTaskIds.has(candidateTaskId)) continue;
         const claim = await claimReadyTask(projectRoot, {
           ...i.boardId !== void 0 ? { boardId: i.boardId } : {},
           ...candidateTaskId !== void 0 ? { taskId: candidateTaskId } : {},
@@ -7013,14 +7129,22 @@ function makeKanbanQueueTool(director, roster) {
         if (costCeiling !== void 0) {
           const remaining = director.getRemainingBudgetUsd();
           if (remaining !== void 0 && remaining < costCeiling) {
-            await updateTaskAssignment(projectRoot, claim.board.id, claim.task.id, {
-              status: "failed",
-              error: `Cost ceiling ${costCeiling} exceeds remaining budget ${remaining.toFixed(4)}`,
-              lastResult: "Skipped by kanban_queue cost gate (Sprint 3)"
-            });
+            budgetRejectedTaskIds.add(claim.task.id);
+            const budgetError = `Cost ceiling ${costCeiling} exceeds remaining budget ${remaining.toFixed(4)}`;
+            await updateTaskAssignment(
+              projectRoot,
+              claim.board.id,
+              claim.task.id,
+              {
+                ...claim.task.assignment ?? {},
+                status: "failed",
+                error: budgetError
+              },
+              { expectedLeaseId: leaseSeeding.leaseId }
+            );
             errors.push({
               taskId: claim.task.id,
-              error: `Cost ceiling ${costCeiling} exceeds remaining budget ${remaining.toFixed(4)}`
+              error: budgetError
             });
             continue;
           }
@@ -7028,12 +7152,20 @@ function makeKanbanQueueTool(director, roster) {
         try {
           const config = buildKanbanSubagentConfig(claim.task, i, roster);
           subagentId = await director.spawn(config);
-          runTaskId = await director.assign({
-            id: randomUUID5(),
+          const dispatchTaskId = randomUUID5();
+          const taskSpec = {
+            id: dispatchTaskId,
             subagentId,
             description: buildKanbanFleetTaskPrompt(claim.board, claim.task, {
-              heartbeatIntervalMs: i.heartbeatIntervalMs ?? 6e4,
-              leaseTtlMs,
+              // The worker must heartbeat against the lease it actually holds.
+              // effectiveLeaseTtlMs is the real lease window (raised from the
+              // requested TTL when needed so the first heartbeat always lands
+              // before expiry), and the computed heartbeatIntervalMs is always
+              // strictly shorter than that window. Passing the raw requested
+              // values here would give the worker a 60s cadence against a
+              // 10s lease, letting the lease expire before its first renewal.
+              heartbeatIntervalMs,
+              leaseTtlMs: effectiveLeaseTtlMs,
               leaseId: leaseSeeding.leaseId,
               leaseExpiresAt: leaseSeeding.leaseExpiresAt
             }),
@@ -7044,16 +7176,51 @@ function makeKanbanQueueTool(director, roster) {
               kanban: {
                 boardId: claim.board.id,
                 taskId: claim.task.id,
-                origin: claim.task.origin
+                origin: claim.task.origin,
+                projectRoot
               }
             }
-          });
-          await updateTaskAssignment(projectRoot, claim.board.id, claim.task.id, {
-            ...claim.task.assignment ?? {},
-            status: "running",
-            subagentId,
-            runTaskId
-          });
+          };
+          const dispatched = await updateTaskAssignment(
+            projectRoot,
+            claim.board.id,
+            claim.task.id,
+            {
+              ...claim.task.assignment ?? {},
+              status: "running",
+              subagentId,
+              runTaskId: dispatchTaskId,
+              // Renew the lease from the actual dispatch moment, not from claim
+              // time. The claim-time lease starts before spawn + queueing, so
+              // `timeoutMs + 60_000` can expire while the worker is still
+              // queued or running, letting recover_stale reclaim and duplicate
+              // the assignment (see auto-extend.ts: timeout extensions can push
+              // execution well past the original timeoutMs). Both heartbeatAt
+              // and leaseExpiresAt are stamped from now so the worker has a
+              // full lease window from the moment it was actually dispatched.
+              heartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+              leaseExpiresAt: new Date(Date.now() + effectiveLeaseTtlMs).toISOString()
+            },
+            { expectedLeaseId: leaseSeeding.leaseId }
+          );
+          if (dispatched === null) {
+            try {
+              await director.terminate(subagentId);
+            } catch (cleanupErr) {
+              errors.push({
+                taskId: claim.task.id,
+                error: `Lease lost during dispatch; orphan subagent ${subagentId} termination failed: ${toErrorMessage(cleanupErr)}`
+              });
+              continue;
+            }
+            errors.push({
+              taskId: claim.task.id,
+              error: `Lease lost during dispatch (reassigned by recovery); subagent ${subagentId} terminated.`
+            });
+            continue;
+          }
+          await director.assign(taskSpec);
+          runTaskId = dispatchTaskId;
           dispatches.push({
             boardId: claim.board.id,
             taskId: claim.task.id,
@@ -7072,28 +7239,97 @@ function makeKanbanQueueTool(director, roster) {
               message = `${message}; cleanup failed for spawned subagent ${subagentId}: ${toErrorMessage(cleanupErr)}`;
             }
           }
-          await updateTaskAssignment(projectRoot, claim.board.id, claim.task.id, {
-            ...claim.task.assignment ?? {},
-            status: "failed",
-            ...subagentId !== void 0 ? { subagentId } : {},
-            ...runTaskId !== void 0 ? { runTaskId } : {},
-            error: message
-          });
+          await updateTaskAssignment(
+            projectRoot,
+            claim.board.id,
+            claim.task.id,
+            {
+              ...claim.task.assignment ?? {},
+              status: "failed",
+              ...subagentId !== void 0 ? { subagentId } : {},
+              ...runTaskId !== void 0 ? { runTaskId } : {},
+              error: message
+            },
+            { expectedLeaseId: leaseSeeding.leaseId }
+          );
           errors.push({ taskId: claim.task.id, error: message });
         }
       }
+      if (!i.awaitCompletion && dispatches.length > 0 && typeof director.fleet?.subscribe === "function") {
+        const ourLeaseId = leaseSeeding.leaseId;
+        const disposers = /* @__PURE__ */ new Map();
+        const renewalStartedAt = Date.now();
+        const maxRenewalWindowMs = 24 * 60 * 6e4;
+        const stopAll = () => {
+          clearInterval(renewalTimer);
+          for (const dispose of disposers.values()) dispose();
+          disposers.clear();
+        };
+        const renewalTimer = setInterval(() => {
+          if (disposers.size === 0 || Date.now() - renewalStartedAt > maxRenewalWindowMs) {
+            stopAll();
+            return;
+          }
+          const refreshedExpiry = new Date(Date.now() + effectiveLeaseTtlMs).toISOString();
+          for (const dispatch of dispatches) {
+            if (!disposers.has(dispatch.runTaskId)) continue;
+            void heartbeatTaskAssignment(projectRoot, dispatch.boardId, dispatch.taskId, {
+              leaseExpiresAt: refreshedExpiry,
+              expectedLeaseId: ourLeaseId
+            }).catch(() => {
+            });
+          }
+        }, heartbeatIntervalMs);
+        renewalTimer.unref?.();
+        for (const dispatch of dispatches) {
+          const dispose = director.fleet.subscribe(dispatch.subagentId, (event) => {
+            if (event.type !== "subagent.completed" && event.type !== "subagent.stopped") return;
+            if (event.type === "subagent.completed" && event.taskId !== dispatch.runTaskId) return;
+            disposers.get(dispatch.runTaskId)?.();
+            disposers.delete(dispatch.runTaskId);
+            if (disposers.size === 0) clearInterval(renewalTimer);
+          });
+          disposers.set(dispatch.runTaskId, dispose);
+        }
+      }
       let results;
       if (i.awaitCompletion && dispatches.length > 0) {
-        results = await director.awaitTasks(dispatches.map((dispatch) => dispatch.runTaskId));
+        const ourLeaseId = leaseSeeding.leaseId;
+        const runTaskIds = new Set(dispatches.map((dispatch) => dispatch.runTaskId));
+        const heartbeatTimer = setInterval(async () => {
+          const refreshedExpiry = new Date(Date.now() + effectiveLeaseTtlMs).toISOString();
+          for (const dispatch of dispatches) {
+            if (!runTaskIds.has(dispatch.runTaskId)) continue;
+            try {
+              await heartbeatTaskAssignment(projectRoot, dispatch.boardId, dispatch.taskId, {
+                leaseExpiresAt: refreshedExpiry,
+                expectedLeaseId: ourLeaseId
+              });
+            } catch {
+            }
+          }
+        }, heartbeatIntervalMs);
+        try {
+          results = await director.awaitTasks(dispatches.map((dispatch) => dispatch.runTaskId));
+        } finally {
+          clearInterval(heartbeatTimer);
+        }
         for (const result of results) {
           const dispatch = dispatches.find((candidate) => candidate.runTaskId === result.taskId);
           if (!dispatch) continue;
-          await updateTaskAssignment(projectRoot, dispatch.boardId, dispatch.taskId, {
-            status: result.status === "success" ? "completed" : "failed",
-            subagentId: result.subagentId,
-            runTaskId: result.taskId,
-            ...result.status === "success" ? { lastResult: resultToText(result) } : { error: resultErrorText(result) }
-          });
+          runTaskIds.delete(dispatch.runTaskId);
+          await updateTaskAssignment(
+            projectRoot,
+            dispatch.boardId,
+            dispatch.taskId,
+            {
+              status: result.status === "success" ? "completed" : "failed",
+              subagentId: result.subagentId,
+              runTaskId: result.taskId,
+              ...result.status === "success" ? { lastResult: resultToText(result) } : { error: resultErrorText(result) }
+            },
+            { expectedLeaseId: ourLeaseId }
+          );
           if (result.status !== "success") {
             resultFailures.push({
               taskId: dispatch.taskId,
@@ -7201,6 +7437,16 @@ function buildKanbanFleetTaskPrompt(board, task, lease) {
     task.origin.phaseId ? `phaseId: ${task.origin.phaseId}` : "",
     task.origin.taskId ? `sourceTaskId: ${task.origin.taskId}` : ""
   ].filter(Boolean).join("\n") : "";
+  const boundaries = [
+    board.boundary?.enabled ? `board: ${describeKanbanBoundary(board.boundary)}` : "",
+    task.boundary?.enabled ? `task: ${describeKanbanBoundary(task.boundary)}` : "",
+    ...(board.boundary?.allow ?? []).map(
+      (selector) => `board allow ${selector.access} ${selector.kind}:${selector.path}`
+    ),
+    ...(task.boundary?.allow ?? []).map(
+      (selector) => `task allow ${selector.access} ${selector.kind}:${selector.path}`
+    )
+  ].filter(Boolean);
   return [
     "You are processing a claimed WrongStack Kanban task.",
     "",
@@ -7223,6 +7469,8 @@ ${checks}` : "",
     metrics ? `Goal metrics:
 ${metrics}` : "",
     task.labels?.length ? `Labels: ${task.labels.join(", ")}` : "",
+    boundaries.length ? `BOUNDARY CONTRACT (enforced by the tool runtime; do not attempt to bypass):
+${boundaries.map((line) => `- ${line}`).join("\n")}` : "",
     "Lease contract (Sprint 1):",
     `- leaseId: ${lease.leaseId}`,
     `- claimedAt: ${task.assignment?.claimedAt ?? "<unknown>"}`,
@@ -7238,10 +7486,21 @@ ${metrics}` : "",
     "Work this task end-to-end. Treat the board as a live plan, not a frozen assignment snapshot.",
     `Before material work and whenever evidence changes the plan, call kanban with action "get_board" and boardId "${board.id}" to reassess current tasks, dependencies, priorities, and peer changes.`,
     "You may use kanban add_task, update_task, split_task, merge_tasks, move_task, delete_task, or dependency actions when reassessment shows the plan should change. Preserve traceability and do not keep obsolete work merely because it existed at dispatch time.",
+    "",
+    "FIELD MAINTENANCE \u2014 keep every task detail current:",
+    '- Call "update_task" to refresh description, priority, type, labels, or estimatedHours as the work evolves.',
+    '- Call "add_note" with author and content to record progress, decisions, or roadblock context.',
+    '- Call "add_check" / "update_check" with description and status (pending/passed/failed) to track acceptance criteria.',
+    '- Call "add_goal_metric" / "update_goal_metric" with name and current/target to report measurable progress.',
+    '- Call "add_link" with url and type (issue/pr/doc/commit/design/file/url/other) to attach evidence.',
+    '- Call "update_task" to set actualHours when you have a final time estimate.',
+    "Do not leave stale or placeholder field values \u2014 the kanban board is the shared source of truth for every stakeholder.",
+    "",
+    "LEASE & LIFECYCLE:",
     "Every successful board mutation updates shared pending work and notifies the owning session. Re-read the board after mutations and adapt to changes made by other agents; never assume your initial todo list remains authoritative.",
-    `When you start, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", and assignmentStatus "running". Include subagentId and runTaskId when you have them.`,
-    `To stay alive in the queue, call kanban with action "heartbeat_assignment", boardId "${board.id}", taskId "${task.id}", and heartbeatAt set to the current time. Cadence must be <= heartbeatIntervalMs and well before leaseExpiresAt.`,
-    `When you finish, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", and assignmentStatus "completed" or "failed". Include lastResult or error.`,
+    `When you start, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", assignmentStatus "running", and expectedLeaseId "${lease.leaseId}". Include subagentId and runTaskId when you have them. The expectedLeaseId fence makes the write a safe no-op if recover_stale already reassigned the task because your lease expired.`,
+    `To stay alive in the queue, call kanban with action "heartbeat_assignment", boardId "${board.id}", taskId "${task.id}", heartbeatAt set to the current time, and expectedLeaseId "${lease.leaseId}". Cadence must be <= heartbeatIntervalMs and well before leaseExpiresAt. The expectedLeaseId fence makes the heartbeat a safe no-op if the lease was reassigned, so a stale worker cannot renew a successor's lease.`,
+    `When you finish, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", assignmentStatus "completed" or "failed", and expectedLeaseId "${lease.leaseId}". Include lastResult or error. Populate every relevant detail field before the terminal mark_assignment so the card's final state is complete.`,
     `If you cannot finish in time, call kanban with action "heartbeat_assignment" to extend the lease, or with action "release_task" to release so another worker can claim. Do NOT silently abandon the assignment.`,
     'On failure the host may call kanban with action "recover_stale" (mode: retry/release/fail); respect its decisions and do not duplicate work in parallel.',
     "When finished, report what changed, what you verified, and any remaining blockers."
@@ -7935,18 +8194,20 @@ function hashStr(s) {
 // src/types/provider.ts
 var CONTEXT_OVERFLOW_RE = /context.length|context.window|max.*tokens?.*exceeded|prompt is too long|too long|exceeds the context|\btokens\b.*exceed|context_length_exceeded/i;
 var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
+var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit/i;
 function classifyProviderError(status, body, message) {
   const type = body?.type;
+  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
   if (status === 0) return "network";
   if (status === 408) return "timeout";
   if (status === 599) return "stream_hang";
+  if (status === 402 || QUOTA_EXHAUSTED_RE.test(text)) return "quota_exhausted";
   if (type === "rate_limit_error" || status === 429) return "rate_limit";
   if (type === "overloaded_error" || status === 529) return "overloaded";
   if (status >= 500) return "server";
   if (type === "authentication_error" || type === "permission_error" || status === 401 || status === 403) {
     return "auth";
   }
-  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
   if (type === "content_filter" || CONTENT_FILTER_RE.test(text)) return "content_filter";
   if (status === 413 || status >= 400 && CONTEXT_OVERFLOW_RE.test(text)) {
     return "context_overflow";
@@ -8021,6 +8282,7 @@ var KIND_TO_CODE = {
   network: ERROR_CODES.PROVIDER_NETWORK_ERROR,
   timeout: ERROR_CODES.PROVIDER_NETWORK_ERROR,
   rate_limit: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  quota_exhausted: ERROR_CODES.PROVIDER_RATE_LIMITED,
   auth: ERROR_CODES.PROVIDER_AUTH_FAILED,
   overloaded: ERROR_CODES.PROVIDER_OVERLOADED,
   context_overflow: ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW,
@@ -8034,6 +8296,84 @@ function kindToCode(kind) {
   return KIND_TO_CODE[kind];
 }
 
+// src/core/model-availability-calendar.ts
+function logicalCalendarTarget(providerId, model) {
+  if (providerId !== "omniroute") return { providerId, model };
+  const slash = model.indexOf("/");
+  return slash > 0 && slash < model.length - 1 ? { providerId: model.slice(0, slash), model: model.slice(slash + 1) } : { providerId, model };
+}
+var WEEKDAYS = {
+  Sun: 0,
+  Mon: 1,
+  Tue: 2,
+  Wed: 3,
+  Thu: 4,
+  Fri: 5,
+  Sat: 6
+};
+function minuteOfDay(value) {
+  const match = /^(\d{2}):(\d{2})$/.exec(value);
+  if (!match) return void 0;
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  if (hour > 23 || minute > 59) return void 0;
+  return hour * 60 + minute;
+}
+function clockAt(date, timezone) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      weekday: "short",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23"
+    }).formatToParts(date);
+    const weekday = parts.find((part) => part.type === "weekday")?.value;
+    const hour = Number(parts.find((part) => part.type === "hour")?.value);
+    const minute = Number(parts.find((part) => part.type === "minute")?.value);
+    if (!weekday || WEEKDAYS[weekday] === void 0 || !Number.isFinite(hour + minute))
+      return void 0;
+    return { day: WEEKDAYS[weekday], minute: hour * 60 + minute };
+  } catch {
+    return void 0;
+  }
+}
+function targetMatches(rule, providerId, model) {
+  if (rule.provider && rule.provider !== providerId) return false;
+  if (rule.model && rule.model !== model) return false;
+  return Boolean(rule.provider || rule.model);
+}
+function timeMatches(rule, day, minute) {
+  const start = minuteOfDay(rule.start);
+  const end = minuteOfDay(rule.end);
+  if (start === void 0 || end === void 0) return false;
+  const days = rule.days?.length ? new Set(rule.days) : void 0;
+  if (start === end) return !days || days.has(day);
+  if (start < end) return (!days || days.has(day)) && minute >= start && minute < end;
+  if (minute >= start) return !days || days.has(day);
+  const previousDay = (day + 6) % 7;
+  return minute < end && (!days || days.has(previousDay));
+}
+function evaluateModelCalendar(rules, providerId, model, at = /* @__PURE__ */ new Date()) {
+  ({ providerId, model } = logicalCalendarTarget(providerId, model));
+  const allowRules = [];
+  let allowMatched = false;
+  for (const rule of rules ?? []) {
+    if (rule.enabled === false || !targetMatches(rule, providerId, model)) continue;
+    const clock = clockAt(at, rule.timezone);
+    if (!clock || minuteOfDay(rule.start) === void 0 || minuteOfDay(rule.end) === void 0)
+      continue;
+    if (rule.mode === "allow_only") {
+      allowRules.push(rule);
+      if (timeMatches(rule, clock.day, clock.minute)) allowMatched = true;
+    } else if (timeMatches(rule, clock.day, clock.minute)) {
+      return { allowed: false, rule };
+    }
+  }
+  if (allowRules.length > 0 && !allowMatched) return { allowed: false, rule: allowRules[0] };
+  return { allowed: true };
+}
+
 // src/core/fallback-profile-manager.ts
 function hasText(value) {
   return typeof value === "string" && value.trim().length > 0;
@@ -8042,7 +8382,8 @@ function providerHasKey(entry) {
   if (!entry) return false;
   if (hasText(entry.apiKey)) return true;
   if (Array.isArray(entry.apiKeys) && entry.apiKeys.some((k) => hasText(k?.apiKey))) return true;
-  if (Array.isArray(entry.envVars) && entry.envVars.some((v) => hasText(process.env[v]))) return true;
+  if (Array.isArray(entry.envVars) && entry.envVars.some((v) => hasText(process.env[v])))
+    return true;
   return false;
 }
 function visibleProviderModels(config, providerId, providerModels) {
@@ -8114,6 +8455,8 @@ var FallbackProfileManager = class {
       const health = this.checkProvider(providerId);
       if (!health.usable) continue;
       if (this.statusTracker && !this.statusTracker.isAvailable(providerId, parsed.model)) continue;
+      if (!evaluateModelCalendar(this.config.modelAvailabilitySchedule, providerId, parsed.model).allowed)
+        continue;
       const allowedModels = this.config.providers?.[providerId]?.models;
       if (allowedModels && !allowedModels.includes(parsed.model)) continue;
       resolved.push({
@@ -8186,6 +8529,8 @@ var FallbackProfileManager = class {
       seen.add(key);
       if (excludeKey && key === excludeKey) continue;
       if (this.statusTracker && !this.statusTracker.isAvailable(providerId, parsed.model)) continue;
+      if (!evaluateModelCalendar(this.config.modelAvailabilitySchedule, providerId, parsed.model).allowed)
+        continue;
       resolved.push({
         providerId,
         model: parsed.model,
@@ -8230,6 +8575,8 @@ var FallbackProfileManager = class {
         seen.add(ref);
         if (excludeKey && ref === excludeKey) continue;
         if (this.statusTracker && !this.statusTracker.isAvailable(id, model)) continue;
+        if (!evaluateModelCalendar(this.config.modelAvailabilitySchedule, id, model).allowed)
+          continue;
         if (favoriteSet.has(ref)) {
           favorites.push(ref);
           continue;
@@ -8507,6 +8854,7 @@ function classifySubagentError(err, hints = {}) {
 function providerErrorToSubagentError(err, message, cause) {
   switch (err.kind) {
     case "rate_limit":
+    case "quota_exhausted":
       return {
         kind: "provider_rate_limit",
         message,
@@ -9896,6 +10244,10 @@ var Director = class _Director {
   largeAnswerStore;
   /** Shared provider/model status tracker, or undefined. */
   statusTracker;
+  /** Session/leader's provider id — absolute last-resort fallback for every spawn. */
+  sessionProvider;
+  /** Session/leader's model id — paired with sessionProvider above. */
+  sessionModel;
   constructor(opts) {
     this.id = opts.config.coordinatorId || randomUUID7();
     this.brain = opts.brain;
@@ -9936,6 +10288,8 @@ var Director = class _Director {
     this.fleetManager = opts.fleetManager;
     this.statusTracker = opts.statusTracker;
     this.logger = opts.logger;
+    this.sessionProvider = opts.sessionProvider;
+    this.sessionModel = opts.sessionModel;
     if (this.sharedScratchpadPath) {
       void fsp5.mkdir(this.sharedScratchpadPath, { recursive: true }).catch((err) => this.logShutdownError("shared_scratchpad_mkdir", err));
     }
@@ -10444,20 +10798,31 @@ var Director = class _Director {
     return result.subagentId;
   }
   resolveSpawnModel(config) {
+    if (config.provider?.trim() === "") config.provider = void 0;
+    if (config.model?.trim() === "") config.model = void 0;
     if (!config.model && this.modelMatrix) {
       const matrix = typeof this.modelMatrix === "function" ? this.modelMatrix() : this.modelMatrix;
       const resolution = resolveModelMatrixResolution(matrix, config.role);
       const entry = resolution?.source === "default" && roleNeedsIndependentReviewModel(config.role) ? void 0 : resolution?.entry;
-      if (entry?.model) {
-        config.model = entry.model;
+      if (entry) {
+        if (entry.model) config.model = entry.model;
         if (entry.provider) config.provider = entry.provider;
         if (entry.fallbackProfile) config.fallbackProfile = entry.fallbackProfile;
         if (entry.modelRuntime) config.modelRuntime = entry.modelRuntime;
-      } else if (entry?.fallbackProfile) {
-        config.fallbackProfile = entry.fallbackProfile;
-        if (entry.modelRuntime) config.modelRuntime = entry.modelRuntime;
       }
     }
+    if (!config.provider && this.sessionProvider) {
+      config.provider = this.sessionProvider;
+      this.logger?.info(
+        `spawn: provider="${config.provider}" for role "${config.role ?? "?"}" fell back to session provider (matrix resolution left it undefined)`
+      );
+    }
+    if (!config.model && this.sessionModel) {
+      config.model = this.sessionModel;
+      this.logger?.info(
+        `spawn: model="${config.model}" for role "${config.role ?? "?"}" fell back to session model (matrix resolution left it undefined)`
+      );
+    }
     if (this.statusTracker && config.provider && config.model) {
       if (!this.statusTracker.isAvailable(config.provider, config.model)) {
         this.logger?.warn(
@@ -14456,6 +14821,145 @@ var AUTO_COMPACT_INTERVAL_MS = 3e5;
 var AUTO_COMPACT_READ_MAX_AGE_MS = 6e5;
 var AUTO_COMPACT_DEFAULT_TTL_MS = 864e5;
 
+// src/coordination/mailbox-types.ts
+var MAILBOX_TYPE_PROPERTIES = {
+  note: {
+    category: "informational",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: false,
+    renderPriority: 20,
+    recipientObligation: "Read for context; no reply needed.",
+    senderGuidance: "General-purpose FYI. Use when no more specific type applies."
+  },
+  ask: {
+    category: "actionable",
+    expectsReply: true,
+    requiresAction: true,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 10,
+    recipientObligation: "Answer as soon as possible \u2014 the sender is waiting.",
+    senderGuidance: "Blocking question. Only use when you need an answer to proceed."
+  },
+  assign: {
+    category: "actionable",
+    expectsReply: false,
+    requiresAction: true,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 10,
+    recipientObligation: "Accept or decline; act on it when current operation allows.",
+    senderGuidance: 'Task delegation. Must be directed to a specific recipient (not "*").'
+  },
+  steer: {
+    category: "actionable",
+    expectsReply: false,
+    requiresAction: true,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 0,
+    // Always rendered first
+    recipientObligation: "Pause current approach, adjust per instruction, then resume.",
+    senderGuidance: "Mid-task direction change. The recipient is already working on something."
+  },
+  btw: {
+    category: "informational",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: false,
+    renderPriority: 30,
+    recipientObligation: "Absorb the information and stay on current task; no reply needed.",
+    senderGuidance: "Low-priority aside. Non-urgent info that can wait."
+  },
+  broadcast: {
+    category: "routing",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: false,
+    renderPriority: 20,
+    recipientObligation: 'Read if addressed to you (direct recipient, alias, or "*").',
+    senderGuidance: 'Multi-recipient envelope. Auto-selected when to is "*" or "@session".'
+  },
+  status: {
+    category: "informational",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: false,
+    renderPriority: 40,
+    recipientObligation: "Use to avoid redundant work; never act on as a task or question.",
+    senderGuidance: "Agent/system status update. Machine-generated, not for human-originated messages."
+  },
+  result: {
+    category: "informational",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 10,
+    recipientObligation: "Factor into next decision; treat as evidence, not a new task.",
+    senderGuidance: "Task completion notice. Share the outcome of finished work."
+  },
+  review: {
+    category: "actionable",
+    expectsReply: false,
+    requiresAction: true,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 10,
+    recipientObligation: "Inspect when convenient; no immediate reply required.",
+    senderGuidance: "Passive review request (code/doc/PR). No reply required."
+  },
+  control: {
+    category: "control_signal",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: true,
+    renderPriority: 999,
+    // Never rendered
+    recipientObligation: 'Handled by the agent loop, NOT folded into conversation. "interrupt" causes cooperative halt.',
+    senderGuidance: "RESERVED for runtime use. Agents must NOT send control messages."
+  }
+};
+function validateSendType(type, to) {
+  if (type === "control") {
+    throw new TypeError(
+      'Type "control" is reserved for runtime use and cannot be set by agents'
+    );
+  }
+  const isMultiRecipient = to === "*" || to.startsWith("@session:");
+  if (type === "assign" && isMultiRecipient) {
+    throw new TypeError(
+      `Type "assign" requires a specific recipient \u2014 multi-recipient target "${to}" is ambiguous`
+    );
+  }
+  if (type === "steer" && isMultiRecipient) {
+    throw new TypeError(
+      `Type "steer" requires a specific recipient \u2014 multi-recipient target "${to}" is ambiguous`
+    );
+  }
+}
+var SESSION_RECIPIENT_PREFIX = "@session:";
+function sessionRecipient(sessionId) {
+  const normalizedSessionId = sessionId.trim();
+  if (!normalizedSessionId) {
+    throw new TypeError('sessionId is required for the "@session" recipient');
+  }
+  return `${SESSION_RECIPIENT_PREFIX}${normalizedSessionId}`;
+}
+function normalizeRecipient(to, sessionId) {
+  const trimmed = to.trim();
+  const normalized = trimmed.toLowerCase();
+  if (normalized === "all") return "*";
+  if (normalized === "@session") return sessionRecipient(sessionId ?? "");
+  return trimmed;
+}
+
 // src/coordination/mailbox-message-codec.ts
 var MESSAGE_TYPES = /* @__PURE__ */ new Set([
   "note",
@@ -14512,6 +15016,19 @@ function parseMessageType(value) {
 function normalizeMailboxMessageType(value) {
   return parseMessageType(value);
 }
+function resolveSendType(type, to) {
+  const normalizedTo = normalizeRecipient(to);
+  const resolved = type ?? (normalizedTo === "*" || normalizedTo.startsWith("@session:") ? "broadcast" : "note");
+  validateSendType(resolved, normalizedTo);
+  return resolved;
+}
+function resolveSendTypeSafe(type, to) {
+  try {
+    return { ok: true, type: resolveSendType(type, to) };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
 function parsePriority(value) {
   if (typeof value === "string" && PRIORITIES.has(value)) {
     return value;
@@ -14623,23 +15140,6 @@ function serializeAckRecord(ack) {
   return JSON.stringify(ack) + "\n";
 }
 
-// src/coordination/mailbox-types.ts
-var SESSION_RECIPIENT_PREFIX = "@session:";
-function sessionRecipient(sessionId) {
-  const normalizedSessionId = sessionId.trim();
-  if (!normalizedSessionId) {
-    throw new TypeError('sessionId is required for the "@session" recipient');
-  }
-  return `${SESSION_RECIPIENT_PREFIX}${normalizedSessionId}`;
-}
-function normalizeRecipient(to, sessionId) {
-  const trimmed = to.trim();
-  const normalized = trimmed.toLowerCase();
-  if (normalized === "all") return "*";
-  if (normalized === "@session") return sessionRecipient(sessionId ?? "");
-  return trimmed;
-}
-
 // src/coordination/global-mailbox.ts
 var MAILBOX_FILE = "_mailbox.jsonl";
 var CLIENT_REGISTRY_FILE = "_mailbox.clients.json";
@@ -15948,7 +16448,7 @@ function makeMailboxTool(opts = {}) {
           description: "Which mailbox operation to perform."
         },
         to: { type: "string", description: "Recipient agent id, base alias, '@session' for the sender's session, or '*' / 'all' for project broadcast." },
-        type: { type: "string", enum: ["note", "ask", "assign", "steer", "btw", "broadcast", "status", "result", "review", "control"], description: "Message type." },
+        type: { type: "string", enum: ["note", "ask", "assign", "steer", "btw", "broadcast", "status", "result", "review", "control"], description: "Required message intent. Actionable: ask (blocking question), assign (task delegation, must have specific to), steer (mid-course direction), review (passive ask). Informational: note (general FYI), btw (low-priority aside), result (completion notice), status (system update). Routing: broadcast (multi-recipient). Reserved: control (runtime only, agents cannot send)." },
         subject: { type: "string", description: "Short subject line." },
         body: { type: "string", description: "Full message content." },
         priority: { type: "string", enum: ["low", "normal", "high"] },
@@ -16058,10 +16558,18 @@ async function executeSend(mb, agentId, sessionId, i) {
   if (!tp) return { ok: false, error: '"type" is required.' };
   if (!subject) return { ok: false, error: '"subject" is required.' };
   if (body === void 0 || body === null) return { ok: false, error: '"body" is required.' };
+  let normalizedTo;
+  try {
+    normalizedTo = normalizeRecipient(to, sessionId);
+  } catch (err) {
+    return { ok: false, error: `"to" is invalid: ${toErrorMessage(err)}` };
+  }
+  const typeResult = resolveSendTypeSafe(tp, normalizedTo);
+  if (!typeResult.ok) return { ok: false, error: `"type" is invalid: ${typeResult.error}` };
   const msg = await mb.send({
     from: agentId,
-    to,
-    type: tp,
+    to: normalizedTo,
+    type: typeResult.type,
     subject,
     body,
     priority: i.priority ?? "normal",
@@ -17163,18 +17671,7 @@ function optionalBoolean(object, key) {
   }
   return value;
 }
-var VALID_TYPES = /* @__PURE__ */ new Set([
-  "note",
-  "ask",
-  "assign",
-  "steer",
-  "btw",
-  "broadcast",
-  "status",
-  "result",
-  "review",
-  "control"
-]);
+var VALID_TYPES = new Set(Object.keys(MAILBOX_TYPE_PROPERTIES));
 var VALID_PRIORITIES = /* @__PURE__ */ new Set(["low", "normal", "high"]);
 var RESERVED_FROM_IDS = /* @__PURE__ */ new Set([
   "leader",
@@ -17219,9 +17716,15 @@ function validateSend(body) {
       `field "from" must not use reserved internal agent id "${fromBase}" \u2014 external agents must use their own identity`
     );
   }
+  const to = normalizeRecipient(requireString(object, "to"));
+  try {
+    resolveSendType(type, to);
+  } catch (err) {
+    throw validationError(`field "type" is invalid: ${err.message}`);
+  }
   const result = {
     from,
-    to: requireString(object, "to"),
+    to,
     type,
     subject: requireString(object, "subject"),
     body: requireString(object, "body"),
@@ -17455,7 +17958,7 @@ function makeMailSendTool(opts = {}) {
   const resolveMailbox = makeResolver(opts);
   return {
     name: "mail_send",
-    description: 'Send mail to any agent on this canonical project, across clients, processes, sessions, branches, and linked Git worktrees (CLI, TUI, WebUI, ACP/MCP/HTTP). Use it to hand off work, ask questions, announce what you just did, or request a review (type="review" \u2014 passive ask, no immediate reply required). to="*" broadcasts to everyone; to="@session" reaches agents in your current session; to="leader" reaches every leader process; an exact id like "leader@a1b2c3d4" reaches one agent. Use project-wide scope (`*` or a base alias) whenever another session may be affected. Recipients see your mail automatically before their next step. Pick the type that matches the intent: note (default), ask (blocking question), assign (task), steer (mid-task direction), result (completion notice), review (passive ask), btw/status/broadcast/control (informational).',
+    description: 'Send mail to any agent on this canonical project, across clients, processes, sessions, branches, and linked Git worktrees (CLI, TUI, WebUI, ACP/MCP/HTTP). Use it to hand off work, ask questions, announce what you just did, or request a review. to="*" broadcasts to everyone; to="@session" reaches agents in your current session; to="leader" reaches every leader process; an exact id like "leader@a1b2c3d4" reaches one agent. Use project-wide scope (`*` or a base alias) whenever another session may be affected. Recipients see your mail automatically before their next step. \n\n\u2500\u2500 TYPE SEMANTICS \u2500\u2500\nThe `type` parameter determines how the recipient must handle your message:\n  actionable (requires a response):\n    ask    \u2014 blocking question, sender waits for an answer\n    assign \u2014 task delegation, act when current op allows (requires specific to, NOT "*")\n    steer  \u2014 mid-task direction change, recipient adjusts course NOW\n    review \u2014 passive ask, inspect when convenient, no reply needed\n  informational (consume for context):\n    note     \u2014 general FYI (default for directed sends)\n    btw      \u2014 low-priority aside, absorb and stay on task\n    result   \u2014 subagent completion notice, factor into next decision\n    status   \u2014 agent/system status update, avoid redundant work\n    broadcast \u2014 multi-recipient envelope (default when to="*" or "@session")\n  control (reserved for runtime use \u2014 agents cannot send this type)\n\nWhen no `type` is provided: broadcast for `*`/`@session`, otherwise note.\nassign/steer with to="*" is rejected (ambiguous). control is rejected (runtime-reserved).\n\nType determines dispatch: steer renders first, control is out-of-band, actionable types show "Action required" footer.',
     usageHint: 'mail_send to="<id>" type="review" body="please skim <file>"',
     category: "Coordination",
     permission: "auto",
@@ -17491,11 +17994,14 @@ function makeMailSendTool(opts = {}) {
       const mb = resolveMailbox(ctx);
       const identity = await register(mb, ctx);
       const to = normalizeRecipient(rawTo, identity.sessionId);
-      const type = i.type ?? (to === "*" || to.startsWith("@session:") ? "broadcast" : "note");
+      const resolvedType = resolveSendType(
+        i.type,
+        to
+      );
       const msg = await mb.send({
         from: identity.callerId,
         to,
-        type,
+        type: resolvedType,
         subject,
         body,
         priority: i.priority ?? "normal",
@@ -18760,6 +19266,7 @@ var DEFAULTS2 = {
   blockAfterRateLimitHits: 3,
   blockAfterFailures: 5,
   blockDurationMs: 3e5,
+  quotaBlockDurationMs: 9e5,
   recoverAfterSuccesses: 3,
   maxErrorHistory: 50
 };
@@ -18772,11 +19279,16 @@ var ProviderModelStatusTracker = class {
     this.events = opts?.events;
   }
   // ── Public API ──────────────────────────────────────────────────────────
+  /** Resolve the logical health/display identity without changing wire routing. */
+  logicalIdentity(providerId, model) {
+    return statusIdentity(providerId, model);
+  }
   /**
    * Record a successful provider call. Resets consecutive failure counters
    * and may transition out of degraded/blocked.
    */
   recordSuccess(providerId, model, _meta) {
+    ({ providerId, model } = statusIdentity(providerId, model));
     const key = pairKey(providerId, model);
     const s = this.getOrCreate(key, providerId, model);
     s.consecutiveFailures = 0;
@@ -18796,9 +19308,11 @@ var ProviderModelStatusTracker = class {
    * @returns The new state after recording this failure.
    */
   recordFailure(providerId, model, kind, status, message, meta) {
+    ({ providerId, model } = statusIdentity(providerId, model));
     const key = pairKey(providerId, model);
     const s = this.getOrCreate(key, providerId, model);
     const now = Date.now();
+    const previousExpiry = s.stateExpiresAt;
     s.consecutiveFailures += 1;
     s.totalFailures += 1;
     s.consecutiveSuccesses = 0;
@@ -18811,6 +19325,7 @@ var ProviderModelStatusTracker = class {
     if (s.firstFailureAt === null) s.firstFailureAt = now;
     switch (kind) {
       case "rate_limit":
+      case "quota_exhausted":
         s.rateLimitHits += 1;
         break;
       case "overloaded":
@@ -18838,14 +19353,20 @@ var ProviderModelStatusTracker = class {
     }
     let newState = s.state;
     let reason = "";
-    if (s.state === "healthy") {
+    const quotaExhausted = kind === "quota_exhausted" || isQuotaExhausted(kind, status, message);
+    if (quotaExhausted) {
+      newState = "blocked";
+      reason = "quota_exhausted";
+      s.stateExpiresAt = now + this.cfg.quotaBlockDurationMs;
+    }
+    if (!quotaExhausted && s.state === "healthy") {
       if (s.consecutiveFailures >= this.cfg.degradedAfterFailures) {
         newState = "degraded";
         reason = `consecutive_failures_${s.consecutiveFailures}`;
         s.stateExpiresAt = now + this.cfg.degradedDurationMs;
       }
     }
-    if (s.state === "degraded" || s.state === "healthy") {
+    if (!quotaExhausted && (s.state === "degraded" || s.state === "healthy")) {
       if (s.rateLimitHits >= this.cfg.blockAfterRateLimitHits) {
         newState = "blocked";
         reason = `rate_limit_threshold_${this.cfg.blockAfterRateLimitHits}`;
@@ -18857,7 +19378,7 @@ var ProviderModelStatusTracker = class {
       }
     }
     if (newState !== "healthy" && meta?.retryAfterMs && meta.retryAfterMs > 0) {
-      const hintExpiry = now + Math.min(meta.retryAfterMs, 6e4);
+      const hintExpiry = now + meta.retryAfterMs;
       if (s.stateExpiresAt === null || hintExpiry > s.stateExpiresAt) {
         s.stateExpiresAt = hintExpiry;
       }
@@ -18866,6 +19387,8 @@ var ProviderModelStatusTracker = class {
       const oldState = s.state;
       s.state = newState;
       this.emitStatusChanged(providerId, model, oldState, newState, reason);
+    } else if (s.state !== "healthy" && s.stateExpiresAt !== previousExpiry) {
+      this.emitStatusChanged(providerId, model, s.state, s.state, "cooldown_extended");
     }
     return newState;
   }
@@ -18876,6 +19399,7 @@ var ProviderModelStatusTracker = class {
    * kind is `auth` (no point retrying ever).
    */
   isAvailable(providerId, model) {
+    ({ providerId, model } = statusIdentity(providerId, model));
     const key = pairKey(providerId, model);
     const s = this.map.get(key);
     if (!s) return true;
@@ -18884,26 +19408,14 @@ var ProviderModelStatusTracker = class {
       s.state = "healthy";
       s.stateExpiresAt = null;
       s.consecutiveFailures = Math.max(0, s.consecutiveFailures - 1);
-      this.emitStatusChanged(
-        providerId,
-        model,
-        oldState,
-        "healthy",
-        "cooldown_expired"
-      );
+      this.emitStatusChanged(providerId, model, oldState, "healthy", "cooldown_expired");
       return true;
     }
     if (s.state === "degraded" && s.stateExpiresAt !== null && Date.now() >= s.stateExpiresAt) {
       const oldState = s.state;
       s.state = "healthy";
       s.stateExpiresAt = null;
-      this.emitStatusChanged(
-        providerId,
-        model,
-        oldState,
-        "healthy",
-        "degraded_timeout_expired"
-      );
+      this.emitStatusChanged(providerId, model, oldState, "healthy", "degraded_timeout_expired");
       return true;
     }
     return s.state !== "blocked";
@@ -18915,6 +19427,7 @@ var ProviderModelStatusTracker = class {
    * than skipped permanently.
    */
   isRateLimited(providerId, model) {
+    ({ providerId, model } = statusIdentity(providerId, model));
     const key = pairKey(providerId, model);
     const s = this.map.get(key);
     if (!s) return false;
@@ -18925,6 +19438,7 @@ var ProviderModelStatusTracker = class {
    * if no failures have been recorded.
    */
   getStatus(providerId, model) {
+    ({ providerId, model } = statusIdentity(providerId, model));
     const key = pairKey(providerId, model);
     const s = this.map.get(key);
     if (!s) return void 0;
@@ -18944,6 +19458,45 @@ var ProviderModelStatusTracker = class {
     }
     return out;
   }
+  /**
+   * Move every expired waiting-room entry back to healthy. Runtime routing
+   * already performs this check lazily; this explicit sweep lets a UI/status
+   * timer refresh the room even while no model calls are being made.
+   *
+   * @returns Number of entries released by this sweep.
+   */
+  sweepExpired() {
+    let released = 0;
+    for (const [key, s] of this.map) {
+      if (s.state === "healthy" || s.stateExpiresAt === null || Date.now() < s.stateExpiresAt)
+        continue;
+      const [providerId, model] = unpairKey(key);
+      const previous = s.state;
+      s.state = "healthy";
+      s.stateExpiresAt = null;
+      s.consecutiveFailures = 0;
+      s.consecutiveSuccesses = 0;
+      this.emitStatusChanged(providerId, model, previous, "healthy", "waiting_room_expired");
+      released += 1;
+    }
+    return released;
+  }
+  /**
+   * Release one entry for an immediate half-open probe on its next real use.
+   * History and totals are retained so operators do not lose diagnostics.
+   */
+  retryNow(providerId, model) {
+    ({ providerId, model } = statusIdentity(providerId, model));
+    const s = this.map.get(pairKey(providerId, model));
+    if (!s || s.state === "healthy") return false;
+    const previous = s.state;
+    s.state = "healthy";
+    s.stateExpiresAt = null;
+    s.consecutiveFailures = 0;
+    s.consecutiveSuccesses = 0;
+    this.emitStatusChanged(providerId, model, previous, "healthy", "manual_half_open");
+    return true;
+  }
   /**
    * Returns only currently blocked entries.
    */
@@ -18969,6 +19522,7 @@ var ProviderModelStatusTracker = class {
    * where we don't want to mutate state during a quick peek.
    */
   isBlocked(providerId, model) {
+    ({ providerId, model } = statusIdentity(providerId, model));
     const key = pairKey(providerId, model);
     const s = this.map.get(key);
     if (!s) return false;
@@ -18984,6 +19538,7 @@ var ProviderModelStatusTracker = class {
    */
   clear(providerId, model) {
     if (providerId && model) {
+      ({ providerId, model } = statusIdentity(providerId, model));
       const key = pairKey(providerId, model);
       const old = this.map.get(key);
       if (old && old.state !== "healthy") {
@@ -19024,6 +19579,34 @@ var ProviderModelStatusTracker = class {
       statuses: all
     };
   }
+  /** Restore non-expired waiting-room entries from a previous process. */
+  restoreSnapshot(value) {
+    if (!value || typeof value !== "object") return 0;
+    const statuses = value.statuses;
+    if (!Array.isArray(statuses)) return 0;
+    let restored = 0;
+    const now = Date.now();
+    for (const raw of statuses) {
+      if (!raw || typeof raw !== "object") continue;
+      const item = raw;
+      if (typeof item["providerId"] !== "string" || typeof item["model"] !== "string") continue;
+      if (item["state"] !== "blocked" && item["state"] !== "degraded") continue;
+      if (typeof item["stateExpiresAt"] !== "number" || item["stateExpiresAt"] <= now) continue;
+      const { providerId, model } = statusIdentity(item["providerId"], item["model"]);
+      const s = this.getOrCreate(pairKey(providerId, model), providerId, model);
+      s.state = item["state"];
+      s.stateExpiresAt = item["stateExpiresAt"];
+      s.consecutiveFailures = safeCount(item["consecutiveFailures"]);
+      s.totalFailures = safeCount(item["totalFailures"]);
+      s.rateLimitHits = safeCount(item["rateLimitHits"]);
+      s.lastFailureAt = safeTimestamp(item["lastFailureAt"]);
+      s.lastErrorStatus = safeNullableNumber(item["lastErrorStatus"]);
+      s.lastErrorMessage = typeof item["lastErrorMessage"] === "string" ? item["lastErrorMessage"] : null;
+      s.lastErrorKind = isProviderErrorKind(item["lastErrorKind"]) ? item["lastErrorKind"] : null;
+      restored += 1;
+    }
+    return restored;
+  }
   // ── Private helpers ─────────────────────────────────────────────────────
   getOrCreate(key, _providerId, _model) {
     let s = this.map.get(key);
@@ -19088,13 +19671,23 @@ var ProviderModelStatusTracker = class {
         oldState,
         newState,
         reason,
-        timestamp: Date.now()
+        timestamp: Date.now(),
+        stateExpiresAt: this.map.get(pairKey(providerId, model))?.stateExpiresAt ?? void 0
       });
     } catch {
     }
   }
 };
 var KEY_SEP = "\0";
+function statusIdentity(providerId, model) {
+  if (providerId !== "omniroute") return { providerId, model };
+  const slash = model.indexOf("/");
+  if (slash <= 0 || slash === model.length - 1) return { providerId, model };
+  return {
+    providerId: model.slice(0, slash),
+    model: model.slice(slash + 1)
+  };
+}
 function pairKey(providerId, model) {
   return `${providerId}${KEY_SEP}${model}`;
 }
@@ -19103,6 +19696,39 @@ function unpairKey(key) {
   if (idx === -1) return [key, ""];
   return [key.slice(0, idx), key.slice(idx + 1)];
 }
+var QUOTA_EXHAUSTED_RE2 = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit/i;
+function isQuotaExhausted(kind, status, message) {
+  if (status === 402) return true;
+  if (kind !== "rate_limit" && kind !== "quota_exhausted" && kind !== "invalid_request" && kind !== "auth")
+    return false;
+  return QUOTA_EXHAUSTED_RE2.test(message);
+}
+function safeCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 0;
+}
+function safeTimestamp(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+function safeNullableNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+var PROVIDER_ERROR_KINDS = /* @__PURE__ */ new Set([
+  "rate_limit",
+  "quota_exhausted",
+  "overloaded",
+  "server",
+  "timeout",
+  "network",
+  "stream_hang",
+  "auth",
+  "context_overflow",
+  "content_filter",
+  "invalid_request",
+  "unknown"
+]);
+function isProviderErrorKind(value) {
+  return typeof value === "string" && PROVIDER_ERROR_KINDS.has(value);
+}
 
 // src/coordination/adaptive-concurrency.ts
 var DEFAULT_CONFIG = Object.freeze({
@@ -22226,7 +22852,6 @@ export {
   ACP_AGENTS,
   AGENTS_BY_PHASE,
   AGENT_CATALOG,
-  TOOLS as AGENT_TOOL_PRESETS,
   ALL_AGENT_DEFINITIONS,
   ALL_FLEET_AGENTS,
   AUDIT_LOG_AGENT,
@@ -22348,11 +22973,8 @@ export {
   makeDependencyWatcherConfig,
   makeDirectorSessionFactory,
   makeFleetEmitTool,
-  makeFleetTool as makeFleetHealthTool,
-  makeFleetTool as makeFleetSessionTool,
   makeFleetStatusTool,
   makeFleetTool,
-  makeFleetTool as makeFleetUsageTool,
   makeKanbanQueueTool,
   makeLLMClassifier,
   makeMailInboxTool,