@@ -6,6 +6,7 @@ import {
   tierGateRequiresTools,
   type AgentFleetDeps,
 } from "./agent-fleet.js";
+import { formatCapabilityUnavailable } from "./capability-preflight.js";
 import { unlimitedAdmissionQueue } from "./admission.js";
 import { createPermissionGate } from "../permission/gate.js";
 import { NOOP_TELEMETRY, type TelemetryEvent } from "../telemetry/index.js";
@@ -157,7 +158,7 @@ describe("spawn_agent requires_tools preflight", () => {
     };
     const session = deps.sessions.get(body.agent_id);
     expect(session?.requiresTools).toEqual(["read_file"]);
-    expect(typeof session?.snapshotRevision).toBe("number");
+    expect("snapshotRevision" in (session ?? {})).toBe(false);
     expect(seenRequires).toEqual(["read_file"]);
     expect(telemetry).toContain("subagent_start");
   });
@@ -196,7 +197,7 @@ describe("spawn_agent requires_tools preflight", () => {
     const body = JSON.parse(result.content) as { agent_id: string };
     const session = deps.sessions.get(body.agent_id);
     expect(session?.requiresTools).toBeUndefined();
-    expect(session?.snapshotRevision).toBeUndefined();
+    expect("snapshotRevision" in (session ?? {})).toBe(false);
   });
 
   test("manage_tasks survives dispatch under a narrow allowlist and stamps canonically", async () => {
@@ -268,6 +269,62 @@ describe("spawn_agent requires_tools preflight", () => {
     expect(deps.sessions.list()).toEqual([]);
     expect(telemetry).toEqual([]);
   });
+
+  test("leaf requires_tools=[submit_result] passes preflight under a narrow allowlist (leaf reporting channel)", async () => {
+    const telemetry: TelemetryEvent[] = [];
+    let runCalled = false;
+    let seenRequires: readonly string[] | undefined;
+    let seenTier: unknown;
+    const deps = makeDeps(async (params) => {
+      runCalled = true;
+      seenRequires = params.requiresTools;
+      seenTier = params.tier;
+      return { report: "done" };
+    }, telemetry);
+    const spawn = createSpawnAgentTool(deps);
+
+    const result = await callSpawn(spawn, {
+      description: "leaf report job",
+      prompt: "read a file and report",
+      agent: "read-only-worker",
+      requires_tools: ["submit_result"],
+    });
+
+    expect(result.isError).not.toBe(true);
+    expect(runCalled).toBe(true);
+    const body = JSON.parse(result.content) as { agent_id: string };
+    expect(deps.sessions.get(body.agent_id)?.requiresTools).toEqual([
+      "submit_result",
+    ]);
+    expect(seenRequires).toEqual(["submit_result"]);
+    expect(seenTier).toBe("leaf");
+  });
+
+  test("whitespace-only requires_tools rejects fail-closed with no session, telemetry, or run", async () => {
+    for (const requiresTools of [["   "], ["read_file", "  "]]) {
+      const telemetry: TelemetryEvent[] = [];
+      let runCalled = false;
+      const deps = makeDeps(async () => {
+        runCalled = true;
+        return { report: "done" };
+      }, telemetry);
+      const spawn = createSpawnAgentTool(deps);
+
+      const result = await callSpawn(spawn, {
+        description: "blank job",
+        prompt: "do it",
+        agent: "read-only-worker",
+        requires_tools: requiresTools,
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content.startsWith("Error:")).toBe(true);
+      expect(result.content).toContain("non-empty tool names");
+      expect(runCalled).toBe(false);
+      expect(deps.sessions.list()).toEqual([]);
+      expect(telemetry).toEqual([]);
+    }
+  });
 });
 
 describe("tierGateRequiresTools", () => {
@@ -305,6 +362,24 @@ describe("tierGateRequiresTools", () => {
     }
   });
 
+  test("tier-gated leaf channel names Tier 3 leaves instead of claiming no director mounts it", () => {
+    const gated = tierGateRequiresTools(["submit_result"], "orchestrator");
+    expect(gated?.alternatives ?? []).toEqual([
+      "bruckheimer",
+      "builder",
+      "counsel",
+    ]);
+    const message = formatCapabilityUnavailable(
+      gated ?? { code: "missing_tool", tool: "submit_result" },
+      "test-orchestrator",
+    );
+    expect(message).toContain("Tier 3 leaf workers only");
+    expect(message).toContain(
+      "Re-dispatch to one of (bruckheimer, builder, counsel)",
+    );
+    expect(message).not.toContain("No spawnable director mounts");
+  });
+
   test("leaf requiring the leaf reporting channel passes", () => {
     expect(
       tierGateRequiresTools(["submit_result", "ask_director"], "leaf"),
 
@@ -67,10 +67,10 @@ import {
   type ReasoningEffort,
 } from "../provider/reasoning-effort.js";
 import type { AgentProfile, CapabilityFilter } from "../agent/profiles.js";
-import { currentProfileSnapshotRevision } from "../agent/profiles.js";
 import {
   DEFAULT_KNOWN_ENGINES,
   formatCapabilityUnavailable,
+  leafTierAlternatives,
   preflightCapabilities,
   rerouteAlternatives,
   type CapabilityUnavailable,
@@ -746,6 +746,7 @@ export function tierGateRequiresTools(
       return {
         code: "missing_tool",
         tool: engine,
+        alternatives: leafTierAlternatives(),
         detail: `"${engine}" mounts on Tier 3 leaf workers only, never on ${tier} directors`,
       };
     }
@@ -1035,9 +1036,6 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
       const doNot =
         rawDoNot?.map((d) => d.trim()).filter((d) => d.length > 0) ?? [];
       const reportFocus = rawReportFocus?.trim();
-      const requiresToolsRaw =
-        rawRequiresTools?.map((t) => t.trim()).filter((t) => t.length > 0) ??
-        [];
 
       let provider: SubAgentProvider = resolveDep(deps.provider);
       const parentEffort = provider.reasoningEffort;
@@ -1126,8 +1124,23 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
 
       // CL-9476: fail closed before any session, telemetry, or worktree exists.
       // A rejection returns here — no auto re-dispatch, no successor, no retry.
+      // The tier below is the single derivation shared by the tier gate and
+      // the run mount: run.ts mounts the leaf reporting channel exactly when
+      // tier is "leaf", so gating on any other value would let a requirement
+      // pass here and die as a stale snapshot at mount (or vice versa).
+      const dispatchTier: SubagentTier = resolved.orchestrator
+        ? (resolved.orchestratorTier ?? resolved.pkg?.tier ?? "orchestrator")
+        : "leaf";
       let requiresTools: readonly string[] | undefined;
-      let snapshotRevision: number | undefined;
+      const rawEntries = rawRequiresTools ?? [];
+      const blankEntry = rawEntries.find((t) => t.trim().length === 0);
+      if (blankEntry !== undefined) {
+        return fleetResult(
+          call.id,
+          `Error: spawn_agent requires_tools entries must be non-empty tool names — got a blank entry. Correct requires_tools to canonical tool names and re-dispatch.`,
+        );
+      }
+      const requiresToolsRaw = rawEntries.map((t) => t.trim());
       if (requiresToolsRaw.length > 0) {
         const preflight = preflightCapabilities({
           required: requiresToolsRaw,
@@ -1150,17 +1163,13 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
         // Tier-gated mounts (fleet verbs, the Tier 3 leaf reporting channel)
         // reject here as missing_tool when the dispatch tier can never mount
         // them — pre-spawn, never surviving to the mount-time stale echo.
-        const dispatchTier: SubagentTier = resolved.orchestrator
-          ? (resolved.orchestratorTier ?? resolved.pkg?.tier ?? "orchestrator")
-          : "leaf";
         const gated = tierGateRequiresTools(preflight.canonical, dispatchTier);
         if (gated !== undefined) {
           return fleetResult(
             call.id,
             formatCapabilityUnavailable(gated, resolved.agentLabel),
           );
         }
-        snapshotRevision = currentProfileSnapshotRevision();
       }
 
       const orchestrator = resolved.orchestrator;
@@ -1208,7 +1217,6 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
         retained: true,
         provider: provider.providerName,
         ...(requiresTools !== undefined ? { requiresTools } : {}),
-        ...(snapshotRevision !== undefined ? { snapshotRevision } : {}),
         ...(deps.parentSessionId !== undefined
           ? { parentSessionId: deps.parentSessionId }
           : {}),
@@ -1540,11 +1548,14 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
             ...(deps.deadlineMs !== undefined
               ? { deadlineMs: deps.deadlineMs }
               : {}),
-            ...(resolved.pkg !== undefined
-              ? { tier: resolved.pkg.tier }
-              : orchestrator
-                ? {}
-                : { tier: "leaf" }),
+            // Single tier derivation (dispatchTier above): the tier gate and
+            // the mount agree by construction, so a gated requirement can
+            // never die as a stale snapshot at mount, or vice versa. An
+            // orchestrator dispatch without a resolved package carries no
+            // tier — run.ts fails closed on fleet mounts from there.
+            ...(resolved.pkg !== undefined || !orchestrator
+              ? { tier: dispatchTier }
+              : {}),
             ...(resolved.pkg?.reportContract?.outputType !== undefined
               ? { reportType: resolved.pkg.reportContract.outputType }
               : {}),
 
@@ -4,6 +4,7 @@ import {
   checkMountedRequiresTools,
   DEFAULT_KNOWN_ENGINES,
   formatCapabilityUnavailable,
+  leafTierAlternatives,
   preflightCapabilities,
   rerouteAlternatives,
   type CapabilityUnavailable,
@@ -101,6 +102,29 @@ describe("preflightCapabilities", () => {
     );
     expect(rerouteAlternatives("run_shell").length).toBeGreaterThan(0);
   });
+
+  test("reroute alternatives sort before the cap of 3 (read_file has 19 mounting directors)", () => {
+    const alternatives = rerouteAlternatives("read_file");
+    expect(alternatives).toEqual(["bruckheimer", "builder", "counsel"]);
+    expect(alternatives).toEqual([...alternatives].sort());
+  });
+
+  test("leaf reporting channel passes preflight under a narrow allowlist omitting post-filter mounts", () => {
+    for (const engine of ["submit_result", "ask_director"]) {
+      expect(preflight([engine], ALLOW_READ_ONLY)).toEqual({
+        ok: true,
+        canonical: [engine],
+      });
+    }
+  });
+
+  test("leafTierAlternatives names sorted Tier 3 leaf directors, never skywalker", () => {
+    const alternatives = leafTierAlternatives();
+    expect(alternatives.length).toBeGreaterThan(0);
+    expect(alternatives.length).toBeLessThanOrEqual(3);
+    expect(alternatives).toEqual([...alternatives].sort());
+    expect(alternatives).not.toContain("skywalker");
+  });
 });
 
 describe("formatCapabilityUnavailable", () => {
@@ -213,6 +237,20 @@ describe("formatCapabilityUnavailable", () => {
     );
     expect(message).toContain('Did you mean "run_shell"?');
   });
+
+  test("stale_snapshot message names every missing tool, not just the first", () => {
+    const message = formatCapabilityUnavailable(
+      {
+        code: "stale_snapshot",
+        tool: "run_shell",
+        tools: ["run_shell", "write_file"],
+      },
+      "test-worker",
+    );
+    expect(message).toContain("stale_snapshot");
+    expect(message).toContain("run_shell");
+    expect(message).toContain("write_file");
+  });
 });
 
 describe("checkMountedRequiresTools", () => {
 
@@ -52,6 +52,8 @@ export interface CapabilityUnavailable {
   code: CapabilityUnavailableCode;
   /** Canonical tool id (or the raw entry for unknown). */
   tool: string;
+  /** Every missing tool, for the multi-missing stale_snapshot echo. */
+  tools?: readonly string[];
   /** Nearest known name, for the unknown_tool typo guard. */
   suggestion?: string;
   /** Spawnable directors that mount the tool, for reroute hints. */
@@ -114,13 +116,21 @@ export const DEFAULT_KNOWN_ENGINES: readonly string[] =
 
 /**
  * Engines mounted outside the capability filter (run.ts appends manage_tasks
- * after filtering), so a requires_tools entry for them passes preflight even
- * when the dispatch filter is a narrow allowlist. The update_plan alias
- * canonicalizes here, so it rides the same exemption — and the mount-time
- * echo in run.ts runs after ALL appends, so the stamped entry always matches
- * the live mount.
+ * after filtering, and mounts the Tier 3 leaf reporting channel
+ * submit_result/ask_director whenever tier is "leaf"), so a requires_tools
+ * entry for them passes preflight even when the dispatch filter is a narrow
+ * allowlist. The update_plan alias canonicalizes here, so it rides the same
+ * exemption — and the mount-time echo in run.ts runs after ALL appends, so
+ * the stamped entry always matches the live mount. Fail-closed: the tier gate
+ * in agent-fleet.ts still rejects submit_result/ask_director on non-leaf
+ * tiers after this exemption, so the bypass never mounts them where run.ts
+ * would not.
  */
-const POST_FILTER_MOUNTED_ENGINES: readonly string[] = ["manage_tasks"];
+const POST_FILTER_MOUNTED_ENGINES: readonly string[] = [
+  "manage_tasks",
+  "submit_result",
+  "ask_director",
+];
 
 /** Alias spellings accepted in requires_tools, for typo suggestions. */
 const SUGGESTION_CANDIDATES: readonly string[] = [
@@ -169,7 +179,9 @@ function nearestToolName(raw: string): string | undefined {
 /**
  * Spawnable directors (closed set minus primary skywalker) whose mounted
  * tool set includes `canonical` — derived from packageToCapabilities over
- * DIRECTOR_REGISTRY, so the hint tracks the envelopes. Capped for messages.
+ * DIRECTOR_REGISTRY, so the hint tracks the envelopes. Sorted before the cap
+ * so the three named are the first alphabetically, not the first in registry
+ * insertion order.
  */
 export function rerouteAlternatives(canonical: string): readonly string[] {
   const want = canonicalToolName(canonical);
@@ -186,9 +198,23 @@ export function rerouteAlternatives(canonical: string): readonly string[] {
     } else if (!capabilities.tools.some((t) => canonicalToolName(t) === want)) {
       out.push(pkg.id);
     }
-    if (out.length >= 3) break;
   }
-  return out.sort();
+  return out.sort().slice(0, 3);
+}
+
+/**
+ * Tier-3 leaf directors (closed set, skywalker excluded) for the tier-gate
+ * hint when requires_tools names the leaf reporting channel on a non-leaf
+ * tier. submit_result/ask_director mount post-filter, so no envelope mentions
+ * them and rerouteAlternatives would report none — this names the directors
+ * that actually mount them instead of the allowlist-miss fallback.
+ */
+export function leafTierAlternatives(): readonly string[] {
+  return Object.values(DIRECTOR_REGISTRY)
+    .filter((pkg) => pkg.id !== "skywalker" && pkg.tier === "leaf")
+    .map((pkg) => pkg.id)
+    .sort()
+    .slice(0, 3);
 }
 
 export function preflightCapabilities(
@@ -313,11 +339,13 @@ export function formatCapabilityUnavailable(
         `Error: worker "${agentLabel}" requires tool "${unavailable.tool}" but this dispatch cannot verify its runtime engine (not in the dispatch's known-engine set). ` +
         `Re-dispatch without requires_tools=["${unavailable.tool}"] or drop the requirement.`
       );
-    case "stale_snapshot":
+    case "stale_snapshot": {
+      const missing = unavailable.tools ?? [unavailable.tool];
       return (
-        `Error: stale_snapshot setup_error (non-continuable) — worker "${agentLabel}" was dispatched requiring "${unavailable.tool}" but the live mount no longer provides it. ` +
+        `Error: stale_snapshot setup_error (non-continuable) — worker "${agentLabel}" was dispatched requiring "${missing.join('", "')}" but the live mount no longer provides ${missing.length === 1 ? "it" : "them"}. ` +
         `Re-dispatch the worker deliberately with a fresh brief instead of retrying in place.`
       );
+    }
     case "unknown_tool": {
       const hint =
         unavailable.suggestion !== undefined
 
@@ -90,6 +90,28 @@ describe("runSubAgent requires_tools mount echo", () => {
     expect(message).not.toContain('continuable": true');
   }, 15_000);
 
+  test("two stamped tools dropped by the filter are both named in the stale_snapshot error", async () => {
+    const cwd = await tmpCwd();
+    const error = await withFailingInference(async (baseURL) => {
+      try {
+        await runSubAgent({
+          ...baseParams(cwd, baseURL),
+          capabilities: { mode: "allow", tools: ["read_file"] },
+          requiresTools: ["run_shell", "write_file"],
+        });
+      } catch (err) {
+        return err;
+      }
+      throw new Error("runSubAgent did not throw");
+    });
+
+    expect(error).toBeInstanceOf(Error);
+    const message = (error as Error).message;
+    expect(message).toContain("stale_snapshot");
+    expect(message).toContain("run_shell");
+    expect(message).toContain("write_file");
+  }, 15_000);
+
   test("stamped tool present in the mount passes through to inference", async () => {
     const cwd = await tmpCwd();
     const error = await withFailingInference(async (baseURL) => {