@wrongstack/core 0.287.0 → 0.291.0

package/dist/coordination/index.js

@@ -57,7 +57,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
   const dir = path.dirname(targetPath);
   await fs.mkdir(dir, { recursive: true });
   const lockPath = path.join(dir, `.${path.basename(targetPath)}.lock`);
-  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const timeoutMs = opts.timeoutMs ?? 15e3;
   const staleMs = opts.staleMs ?? 3e4;
   const started = Date.now();
   let handle;
@@ -67,6 +67,13 @@ async function withFileLock(targetPath, fn, opts = {}) {
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
+      if (handle) {
+        await handle.close().catch(() => {
+        });
+        await fs.unlink(lockPath).catch(() => {
+        });
+        handle = void 0;
+      }
       const code = err.code;
       if (code === "ENOENT") {
         await fs.mkdir(dir, { recursive: true });
@@ -449,6 +456,16 @@ async function expandGlob(pattern) {
 }
 
 // src/utils/message-invariants.ts
+function hasMeaningfulContent(content) {
+  if (typeof content === "string") return content.trim().length > 0;
+  return content.some((block) => {
+    if (block.type === "text") return block.text.trim().length > 0;
+    if (block.type === "thinking") {
+      return block.thinking.trim().length > 0 || Boolean(block.signature);
+    }
+    return true;
+  });
+}
 function repairToolUseAdjacency(messages) {
   const removedToolUses = [];
   const removedToolResults = [];
@@ -536,13 +553,12 @@ function mapContent(msg, fn) {
   return { ...msg, content: next };
 }
 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 {
@@ -598,6 +614,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";
@@ -626,11 +647,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";
@@ -1617,8 +1633,8 @@ function stringArray(value) {
 
 // src/coordination/agent-subagent-runner.ts
 function withDisabledToolFiltering(factory) {
-  return async (config) => {
-    const result = await factory(config);
+  return async (config, task) => {
+    const result = await factory(config, task);
     const disabled = config.disabledTools ?? [];
     if (disabled.length === 0) return result;
     const registry = result.agent.tools;
@@ -1634,10 +1650,36 @@ function makeAgentSubagentRunner(opts) {
   const format = opts.formatTaskInput ?? defaultFormatTaskInput;
   return async (task, ctx) => {
     const taskStartedAt = Date.now();
-    const factoryResult = await opts.factory(ctx.config);
+    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;
@@ -1662,6 +1704,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) {
@@ -1673,6 +1736,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);
@@ -2966,6 +3040,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"
+      ]
+    }
   }
 ];
 
@@ -4544,12 +4652,12 @@ var CollabSession = class extends EventEmitter {
     for (const obj of this.extractJsonObjects(text)) {
       const type = "finding" in obj ? "bug.found" : "plan" in obj ? "refactor.plan" : "evaluation" in obj ? "critic.evaluation" : null;
       if (!type) continue;
-      const validationError = validateFleetEventEmission(
+      const validationError2 = validateFleetEventEmission(
         type,
         obj,
         this.roleFromSubagentId(result.subagentId) ?? void 0
       );
-      if (validationError) continue;
+      if (validationError2) continue;
       this.fleetBus.emit({
         subagentId: result.subagentId,
         taskId: result.taskId,
@@ -4700,7 +4808,9 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
         level: "warning" /* WARNING */,
         message: `${role} hit ${payload.kind} soft limit (${payload.used}/${payload.limit})`,
         budgetKind: payload.kind,
-        elapsedMs: payload.timeoutMs,
+        // `used` is elapsed milliseconds for timeout kinds. `timeoutMs` is the
+        // negotiation response deadline (normally 60s), not agent runtime.
+        elapsedMs: payload.kind === "timeout" || payload.kind === "idle_timeout" ? payload.used : void 0,
         limit: payload.limit,
         btwNotes
       };
@@ -4724,12 +4834,10 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
           return;
         }
         this.lastTimeoutProgress.set(e.subagentId, progress);
-        const newLimit = Math.min(
-          Math.ceil((payload.timeoutMs ?? payload.limit) * 2),
-          24 * 60 * 6e4
-        );
+        const newLimit = Math.min(Math.ceil(payload.limit * 2), 24 * 60 * 6e4);
         setImmediate(() => {
-          payload.extend({ timeoutMs: newLimit });
+          const field = payload.kind === "timeout" ? "timeoutMs" : "idleTimeoutMs";
+          payload.extend({ [field]: newLimit });
         });
         return;
       }
@@ -4989,7 +5097,11 @@ var FLEET_ROSTER_BUDGETS = {
     idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
     maxIterations: 1e3,
     maxToolCalls: 2500,
-    maxTokens: 3e4,
+    // Monitoring passes routinely include a large system prompt plus fleet
+    // context. 30k was below observed single-pass usage and therefore triggered
+    // a post-response negotiation every run; 96k leaves headroom while the cost
+    // and tool/iteration caps still bound runaway work.
+    maxTokens: 96e3,
     maxCostUsd: 0.5
   },
   ...Object.fromEntries(
@@ -6207,6 +6319,8 @@ function rosterSummaryFromConfigs(roster) {
 import { randomUUID as randomUUID5 } from "node:crypto";
 import {
   claimReadyTask,
+  describeKanbanBoundary,
+  heartbeatTaskAssignment,
   listReadyTasks,
   updateTaskAssignment
 } from "@wrongstack/kanban";
@@ -6961,13 +7075,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 } : {}
@@ -6975,9 +7095,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 } : {},
@@ -7002,14 +7124,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;
           }
@@ -7017,31 +7147,75 @@ 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
             }),
             ...i.maxToolCalls !== void 0 ? { maxToolCalls: i.maxToolCalls } : {},
             ...i.timeoutMs !== void 0 ? { timeoutMs: i.timeoutMs } : {},
             context: {
+              ...claim.task.type !== void 0 ? { taskType: claim.task.type } : {},
               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,
@@ -7060,28 +7234,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,
@@ -7189,6 +7432,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.",
     "",
@@ -7211,6 +7464,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>"}`,
@@ -7223,10 +7478,24 @@ ${metrics}` : "",
     `- maxAttempts: ${task.assignment?.maxAttempts ?? "<unset>"}`,
     `- costCeilingUsd: ${task.assignment?.costCeilingUsd ?? task.costCeilingUsd ?? "<unset>"}`,
     "",
-    "Work this task end-to-end. If scope is too broad or too small, use the kanban tool to split_task or merge_tasks instead of losing traceability.",
-    `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.`,
+    "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}", 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."
@@ -7621,8 +7890,8 @@ function makeFleetEmitTool(director) {
     async execute(input, ctx) {
       const i = input;
       const role = ctx.meta["agentRole"];
-      const validationError = validateFleetEventEmission(i.type, i.payload ?? {}, role);
-      if (validationError) return { ok: false, error: validationError };
+      const validationError2 = validateFleetEventEmission(i.type, i.payload ?? {}, role);
+      if (validationError2) return { ok: false, error: validationError2 };
       const callerId = ctx.agentId && ctx.agentId !== "unknown" ? ctx.agentId : director.id;
       const taskId = ctx.meta["subagentTaskId"];
       director.fleet.emit({
@@ -7710,25 +7979,32 @@ var FleetBus = class {
   }
   emit(event) {
     const byId = this.byId.get(event.subagentId);
-    if (byId)
-      for (const h of byId) {
+    if (byId && byId.size > 0) {
+      const snapshot = [...byId];
+      for (const h of snapshot) {
         try {
           h(event);
         } catch {
         }
       }
+    }
     const byType = this.byType.get(event.type);
-    if (byType)
-      for (const h of byType) {
+    if (byType && byType.size > 0) {
+      const snapshot = [...byType];
+      for (const h of snapshot) {
         try {
           h(event);
         } catch {
         }
       }
-    for (const h of this.any) {
-      try {
-        h(event);
-      } catch {
+    }
+    if (this.any.size > 0) {
+      const snapshot = [...this.any];
+      for (const h of snapshot) {
+        try {
+          h(event);
+        } catch {
+        }
       }
     }
   }
@@ -7913,18 +8189,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";
@@ -7999,6 +8277,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,
@@ -8012,6 +8291,311 @@ 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;
+}
+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;
+  return false;
+}
+function visibleProviderModels(config, providerId, providerModels) {
+  const entry = config.providers?.[providerId];
+  return entry?.models !== void 0 ? [...entry.models] : providerModels;
+}
+function buildProfiles(config) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const [name, chain] of Object.entries(config.fallbackProfiles ?? {})) {
+    if (Array.isArray(chain) && chain.length > 0) {
+      entries.set(name, Object.freeze([...chain]));
+    }
+  }
+  return entries;
+}
+var FallbackProfileManager = class {
+  /** Immutable snapshot of config.fallbackProfiles for the active config. */
+  profiles;
+  /** Active frozen config snapshot for provider lookups. */
+  config;
+  /** Optional shared runtime status tracker. */
+  statusTracker;
+  constructor(config, opts) {
+    this.config = config;
+    this.profiles = buildProfiles(config);
+    this.statusTracker = opts?.statusTracker;
+  }
+  /**
+   * Bind (or replace) the shared runtime status tracker.
+   * Called by the boot path after the tracker is created.
+   */
+  setStatusTracker(tracker) {
+    this.statusTracker = tracker;
+  }
+  // ── Profile existence ──────────────────────────────────────────────────
+  hasProfile(name) {
+    return this.profiles.has(name);
+  }
+  listProfiles() {
+    return Object.freeze([...this.profiles.keys()]);
+  }
+  // ── Resolution ─────────────────────────────────────────────────────────
+  /**
+   * Resolve a named fallback profile to a validated, provider-filtered chain.
+   *
+   * Returns an empty chain when:
+   * - The profile doesn't exist.
+   * - Every entry's provider is missing, has no key, or has no matching model.
+   *
+   * @param name - Profile name from config.fallbackProfiles.
+   * @param defaultProvider - Used when an entry has no explicit provider.
+   * @param exclude - Optional { providerId, model } to skip (avoid self-fallback).
+   */
+  resolve(name, opts = {}) {
+    const defaultProvider = opts.defaultProvider ?? this.config.provider;
+    const chain = this.profiles.get(name);
+    if (!chain) return FREEZER_EMPTY;
+    const excludeKey = opts.exclude ? `${opts.exclude.providerId}/${opts.exclude.model}` : void 0;
+    const resolved = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const ref of chain) {
+      const parsed = parseModelRef(ref);
+      if (!parsed.model) continue;
+      const providerId = parsed.provider ?? defaultProvider;
+      const key = `${providerId}/${parsed.model}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      if (excludeKey && key === excludeKey) continue;
+      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({
+        providerId,
+        model: parsed.model,
+        providerSwitched: providerId !== (opts.exclude?.providerId ?? this.config.provider)
+      });
+    }
+    return Object.freeze(resolved);
+  }
+  /**
+   * Resolve the effective fallback chain for a session: explicit fallbackModels
+   * first, then named profile, then smart default (unless disabled).
+   *
+   * Mirrors the previous `effectiveFallbackChain()` logic but centralized.
+   */
+  resolveEffective(opts = {}) {
+    if (opts.fallbackModels && opts.fallbackModels.length > 0) {
+      const resolved = this.resolveRefs(opts.fallbackModels, opts.exclude);
+      if (resolved.length > 0) return resolved;
+    }
+    if (opts.fallbackProfile) {
+      const resolved = this.resolve(opts.fallbackProfile, { exclude: opts.exclude });
+      if (resolved.length > 0) return resolved;
+    }
+    if (opts.fallbackAuto !== false) {
+      return this.smartDefault(opts.exclude);
+    }
+    return FREEZER_EMPTY;
+  }
+  // ── Provider availability (read-only) ──────────────────────────────────
+  checkProvider(providerId) {
+    const entry = this.config.providers?.[providerId];
+    const isPrimary = providerId === this.config.provider;
+    const hasKey = providerHasKey(entry) || isPrimary && hasText(this.config.apiKey);
+    const hasEndpoint = hasText(entry?.baseUrl) || isPrimary && hasText(this.config.baseUrl);
+    const hasModels = Array.isArray(entry?.models) && entry.models.length > 0 || isPrimary && hasText(this.config.model);
+    return Object.freeze({
+      providerId,
+      hasKey,
+      hasEndpoint,
+      hasModels,
+      usable: hasKey || hasEndpoint
+    });
+  }
+  // ── Rebuild on config change ───────────────────────────────────────────
+  /**
+   * Atomically replace the active immutable snapshot while preserving this
+   * service identity for every injected consumer.
+   */
+  reload(newConfig) {
+    this.config = newConfig;
+    this.profiles = buildProfiles(newConfig);
+  }
+  // ── Internal helpers ───────────────────────────────────────────────────
+  /**
+   * Resolve an array of model ref strings (from explicit fallbackModels config).
+   * Public so consumers like one-shot-llm can use it directly.
+   */
+  resolveRefs(refs, exclude) {
+    const excludeKey = exclude ? `${exclude.providerId}/${exclude.model}` : void 0;
+    const resolved = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const ref of refs) {
+      const parsed = parseModelRef(ref);
+      if (!parsed.model) continue;
+      const providerId = parsed.provider ?? this.config.provider;
+      const key = `${providerId}/${parsed.model}`;
+      if (seen.has(key)) continue;
+      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,
+        providerSwitched: providerId !== (exclude?.providerId ?? this.config.provider)
+      });
+    }
+    return Object.freeze(resolved);
+  }
+  /**
+   * Derive a smart default chain from configured providers when nothing
+   * explicit is set. Same-provider alternatives first, then cross-provider.
+   * Limited to 4 entries to avoid burning through models on a transient blip.
+   */
+  smartDefault(exclude) {
+    const leaderProvider = this.config.provider;
+    const leaderModel = this.config.model;
+    const providers = this.config.providers ?? {};
+    const favoriteSet = new Set(
+      (this.config.favoriteModels ?? []).map((ref) => {
+        const p = parseModelRef(ref);
+        return `${p.provider ?? leaderProvider}/${p.model}`;
+      })
+    );
+    const hasFavorites = favoriteSet.size > 0;
+    const favoritesOnly = this.config.favoriteModelsOnly === true;
+    const seen = /* @__PURE__ */ new Set();
+    const favorites = [];
+    const sameProvider = [];
+    const crossProvider = [];
+    const excludeKey = exclude ? `${exclude.providerId}/${exclude.model}` : void 0;
+    const ids = Object.keys(providers).sort(
+      (a, b) => a === leaderProvider ? -1 : b === leaderProvider ? 1 : a.localeCompare(b)
+    );
+    for (const id of ids) {
+      const entry = providers[id];
+      if (!this.checkProvider(id).usable) continue;
+      const models = visibleProviderModels(this.config, id, entry?.models ?? []);
+      for (const model of models) {
+        if (id === leaderProvider && model === leaderModel) continue;
+        const ref = `${id}/${model}`;
+        if (seen.has(ref)) continue;
+        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;
+        }
+        if (favoritesOnly && hasFavorites) continue;
+        (id === leaderProvider ? sameProvider : crossProvider).push(ref);
+      }
+    }
+    const MAX = 4;
+    const all = [...favorites, ...sameProvider, ...crossProvider].slice(0, MAX);
+    return Object.freeze(
+      all.map((ref) => {
+        const p = parseModelRef(ref);
+        return {
+          providerId: p.provider ?? leaderProvider,
+          model: p.model,
+          providerSwitched: (p.provider ?? leaderProvider) !== (exclude?.providerId ?? leaderProvider)
+        };
+      })
+    );
+  }
+};
+var FREEZER_EMPTY = Object.freeze([]);
+
 // src/core/fallback-model.ts
 function parseModelRef(ref) {
   const trimmed = ref.trim();
@@ -8030,8 +8614,8 @@ function parseModelRef(ref) {
 }
 function fallbackProfileChain(config, profileName) {
   if (!profileName) return [];
-  const chain = config.fallbackProfiles?.[profileName];
-  return Array.isArray(chain) ? chain.filter((ref) => parseModelRef(ref).model) : [];
+  const mgr = new FallbackProfileManager(config);
+  return mgr.resolve(profileName).map((e) => `${e.providerId}/${e.model}`);
 }
 var DEFAULT_PRIMARY_COOLDOWN_MAX_MS = 10 * 6e4;
 
@@ -8265,6 +8849,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,
@@ -9652,6 +10237,8 @@ var Director = class _Director {
   collab;
   /** Prevents large `ask_subagent` answers from bloating the leader's context window. */
   largeAnswerStore;
+  /** Shared provider/model status tracker, or undefined. */
+  statusTracker;
   constructor(opts) {
     this.id = opts.config.coordinatorId || randomUUID7();
     this.brain = opts.brain;
@@ -9690,6 +10277,7 @@ var Director = class _Director {
       opts.checkpointDebounceMs ?? 250
     ) : null;
     this.fleetManager = opts.fleetManager;
+    this.statusTracker = opts.statusTracker;
     this.logger = opts.logger;
     if (this.sharedScratchpadPath) {
       void fsp5.mkdir(this.sharedScratchpadPath, { recursive: true }).catch((err) => this.logShutdownError("shared_scratchpad_mkdir", err));
@@ -9812,6 +10400,14 @@ var Director = class _Director {
         title
       }
     );
+    if (failed) {
+      void this.appendSessionEvent({
+        type: "agent_error",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        agentId: r.subagentId,
+        error: errorString ?? r.status
+      });
+    }
     if (this.fleetManager) {
       void this.fleetManager.flushManifest();
     } else {
@@ -9894,53 +10490,53 @@ var Director = class _Director {
           payload.extend(extra);
         });
       };
-      if (this.brain) {
-        void this.brain.decide({
-          id: `director-budget-${e.subagentId}-${payload.kind}`,
-          sessionId: this.currentSessionId(),
-          source: "director",
-          question: `Should the director extend the ${payload.kind} budget for subagent ${e.subagentId}?`,
-          context: [
-            e.taskId ? `Task id: ${e.taskId}` : void 0,
-            `Used: ${payload.used}`,
-            `Limit: ${payload.limit}`,
-            `Prior extensions for this kind: ${prior}`
-          ].filter(Boolean).join("\n"),
-          risk: payload.kind === "cost" ? "high" : "medium",
-          fallback: "continue",
-          options: [
-            {
-              id: "extend",
-              label: "Grant the director default budget extension",
-              consequence: "The subagent continues with a larger per-kind budget.",
-              risk: payload.kind === "cost" ? "high" : "medium",
-              recommended: true
-            },
-            {
-              id: "stop",
-              label: "Stop this subagent at the current budget limit",
-              consequence: "The current task will fail or stop due to budget pressure.",
-              risk: "low"
-            }
-          ]
-        }).then((decision) => {
-          if (decision.type === "deny") {
-            payload.deny();
-            return;
-          }
-          if (decision.type === "ask_human") {
-            payload.deny();
-            return;
-          }
-          if (decision.optionId === "stop") {
-            payload.deny();
-            return;
-          }
-          grantExtension();
-        }).catch(() => payload.deny());
+      if (payload.kind !== "cost" || !this.brain) {
+        grantExtension();
         return;
       }
-      grantExtension();
+      void this.brain.decide({
+        id: `director-budget-${e.subagentId}-${payload.kind}`,
+        sessionId: this.currentSessionId(),
+        source: "director",
+        question: `Should the director extend the ${payload.kind} budget for subagent ${e.subagentId}?`,
+        context: [
+          e.taskId ? `Task id: ${e.taskId}` : void 0,
+          `Used: ${payload.used}`,
+          `Limit: ${payload.limit}`,
+          `Prior extensions for this kind: ${prior}`
+        ].filter(Boolean).join("\n"),
+        risk: "high",
+        fallback: "continue",
+        options: [
+          {
+            id: "extend",
+            label: "Grant the director default budget extension",
+            consequence: "The subagent continues with a larger cost budget.",
+            risk: "high",
+            recommended: true
+          },
+          {
+            id: "stop",
+            label: "Stop this subagent at the current budget limit",
+            consequence: "The current task will fail or stop due to budget pressure.",
+            risk: "low"
+          }
+        ]
+      }).then((decision) => {
+        if (decision.type === "deny") {
+          payload.deny();
+          return;
+        }
+        if (decision.type === "ask_human") {
+          payload.deny();
+          return;
+        }
+        if (decision.optionId === "stop") {
+          payload.deny();
+          return;
+        }
+        grantExtension();
+      }).catch(() => payload.deny());
     });
   }
   /**
@@ -10198,9 +10794,20 @@ var Director = class _Director {
       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 (this.statusTracker && config.provider && config.model) {
+      if (!this.statusTracker.isAvailable(config.provider, config.model)) {
+        this.logger?.warn(
+          `spawn: resolved model "${config.provider}/${config.model}" for role "${config.role ?? "?"}" is blocked by the status tracker. The subagent will attempt its fallback chain.`
+        );
+      }
+    }
   }
   enforceSpawnCaps(config) {
     if (this.fleetManager) {
@@ -10708,6 +11315,11 @@ var Director = class _Director {
   }
   async remove(subagentId) {
     this.clearSubagentIdleRetirement(subagentId);
+    void this.appendSessionEvent({
+      type: "agent_stopped",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agentId: subagentId
+    });
     await this.coordinator.remove(subagentId);
     const bridge = this.subagentBridges.get(subagentId);
     if (bridge) {
@@ -11082,24 +11694,24 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * Scrub secrets out of conversation-turn events before they are observed
    * for the summary, written to the JSONL log, or surfaced on resume. Only
-   * `user_input`, `llm_response`, and `context_snapshot` carry free-form
-   * user/model text; other event types either have no secret-bearing content
-   * or are already scrubbed upstream (tool results). Snapshot normalization
-   * also strips transient token-cache fields even when no scrubber is set.
+   * Conversation events carry free-form user/model text. Snapshot and exact
+   * message-journal normalization also strips transient token-cache fields
+   * even when no scrubber is set.
    */
   scrubEvent(event) {
     const s = this.secretScrubber;
-    if (event.type === "context_snapshot") {
+    const persistMessage = (message) => {
+      const { _estTokens: _ignored, ...persisted } = message;
       return {
-        ...event,
-        messages: event.messages.map((message) => {
-          const { _estTokens: _ignored, ...persisted } = message;
-          return {
-            ...persisted,
-            content: typeof persisted.content === "string" ? s?.scrub(persisted.content) ?? persisted.content : s?.scrubObject(persisted.content) ?? persisted.content
-          };
-        })
+        ...persisted,
+        content: typeof persisted.content === "string" ? s?.scrub(persisted.content) ?? persisted.content : s?.scrubObject(persisted.content) ?? persisted.content
       };
+    };
+    if (event.type === "context_snapshot" || event.type === "messages_replaced") {
+      return { ...event, messages: event.messages.map(persistMessage) };
+    }
+    if (event.type === "message_appended" || event.type === "message_updated") {
+      return { ...event, message: persistMessage(event.message) };
     }
     if (!s) return event;
     if (event.type === "user_input") {
@@ -11154,7 +11766,8 @@ var FileSessionWriter = class _FileSessionWriter {
     this.bufferSynchronousEvent(event);
   }
   recordFileObservation(input) {
-    if (!input.path || !/^[a-f\d]{64}$/i.test(input.hash) || !Number.isFinite(input.mtimeMs)) return;
+    if (!input.path || !/^[a-f\d]{64}$/i.test(input.hash) || !Number.isFinite(input.mtimeMs))
+      return;
     this.bufferSynchronousEvent({
       type: "file_observation",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -11316,12 +11929,7 @@ var FileSessionWriter = class _FileSessionWriter {
       const now = Date.now();
       if (now - this.lastAppendWarnAt > 5e3) {
         const suppressed = this.appendFailCount - 1;
-        const tail = suppressed > 0 ? ` (+${suppressed} suppressed)` : "";
-        console.warn(
-          "[session] flush failed:",
-          toErrorMessage(err),
-          tail
-        );
+        console.warn(JSON.stringify({ level: "warn", event: "session.flush_failed", sessionId: this.id, message: toErrorMessage(err), ...suppressed > 0 ? { suppressed } : {}, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
         this.lastAppendWarnAt = now;
         this.appendFailCount = 0;
       }
@@ -11341,6 +11949,43 @@ var FileSessionWriter = class _FileSessionWriter {
       });
     }
   }
+  /**
+   * Rebuild every accumulated summary counter by replaying the JSONL as it now
+   * stands on disk.
+   *
+   * Only truncation needs this: the counters are fed by `observeForSummary` as
+   * events go by and cannot un-count. Reading the whole file is fine here —
+   * rewind is a rare, explicitly user-driven operation, and the alternative
+   * (reversing each counter per discarded event) has to stay in lockstep with
+   * observeForSummary forever.
+   *
+   * `title` is deliberately re-derived too: the first surviving user_input may
+   * differ once earlier prompts are gone.
+   */
+  async recomputeSummaryFromDisk() {
+    if (!this.filePath) return;
+    const raw = await fsp6.readFile(this.filePath, "utf8").catch(() => null);
+    if (raw === null) return;
+    this.iterationCount = 0;
+    this.toolCallCount = 0;
+    this.toolErrorCount = 0;
+    this.toolBreakdown = {};
+    this.fileChangeCount = 0;
+    this.compactionCount = 0;
+    this.outcome = void 0;
+    this.openToolUses = /* @__PURE__ */ new Set();
+    this.tokenIn = 0;
+    this.tokenOut = 0;
+    this.summary = { ...this.summary, title: "(empty session)", tokenTotal: 0 };
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) continue;
+      try {
+        this.observeForSummary(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+  }
   observeForSummary(event) {
     if (event.type === "llm_response") {
       for (const block of event.content) {
@@ -11391,10 +12036,7 @@ var FileSessionWriter = class _FileSessionWriter {
   }
   async doClose() {
     if (this.pendingFileSnapshots.length > 0) {
-      await this.writeFileSnapshot(
-        this.activePromptIndex ?? 0,
-        [...this.pendingFileSnapshots]
-      );
+      await this.writeFileSnapshot(this.activePromptIndex ?? 0, [...this.pendingFileSnapshots]);
       this.pendingFileSnapshots = [];
     }
     this.closed = true;
@@ -11514,7 +12156,7 @@ var FileSessionWriter = class _FileSessionWriter {
    * so post-checkpoint content is never read or parsed — O(1) memory instead
    * of O(N) JSON.parse calls over the full file.
    */
-  async truncateToCheckpoint(targetPromptIndex) {
+  async truncateToCheckpoint(targetPromptIndex, revertedFiles = []) {
     if (!this.filePath) return 0;
     if (this.flushTimer) {
       clearTimeout(this.flushTimer);
@@ -11525,7 +12167,7 @@ var FileSessionWriter = class _FileSessionWriter {
     const CHUNK_SIZE = 65536;
     let fd;
     let fileOffset = 0;
-    let lineStartOffset = 0;
+    let pendingLine = Buffer.alloc(0);
     let checkpointByteOffset = -1;
     let removedCount = 0;
     let targetCheckpointSeen = false;
@@ -11535,17 +12177,18 @@ var FileSessionWriter = class _FileSessionWriter {
         const buf = Buffer.alloc(CHUNK_SIZE);
         const { bytesRead } = await fd.read(buf, 0, CHUNK_SIZE, fileOffset);
         if (bytesRead === 0) break;
+        const carriedBytes = pendingLine.length;
+        const chunk = carriedBytes === 0 ? buf.subarray(0, bytesRead) : Buffer.concat([pendingLine, buf.subarray(0, bytesRead)]);
+        const chunkFileOffset = fileOffset - carriedBytes;
         let chunkPos = 0;
-        while (chunkPos < bytesRead) {
-          const idx = buf.indexOf("\n", chunkPos);
-          if (idx === -1) {
-            lineStartOffset = fileOffset + chunkPos;
-            break;
-          }
+        while (chunkPos < chunk.length) {
+          const idx = chunk.indexOf("\n", chunkPos);
+          if (idx === -1) break;
+          const lineStartOffset = chunkFileOffset + chunkPos;
           if (checkpointByteOffset !== -1) {
             removedCount++;
           } else {
-            const lineBytes = buf.subarray(chunkPos, idx);
+            const lineBytes = chunk.subarray(chunkPos, idx);
             const line = new TextDecoder("utf-8", { fatal: false }).decode(lineBytes);
             if (line.trim()) {
               try {
@@ -11571,12 +12214,9 @@ var FileSessionWriter = class _FileSessionWriter {
             }
           }
           chunkPos = idx + 1;
-          lineStartOffset = fileOffset + chunkPos;
         }
+        pendingLine = chunk.subarray(chunkPos);
         fileOffset += bytesRead;
-        if (chunkPos >= bytesRead) {
-          lineStartOffset = fileOffset;
-        }
       }
     } finally {
       await fd?.close();
@@ -11656,17 +12296,19 @@ var FileSessionWriter = class _FileSessionWriter {
       this.handle = await fsp6.open(this.filePath, "a", 384).catch(() => this.handle);
       throw err;
     }
+    await this.recomputeSummaryFromDisk();
+    const reverted = [...revertedFiles];
     await this.append({
       type: "rewound",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       toPromptIndex: targetPromptIndex,
-      revertedFiles: []
+      revertedFiles: reverted
     });
     this.activePromptIndex = targetPromptIndex;
     this.events?.emit("session.rewound", {
       sessionId: this.id,
       toPromptIndex: targetPromptIndex,
-      revertedFiles: [],
+      revertedFiles: reverted,
       removedEvents: removedCount
     });
     return removedCount;
@@ -11707,7 +12349,11 @@ var FileSessionWriter = class _FileSessionWriter {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       context
     });
-    this.events?.emit("in_flight.started", { sessionId: this.id, context, ts: (/* @__PURE__ */ new Date()).toISOString() });
+    this.events?.emit("in_flight.started", {
+      sessionId: this.id,
+      context,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    });
   }
   /**
    * Close the in-flight marker. Idempotent in spirit
@@ -11718,10 +12364,7 @@ var FileSessionWriter = class _FileSessionWriter {
    */
   async clearInFlightMarker(reason) {
     if (this.pendingFileSnapshots.length > 0) {
-      await this.writeFileSnapshot(
-        this.activePromptIndex ?? 0,
-        [...this.pendingFileSnapshots]
-      );
+      await this.writeFileSnapshot(this.activePromptIndex ?? 0, [...this.pendingFileSnapshots]);
       this.pendingFileSnapshots = [];
     }
     await this.append({
@@ -11729,7 +12372,11 @@ var FileSessionWriter = class _FileSessionWriter {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       reason
     });
-    this.events?.emit("in_flight.ended", { sessionId: this.id, reason, ts: (/* @__PURE__ */ new Date()).toISOString() });
+    this.events?.emit("in_flight.ended", {
+      sessionId: this.id,
+      reason,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    });
   }
 };
 
@@ -12120,6 +12767,13 @@ function defaultRunGit(args, cwd) {
   });
 }
 
+// src/storage/session-id.ts
+function generateSessionId(startedAt, _model) {
+  const date = startedAt.slice(0, 10);
+  const seedTime = Number.isNaN(Date.parse(startedAt)) ? Date.now() : Date.parse(startedAt);
+  return `${date}/sess_${ulid(seedTime)}`;
+}
+
 // src/storage/session-resume-validation.ts
 import { createHash as createHash3 } from "node:crypto";
 import * as fsp8 from "node:fs/promises";
@@ -12229,12 +12883,14 @@ function formatResumeValidationNotice(validation, projectRoot) {
     ...shown
   ].join("\n");
 }
-
-// src/storage/session-id.ts
-function generateSessionId(startedAt, _model) {
-  const date = startedAt.slice(0, 10);
-  const seedTime = Number.isNaN(Date.parse(startedAt)) ? Date.now() : Date.parse(startedAt);
-  return `${date}/sess_${ulid(seedTime)}`;
+function formatInterruptedToolNotice(pendingToolUseCount) {
+  if (!Number.isFinite(pendingToolUseCount) || pendingToolUseCount <= 0) return null;
+  const plural = pendingToolUseCount === 1 ? "tool call was" : "tool calls were";
+  return [
+    "[SESSION RESUME INTERRUPTED WORK]",
+    `The previous run left ${pendingToolUseCount} ${plural} in flight \u2014 no result was recorded before it stopped (crash or interrupt).`,
+    "Those interrupted tool calls were removed from the restored conversation and were NOT re-executed. Re-run the work if it still needs doing."
+  ].join("\n");
 }
 
 // src/storage/session-summary.ts
@@ -12280,18 +12936,27 @@ function isReplayableMessage(value) {
   const candidate = value;
   return (candidate.role === "user" || candidate.role === "assistant" || candidate.role === "system") && (typeof candidate.content === "string" || Array.isArray(candidate.content));
 }
+function trackMessageToolState(message, openToolUses) {
+  if (!Array.isArray(message.content)) return;
+  for (const block of message.content) {
+    if (block.type === "tool_use") openToolUses.add(block.id);
+    else if (block.type === "tool_result") openToolUses.delete(block.tool_use_id);
+  }
+}
+function replayableMessage(value, fallbackTs) {
+  if (!isReplayableMessage(value)) return null;
+  const { _estTokens: _ignored, ...message } = value;
+  return message.ts === void 0 && fallbackTs ? { ...message, ts: fallbackTs } : message;
+}
 function applyContextSnapshot(target, openToolUses, snapshot) {
   if (!Array.isArray(snapshot) || !snapshot.every(isReplayableMessage)) return false;
   target.length = 0;
   openToolUses.clear();
   for (const raw of snapshot) {
-    const { _estTokens: _ignored, ...message } = raw;
+    const message = replayableMessage(raw);
+    if (!message) return false;
     target.push(message);
-    if (!Array.isArray(message.content)) continue;
-    for (const block of message.content) {
-      if (block.type === "tool_use") openToolUses.add(block.id);
-      else if (block.type === "tool_result") openToolUses.delete(block.tool_use_id);
-    }
+    trackMessageToolState(message, openToolUses);
   }
   return true;
 }
@@ -12444,10 +13109,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       handle = await fsp9.open(file, "a", 384);
     } catch (err) {
       this.emitError(id, file, "create", toErrorMessage(err), false);
-      throw new Error(
-        `Failed to open session file: ${toErrorMessage(err)}`,
-        { cause: err }
-      );
+      throw new Error(`Failed to open session file: ${toErrorMessage(err)}`, { cause: err });
     }
     try {
       const writer = new FileSessionWriter(id, handle, startedAt, meta, this.events, {
@@ -12460,10 +13122,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this.emitWrite(id, file, "create", "success", Date.now() - t0);
       return writer;
     } catch (err) {
-      await handle.close().catch((e) => this.logWarn(
-        "Session handle close failed",
-        { event: "session_store.handle_close_failed", message: e instanceof Error ? e.message : String(e) }
-      ));
+      await handle.close().catch(
+        (e) => this.logWarn("Session handle close failed", {
+          event: "session_store.handle_close_failed",
+          message: e instanceof Error ? e.message : String(e)
+        })
+      );
       this.emitError(id, file, "create", toErrorMessage(err), true);
       throw err;
     }
@@ -12482,9 +13146,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         }
       }
       if (boundary === -1) {
-        throw new Error(
-          `Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`
-        );
+        throw new Error(`Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`);
       }
     }
     const parentPrefix = parent.events.slice(0, boundary + 1);
@@ -12531,7 +13193,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   async materializeWorkspaceCheckpoint(checkpoint, targetRoot) {
     if (!this.checkpointCas) {
-      throw new Error("Workspace checkpoint materialization requires a projectRoot-aware session store");
+      throw new Error(
+        "Workspace checkpoint materialization requires a projectRoot-aware session store"
+      );
     }
     return this.checkpointCas.materialize(checkpoint, targetRoot);
   }
@@ -12539,34 +13203,44 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const file = this.sessionPath(id, ".jsonl");
     const t0 = Date.now();
     const data = await this.load(id);
-    let resumedData = data;
+    const noticeMessages = [];
+    let resumeValidation;
     if (this.projectRoot) {
       try {
-        const resumeValidation = await validateResumeFileObservations(data.events, this.projectRoot);
+        resumeValidation = await validateResumeFileObservations(data.events, this.projectRoot);
         const notice = formatResumeValidationNotice(resumeValidation, this.projectRoot);
-        resumedData = {
-          ...data,
-          resumeValidation,
-          ...notice ? {
-            messages: [
-              ...data.messages,
-              { role: "system", content: notice, ts: resumeValidation.checkedAt }
-            ]
-          } : {}
-        };
+        if (notice) {
+          noticeMessages.push({
+            role: "system",
+            content: notice,
+            ts: resumeValidation.checkedAt
+          });
+        }
       } catch (err) {
         this.emitError(id, file, "resume_validation", toErrorMessage(err), true);
       }
     }
+    const interruptedNotice = formatInterruptedToolNotice(data.pendingToolUseCount ?? 0);
+    if (interruptedNotice) {
+      noticeMessages.push({
+        role: "system",
+        content: interruptedNotice,
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    const resumedData = {
+      ...data,
+      ...resumeValidation ? { resumeValidation } : {},
+      ...noticeMessages.length > 0 ? { messages: [...data.messages, ...noticeMessages] } : {}
+    };
     let handle;
     try {
       handle = await fsp9.open(file, "a", 384);
     } catch (err) {
       this.emitError(id, file, "resume", toErrorMessage(err), false);
-      throw new Error(
-        `Failed to open session "${id}" for append: ${toErrorMessage(err)}`,
-        { cause: err }
-      );
+      throw new Error(`Failed to open session "${id}" for append: ${toErrorMessage(err)}`, {
+        cause: err
+      });
     }
     try {
       const writer = new FileSessionWriter(
@@ -12594,10 +13268,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this.emitWrite(id, file, "resume", "success", Date.now() - t0);
       return { writer, data: resumedData };
     } catch (err) {
-      await handle.close().catch((e) => this.logWarn(
-        "Session handle close failed",
-        { event: "session_store.handle_close_failed", message: e instanceof Error ? e.message : String(e) }
-      ));
+      await handle.close().catch(
+        (e) => this.logWarn("Session handle close failed", {
+          event: "session_store.handle_close_failed",
+          message: e instanceof Error ? e.message : String(e)
+        })
+      );
       this.emitError(id, file, "resume", toErrorMessage(err), true);
       throw err;
     }
@@ -12648,6 +13324,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       let sessionForkedEvent;
       const messages = mode.full ? [] : void 0;
       const openToolUses = mode.full ? /* @__PURE__ */ new Set() : void 0;
+      let exactJournalActive = false;
       let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
       const stream = createReadStream(file, { encoding: "utf8" });
       const rl = createInterface({ input: stream, crlfDelay: Infinity });
@@ -12672,20 +13349,59 @@ var DefaultSessionStore = class _DefaultSessionStore {
                 sessionForkedEvent = ev;
               }
               if (mode.full && messages !== void 0 && openToolUses !== void 0) {
-                if (ev.type === "context_snapshot") {
+                if (ev.type === "message_appended" && ev.version === 1) {
+                  const message = replayableMessage(ev.message, ev.ts);
+                  if (message) {
+                    if (!exactJournalActive) {
+                      messages.length = 0;
+                      openToolUses.clear();
+                      exactJournalActive = true;
+                    }
+                    messages.push(message);
+                    trackMessageToolState(message, openToolUses);
+                  } else {
+                    this.events?.emit("session.damaged", {
+                      sessionId: id,
+                      detail: "Ignored malformed message_appended event"
+                    });
+                  }
+                } else if (ev.type === "message_updated" && ev.version === 1) {
+                  const message = replayableMessage(ev.message, ev.ts);
+                  if (message && exactJournalActive && ev.index >= 0 && ev.index < messages.length) {
+                    messages[ev.index] = message;
+                    openToolUses.clear();
+                    for (const current of messages) trackMessageToolState(current, openToolUses);
+                  } else {
+                    this.events?.emit("session.damaged", {
+                      sessionId: id,
+                      detail: `Ignored malformed message_updated event at index ${ev.index}`
+                    });
+                  }
+                } else if (ev.type === "messages_replaced" && ev.version === 1) {
+                  if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
+                    exactJournalActive = true;
+                  } else {
+                    this.events?.emit("session.damaged", {
+                      sessionId: id,
+                      detail: "Ignored malformed messages_replaced event"
+                    });
+                  }
+                } else if (ev.type === "context_snapshot") {
                   if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
                     this.events?.emit("session.damaged", {
                       sessionId: id,
                       detail: "Ignored malformed context_snapshot event"
                     });
                   }
-                } else if (ev.type === "user_input") {
+                } else if (!exactJournalActive && ev.type === "user_input") {
                   openToolUses.clear();
                   messages.push({ role: "user", content: ev.content, ts: ev.ts });
                 } else if (ev.type === "llm_response") {
-                  messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
-                  for (const b of ev.content) {
-                    if (b.type === "tool_use") openToolUses.add(b.id);
+                  if (!exactJournalActive) {
+                    messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
+                    for (const b of ev.content) {
+                      if (b.type === "tool_use") openToolUses.add(b.id);
+                    }
                   }
                   usage = {
                     input: usage.input + (ev.usage.input ?? 0),
@@ -12693,7 +13409,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
                     cacheRead: (usage.cacheRead ?? 0) + (ev.usage.cacheRead ?? 0),
                     cacheWrite: (usage.cacheWrite ?? 0) + (ev.usage.cacheWrite ?? 0)
                   };
-                } else if (ev.type === "tool_result") {
+                } else if (!exactJournalActive && ev.type === "tool_result") {
                   if (!openToolUses.has(ev.id)) {
                     this.events?.emit("session.damaged", {
                       sessionId: id,
@@ -12765,7 +13481,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
         } : void 0
       };
       const toolCallEnds = extractToolCallEnds(events);
-      const data = { metadata: meta, events, messages: finalMessages, usage, toolCallEnds };
+      const pendingToolUseCount = openToolUses && openToolUses.size > 0 ? openToolUses.size : void 0;
+      const data = {
+        metadata: meta,
+        events,
+        messages: finalMessages,
+        usage,
+        toolCallEnds,
+        ...pendingToolUseCount !== void 0 ? { pendingToolUseCount } : {}
+      };
       if (mode.full) {
         if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
           const oldest = this._loadCache.keys().next().value;
@@ -12781,7 +13505,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
       errorMsg = toErrorMessage(err);
       throw err;
     } finally {
-      this.emitRead(id, file, mode.full ? "load" : "load_events_only", outcome, Date.now() - t0, errorMsg);
+      this.emitRead(
+        id,
+        file,
+        mode.full ? "load" : "load_events_only",
+        outcome,
+        Date.now() - t0,
+        errorMsg
+      );
       if (cacheHit) {
         this.events?.emit("storage.cache_hit", {
           sessionId: id,
@@ -12983,7 +13714,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
     } finally {
-      this.emitWrite("~compact~", this.indexFile, "compact", outcome, Date.now() - t0, void 0, errorMsg);
+      this.emitWrite(
+        "~compact~",
+        this.indexFile,
+        "compact",
+        outcome,
+        Date.now() - t0,
+        void 0,
+        errorMsg
+      );
     }
   }
   /**
@@ -13055,7 +13794,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
    */
   async rebuildIndex() {
     const ids = await this.collectSessionIds(this.dir);
-    const summaries = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
+    const summaries = await Promise.all(
+      ids.map((id) => this.summaryFor(id).catch(() => null))
+    );
     const valid = summaries.filter((s) => s !== null);
     const lines = valid.map((s) => JSON.stringify(s)).join("\n") + "\n";
     await withFileLock(this.indexFile, async () => {
@@ -13096,7 +13837,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const shardKeys = [""];
     for (const entry of entries) {
       if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
-      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments") continue;
+      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
+        continue;
       if (entry.isDirectory()) shardKeys.push(entry.name);
     }
     return shardKeys;
@@ -13218,10 +13960,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
-        this.logWarn(
-          "Session manifest write failed",
-          { event: "session_store.manifest_write_failed", sessionId: id, message: msg }
-        );
+        this.logWarn("Session manifest write failed", {
+          event: "session_store.manifest_write_failed",
+          sessionId: id,
+          message: msg
+        });
       });
       outcome = "failure";
       errorMsg = "summary fallback \xE2\u20AC\u201D manifest rebuilt";
@@ -13328,24 +14071,28 @@ var DefaultSessionStore = class _DefaultSessionStore {
       if (r.status === "rejected") {
         const msg = r.reason instanceof Error ? r.reason.message : String(r.reason);
         if (r.reason?.code !== "ENOENT") {
-          console.warn(JSON.stringify({
-            level: "warn",
-            event: "session_store.delete_failed",
-            sessionId: id,
-            message: msg,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          }));
+          console.warn(
+            JSON.stringify({
+              level: "warn",
+              event: "session_store.delete_failed",
+              sessionId: id,
+              message: msg,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
         }
       }
     }
     await fsp9.rm(sessDir, { recursive: true, force: true }).catch((err) => {
-      console.warn(JSON.stringify({
-        level: "warn",
-        event: "session_store.rmdir_failed",
-        sessionId: id,
-        message: toErrorMessage(err),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "session_store.rmdir_failed",
+          sessionId: id,
+          message: toErrorMessage(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
     });
     await this.writeTombstone(id);
   }
@@ -14052,6 +14799,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",
@@ -14108,6 +14994,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;
@@ -14219,11 +15118,6 @@ function serializeAckRecord(ack) {
   return JSON.stringify(ack) + "\n";
 }
 
-// src/coordination/mailbox-types.ts
-function normalizeRecipient(to) {
-  return to.trim().toLowerCase() === "all" ? "*" : to.trim();
-}
-
 // src/coordination/global-mailbox.ts
 var MAILBOX_FILE = "_mailbox.jsonl";
 var CLIENT_REGISTRY_FILE = "_mailbox.clients.json";
@@ -14355,9 +15249,9 @@ var GlobalMailbox = class {
     const msg = {
       id: randomUUID10(),
       from: input.from,
-      // "all" is an accepted spelling of the broadcast address — canonical
-      // form on disk is '*' so every query/checker matches it.
-      to: normalizeRecipient(input.to),
+      // "all" maps to project broadcast; "@session" is resolved against the
+      // sender's session before persistence so recipients can match it exactly.
+      to: normalizeRecipient(input.to, input.senderSessionId),
       type: normalizeMailboxMessageType(input.type),
       subject: input.subject,
       body: input.body,
@@ -14367,6 +15261,7 @@ var GlobalMailbox = class {
       timestamp: now,
       replyTo: input.replyTo,
       taskContext: input.taskContext,
+      senderSessionId: input.senderSessionId,
       expiresAt: input.ttlMs !== void 0 ? new Date(Date.now() + input.ttlMs).toISOString() : void 0
     };
     const line = JSON.stringify(msg) + LINE_SEPARATOR;
@@ -14422,6 +15317,7 @@ var GlobalMailbox = class {
     for (const m of candidates) {
       if (q.to !== void 0 && m.to !== q.to && m.to !== "*") continue;
       if (q.from !== void 0 && m.from !== q.from) continue;
+      if (q.sessionId !== void 0 && m.senderSessionId !== q.sessionId) continue;
       if (q.unreadBy !== void 0 && q.unreadBy in m.readBy) continue;
       if (q.incompleteOnly && m.completed) continue;
       if (queryType !== void 0 && m.type !== queryType) continue;
@@ -14551,8 +15447,9 @@ var GlobalMailbox = class {
     if (updated.length > 0) this.publishHqMailboxSnapshot();
     return updated;
   }
-  async unreadCount(forAgentId) {
+  async unreadCount(forAgentId, sessionId) {
     const all = await this._readMessagesCached();
+    const scopedSessionRecipient = sessionId === void 0 ? void 0 : sessionRecipient(sessionId);
     let count = 0;
     if (this._recipientIndex !== null) {
       const indices = /* @__PURE__ */ new Set();
@@ -14560,6 +15457,10 @@ var GlobalMailbox = class {
       if (direct !== void 0) for (const i of direct) indices.add(i);
       const broadcasts = this._recipientIndex.get("*");
       if (broadcasts !== void 0) for (const i of broadcasts) indices.add(i);
+      if (scopedSessionRecipient !== void 0) {
+        const sessionBroadcasts = this._recipientIndex.get(scopedSessionRecipient);
+        if (sessionBroadcasts !== void 0) for (const i of sessionBroadcasts) indices.add(i);
+      }
       for (const i of indices) {
         const m = all[i];
         if (!(forAgentId in m.readBy) && !m.completed) count++;
@@ -14567,9 +15468,7 @@ var GlobalMailbox = class {
     } else {
       for (let i = 0; i < all.length; i++) {
         const m = all[i];
-        if ((m.to === forAgentId || m.to === "*") && !(forAgentId in m.readBy) && !m.completed) {
-          count++;
-        }
+        if ((m.to === forAgentId || m.to === "*" || m.to === scopedSessionRecipient) && !(forAgentId in m.readBy) && !m.completed) count++;
       }
     }
     return count;
@@ -14673,7 +15572,7 @@ var GlobalMailbox = class {
       toolCalls: 0,
       registeredAt: now,
       lastSeenAt: now,
-      pid: input.pid,
+      pid: input.pid ?? process.pid,
       source: input.source
     };
     await withFileLock(this.registryPath, async () => {
@@ -14705,7 +15604,7 @@ var GlobalMailbox = class {
         lastActivityAt: now,
         lastSeenAt: now,
         online: true,
-        pid: input.pid,
+        pid: input.pid ?? process.pid,
         ...input.source !== void 0 ? { source: input.source } : {}
       }
     });
@@ -14832,7 +15731,7 @@ var GlobalMailbox = class {
       source: input.source,
       registeredAt: now,
       lastSeenAt: now,
-      pid: input.pid
+      pid: input.pid ?? process.pid
     };
     await withFileLock(this.clientRegistryPath, async () => {
       const registry = await this._readClientRegistry({ fresh: true });
@@ -15342,6 +16241,48 @@ var GlobalMailbox = class {
   async _ensureRegistry() {
     await fsp11.mkdir(path14.dirname(this.registryPath), { recursive: true });
   }
+  /** Minimal shape-check for a deserialized agent registry entry.
+   *  Logs a warning and returns `false` for structurally invalid data
+   *  so a single corrupted entry doesn't break the entire registry. */
+  _parseAgentEntry(value) {
+    if (typeof value !== "object" || value === null) return null;
+    const v = value;
+    if (typeof v.agentId !== "string") return null;
+    if (typeof v.sessionId !== "string") return null;
+    const statuses = ["idle", "busy", "running", "streaming", "waiting_user", "error"];
+    const status = typeof v.status === "string" && statuses.includes(v.status) ? v.status : "idle";
+    return {
+      ...v,
+      agentId: v.agentId,
+      sessionId: v.sessionId,
+      name: typeof v.name === "string" ? v.name : v.agentId,
+      registeredAt: typeof v.registeredAt === "string" ? v.registeredAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+      lastSeenAt: typeof v.lastSeenAt === "string" ? v.lastSeenAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+      iterations: typeof v.iterations === "number" && Number.isFinite(v.iterations) ? v.iterations : 0,
+      toolCalls: typeof v.toolCalls === "number" && Number.isFinite(v.toolCalls) ? v.toolCalls : 0,
+      pid: typeof v.pid === "number" && Number.isFinite(v.pid) ? v.pid : 0,
+      status
+    };
+  }
+  /** Minimal shape-check for a deserialized client registry entry. */
+  _parseClientEntry(value) {
+    if (typeof value !== "object" || value === null) return null;
+    const v = value;
+    if (typeof v.clientId !== "string") return null;
+    if (typeof v.sessionId !== "string") return null;
+    const sources = ["repl", "tui", "webui", "http"];
+    const source = typeof v.source === "string" && sources.includes(v.source) ? v.source : "http";
+    return {
+      ...v,
+      clientId: v.clientId,
+      sessionId: v.sessionId,
+      name: typeof v.name === "string" ? v.name : v.clientId,
+      registeredAt: typeof v.registeredAt === "string" ? v.registeredAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+      lastSeenAt: typeof v.lastSeenAt === "string" ? v.lastSeenAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+      pid: typeof v.pid === "number" && Number.isFinite(v.pid) ? v.pid : 0,
+      source
+    };
+  }
   async _readRegistry(opts) {
     if (!opts?.fresh && this._registryCache && Date.now() - this._registryCacheAt < REGISTRY_CACHE_TTL_MS) {
       return new Map(this._registryCache);
@@ -15351,7 +16292,12 @@ var GlobalMailbox = class {
       const data = JSON.parse(raw);
       const map = /* @__PURE__ */ new Map();
       for (const [id, agent] of Object.entries(data)) {
-        map.set(id, agent);
+        const parsed = this._parseAgentEntry(agent);
+        if (parsed) {
+          map.set(id, parsed);
+        } else {
+          console.warn(JSON.stringify({ level: "warn", event: "mailbox.registry.invalid_agent", message: `Skipping malformed agent entry "${id}" in registry`, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+        }
       }
       this._registryCache = map;
       this._registryCacheAt = Date.now();
@@ -15397,7 +16343,12 @@ var GlobalMailbox = class {
       const data = JSON.parse(raw);
       const map = /* @__PURE__ */ new Map();
       for (const [id, client] of Object.entries(data)) {
-        map.set(id, client);
+        const parsed = this._parseClientEntry(client);
+        if (parsed) {
+          map.set(id, parsed);
+        } else {
+          console.warn(JSON.stringify({ level: "warn", event: "mailbox.registry.invalid_client", message: `Skipping malformed client entry "${id}" in client registry`, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+        }
       }
       this._clientRegistryCache = map;
       this._clientRegistryCacheAt = Date.now();
@@ -15457,10 +16408,10 @@ function makeMailboxTool(opts = {}) {
   });
   const agentId = opts.agentId ?? "leader";
   const sessionId = opts.sessionId ?? "default";
-  const shortHint = "Sub-commands: check (unread), send (to/broadcast), ack (read/complete), query (filter), status (all agents), online (active only), unread (count).";
+  const shortHint = "Sub-commands: check (unread), send (exact/base/@session/project broadcast), ack (read/complete), query (filter), status (all agents), online (active only), unread (count).";
   return {
     name: "mailbox",
-    description: "Low-level inter-agent mailbox with 7 actions (check, send, ack, query, status, online, unread). For most use cases, prefer the simpler `mail_send` and `mail_inbox` tools \u2014 they cover the common send/read operations with a cleaner interface. This tool is for advanced queries (filter by sender, priority, since-timestamp), agent status/online lists, and message ack/control.",
+    description: 'Low-level inter-agent mailbox with 7 actions (check, send, ack, query, status, online, unread). For most use cases, prefer the simpler `mail_send` and `mail_inbox` tools \u2014 they cover the common send/read operations with a cleaner interface. This tool is for advanced queries (filter by sender, sender session, priority, since-timestamp), agent status/online lists, and message ack/control. Use to="@session" only for session-local coordination; use "*" or a base alias when another session may be affected.',
     usageHint: shortHint + " For simple send/read, use mail_send / mail_inbox instead.",
     category: "Coordination",
     permission: "auto",
@@ -15474,8 +16425,8 @@ function makeMailboxTool(opts = {}) {
           enum: ["check", "send", "ack", "query", "status", "online", "unread"],
           description: "Which mailbox operation to perform."
         },
-        to: { type: "string", description: "Recipient agent id, or '*' / 'all' for broadcast." },
-        type: { type: "string", enum: ["note", "ask", "assign", "steer", "btw", "broadcast", "status", "result", "review", "control"], description: "Message type." },
+        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: "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"] },
@@ -15490,6 +16441,7 @@ function makeMailboxTool(opts = {}) {
         from: { type: "string", description: "Filter by sender." },
         minPriority: { type: "string", enum: ["low", "normal", "high"] },
         since: { type: "string", description: "ISO8601 timestamp \u2014 only messages after this." },
+        sessionId: { type: "string", description: "Filter query results by sender session id." },
         limit: { type: "number", description: "Max messages to return." }
       },
       required: ["action"]
@@ -15519,7 +16471,7 @@ function makeMailboxTool(opts = {}) {
       }
       switch (action) {
         case "check":
-          return executeCheck(mb, callerId, [baseCallerId], i);
+          return executeCheck(mb, callerId, callerSessionId, [baseCallerId], i);
         case "send":
           return executeSend(mb, callerId, callerSessionId, i);
         case "ack":
@@ -15531,19 +16483,23 @@ function makeMailboxTool(opts = {}) {
         case "online":
           return executeOnline(mb);
         case "unread":
-          return executeUnread(mb, callerId, [baseCallerId]);
+          return executeUnread(mb, callerId, callerSessionId, [baseCallerId]);
         default:
           return { ok: false, error: `Unknown action: "${action}". Use check, send, ack, query, status, online, or unread.` };
       }
     }
   };
 }
-async function executeCheck(mb, agentId, aliases, i) {
+async function executeCheck(mb, agentId, sessionId, aliases, i) {
   const limit = i.limit ?? 20;
   const markRead = i.markRead ?? true;
   const completed = i.completed ?? false;
   const outcome = i.outcome;
-  const targets = [agentId, ...aliases.filter((al) => al && al !== agentId)];
+  const targets = [
+    agentId,
+    ...aliases.filter((al) => al && al !== agentId),
+    `@session:${sessionId}`
+  ];
   const batches = await Promise.all(
     targets.map(
       (to) => mb.query({ to, unreadBy: agentId, limit, minPriority: "low" }).catch(() => [])
@@ -15571,7 +16527,7 @@ async function executeCheck(mb, agentId, aliases, i) {
     summary: acked.length === 0 ? "No unread messages." : `${acked.length} unread message(s)${markRead ? " (marked read)" : ""}${completed ? " (completed)" : ""}.`
   };
 }
-async function executeSend(mb, agentId, _sessionId, i) {
+async function executeSend(mb, agentId, sessionId, i) {
   const to = i.to;
   const tp = i.type;
   const subject = i.subject;
@@ -15580,14 +16536,23 @@ 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",
-    replyTo: i.replyTo
+    replyTo: i.replyTo,
+    senderSessionId: sessionId
   });
   return {
     ok: true,
@@ -15630,6 +16595,7 @@ async function executeQuery(mb, i) {
     type: i.type,
     minPriority: i.minPriority,
     since: i.since,
+    sessionId: i.sessionId,
     limit
   });
   return { ok: true, count: messages.length, messages, summary: `${messages.length} message(s).` };
@@ -15676,8 +16642,12 @@ async function executeOnline(mb) {
     summary: `${agents.length} online agent(s).`
   };
 }
-async function executeUnread(mb, agentId, aliases = []) {
-  const targets = [agentId, ...aliases.filter((al) => al && al !== agentId)];
+async function executeUnread(mb, agentId, sessionId, aliases = []) {
+  const targets = [
+    agentId,
+    ...aliases.filter((al) => al && al !== agentId),
+    `@session:${sessionId}`
+  ];
   const batches = await Promise.all(
     targets.map((to) => mb.query({ to, unreadBy: agentId, limit: 200 }).catch(() => []))
   );
@@ -16357,6 +17327,591 @@ Idle workers: ${idleWorkerIds.join(", ")}`,
   }
 };
 
+// src/coordination/mailbox-http-router.ts
+import { timingSafeEqual } from "node:crypto";
+var MAILBOX_HTTP_MAX_BODY_BYTES = 256 * 1024;
+var MAILBOX_HTTP_RATE_LIMIT_PER_MINUTE = 120;
+var MAILBOX_HTTP_RATE_LIMIT_WINDOW_MS = 6e4;
+function authorizeMailboxBearerToken(request, expectedToken) {
+  const header = request.headers.authorization;
+  if (typeof header !== "string") return { allowed: false };
+  const match = /^Bearer\s+(.+)$/i.exec(header);
+  if (match === null) return { allowed: false };
+  const presented = Buffer.from(match[1] ?? "", "utf8");
+  const expected = Buffer.from(expectedToken, "utf8");
+  if (presented.length !== expected.length || !timingSafeEqual(presented, expected)) {
+    return { allowed: false };
+  }
+  return { allowed: true, rateLimitKey: expectedToken };
+}
+var MailboxHttpRateLimiter = class {
+  constructor(limit = MAILBOX_HTTP_RATE_LIMIT_PER_MINUTE, windowMs = MAILBOX_HTTP_RATE_LIMIT_WINDOW_MS) {
+    this.limit = limit;
+    this.windowMs = windowMs;
+  }
+  limit;
+  windowMs;
+  hits = /* @__PURE__ */ new Map();
+  allow(key) {
+    const now = Date.now();
+    const cutoff = now - this.windowMs;
+    const fresh = (this.hits.get(key) ?? []).filter((timestamp) => timestamp > cutoff);
+    if (fresh.length >= this.limit) {
+      this.hits.set(key, fresh);
+      return false;
+    }
+    fresh.push(now);
+    this.hits.set(key, fresh);
+    return true;
+  }
+  cleanup() {
+    const cutoff = Date.now() - this.windowMs;
+    for (const [key, timestamps] of this.hits) {
+      const fresh = timestamps.filter((timestamp) => timestamp > cutoff);
+      if (fresh.length === 0) this.hits.delete(key);
+      else this.hits.set(key, fresh);
+    }
+  }
+};
+function createMailboxHttpRouter(options) {
+  const maxBodyBytes = options.maxBodyBytes ?? MAILBOX_HTTP_MAX_BODY_BYTES;
+  const closeSseStreams = /* @__PURE__ */ new Set();
+  return {
+    async handle(request, response, routePath) {
+      try {
+        const url = routePath ?? request.url ?? "/";
+        const method = request.method ?? "GET";
+        if (method === "GET" && url === "/healthz") {
+          writeJson(response, 200, { ok: true });
+          return;
+        }
+        const access2 = options.authorize ? await options.authorize(request) : { allowed: true };
+        if (!access2.allowed) {
+          const forwardedFor = request.headers["x-forwarded-for"];
+          const clientIp = (Array.isArray(forwardedFor) ? forwardedFor[0] : forwardedFor)?.split(",")[0]?.trim() ?? request.socket?.remoteAddress ?? "unknown";
+          console.warn(JSON.stringify({
+            level: "warn",
+            event: "mailbox.http_auth_failure",
+            message: `Mailbox HTTP auth rejected for ${request.method ?? "?"} ${request.url ?? "?"} from ${clientIp}`,
+            method: request.method,
+            url: request.url,
+            clientIp,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }));
+          writeJson(
+            response,
+            access2.status ?? 401,
+            access2.body ?? {
+              error: { code: "UNAUTHORIZED", message: "invalid or missing bearer token" }
+            }
+          );
+          return;
+        }
+        if (options.rateLimiter && access2.rateLimitKey !== void 0 && !options.rateLimiter.allow(access2.rateLimitKey)) {
+          writeJson(response, 429, {
+            error: {
+              code: "RATE_LIMITED",
+              message: `rate limit exceeded: max ${options.rateLimiter.limit} requests per ${options.rateLimiter.windowMs / 1e3}s`
+            }
+          });
+          return;
+        }
+        await dispatchMailboxRoute(
+          options.mailbox,
+          options.eventEmitter,
+          request,
+          response,
+          method,
+          url,
+          maxBodyBytes,
+          closeSseStreams
+        );
+      } catch (error) {
+        const code = error instanceof MailboxHttpValidationError ? "VALIDATION_ERROR" : "INTERNAL_ERROR";
+        const status = code === "VALIDATION_ERROR" ? 400 : 500;
+        writeJson(response, status, {
+          error: {
+            code,
+            message: error instanceof Error ? error.message : "unknown error"
+          }
+        });
+      }
+    },
+    close() {
+      for (const close of [...closeSseStreams]) close();
+      closeSseStreams.clear();
+    }
+  };
+}
+async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, method, url, maxBodyBytes, closeSseStreams) {
+  if (method === "POST" && url === "/mailbox/send") {
+    const input = validateSend(await readJsonBody(request, maxBodyBytes));
+    writeJson(response, 201, await mailbox.send(input));
+    return;
+  }
+  if (method === "POST" && url === "/mailbox/query") {
+    const messages = await mailbox.query(validateQuery(await readJsonBody(request, maxBodyBytes)));
+    writeJson(response, 200, { data: messages, count: messages.length });
+    return;
+  }
+  if (method === "POST" && url === "/mailbox/check") {
+    const result = await checkMailbox(
+      mailbox,
+      validateCheck(await readJsonBody(request, maxBodyBytes))
+    );
+    writeJson(response, 200, result);
+    return;
+  }
+  if (method === "POST" && url === "/mailbox/ack") {
+    const updated = await mailbox.ack(validateAck(await readJsonBody(request, maxBodyBytes)));
+    writeJson(response, 200, { updated });
+    return;
+  }
+  if (method === "POST" && url === "/mailbox/ack-many") {
+    const updated = await mailbox.ackMany(
+      validateAckMany(await readJsonBody(request, maxBodyBytes))
+    );
+    writeJson(response, 200, { updated, count: updated.length });
+    return;
+  }
+  if (method === "POST" && url === "/mailbox/unread-count") {
+    const body = await readJsonBody(request, maxBodyBytes);
+    writeJson(response, 200, { count: await mailbox.unreadCount(requireString(body, "forAgentId")) });
+    return;
+  }
+  if (method === "POST" && url === "/mailbox/agents/register") {
+    await mailbox.registerAgent(validateAgentRegistration(await readJsonBody(request, maxBodyBytes)));
+    writeJson(response, 200, { ok: true });
+    return;
+  }
+  if (method === "POST" && url === "/mailbox/agents/heartbeat") {
+    await mailbox.heartbeat(validateAgentHeartbeat(await readJsonBody(request, maxBodyBytes)));
+    writeJson(response, 200, { ok: true });
+    return;
+  }
+  if (method === "POST" && url === "/mailbox/register-client") {
+    await mailbox.registerClient(validateClientRegistration(await readJsonBody(request, maxBodyBytes)));
+    writeJson(response, 200, { ok: true });
+    return;
+  }
+  if (method === "POST" && url === "/mailbox/heartbeat") {
+    await mailbox.clientHeartbeat(validateClientHeartbeat(await readJsonBody(request, maxBodyBytes)));
+    writeJson(response, 200, { ok: true });
+    return;
+  }
+  if (method === "POST" && url === "/mailbox/purge-clients") {
+    writeJson(response, 200, { ok: true, purged: await mailbox.purgeClients() });
+    return;
+  }
+  if (method === "GET" && url === "/mailbox/agents") {
+    const agents = await mailbox.getAgentStatuses();
+    writeJson(response, 200, { data: agents, count: agents.length });
+    return;
+  }
+  if (method === "GET" && url === "/mailbox/agents/online") {
+    const agents = await mailbox.getOnlineAgents();
+    writeJson(response, 200, { data: agents, count: agents.length });
+    return;
+  }
+  if (method === "GET" && url === "/mailbox/events" && eventEmitter) {
+    handleSse(request, response, eventEmitter, closeSseStreams);
+    return;
+  }
+  writeJson(response, 404, {
+    error: { code: "NOT_FOUND", message: `no route for ${method} ${url}` }
+  });
+}
+function handleSse(request, response, eventEmitter, closeSseStreams) {
+  response.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-store",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no"
+  });
+  response.write(": connected\n\n");
+  const unsubscribe = eventEmitter.subscribe((event) => {
+    try {
+      response.write(`data: ${JSON.stringify(event)}
+
+`);
+    } catch {
+      unsubscribe();
+    }
+  });
+  const keepAlive = setInterval(() => {
+    try {
+      response.write(": keepalive\n\n");
+    } catch {
+      clearInterval(keepAlive);
+    }
+  }, 15e3);
+  let closed = false;
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    clearInterval(keepAlive);
+    unsubscribe();
+    closeSseStreams.delete(close);
+    try {
+      response.end();
+    } catch {
+    }
+  };
+  closeSseStreams.add(close);
+  request.once("close", close);
+}
+async function readJsonBody(request, maxBodyBytes) {
+  const lengthHeader = request.headers["content-length"];
+  if (typeof lengthHeader === "string") {
+    const declared = Number.parseInt(lengthHeader, 10);
+    if (Number.isInteger(declared) && declared > maxBodyBytes) {
+      throw validationError(`request body too large: ${declared} bytes (max ${maxBodyBytes})`);
+    }
+  }
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of request) {
+    const buffer = chunk;
+    total += buffer.length;
+    if (total > maxBodyBytes) {
+      throw validationError(`request body too large: > ${maxBodyBytes} bytes`);
+    }
+    chunks.push(buffer);
+  }
+  if (total === 0) return {};
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch (error) {
+    throw validationError(
+      `invalid JSON body: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function writeJson(response, status, body) {
+  response.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store"
+  });
+  response.end(JSON.stringify(body));
+}
+var MailboxHttpValidationError = class extends Error {
+};
+function validationError(message) {
+  return new MailboxHttpValidationError(message);
+}
+function requireString(object, key) {
+  if (typeof object !== "object" || object === null) {
+    throw validationError("expected JSON object body");
+  }
+  const value = object[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw validationError(`field "${key}" is required (string)`);
+  }
+  return value;
+}
+function requireNumber(object, key) {
+  if (typeof object !== "object" || object === null) {
+    throw validationError("expected JSON object body");
+  }
+  const value = object[key];
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    throw validationError(`field "${key}" is required (integer)`);
+  }
+  return value;
+}
+function optionalString3(object, key) {
+  if (typeof object !== "object" || object === null) return void 0;
+  const value = object[key];
+  if (value === void 0) return void 0;
+  if (value === null) {
+    throw validationError(`field "${key}" must not be null when present`);
+  }
+  if (typeof value !== "string") {
+    throw validationError(`field "${key}" must be a string when present`);
+  }
+  return value;
+}
+function optionalNumber(object, key) {
+  if (typeof object !== "object" || object === null) return void 0;
+  const value = object[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "number") {
+    throw validationError(`field "${key}" must be a number when present`);
+  }
+  return value;
+}
+function optionalBoolean(object, key) {
+  if (typeof object !== "object" || object === null) return void 0;
+  const value = object[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "boolean") {
+    throw validationError(`field "${key}" must be a boolean when present`);
+  }
+  return value;
+}
+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",
+  "fleet",
+  "hq",
+  "mailbox-bridge",
+  "mailbox-bridge-watchdog",
+  "tech-stack-consumer",
+  "*"
+]);
+var RESERVED_READER_IDS = /* @__PURE__ */ new Set([
+  "leader",
+  "fleet",
+  "hq",
+  "mailbox-bridge",
+  "mailbox-bridge-watchdog",
+  "tech-stack-consumer"
+]);
+function validateReaderId(id) {
+  const base = id.split("@")[0].toLowerCase();
+  if (RESERVED_READER_IDS.has(base)) {
+    throw validationError(`"readerId" must not use reserved internal agent id "${base}"`);
+  }
+}
+function validateSend(body) {
+  if (typeof body !== "object" || body === null) {
+    throw validationError("expected JSON object body");
+  }
+  const object = body;
+  const type = requireString(object, "type");
+  if (!VALID_TYPES.has(type)) {
+    throw validationError(`field "type" must be one of ${[...VALID_TYPES].join(", ")}`);
+  }
+  const priority = optionalString3(object, "priority");
+  if (priority !== void 0 && !VALID_PRIORITIES.has(priority)) {
+    throw validationError(`field "priority" must be one of ${[...VALID_PRIORITIES].join(", ")}`);
+  }
+  const from = requireString(object, "from");
+  const fromBase = from.split("@")[0].toLowerCase();
+  if (RESERVED_FROM_IDS.has(fromBase)) {
+    throw validationError(
+      `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,
+    type,
+    subject: requireString(object, "subject"),
+    body: requireString(object, "body"),
+    priority
+  };
+  const replyTo = optionalString3(object, "replyTo");
+  if (replyTo !== void 0) result.replyTo = replyTo;
+  const ttlMs = optionalNumber(object, "ttlMs");
+  if (ttlMs !== void 0) {
+    if (!Number.isInteger(ttlMs) || ttlMs < 1) {
+      throw validationError('field "ttlMs" must be a positive integer when present');
+    }
+    result.ttlMs = ttlMs;
+  }
+  return result;
+}
+function validateQuery(body) {
+  if (typeof body !== "object" || body === null) {
+    throw validationError("expected JSON object body");
+  }
+  const object = body;
+  const result = {};
+  const to = optionalString3(object, "to");
+  const from = optionalString3(object, "from");
+  const unreadBy = optionalString3(object, "unreadBy");
+  const type = optionalString3(object, "type");
+  const minPriority = optionalString3(object, "minPriority");
+  const since = optionalString3(object, "since");
+  const limit = optionalNumber(object, "limit");
+  if (limit !== void 0) {
+    if (!Number.isInteger(limit) || limit < 1) {
+      throw validationError('field "limit" must be a positive integer when present');
+    }
+  }
+  const incompleteOnly = optionalBoolean(object, "incompleteOnly");
+  if (to !== void 0) result.to = to;
+  if (from !== void 0) result.from = from;
+  if (unreadBy !== void 0) result.unreadBy = unreadBy;
+  if (type !== void 0) {
+    if (!VALID_TYPES.has(type)) {
+      throw validationError(`field "type" must be one of ${[...VALID_TYPES].join(", ")}`);
+    }
+    result.type = type;
+  }
+  if (minPriority !== void 0) {
+    if (!VALID_PRIORITIES.has(minPriority)) {
+      throw validationError(
+        `field "minPriority" must be one of ${[...VALID_PRIORITIES].join(", ")}`
+      );
+    }
+    result.minPriority = minPriority;
+  }
+  if (since !== void 0) result.since = since;
+  if (limit !== void 0) result.limit = limit;
+  if (incompleteOnly !== void 0) result.incompleteOnly = incompleteOnly;
+  return result;
+}
+async function checkMailbox(mailbox, input) {
+  const limit = input.limit ?? 20;
+  const markRead = input.markRead ?? true;
+  const completed = input.completed ?? false;
+  const targets = input.baseId !== void 0 && input.baseId !== input.agentId ? [input.agentId, input.baseId] : [input.agentId];
+  const batches = await Promise.all(
+    targets.map((to) => mailbox.query({ to, unreadBy: input.agentId, limit }))
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const messages = batches.flat().filter((message) => {
+    if (seen.has(message.id) || message.from === input.agentId) return false;
+    seen.add(message.id);
+    return true;
+  }).slice(0, limit);
+  const data = markRead || completed ? await mailbox.ackMany({
+    acks: messages.map((message) => ({
+      messageId: message.id,
+      readerId: input.agentId,
+      read: markRead,
+      completed,
+      outcome: completed ? input.outcome : void 0
+    }))
+  }) : messages;
+  return { data, count: data.length };
+}
+function validateCheck(body) {
+  if (typeof body !== "object" || body === null) {
+    throw validationError("expected JSON object body");
+  }
+  const object = body;
+  const result = { agentId: requireString(object, "agentId") };
+  const baseId = optionalString3(object, "baseId");
+  const limit = optionalNumber(object, "limit");
+  const markRead = optionalBoolean(object, "markRead");
+  const completed = optionalBoolean(object, "completed");
+  const outcome = optionalString3(object, "outcome");
+  if (baseId !== void 0) result.baseId = baseId;
+  if (limit !== void 0) {
+    if (!Number.isInteger(limit) || limit < 1) {
+      throw validationError('field "limit" must be a positive integer when present');
+    }
+    result.limit = limit;
+  }
+  if (markRead !== void 0) result.markRead = markRead;
+  if (completed !== void 0) result.completed = completed;
+  if (outcome !== void 0) result.outcome = outcome;
+  return result;
+}
+function validateAck(body) {
+  if (typeof body !== "object" || body === null) {
+    throw validationError("expected JSON object body");
+  }
+  const object = body;
+  const readerId = requireString(object, "readerId");
+  validateReaderId(readerId);
+  const result = {
+    messageId: requireString(object, "messageId"),
+    readerId
+  };
+  const read = optionalBoolean(object, "read");
+  const completed = optionalBoolean(object, "completed");
+  const outcome = optionalString3(object, "outcome");
+  if (read !== void 0) result.read = read;
+  if (completed !== void 0) result.completed = completed;
+  if (outcome !== void 0) result.outcome = outcome;
+  return result;
+}
+function validateAckMany(body) {
+  if (typeof body !== "object" || body === null) {
+    throw validationError("expected JSON object body");
+  }
+  const raw = body["acks"];
+  if (!Array.isArray(raw)) throw validationError('field "acks" is required (array)');
+  return { acks: raw.map((entry) => validateAck(entry)) };
+}
+function validateAgentRegistration(body) {
+  if (typeof body !== "object" || body === null) {
+    throw validationError("expected JSON object body");
+  }
+  const object = body;
+  const agentId = requireString(object, "agentId");
+  validateReaderId(agentId);
+  const pid = requireNumber(object, "pid");
+  if (!Number.isInteger(pid) || pid < 1) {
+    throw validationError('field "pid" must be a positive integer');
+  }
+  const result = {
+    agentId,
+    sessionId: optionalString3(object, "sessionId") ?? "external",
+    name: requireString(object, "name"),
+    pid,
+    source: "http"
+  };
+  const role = optionalString3(object, "role");
+  if (role !== void 0) result.role = role;
+  return result;
+}
+function validateAgentHeartbeat(body) {
+  if (typeof body !== "object" || body === null) {
+    throw validationError("expected JSON object body");
+  }
+  const object = body;
+  const result = { agentId: requireString(object, "agentId") };
+  const status = optionalString3(object, "status");
+  const currentTool = optionalString3(object, "currentTool");
+  const currentTask = optionalString3(object, "currentTask");
+  const iterations = optionalNumber(object, "iterations");
+  const toolCalls = optionalNumber(object, "toolCalls");
+  if (status !== void 0) result.status = status;
+  if (currentTool !== void 0) result.currentTool = currentTool;
+  if (currentTask !== void 0) result.currentTask = currentTask;
+  if (iterations !== void 0) {
+    if (!Number.isInteger(iterations) || iterations < 0) {
+      throw validationError('field "iterations" must be a non-negative integer when present');
+    }
+    result.iterations = iterations;
+  }
+  if (toolCalls !== void 0) {
+    if (!Number.isInteger(toolCalls) || toolCalls < 0) {
+      throw validationError('field "toolCalls" must be a non-negative integer when present');
+    }
+    result.toolCalls = toolCalls;
+  }
+  return result;
+}
+function validateClientRegistration(body) {
+  if (typeof body !== "object" || body === null) {
+    throw validationError("expected JSON object body");
+  }
+  const object = body;
+  const pid = requireNumber(object, "pid");
+  if (!Number.isInteger(pid) || pid < 1) {
+    throw validationError('field "pid" must be a positive integer');
+  }
+  return {
+    clientId: requireString(object, "clientId"),
+    sessionId: optionalString3(object, "sessionId") ?? "external",
+    name: requireString(object, "name"),
+    source: "http",
+    pid
+  };
+}
+function validateClientHeartbeat(body) {
+  if (typeof body !== "object" || body === null) {
+    throw validationError("expected JSON object body");
+  }
+  const object = body;
+  const clientId = requireString(object, "clientId");
+  const sessionId = optionalString3(object, "sessionId");
+  return sessionId ? { clientId, sessionId } : { clientId };
+}
+
 // src/coordination/mail-tools.ts
 function makeResolver(opts) {
   return opts.resolveMailbox ?? ((ctx) => new GlobalMailbox(opts.projectDir ?? defaultResolveProjectDir(ctx), opts.events));
@@ -16381,7 +17936,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="leader" reaches every leader process; an exact id like "leader@a1b2c3d4" reaches one agent. 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",
@@ -16392,7 +17947,7 @@ function makeMailSendTool(opts = {}) {
       properties: {
         to: {
           type: "string",
-          description: 'Recipient: exact agent id ("leader@a1b2c3d4"), base alias ("leader"), or "*" / "all" for everyone.'
+          description: 'Recipient: exact agent id ("leader@a1b2c3d4"), base alias ("leader"), "@session" for your current session, or "*" / "all" for everyone.'
         },
         subject: { type: "string", description: "Short subject line." },
         body: { type: "string", description: "The message." },
@@ -16414,18 +17969,22 @@ function makeMailSendTool(opts = {}) {
       if (!rawTo || !subject || body === void 0 || body === null) {
         return { ok: false, error: '"to", "subject" and "body" are required.' };
       }
-      const to = normalizeRecipient(rawTo);
       const mb = resolveMailbox(ctx);
       const identity = await register(mb, ctx);
-      const type = i.type ?? (to === "*" ? "broadcast" : "note");
+      const to = normalizeRecipient(rawTo, identity.sessionId);
+      const resolvedType = resolveSendType(
+        i.type,
+        to
+      );
       const msg = await mb.send({
         from: identity.callerId,
         to,
-        type,
+        type: resolvedType,
         subject,
         body,
         priority: i.priority ?? "normal",
-        replyTo: i.replyTo
+        replyTo: i.replyTo,
+        senderSessionId: identity.sessionId
       });
       return {
         ok: true,
@@ -16441,7 +18000,7 @@ function makeMailInboxTool(opts = {}) {
   const resolveMailbox = makeResolver(opts);
   return {
     name: "mail_inbox",
-    description: 'Read your unread project-wide mail from agents in any client, session, branch, or linked Git worktree and mark it read. Covers mail addressed to you directly, to your base name (e.g. "leader"), and broadcasts ("*"). Urgent steer/btw mail is already injected automatically \u2014 use this to catch up on notes, questions, handoffs, results, and review requests (type="review" \u2014 passive asks where no reply is required). Best called after a long stretch of tool work. Set completed=true to finish every returned message in the same call.',
+    description: 'Read your unread project-wide mail from agents in any client, session, branch, or linked Git worktree and mark it read. Covers mail addressed to you directly, to your base name (e.g. "leader"), to your current session, and project broadcasts ("*"). Urgent steer/btw mail is already injected automatically \u2014 use this to catch up on notes, questions, handoffs, results, and review requests (type="review" \u2014 passive asks where no reply is required). Best called after a long stretch of tool work. Set completed=true to finish every returned message in the same call.',
     usageHint: 'mail_inbox  (optionally: limit=10, markRead=false to peek, completed=true outcome="handled")',
     category: "Coordination",
     permission: "auto",
@@ -16475,6 +18034,7 @@ function makeMailInboxTool(opts = {}) {
       const identity = await register(mb, ctx);
       const targets = [identity.callerId];
       if (identity.baseId !== identity.callerId) targets.push(identity.baseId);
+      targets.push(`@session:${identity.sessionId}`);
       const batches = await Promise.all(
         targets.map(
           (to) => mb.query({ to, unreadBy: identity.callerId, limit }).catch(() => [])
@@ -16555,9 +18115,8 @@ var DefaultMailbox = class {
     const msg = {
       id: randomUUID12(),
       from: input.from,
-      // "all" is an accepted spelling of the broadcast address — canonical
-      // form on disk is '*' so every query/checker matches it.
-      to: normalizeRecipient(input.to),
+      // Resolve project/session aliases before persisting the message.
+      to: normalizeRecipient(input.to, input.senderSessionId),
       type: normalizeMailboxMessageType(input.type),
       subject: input.subject,
       body: input.body,
@@ -16566,7 +18125,8 @@ var DefaultMailbox = class {
       completed: false,
       timestamp: now,
       replyTo: input.replyTo,
-      taskContext: input.taskContext
+      taskContext: input.taskContext,
+      senderSessionId: input.senderSessionId
     };
     const line = JSON.stringify(msg) + LINE_SEPARATOR2;
     await fsp12.mkdir(path15.dirname(this.filePath), { recursive: true });
@@ -16610,6 +18170,7 @@ var DefaultMailbox = class {
     const passes = (msg) => {
       if (q.to !== void 0 && msg.to !== q.to && msg.to !== "*") return false;
       if (q.from !== void 0 && msg.from !== q.from) return false;
+      if (q.sessionId !== void 0 && msg.senderSessionId !== q.sessionId) return false;
       if (q.unreadBy !== void 0 && q.unreadBy in msg.readBy) return false;
       if (q.incompleteOnly && msg.completed) return false;
       if (queryType !== void 0 && msg.type !== queryType) return false;
@@ -16731,10 +18292,11 @@ var DefaultMailbox = class {
   }
   async heartbeat(_input) {
   }
-  async unreadCount(forAgentId) {
+  async unreadCount(forAgentId, sessionId) {
     const all = await this._readAllCached();
+    const scopedSessionRecipient = sessionId === void 0 ? void 0 : sessionRecipient(sessionId);
     return all.filter(
-      (m) => (m.to === forAgentId || m.to === "*") && !(forAgentId in m.readBy) && !m.completed
+      (m) => (m.to === forAgentId || m.to === "*" || m.to === scopedSessionRecipient) && !(forAgentId in m.readBy) && !m.completed
     ).length;
   }
   async close() {
@@ -17213,7 +18775,7 @@ function validateWatchdogOptions(cfg) {
 
 // src/coordination/mailbox-hooks.ts
 function createMailboxHooks(opts) {
-  const { mailbox, agentId, notifyNewMail = true, heartbeat = true } = opts;
+  const { mailbox, agentId, sessionId, notifyNewMail = true, heartbeat = true } = opts;
   let lastUnreadCount = -1;
   return {
     /**
@@ -17222,7 +18784,7 @@ function createMailboxHooks(opts) {
      */
     async beforeTool(events) {
       try {
-        const count = await mailbox.unreadCount(agentId);
+        const count = await mailbox.unreadCount(agentId, sessionId);
         if (notifyNewMail && count !== lastUnreadCount) {
           lastUnreadCount = count;
           events.emit("mailbox.unread_count", { agentId, count });
@@ -17279,10 +18841,8 @@ async function loadLog(storageDir, projectRoot) {
   }
 }
 async function saveLog(storageDir, log) {
-  await fs3.mkdir(storageDir, { recursive: true });
-  const tmp = `${logPath(storageDir)}.tmp.${Date.now()}`;
-  await fs3.writeFile(tmp, JSON.stringify(log, null, 2) + "\n", "utf-8");
-  await fs3.rename(tmp, logPath(storageDir));
+  await atomicWrite(logPath(storageDir), `${JSON.stringify(log, null, 2)}
+`);
 }
 function detectEcosystem(manifestPath) {
   const name = path16.win32.basename(manifestPath).toLowerCase();
@@ -17677,6 +19237,477 @@ async function probeHealthz(url) {
   }
 }
 
+// src/coordination/provider-status-tracker.ts
+var DEFAULTS2 = {
+  degradedAfterFailures: 2,
+  degradedDurationMs: 3e4,
+  blockAfterRateLimitHits: 3,
+  blockAfterFailures: 5,
+  blockDurationMs: 3e5,
+  quotaBlockDurationMs: 9e5,
+  recoverAfterSuccesses: 3,
+  maxErrorHistory: 50
+};
+var ProviderModelStatusTracker = class {
+  cfg;
+  map = /* @__PURE__ */ new Map();
+  events;
+  constructor(opts) {
+    this.cfg = { ...DEFAULTS2, ...opts?.config };
+    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;
+    s.consecutiveSuccesses += 1;
+    s.totalSuccesses += 1;
+    s.lastSuccessAt = Date.now();
+    if (s.state !== "healthy" && s.consecutiveSuccesses >= this.cfg.recoverAfterSuccesses) {
+      const oldState = s.state;
+      s.state = "healthy";
+      s.stateExpiresAt = null;
+      this.emitStatusChanged(providerId, model, oldState, "healthy", "success_streak_recovery");
+    }
+  }
+  /**
+   * Record a failed provider call. Transitions state based on thresholds.
+   *
+   * @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;
+    s.lastFailureAt = now;
+    s.lastErrorKind = kind;
+    s.lastErrorMessage = message;
+    s.lastErrorStatus = status;
+    if (meta?.sessionId) s.lastSessionId = meta.sessionId;
+    if (meta?.agentId) s.lastAgentId = meta.agentId;
+    if (s.firstFailureAt === null) s.firstFailureAt = now;
+    switch (kind) {
+      case "rate_limit":
+      case "quota_exhausted":
+        s.rateLimitHits += 1;
+        break;
+      case "overloaded":
+        s.overloadedHits += 1;
+        break;
+      case "server":
+      case "stream_hang":
+        s.serverErrors += 1;
+        break;
+      default:
+        s.otherErrors += 1;
+    }
+    const entry = Object.freeze({
+      timestamp: now,
+      kind,
+      status,
+      message,
+      sessionId: meta?.sessionId,
+      agentId: meta?.agentId,
+      retryAfterMs: meta?.retryAfterMs
+    });
+    s.recentErrors.unshift(entry);
+    if (s.recentErrors.length > this.cfg.maxErrorHistory) {
+      s.recentErrors = s.recentErrors.slice(0, this.cfg.maxErrorHistory);
+    }
+    let newState = s.state;
+    let reason = "";
+    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 (!quotaExhausted && (s.state === "degraded" || s.state === "healthy")) {
+      if (s.rateLimitHits >= this.cfg.blockAfterRateLimitHits) {
+        newState = "blocked";
+        reason = `rate_limit_threshold_${this.cfg.blockAfterRateLimitHits}`;
+        s.stateExpiresAt = now + this.cfg.blockDurationMs;
+      } else if (s.consecutiveFailures >= this.cfg.blockAfterFailures) {
+        newState = "blocked";
+        reason = `consecutive_failures_${s.consecutiveFailures}`;
+        s.stateExpiresAt = now + this.cfg.blockDurationMs;
+      }
+    }
+    if (newState !== "healthy" && meta?.retryAfterMs && meta.retryAfterMs > 0) {
+      const hintExpiry = now + meta.retryAfterMs;
+      if (s.stateExpiresAt === null || hintExpiry > s.stateExpiresAt) {
+        s.stateExpiresAt = hintExpiry;
+      }
+    }
+    if (s.state !== newState) {
+      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;
+  }
+  /**
+   * Check if a (providerId, model) pair is currently usable.
+   * Returns `true` when healthy or degraded (degraded is still usable,
+   * just known flaky). Returns `false` when blocked or when the error
+   * 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;
+    if (s.state === "blocked" && s.stateExpiresAt !== null && Date.now() >= s.stateExpiresAt) {
+      const oldState = s.state;
+      s.state = "healthy";
+      s.stateExpiresAt = null;
+      s.consecutiveFailures = Math.max(0, s.consecutiveFailures - 1);
+      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");
+      return true;
+    }
+    return s.state !== "blocked";
+  }
+  /**
+   * Check if a (providerId, model) pair is currently rate-limited.
+   * This is a stronger signal than just `!isAvailable()` — it tells
+   * callers that requests should be re-tried after a delay rather
+   * 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;
+    return s.lastErrorKind === "rate_limit" && s.state !== "healthy";
+  }
+  /**
+   * Get the full status for a (providerId, model) pair, or `undefined`
+   * 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;
+    this.isAvailable(providerId, model);
+    return this.freezeStatus(key, s);
+  }
+  /**
+   * Returns a snapshot of ALL tracked provider/model statuses.
+   * Useful for the `/provider-status` command and WebUI.
+   */
+  getAllStatuses() {
+    const out = [];
+    for (const [key, s] of this.map) {
+      const [providerId, model] = unpairKey(key);
+      this.isAvailable(providerId, model);
+      out.push(this.freezeStatus(key, s));
+    }
+    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.
+   */
+  getBlocked() {
+    return this.getAllStatuses().filter((s) => s.state === "blocked");
+  }
+  /**
+   * Returns only currently degraded entries.
+   */
+  getDegraded() {
+    return this.getAllStatuses().filter((s) => s.state === "degraded");
+  }
+  /**
+   * Filter an array of objects that have `providerId` and `model` fields,
+   * removing entries whose (providerId, model) is blocked.
+   */
+  filterAvailable(entries) {
+    return entries.filter((e) => this.isAvailable(e.providerId, e.model));
+  }
+  /**
+   * Check if a (providerId, model) pair would be blocked, WITHOUT the
+   * side-effect of auto-recovering stale entries. Used in hot paths
+   * 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;
+    if (s.state !== "blocked") return false;
+    if (s.stateExpiresAt !== null && Date.now() >= s.stateExpiresAt) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Reset tracking for a specific (providerId, model) pair, or for ALL
+   * pairs when both arguments are omitted.
+   */
+  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") {
+        this.emitStatusChanged(providerId, model, old.state, "healthy", "manual_clear");
+      }
+      this.map.delete(key);
+    } else {
+      for (const [key, s] of this.map) {
+        if (s.state !== "healthy") {
+          const [pid, mdl] = unpairKey(key);
+          this.emitStatusChanged(pid, mdl, s.state, "healthy", "manual_clear_all");
+        }
+      }
+      this.map.clear();
+    }
+  }
+  /**
+   * Get a JSON-safe snapshot suitable for WebUI rendering.
+   * Includes summary stats + per-pair details.
+   */
+  getSnapshot() {
+    const all = this.getAllStatuses();
+    const healthy = [];
+    const degraded = [];
+    const blocked = [];
+    for (const s of all) {
+      if (s.state === "blocked") blocked.push(s);
+      else if (s.state === "degraded") degraded.push(s);
+      else healthy.push(s);
+    }
+    return {
+      totalPairs: all.length,
+      healthy: healthy.length,
+      degraded: degraded.length,
+      blocked: blocked.length,
+      totalFailures: all.reduce((sum, s) => sum + s.totalFailures, 0),
+      totalRateLimits: all.reduce((sum, s) => sum + s.rateLimitHits, 0),
+      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);
+    if (!s) {
+      s = {
+        state: "healthy",
+        consecutiveFailures: 0,
+        totalFailures: 0,
+        rateLimitHits: 0,
+        overloadedHits: 0,
+        serverErrors: 0,
+        otherErrors: 0,
+        consecutiveSuccesses: 0,
+        totalSuccesses: 0,
+        lastSuccessAt: null,
+        firstFailureAt: null,
+        lastFailureAt: null,
+        stateExpiresAt: null,
+        lastErrorKind: null,
+        lastErrorMessage: null,
+        lastErrorStatus: null,
+        lastSessionId: null,
+        lastAgentId: null,
+        recentErrors: []
+      };
+      this.map.set(key, s);
+    }
+    return s;
+  }
+  freezeStatus(key, s) {
+    const [providerId, model] = unpairKey(key);
+    return Object.freeze({
+      providerId,
+      model,
+      state: s.state,
+      consecutiveFailures: s.consecutiveFailures,
+      totalFailures: s.totalFailures,
+      rateLimitHits: s.rateLimitHits,
+      overloadedHits: s.overloadedHits,
+      serverErrors: s.serverErrors,
+      otherErrors: s.otherErrors,
+      consecutiveSuccesses: s.consecutiveSuccesses,
+      totalSuccesses: s.totalSuccesses,
+      lastSuccessAt: s.lastSuccessAt,
+      firstFailureAt: s.firstFailureAt,
+      lastFailureAt: s.lastFailureAt,
+      stateExpiresAt: s.stateExpiresAt,
+      lastErrorKind: s.lastErrorKind,
+      lastErrorMessage: s.lastErrorMessage,
+      lastErrorStatus: s.lastErrorStatus,
+      lastSessionId: s.lastSessionId,
+      lastAgentId: s.lastAgentId,
+      recentErrors: Object.freeze([...s.recentErrors])
+    });
+  }
+  emitStatusChanged(providerId, model, oldState, newState, reason) {
+    if (!this.events) return;
+    try {
+      this.events.emit("provider.status_changed", {
+        providerId,
+        model,
+        oldState,
+        newState,
+        reason,
+        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}`;
+}
+function unpairKey(key) {
+  const idx = key.indexOf(KEY_SEP);
+  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({
   enabled: false,
@@ -17873,6 +19904,14 @@ var AgentMonitorService = class _AgentMonitorService {
    * the JSONL line is written once, when the segment closes.
    */
   _openStreams = /* @__PURE__ */ new Map();
+  /**
+   * FIFO chain of in-flight transcript appends. Writes stay fire-and-forget so
+   * a slow disk never stalls a subagent, but `close()` must be able to wait for
+   * them: without this the process can exit between `stop()` flushing the open
+   * segments and those appends reaching disk, losing exactly the text that was
+   * on screen. Mirrors FleetManager.closeManifest()'s drain.
+   */
+  _writeChain = Promise.resolve();
   /** Disposers for FleetBus subscriptions, keyed by subagentId. */
   _subscriptions = /* @__PURE__ */ new Map();
   /** Generic fleet-wide subscription disposer. */
@@ -17904,6 +19943,58 @@ var AgentMonitorService = class _AgentMonitorService {
   getAllSessions() {
     return Array.from(this._sessions.values());
   }
+  /**
+   * Rebuild the virtual sessions from the on-disk transcripts.
+   *
+   * The ring only holds what THIS process observed, so after a resume it is
+   * empty and `getAllSessions()` reports no subagents even though every
+   * transcript is sitting in `transcriptsDir`. This reads them back so a
+   * resumed surface can show the prior run's subagent work.
+   *
+   * Entries already in the ring win: a live subagent's in-memory segment is
+   * newer than its JSONL, which is only written when a segment closes.
+   */
+  async loadSessionsFromDisk() {
+    let subagentIds;
+    try {
+      const dirents = await fs4.readdir(this._transcriptsDir, { withFileTypes: true });
+      subagentIds = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+    } catch {
+      return this.getAllSessions();
+    }
+    for (const subagentId of subagentIds) {
+      if (this._sessions.has(subagentId)) continue;
+      const transcript = await this._readTranscriptFile(subagentId);
+      if (transcript.length === 0) continue;
+      const first = expectDefined(transcript[0]);
+      const last = expectDefined(transcript[transcript.length - 1]);
+      this._sessions.set(subagentId, {
+        subagentId,
+        agentName: last.agentName || first.agentName || subagentId,
+        createdAt: first.ts,
+        // The run is over as far as this process is concerned; nothing on disk
+        // says whether it finished or was killed mid-flight.
+        status: "restored",
+        transcript: transcript.slice(-this._maxEntries)
+      });
+    }
+    return this.getAllSessions();
+  }
+  async _readTranscriptFile(subagentId) {
+    const file = path18.join(this._transcriptsDir, subagentId, "transcript.jsonl");
+    const raw = await fs4.readFile(file, "utf8").catch(() => null);
+    if (raw === null) return [];
+    const out = [];
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) continue;
+      try {
+        out.push(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+    return out;
+  }
   /** Get a specific agent's virtual session, or undefined. */
   getSession(subagentId) {
     return this._sessions.get(subagentId);
@@ -17931,6 +20022,21 @@ var AgentMonitorService = class _AgentMonitorService {
       this._routeEvent(event.subagentId, event.type, event.payload);
     });
   }
+  /**
+   * Stop listening and wait for every queued transcript write to reach disk.
+   *
+   * `stop()` alone only *starts* the flush of the open segments; the appends are
+   * fire-and-forget, so a caller that exits right after it loses precisely the
+   * text that was streaming. Shutdown paths should await this instead.
+   *
+   * A hard kill (SIGKILL, power loss) still loses the open segments — they live
+   * only in the ring until a segment closes. Bounding that would mean writing
+   * each delta, which fragments every reply into single-word JSONL lines.
+   */
+  async close() {
+    this.stop();
+    await this._writeChain;
+  }
   /** Stop listening and clean up all subscriptions. */
   stop() {
     if (!this._started) return;
@@ -18125,8 +20231,7 @@ var AgentMonitorService = class _AgentMonitorService {
     const open6 = this._openStreams.get(subagentId);
     if (!open6) return;
     this._openStreams.delete(subagentId);
-    this._appendToFile(subagentId, open6.entry).catch(() => {
-    });
+    this._enqueueWrite(subagentId, open6.entry);
     this._emitEntry(open6.entry);
   }
   _addEntry(subagentId, entry) {
@@ -18137,8 +20242,7 @@ var AgentMonitorService = class _AgentMonitorService {
     if (session.transcript.length > this._maxEntries) {
       session.transcript.splice(0, session.transcript.length - this._maxEntries);
     }
-    this._appendToFile(subagentId, entry).catch(() => {
-    });
+    this._enqueueWrite(subagentId, entry);
     this._emitEntry(entry);
   }
   /** Announce a transcript entry on the local bus + HQ callback. */
@@ -18152,10 +20256,23 @@ var AgentMonitorService = class _AgentMonitorService {
       iteration: entry.iteration,
       ts: entry.ts,
       toolName: entry.toolName,
+      toolOk: entry.toolOk,
       costUsd: entry.costUsd
     });
     this._onEntry?.(entry);
   }
+  /**
+   * Queue a transcript append. Serialized so two entries for the same subagent
+   * cannot interleave into a torn line, and retained on `_writeChain` so
+   * `close()` can wait for them. Never rejects — a transcript write failing must
+   * not take down the agent it is watching.
+   */
+  _enqueueWrite(subagentId, entry) {
+    this._writeChain = this._writeChain.then(
+      () => this._appendToFile(subagentId, entry).catch(() => {
+      })
+    );
+  }
   async _appendToFile(subagentId, entry) {
     const dir = path18.join(this._transcriptsDir, subagentId);
     await fs4.mkdir(dir, { recursive: true });
@@ -20196,7 +22313,7 @@ var AutonomousCoordinator = class _AutonomousCoordinator {
           }
           if (this.dag.hasDeadlock()) {
             const blocked = this.dag.getBlocked();
-            (this.events?.emit)("autonomous:deadlock", { blocked });
+            this._busEmit("autonomous:deadlock", { blocked });
             this._emit({ type: "deadlock:detected", goalId: blocked[0]?.id ?? "", text: `Deadlock detected: ${blocked.map((n) => n.id).join(", ")}` });
           }
           break;
@@ -20217,14 +22334,14 @@ var AutonomousCoordinator = class _AutonomousCoordinator {
         if (decision.type === "deny") {
           const blocked = this.dag.getBlocked();
           if (blocked.length > 0 && this.dag.hasDeadlock()) {
-            (this.events?.emit)("autonomous:deadlock", { blocked });
+            this._busEmit("autonomous:deadlock", { blocked });
             this._emit({ type: "deadlock:detected", goalId: blocked[0]?.id ?? "", text: `Deadlock detected: ${blocked.map((n) => n.id).join(", ")}` });
             this.running = false;
           }
           break;
         }
         if (decision.type === "ask_human") {
-          (this.events?.emit)("autonomous:ask_human", { prompt: decision.prompt });
+          this._busEmit("autonomous:ask_human", { prompt: decision.prompt });
           break;
         }
         if (decision.optionId) {
@@ -20628,15 +22745,20 @@ ${input.detail}`
       }
     }
   }
+  /** Emit on the optional shared bus; no-op when no bus was wired. */
+  _busEmit(type, payload) {
+    if (!this.events) return;
+    this.events.emit(type, payload);
+  }
   _onDagEvent(event) {
     if (event.type === "node:ready") {
       const node = this.dag.getNode(event.nodeId);
       if (node) {
-        (this.events?.emit)("autonomous:task_ready", { taskId: event.nodeId, description: node.description });
+        this._busEmit("autonomous:task_ready", { taskId: event.nodeId, description: node.description });
       }
     }
     if (event.type === "graph:done") {
-      (this.events?.emit)("autonomous:all_done", this.getStats());
+      this._busEmit("autonomous:all_done", this.getStats());
     }
   }
   _onSubagentTerminated(e) {
@@ -20708,7 +22830,6 @@ export {
   ACP_AGENTS,
   AGENTS_BY_PHASE,
   AGENT_CATALOG,
-  TOOLS as AGENT_TOOL_PRESETS,
   ALL_AGENT_DEFINITIONS,
   ALL_FLEET_AGENTS,
   AUDIT_LOG_AGENT,
@@ -20768,17 +22889,23 @@ export {
   MAILBOX_HEALTH_DEFAULT_FROM,
   MAILBOX_HEALTH_DEFAULT_INTERVAL_MS,
   MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS,
+  MAILBOX_HTTP_MAX_BODY_BYTES,
+  MAILBOX_HTTP_RATE_LIMIT_PER_MINUTE,
+  MAILBOX_HTTP_RATE_LIMIT_WINDOW_MS,
   MATRIX_PHASE_KEYS,
   MAX_SUBAGENT_STRUCTURED_REPORT_CHARS,
   MEDIUM_BUDGET,
   META_AGENTS,
   MailboxHealthWatchdog,
+  MailboxHttpRateLimiter,
   NULL_FLEET_BUS,
   ObservableBrainArbiter,
   PLANNING_AGENTS,
+  ProviderModelStatusTracker,
   REFACTOR_PLANNER_AGENT,
   REVIEW_AGENTS,
   SECURITY_SCANNER_AGENT,
+  SESSION_RECIPIENT_PREFIX,
   SUBAGENT_STRUCTURED_REPORT_META_KEY,
   SubagentBudget,
   TIMEOUT_PREEMPT_FRACTION,
@@ -20791,6 +22918,7 @@ export {
   applyRosterBudget,
   attachAutoExtend,
   attachDepWatcherBridge,
+  authorizeMailboxBearerToken,
   brainDecisionKey,
   buildDownAlert,
   buildRecoveryAlert,
@@ -20800,6 +22928,7 @@ export {
   createDelegateTool,
   createLedgerGuardBrainArbiter,
   createMailboxHooks,
+  createMailboxHttpRouter,
   createMessage,
   detectEcosystem,
   dispatchAgent,
@@ -20822,11 +22951,8 @@ export {
   makeDependencyWatcherConfig,
   makeDirectorSessionFactory,
   makeFleetEmitTool,
-  makeFleetTool as makeFleetHealthTool,
-  makeFleetTool as makeFleetSessionTool,
   makeFleetStatusTool,
   makeFleetTool,
-  makeFleetTool as makeFleetUsageTool,
   makeKanbanQueueTool,
   makeLLMClassifier,
   makeMailInboxTool,
@@ -20860,6 +22986,7 @@ export {
   rosterSummaryFromConfigs,
   sameModelReference,
   scoreAgents,
+  sessionRecipient,
   startPackageOutdatedWatcher,
   subagentNeedsWorktree,
   terminalPolicyDecision,