@@ -82,7 +82,7 @@ In TUI chat mode there is no completion gate — the session stays open across t
 - Wires `ask_operator` to an operator-gate event resolved by a modal
 - Mounts the OpenTUI host via `mountRunnerHost` (`src/tui/runner/host.ts`), which mounts `mountProductHost` (`src/tui/product-host.ts`) over the shell (`src/tui/shell/`)
 - Bridges reactor events to the OpenTUI host via a plain `EventEmitter`
-- **Mid-run injection** — Shell `session-queue` items drain at the parent
+- **Mid-run injection** — Shell `delivery-queue` items drain at the parent
   `tool.boundary` through `SessionPort.deliver`. Production `routeQueuedDelivery`
   live-injects in-flight parent-boundary steers via `agentProxy.deliver`
   (`Agent.deliver`) into one captured agent identity — never re-reading
@@ -220,7 +220,7 @@ The **`spawn_agent`** tool starts a fleet agent on a separate inference source (
 
 Workers ask the spawning parent with **`ask_director`** (not the human). That parks a question while the worker stays `running`. On the TUI primary that arrives as an idle-send wake. On a nested orchestrator the question arrives as mailbox mail with an `awaiting_director` status — that is not terminal. Once a parked ask is surfaced (TUI wake, nested mailbox mail, or a successful `list_agents`), further `list_agents` calls fail closed until **`send_input`** answers or the ask is dropped — `list_agents` is not a poll. The parent answers with **`send_input`**, then continues. Escalate to the human with **`ask_operator`** only when the parent cannot resolve it.
 
-When the parent TUI is not blocked in an in-flight tool call, the runner publishes an authoritative snapshot of currently pending top-level questions on each store notification, including empty snapshots before fleet-count updates. During synchronous session rotation, a runner-owned barrier suppresses both publications before delivery-generation invalidation, transcript clearing, and worker cancellation; successful reset reconciles a fresh snapshot before resuming asynchronous backend rebuild. The bridge drops resolved, cancelled, replaced, terminal, and removed asks and delivers each session/question identity once while pending. A coalesced wake starts only when the parent is not processing and every operator gate is closed, including parent-idle fleet holds where the shell stays busy. Worker gates do not manufacture parent processing. Replies use `send_input`'s `target` field with the worker session ID, never its shared catalog ID. Synthetic wakes use `SessionPort.deliver` through queued-delivery's idle-send path without entering the user follow-up queue or composer `/feedback` capture.
+When the parent TUI is not blocked in an in-flight tool call, the runner publishes an authoritative snapshot of currently pending top-level questions on each store notification, including empty snapshots before fleet-count updates. During synchronous session rotation, a runner-owned barrier suppresses both publications before delivery-generation invalidation, transcript clearing, and worker cancellation; successful reset reconciles a fresh snapshot before resuming asynchronous backend rebuild. The bridge drops resolved, cancelled, replaced, terminal, and removed asks and delivers each session/question identity once while pending. A coalesced wake starts only when the parent is not processing and every operator gate is closed, including parent-idle fleet holds where the shell stays busy. Worker gates do not manufacture parent processing. Replies use `send_input`'s `target` field with the worker session ID, never its shared catalog ID. Synthetic wakes use `SessionPort.deliver` through delivery-queue's idle-send path without entering the user follow-up queue or composer `/feedback` capture.
 
 When profiles exist (local `.agents/agents/` and/or enabled **`kind: "agent"`** plugins, including **data-only** markdown plugins with no `index.ts`), the chat model also receives **`search_agents`** — a lexical index over profile id, description, and role text so the model can discover ids before calling `spawn_agent(agent=...)`. Default results are id, description, and spawn metadata (orchestrator flag, source). Pass `include_body=true` to include each match's loaded system prompt / body (truncated) so the parent can inspect plugin or Claude marketplace agents without `read_file` on paths outside the session cwd (path-escape blocks those roots by design; writes remain blocked). `spawn_agent` and `search_agents` are core tools on the primary session.
 
 
@@ -463,7 +463,7 @@ the directors guard on; the full set of reactor and stream event types is
 treat that as canonical rather than this section or any other doc's partial
 list.
 
-Mid-run queue/steer/interrupt state is a pure state machine in `src/tui/session-queue.ts` (interaction contract §3): `enqueue` (kind `"queue"`) and `enqueueSteer` (kind `"steer"`) share one pending pool, drained steer-first, then queue, both FIFO within their class. Mid-run gestures: Enter soft-steers (drain at the next **parent** `tool.boundary` — the parent tool finishing, not a child; parent-busy holds steers), Alt+Enter queues a follow-up (drain on **session-idle**: parent-idle and no live fleet lanes), Ctrl+C stops. Idle-with-fleet is shipped: with live fleet lanes the bridge holds the run busy after the parent turn settles (`fleet` events carry the live count), mid-hold Enter upgrades to an immediate new turn, and the last lane terminalizing releases the hold and drains follow-ups.
+Mid-run queue/steer/interrupt state is a pure state machine in `src/tui/delivery-queue.ts` (interaction contract §3): `enqueue` (kind `"queue"`) and `enqueueSteer` (kind `"steer"`) share one pending pool, drained steer-first, then queue, both FIFO within their class. Mid-run gestures: Enter soft-steers (drain at the next **parent** `tool.boundary` — the parent tool finishing, not a child; parent-busy holds steers), Alt+Enter queues a follow-up (drain on **session-idle**: parent-idle and no live fleet lanes), Ctrl+C stops. Idle-with-fleet is shipped: with live fleet lanes the bridge holds the run busy after the parent turn settles (`fleet` events carry the live count), mid-hold Enter upgrades to an immediate new turn, and the last lane terminalizing releases the hold and drains follow-ups.
 
 ### Lifecycle Hooks
 
 
@@ -34,7 +34,7 @@ row at a time down to its 3-row base — never the transcript
 (`COLLAPSE_ORDER` in `zones.ts`).
 
 Horizontally, every surface sits inside one shared gutter
-(`resolveSideMargin`, `src/tui/geometry/margins.ts`) so the shell reads
+(`resolveSideMargin`, `src/tui/geometry/zones.ts`) so the shell reads
 as a single column of content rather than stacked panes.
 `resolveGeometry` always returns `layoutMode: "stack"` — full-width
 y-stack, no dual-column rail. Live workers paint in the agents strip
@@ -711,7 +711,7 @@ thing they were trying to deliver. It now reports `interrupt — N pending
 kept`: the run stops, the queue survives, and those messages are handed over
 at the interrupt itself (`doInterrupt` drains after `port.interrupt()`), not
 left waiting on an idle event the stop may never produce (`interrupt` in
-`session-queue.ts` no longer clears `items`).
+`delivery-queue.ts` no longer clears `items`).
 
 **Fleet agent lanes on redirect.** Soft steer (Enter mid-run) and follow-up
 (queued drain) leave running workers alone — they never call
 
@@ -3,12 +3,13 @@ import type { AgentTool } from "@intx/agent";
 import type { ToolDefinition } from "@intx/types/runtime";
 import { type } from "arktype";
 import { scrubSecretShapedContent } from "../plugins/tool-result-secret-scrub.js";
+import {
+  lexicalFields,
+  scoreLexical,
+  tokenizeLexical,
+} from "./lexical-rank.js";
 import type { AgentProfile } from "./profiles.js";
 
-function tokenize(text: string): string[] {
-  return text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
-}
-
 function profileSearchText(profile: AgentProfile): string {
   const parts = [
     profile.id,
@@ -30,27 +31,18 @@ export function createAgentIndex(
     profile: AgentProfile,
     queryTokens: string[],
     rawQuery: string,
-  ): number => {
-    const idTokens = tokenize(profile.id);
-    const blob = profileSearchText(profile).toLowerCase();
-    const blobTokens = new Set(tokenize(blob));
-    let total = 0;
-    for (const token of queryTokens) {
-      if (idTokens.includes(token)) total += 3;
-      else if (blobTokens.has(token)) total += 1;
-      else if (profile.id.toLowerCase().includes(token)) total += 0.75;
-      else if (blob.includes(token)) total += 0.25;
-    }
-    if (profile.id.toLowerCase().includes(rawQuery)) total += 1;
-    if ((profile.description ?? "").toLowerCase().includes(rawQuery))
-      total += 0.5;
-    return total;
-  };
+  ): number =>
+    scoreLexical(
+      lexicalFields(profile.id, profileSearchText(profile)),
+      queryTokens,
+      rawQuery,
+    ) +
+    ((profile.description ?? "").toLowerCase().includes(rawQuery) ? 0.5 : 0);
 
   return {
     search(query: string, limit = 12): AgentProfile[] {
       const rawQuery = query.toLowerCase().trim();
-      const queryTokens = tokenize(query);
+      const queryTokens = tokenizeLexical(query);
       const profiles = getProfiles();
       if (queryTokens.length === 0) return profiles.slice(0, limit);
       return profiles