From 34ed827de2d1d2b7f15f8fd93aa213da0e8ece9a Mon Sep 17 00:00:00 2001
From: Copilot <223556219+Copilot@users.noreply.github.com>
Date: Tue, 1 Sep 2026 10:52:04 +0300
Subject: [PATCH] fix(coordinator): restore mandatory dispatch contract

Closes #1231

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../restore-coordinator-dispatch-contract.md  |  6 ++
 .github/agents/squad.agent.md                 | 25 +++++--
 .squad-templates/routing.md                   |  2 +-
 .squad-templates/squad.agent.md               | 25 +++++--
 packages/squad-cli/templates/routing.md       |  2 +-
 .../templates/squad.agent.md.template         | 25 +++++--
 packages/squad-sdk/templates/routing.md       |  2 +-
 .../templates/squad.agent.md.template         | 25 +++++--
 templates/routing.md                          |  2 +-
 templates/squad.agent.md.template             | 25 +++++--
 test/coordinator-inline-dispatch-gate.test.ts | 70 ++++++++++++++++---
 11 files changed, 159 insertions(+), 50 deletions(-)
 create mode 100644 .changeset/restore-coordinator-dispatch-contract.md

diff --git a/.changeset/restore-coordinator-dispatch-contract.md b/.changeset/restore-coordinator-dispatch-contract.md
new file mode 100644
index 000000000..64edba66f
--- /dev/null
+++ b/.changeset/restore-coordinator-dispatch-contract.md
@@ -0,0 +1,6 @@
+---
+"@bradygaster/squad-cli": patch
+"@bradygaster/squad-sdk": patch
+---
+
+Restore the coordinator's mandatory dispatch contract and start Scribe on the first Team Mode turn so domain work cannot silently fall back to inline execution.
diff --git a/.github/agents/squad.agent.md b/.github/agents/squad.agent.md
index 38e1f9adb..41af10e49 100644
--- a/.github/agents/squad.agent.md
+++ b/.github/agents/squad.agent.md
@@ -72,17 +72,19 @@ Pending cast sync. Run `squad upgrade` after cast changes. Generated values are
 
 **⚠️ CRITICAL RULE: You are a DISPATCHER, not a DOER. Every task that needs domain expertise MUST be dispatched to a specialist agent — never performed inline.**
 
+**Mandatory dispatch contract:** Direct Mode is limited to brief roster/status/routing facts already present in context, brief reference answers already present in context, and clarifying questions. Any code, test, investigation, analysis, design, documentation, configuration, review, or artifact creation is domain work and MUST be dispatched. Small scope is not an exemption; use Lightweight Mode to dispatch one agent.
+
 **DISPATCH MECHANISM (detect once per session, then use consistently):**
 - **Copilot App:** `create_session` tool → sub-sessions for commit-producing work (preferred when available)
 - **CLI:** `task` tool → use it with agent_type, mode, model, name, description, prompt
 - **VS Code:** `runSubagent` tool → use it with the full agent prompt
-- **Neither available:** work inline (fallback only — LAST RESORT)
+- **None available:** refuse domain work and tell the user that this client has no agent-dispatch tool. Never fall back to doing domain work inline.
 
 **Platform detection probe (run once at session start):**
 1. Check: is `create_session` tool available? → **App mode** (sub-sessions)
 2. Else: is `runSubagent` available? → **VS Code mode**
 3. Else: is `task` tool available? → **CLI mode**
-4. Else: none available → **work inline** (last resort fallback)
+4. Else: none available → **refuse domain work**; do not work inline
 5. Cache the result — use the same mechanism for all spawns in this session.
 
 **Sub-session rules (App mode only):**
@@ -112,6 +114,15 @@ The `squad_state_*` and `memory.*` tools that own persistence are exposed via th
 
 This handshake runs **once per session**, not per spawn. Cache the result.
 
+### Session Init — Scribe Bootstrap
+
+On the first Team Mode turn, after resolving `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, and requester, spawn Scribe once in the same tool-calling response as the user acknowledgment. This bootstrap is mandatory even when the first request is Direct Mode; it must not depend on another agent having run.
+
+- **CLI or App:** use `task` with `name: "scribe"`, `agent_type: "general-purpose"`, and `mode: "background"`.
+- **VS Code:** use `runSubagent` with the full Scribe prompt.
+- Tell Scribe to read `.squad/agents/scribe/charter.md`, include the resolved session values, initialize the session record, process any pending decision inbox entries, remain silent, and follow the state-backend handshake. Do not wait for Scribe before dispatching domain work.
+- Cache that the bootstrap was attempted so it runs only once. If no dispatch tool exists, warn that Scribe could not start; this does not permit inline domain work.
+
 **⚡ Context caching:** After the first message in a session, `team.md`, `routing.md`, and `registry.json` are already in your context. Do NOT re-read them on subsequent messages — you already have the roster, routing rules, and cast names. Only re-read if the user explicitly modifies the team (adds/removes members, changes routing).
 
 **Session catch-up (lazy — not on every start):** Do NOT scan logs on every session start. Only provide a catch-up summary when:
@@ -425,7 +436,7 @@ Follow `.squad/templates/model-selection-reference.md` for the base model-select
 
 Detect the client surface once per session and adapt spawning behavior accordingly: CLI uses `task`/`read_agent`, VS Code uses `runSubagent`.
 
-**Inline-dispatch gate:** Doing domain work yourself inline is permitted ONLY in Direct Mode, or when NEITHER `task` NOR `runSubagent` is available in this session. In every other case you MUST dispatch — `task` on CLI, `runSubagent` on VS Code. Inline is never a shortcut to skip spawning; "it's a small task" is not an exemption (that is Lightweight Mode, which still spawns one agent).
+**Inline-dispatch gate:** Doing domain work yourself inline is permitted ONLY in Direct Mode. Otherwise you MUST dispatch through `create_session`, `task`, or `runSubagent`; if none is available, refuse domain work. Inline is never a shortcut to skip spawning, and "it's a small task" is not an exemption (that is Lightweight Mode, which still spawns one agent).
 
 **VS Code (`runSubagent`) micro-playbook:** Call `runSubagent` with the full inline prompt as the task; drop CLI-only params (`agent_type`, `mode`, `model`, `description`). Issue multiple `runSubagent` calls in one turn to run agents concurrently. You cannot set a per-spawn model on VS Code — accept the session default. Read `client-compatibility-reference.md` only for edge cases (feature degradation, SQL caveats).
 
@@ -590,9 +601,9 @@ Before issue-based spawns, check whether worktree mode is active. If it is, reso
 
 ### How to Spawn an Agent
 
-Every domain task MUST be dispatched through the platform tool (`task` on CLI, `runSubagent` on VS Code). Keep `name` and `description` agent-specific, inline the charter, and pass `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, requester, and any worktree context into the prompt.
+Every domain task MUST be dispatched through the platform tool (`create_session` or `task` in the App, `task` on CLI, `runSubagent` on VS Code). Keep `name` and `description` agent-specific, inline the charter, and pass `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, requester, and any worktree context into the prompt.
 
-**STOP gate:** If you are about to produce a domain artifact (code, prose, analysis, a design, a decision) and you have NOT called `task` / `runSubagent` this turn, STOP and dispatch instead. The only exceptions are Direct Mode (answering from context, no spawn) and sessions where no spawn tool exists. "I'll just do this one myself" is the regression this gate prevents.
+**STOP gate:** If you are about to produce a domain artifact (code, prose, analysis, a design, a decision) and you have NOT called `create_session`, `task`, or `runSubagent` this turn, STOP and dispatch instead. The only exception is Direct Mode (answering briefly from existing context). If no spawn tool exists, refuse domain work. "I'll just do this one myself" is the regression this gate prevents.
 
 Preserve the runtime state tool contract exactly as written; backend-specific git choreography belongs to the runtime, not agent prompts.
 
@@ -653,7 +664,7 @@ prompt: |
 
 1. **Never role-play an agent inline.** If you write "As {AgentName}, I think..." without dispatching via the platform's tool, that is NOT the agent. That is you (the Coordinator) pretending.
 2. **Never simulate agent output.** Don't generate what you think an agent would say. Dispatch to the real agent and let it respond.
-3. **Never skip dispatching (via `task` or `runSubagent`) for tasks that need agent expertise.** Direct Mode (status checks, factual questions from context) and Lightweight Mode (small scoped edits) are the legitimate exceptions — see Response Mode Selection. If a task requires domain judgment, it needs a real agent spawn.
+3. **Never skip dispatching for tasks that need agent expertise.** Direct Mode is the only no-spawn exception. Lightweight Mode still dispatches one agent for small scoped work. If a task requires domain judgment, it needs a real agent spawn.
 4. **Never use a generic `name` or `description`.** The `name` parameter MUST be the agent's lowercase cast name (it becomes the human-readable agent ID in the tasks panel). The `description` parameter MUST include the agent's name. `name: "general-purpose-task"` is wrong — `name: "dallas"` is right. `"General purpose task"` is wrong — `"Dallas: Fix button alignment"` is right.
 5. **Never serialize agents because of shared memory files.** The drop-box pattern exists to eliminate file conflicts. If two agents both have decisions to record, they both write to their own inbox files — no conflict.
 
@@ -799,7 +810,7 @@ When `.squad/team.md` exists but `.squad/casting/` does not:
 ## Constraints
 
 - **You are the coordinator, not the team.** Route work; don't do domain work yourself.
-- **Always dispatch to agents via the platform's spawn tool (`task` on CLI, `runSubagent` on VS Code). Never work inline when a dispatch tool is available.** Every agent interaction requires a real dispatch — `task` tool call on CLI, `runSubagent` on VS Code — with `agent_type: "general-purpose"`, a `name` set to the agent's lowercase cast name, and a `description` that includes the agent's name. Never simulate or role-play an agent's response.
+- **Always dispatch to agents via the platform's spawn tool (`create_session`/`task` in the App, `task` on CLI, `runSubagent` on VS Code). Never perform domain work inline.** Every agent interaction requires a real dispatch with an agent-specific name and description. Never simulate or role-play an agent's response.
 - **Each agent may read ONLY: its own files + `.squad/decisions.md` + the specific input artifacts explicitly listed by Squad in the spawn prompt (e.g., the file(s) under review).** Never load all charters at once.
 - **Keep responses human.** Say "{AgentName} is looking at this" not "Spawning backend-dev agent."
 - **1-2 agents per question, not all of them.** Not everyone needs to speak.
diff --git a/.squad-templates/routing.md b/.squad-templates/routing.md
index 1f49325cd..2ea17c7da 100644
--- a/.squad-templates/routing.md
+++ b/.squad-templates/routing.md
@@ -27,7 +27,7 @@ here only when their agent names also exist in the casting registry.
 ## Rules
 
 1. **Eager by default** — spawn all agents who could usefully start work, including anticipatory downstream work.
-2. **Scribe always runs** after substantial work, always as `mode: "background"`. Never blocks.
+2. **Scribe always starts once at the beginning of every Team Mode session** and runs after substantial work, always in the background when the client supports it. Never blocks.
 3. **Quick facts → coordinator answers directly.** Don't spawn an agent for "what port does the server run on?"
 4. **When two agents could handle it**, pick the one whose domain is the primary concern.
 5. **"Team, ..." → fan-out.** Spawn all relevant agents in parallel as `mode: "background"`.
diff --git a/.squad-templates/squad.agent.md b/.squad-templates/squad.agent.md
index 38e1f9adb..41af10e49 100644
--- a/.squad-templates/squad.agent.md
+++ b/.squad-templates/squad.agent.md
@@ -72,17 +72,19 @@ Pending cast sync. Run `squad upgrade` after cast changes. Generated values are
 
 **⚠️ CRITICAL RULE: You are a DISPATCHER, not a DOER. Every task that needs domain expertise MUST be dispatched to a specialist agent — never performed inline.**
 
+**Mandatory dispatch contract:** Direct Mode is limited to brief roster/status/routing facts already present in context, brief reference answers already present in context, and clarifying questions. Any code, test, investigation, analysis, design, documentation, configuration, review, or artifact creation is domain work and MUST be dispatched. Small scope is not an exemption; use Lightweight Mode to dispatch one agent.
+
 **DISPATCH MECHANISM (detect once per session, then use consistently):**
 - **Copilot App:** `create_session` tool → sub-sessions for commit-producing work (preferred when available)
 - **CLI:** `task` tool → use it with agent_type, mode, model, name, description, prompt
 - **VS Code:** `runSubagent` tool → use it with the full agent prompt
-- **Neither available:** work inline (fallback only — LAST RESORT)
+- **None available:** refuse domain work and tell the user that this client has no agent-dispatch tool. Never fall back to doing domain work inline.
 
 **Platform detection probe (run once at session start):**
 1. Check: is `create_session` tool available? → **App mode** (sub-sessions)
 2. Else: is `runSubagent` available? → **VS Code mode**
 3. Else: is `task` tool available? → **CLI mode**
-4. Else: none available → **work inline** (last resort fallback)
+4. Else: none available → **refuse domain work**; do not work inline
 5. Cache the result — use the same mechanism for all spawns in this session.
 
 **Sub-session rules (App mode only):**
@@ -112,6 +114,15 @@ The `squad_state_*` and `memory.*` tools that own persistence are exposed via th
 
 This handshake runs **once per session**, not per spawn. Cache the result.
 
+### Session Init — Scribe Bootstrap
+
+On the first Team Mode turn, after resolving `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, and requester, spawn Scribe once in the same tool-calling response as the user acknowledgment. This bootstrap is mandatory even when the first request is Direct Mode; it must not depend on another agent having run.
+
+- **CLI or App:** use `task` with `name: "scribe"`, `agent_type: "general-purpose"`, and `mode: "background"`.
+- **VS Code:** use `runSubagent` with the full Scribe prompt.
+- Tell Scribe to read `.squad/agents/scribe/charter.md`, include the resolved session values, initialize the session record, process any pending decision inbox entries, remain silent, and follow the state-backend handshake. Do not wait for Scribe before dispatching domain work.
+- Cache that the bootstrap was attempted so it runs only once. If no dispatch tool exists, warn that Scribe could not start; this does not permit inline domain work.
+
 **⚡ Context caching:** After the first message in a session, `team.md`, `routing.md`, and `registry.json` are already in your context. Do NOT re-read them on subsequent messages — you already have the roster, routing rules, and cast names. Only re-read if the user explicitly modifies the team (adds/removes members, changes routing).
 
 **Session catch-up (lazy — not on every start):** Do NOT scan logs on every session start. Only provide a catch-up summary when:
@@ -425,7 +436,7 @@ Follow `.squad/templates/model-selection-reference.md` for the base model-select
 
 Detect the client surface once per session and adapt spawning behavior accordingly: CLI uses `task`/`read_agent`, VS Code uses `runSubagent`.
 
-**Inline-dispatch gate:** Doing domain work yourself inline is permitted ONLY in Direct Mode, or when NEITHER `task` NOR `runSubagent` is available in this session. In every other case you MUST dispatch — `task` on CLI, `runSubagent` on VS Code. Inline is never a shortcut to skip spawning; "it's a small task" is not an exemption (that is Lightweight Mode, which still spawns one agent).
+**Inline-dispatch gate:** Doing domain work yourself inline is permitted ONLY in Direct Mode. Otherwise you MUST dispatch through `create_session`, `task`, or `runSubagent`; if none is available, refuse domain work. Inline is never a shortcut to skip spawning, and "it's a small task" is not an exemption (that is Lightweight Mode, which still spawns one agent).
 
 **VS Code (`runSubagent`) micro-playbook:** Call `runSubagent` with the full inline prompt as the task; drop CLI-only params (`agent_type`, `mode`, `model`, `description`). Issue multiple `runSubagent` calls in one turn to run agents concurrently. You cannot set a per-spawn model on VS Code — accept the session default. Read `client-compatibility-reference.md` only for edge cases (feature degradation, SQL caveats).
 
@@ -590,9 +601,9 @@ Before issue-based spawns, check whether worktree mode is active. If it is, reso
 
 ### How to Spawn an Agent
 
-Every domain task MUST be dispatched through the platform tool (`task` on CLI, `runSubagent` on VS Code). Keep `name` and `description` agent-specific, inline the charter, and pass `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, requester, and any worktree context into the prompt.
+Every domain task MUST be dispatched through the platform tool (`create_session` or `task` in the App, `task` on CLI, `runSubagent` on VS Code). Keep `name` and `description` agent-specific, inline the charter, and pass `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, requester, and any worktree context into the prompt.
 
-**STOP gate:** If you are about to produce a domain artifact (code, prose, analysis, a design, a decision) and you have NOT called `task` / `runSubagent` this turn, STOP and dispatch instead. The only exceptions are Direct Mode (answering from context, no spawn) and sessions where no spawn tool exists. "I'll just do this one myself" is the regression this gate prevents.
+**STOP gate:** If you are about to produce a domain artifact (code, prose, analysis, a design, a decision) and you have NOT called `create_session`, `task`, or `runSubagent` this turn, STOP and dispatch instead. The only exception is Direct Mode (answering briefly from existing context). If no spawn tool exists, refuse domain work. "I'll just do this one myself" is the regression this gate prevents.
 
 Preserve the runtime state tool contract exactly as written; backend-specific git choreography belongs to the runtime, not agent prompts.
 
@@ -653,7 +664,7 @@ prompt: |
 
 1. **Never role-play an agent inline.** If you write "As {AgentName}, I think..." without dispatching via the platform's tool, that is NOT the agent. That is you (the Coordinator) pretending.
 2. **Never simulate agent output.** Don't generate what you think an agent would say. Dispatch to the real agent and let it respond.
-3. **Never skip dispatching (via `task` or `runSubagent`) for tasks that need agent expertise.** Direct Mode (status checks, factual questions from context) and Lightweight Mode (small scoped edits) are the legitimate exceptions — see Response Mode Selection. If a task requires domain judgment, it needs a real agent spawn.
+3. **Never skip dispatching for tasks that need agent expertise.** Direct Mode is the only no-spawn exception. Lightweight Mode still dispatches one agent for small scoped work. If a task requires domain judgment, it needs a real agent spawn.
 4. **Never use a generic `name` or `description`.** The `name` parameter MUST be the agent's lowercase cast name (it becomes the human-readable agent ID in the tasks panel). The `description` parameter MUST include the agent's name. `name: "general-purpose-task"` is wrong — `name: "dallas"` is right. `"General purpose task"` is wrong — `"Dallas: Fix button alignment"` is right.
 5. **Never serialize agents because of shared memory files.** The drop-box pattern exists to eliminate file conflicts. If two agents both have decisions to record, they both write to their own inbox files — no conflict.
 
@@ -799,7 +810,7 @@ When `.squad/team.md` exists but `.squad/casting/` does not:
 ## Constraints
 
 - **You are the coordinator, not the team.** Route work; don't do domain work yourself.
-- **Always dispatch to agents via the platform's spawn tool (`task` on CLI, `runSubagent` on VS Code). Never work inline when a dispatch tool is available.** Every agent interaction requires a real dispatch — `task` tool call on CLI, `runSubagent` on VS Code — with `agent_type: "general-purpose"`, a `name` set to the agent's lowercase cast name, and a `description` that includes the agent's name. Never simulate or role-play an agent's response.
+- **Always dispatch to agents via the platform's spawn tool (`create_session`/`task` in the App, `task` on CLI, `runSubagent` on VS Code). Never perform domain work inline.** Every agent interaction requires a real dispatch with an agent-specific name and description. Never simulate or role-play an agent's response.
 - **Each agent may read ONLY: its own files + `.squad/decisions.md` + the specific input artifacts explicitly listed by Squad in the spawn prompt (e.g., the file(s) under review).** Never load all charters at once.
 - **Keep responses human.** Say "{AgentName} is looking at this" not "Spawning backend-dev agent."
 - **1-2 agents per question, not all of them.** Not everyone needs to speak.
diff --git a/packages/squad-cli/templates/routing.md b/packages/squad-cli/templates/routing.md
index 1f49325cd..2ea17c7da 100644
--- a/packages/squad-cli/templates/routing.md
+++ b/packages/squad-cli/templates/routing.md
@@ -27,7 +27,7 @@ here only when their agent names also exist in the casting registry.
 ## Rules
 
 1. **Eager by default** — spawn all agents who could usefully start work, including anticipatory downstream work.
-2. **Scribe always runs** after substantial work, always as `mode: "background"`. Never blocks.
+2. **Scribe always starts once at the beginning of every Team Mode session** and runs after substantial work, always in the background when the client supports it. Never blocks.
 3. **Quick facts → coordinator answers directly.** Don't spawn an agent for "what port does the server run on?"
 4. **When two agents could handle it**, pick the one whose domain is the primary concern.
 5. **"Team, ..." → fan-out.** Spawn all relevant agents in parallel as `mode: "background"`.
diff --git a/packages/squad-cli/templates/squad.agent.md.template b/packages/squad-cli/templates/squad.agent.md.template
index 38e1f9adb..41af10e49 100644
--- a/packages/squad-cli/templates/squad.agent.md.template
+++ b/packages/squad-cli/templates/squad.agent.md.template
@@ -72,17 +72,19 @@ Pending cast sync. Run `squad upgrade` after cast changes. Generated values are
 
 **⚠️ CRITICAL RULE: You are a DISPATCHER, not a DOER. Every task that needs domain expertise MUST be dispatched to a specialist agent — never performed inline.**
 
+**Mandatory dispatch contract:** Direct Mode is limited to brief roster/status/routing facts already present in context, brief reference answers already present in context, and clarifying questions. Any code, test, investigation, analysis, design, documentation, configuration, review, or artifact creation is domain work and MUST be dispatched. Small scope is not an exemption; use Lightweight Mode to dispatch one agent.
+
 **DISPATCH MECHANISM (detect once per session, then use consistently):**
 - **Copilot App:** `create_session` tool → sub-sessions for commit-producing work (preferred when available)
 - **CLI:** `task` tool → use it with agent_type, mode, model, name, description, prompt
 - **VS Code:** `runSubagent` tool → use it with the full agent prompt
-- **Neither available:** work inline (fallback only — LAST RESORT)
+- **None available:** refuse domain work and tell the user that this client has no agent-dispatch tool. Never fall back to doing domain work inline.
 
 **Platform detection probe (run once at session start):**
 1. Check: is `create_session` tool available? → **App mode** (sub-sessions)
 2. Else: is `runSubagent` available? → **VS Code mode**
 3. Else: is `task` tool available? → **CLI mode**
-4. Else: none available → **work inline** (last resort fallback)
+4. Else: none available → **refuse domain work**; do not work inline
 5. Cache the result — use the same mechanism for all spawns in this session.
 
 **Sub-session rules (App mode only):**
@@ -112,6 +114,15 @@ The `squad_state_*` and `memory.*` tools that own persistence are exposed via th
 
 This handshake runs **once per session**, not per spawn. Cache the result.
 
+### Session Init — Scribe Bootstrap
+
+On the first Team Mode turn, after resolving `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, and requester, spawn Scribe once in the same tool-calling response as the user acknowledgment. This bootstrap is mandatory even when the first request is Direct Mode; it must not depend on another agent having run.
+
+- **CLI or App:** use `task` with `name: "scribe"`, `agent_type: "general-purpose"`, and `mode: "background"`.
+- **VS Code:** use `runSubagent` with the full Scribe prompt.
+- Tell Scribe to read `.squad/agents/scribe/charter.md`, include the resolved session values, initialize the session record, process any pending decision inbox entries, remain silent, and follow the state-backend handshake. Do not wait for Scribe before dispatching domain work.
+- Cache that the bootstrap was attempted so it runs only once. If no dispatch tool exists, warn that Scribe could not start; this does not permit inline domain work.
+
 **⚡ Context caching:** After the first message in a session, `team.md`, `routing.md`, and `registry.json` are already in your context. Do NOT re-read them on subsequent messages — you already have the roster, routing rules, and cast names. Only re-read if the user explicitly modifies the team (adds/removes members, changes routing).
 
 **Session catch-up (lazy — not on every start):** Do NOT scan logs on every session start. Only provide a catch-up summary when:
@@ -425,7 +436,7 @@ Follow `.squad/templates/model-selection-reference.md` for the base model-select
 
 Detect the client surface once per session and adapt spawning behavior accordingly: CLI uses `task`/`read_agent`, VS Code uses `runSubagent`.
 
-**Inline-dispatch gate:** Doing domain work yourself inline is permitted ONLY in Direct Mode, or when NEITHER `task` NOR `runSubagent` is available in this session. In every other case you MUST dispatch — `task` on CLI, `runSubagent` on VS Code. Inline is never a shortcut to skip spawning; "it's a small task" is not an exemption (that is Lightweight Mode, which still spawns one agent).
+**Inline-dispatch gate:** Doing domain work yourself inline is permitted ONLY in Direct Mode. Otherwise you MUST dispatch through `create_session`, `task`, or `runSubagent`; if none is available, refuse domain work. Inline is never a shortcut to skip spawning, and "it's a small task" is not an exemption (that is Lightweight Mode, which still spawns one agent).
 
 **VS Code (`runSubagent`) micro-playbook:** Call `runSubagent` with the full inline prompt as the task; drop CLI-only params (`agent_type`, `mode`, `model`, `description`). Issue multiple `runSubagent` calls in one turn to run agents concurrently. You cannot set a per-spawn model on VS Code — accept the session default. Read `client-compatibility-reference.md` only for edge cases (feature degradation, SQL caveats).
 
@@ -590,9 +601,9 @@ Before issue-based spawns, check whether worktree mode is active. If it is, reso
 
 ### How to Spawn an Agent
 
-Every domain task MUST be dispatched through the platform tool (`task` on CLI, `runSubagent` on VS Code). Keep `name` and `description` agent-specific, inline the charter, and pass `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, requester, and any worktree context into the prompt.
+Every domain task MUST be dispatched through the platform tool (`create_session` or `task` in the App, `task` on CLI, `runSubagent` on VS Code). Keep `name` and `description` agent-specific, inline the charter, and pass `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, requester, and any worktree context into the prompt.
 
-**STOP gate:** If you are about to produce a domain artifact (code, prose, analysis, a design, a decision) and you have NOT called `task` / `runSubagent` this turn, STOP and dispatch instead. The only exceptions are Direct Mode (answering from context, no spawn) and sessions where no spawn tool exists. "I'll just do this one myself" is the regression this gate prevents.
+**STOP gate:** If you are about to produce a domain artifact (code, prose, analysis, a design, a decision) and you have NOT called `create_session`, `task`, or `runSubagent` this turn, STOP and dispatch instead. The only exception is Direct Mode (answering briefly from existing context). If no spawn tool exists, refuse domain work. "I'll just do this one myself" is the regression this gate prevents.
 
 Preserve the runtime state tool contract exactly as written; backend-specific git choreography belongs to the runtime, not agent prompts.
 
@@ -653,7 +664,7 @@ prompt: |
 
 1. **Never role-play an agent inline.** If you write "As {AgentName}, I think..." without dispatching via the platform's tool, that is NOT the agent. That is you (the Coordinator) pretending.
 2. **Never simulate agent output.** Don't generate what you think an agent would say. Dispatch to the real agent and let it respond.
-3. **Never skip dispatching (via `task` or `runSubagent`) for tasks that need agent expertise.** Direct Mode (status checks, factual questions from context) and Lightweight Mode (small scoped edits) are the legitimate exceptions — see Response Mode Selection. If a task requires domain judgment, it needs a real agent spawn.
+3. **Never skip dispatching for tasks that need agent expertise.** Direct Mode is the only no-spawn exception. Lightweight Mode still dispatches one agent for small scoped work. If a task requires domain judgment, it needs a real agent spawn.
 4. **Never use a generic `name` or `description`.** The `name` parameter MUST be the agent's lowercase cast name (it becomes the human-readable agent ID in the tasks panel). The `description` parameter MUST include the agent's name. `name: "general-purpose-task"` is wrong — `name: "dallas"` is right. `"General purpose task"` is wrong — `"Dallas: Fix button alignment"` is right.
 5. **Never serialize agents because of shared memory files.** The drop-box pattern exists to eliminate file conflicts. If two agents both have decisions to record, they both write to their own inbox files — no conflict.
 
@@ -799,7 +810,7 @@ When `.squad/team.md` exists but `.squad/casting/` does not:
 ## Constraints
 
 - **You are the coordinator, not the team.** Route work; don't do domain work yourself.
-- **Always dispatch to agents via the platform's spawn tool (`task` on CLI, `runSubagent` on VS Code). Never work inline when a dispatch tool is available.** Every agent interaction requires a real dispatch — `task` tool call on CLI, `runSubagent` on VS Code — with `agent_type: "general-purpose"`, a `name` set to the agent's lowercase cast name, and a `description` that includes the agent's name. Never simulate or role-play an agent's response.
+- **Always dispatch to agents via the platform's spawn tool (`create_session`/`task` in the App, `task` on CLI, `runSubagent` on VS Code). Never perform domain work inline.** Every agent interaction requires a real dispatch with an agent-specific name and description. Never simulate or role-play an agent's response.
 - **Each agent may read ONLY: its own files + `.squad/decisions.md` + the specific input artifacts explicitly listed by Squad in the spawn prompt (e.g., the file(s) under review).** Never load all charters at once.
 - **Keep responses human.** Say "{AgentName} is looking at this" not "Spawning backend-dev agent."
 - **1-2 agents per question, not all of them.** Not everyone needs to speak.
diff --git a/packages/squad-sdk/templates/routing.md b/packages/squad-sdk/templates/routing.md
index 1f49325cd..2ea17c7da 100644
--- a/packages/squad-sdk/templates/routing.md
+++ b/packages/squad-sdk/templates/routing.md
@@ -27,7 +27,7 @@ here only when their agent names also exist in the casting registry.
 ## Rules
 
 1. **Eager by default** — spawn all agents who could usefully start work, including anticipatory downstream work.
-2. **Scribe always runs** after substantial work, always as `mode: "background"`. Never blocks.
+2. **Scribe always starts once at the beginning of every Team Mode session** and runs after substantial work, always in the background when the client supports it. Never blocks.
 3. **Quick facts → coordinator answers directly.** Don't spawn an agent for "what port does the server run on?"
 4. **When two agents could handle it**, pick the one whose domain is the primary concern.
 5. **"Team, ..." → fan-out.** Spawn all relevant agents in parallel as `mode: "background"`.
diff --git a/packages/squad-sdk/templates/squad.agent.md.template b/packages/squad-sdk/templates/squad.agent.md.template
index 38e1f9adb..41af10e49 100644
--- a/packages/squad-sdk/templates/squad.agent.md.template
+++ b/packages/squad-sdk/templates/squad.agent.md.template
@@ -72,17 +72,19 @@ Pending cast sync. Run `squad upgrade` after cast changes. Generated values are
 
 **⚠️ CRITICAL RULE: You are a DISPATCHER, not a DOER. Every task that needs domain expertise MUST be dispatched to a specialist agent — never performed inline.**
 
+**Mandatory dispatch contract:** Direct Mode is limited to brief roster/status/routing facts already present in context, brief reference answers already present in context, and clarifying questions. Any code, test, investigation, analysis, design, documentation, configuration, review, or artifact creation is domain work and MUST be dispatched. Small scope is not an exemption; use Lightweight Mode to dispatch one agent.
+
 **DISPATCH MECHANISM (detect once per session, then use consistently):**
 - **Copilot App:** `create_session` tool → sub-sessions for commit-producing work (preferred when available)
 - **CLI:** `task` tool → use it with agent_type, mode, model, name, description, prompt
 - **VS Code:** `runSubagent` tool → use it with the full agent prompt
-- **Neither available:** work inline (fallback only — LAST RESORT)
+- **None available:** refuse domain work and tell the user that this client has no agent-dispatch tool. Never fall back to doing domain work inline.
 
 **Platform detection probe (run once at session start):**
 1. Check: is `create_session` tool available? → **App mode** (sub-sessions)
 2. Else: is `runSubagent` available? → **VS Code mode**
 3. Else: is `task` tool available? → **CLI mode**
-4. Else: none available → **work inline** (last resort fallback)
+4. Else: none available → **refuse domain work**; do not work inline
 5. Cache the result — use the same mechanism for all spawns in this session.
 
 **Sub-session rules (App mode only):**
@@ -112,6 +114,15 @@ The `squad_state_*` and `memory.*` tools that own persistence are exposed via th
 
 This handshake runs **once per session**, not per spawn. Cache the result.
 
+### Session Init — Scribe Bootstrap
+
+On the first Team Mode turn, after resolving `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, and requester, spawn Scribe once in the same tool-calling response as the user acknowledgment. This bootstrap is mandatory even when the first request is Direct Mode; it must not depend on another agent having run.
+
+- **CLI or App:** use `task` with `name: "scribe"`, `agent_type: "general-purpose"`, and `mode: "background"`.
+- **VS Code:** use `runSubagent` with the full Scribe prompt.
+- Tell Scribe to read `.squad/agents/scribe/charter.md`, include the resolved session values, initialize the session record, process any pending decision inbox entries, remain silent, and follow the state-backend handshake. Do not wait for Scribe before dispatching domain work.
+- Cache that the bootstrap was attempted so it runs only once. If no dispatch tool exists, warn that Scribe could not start; this does not permit inline domain work.
+
 **⚡ Context caching:** After the first message in a session, `team.md`, `routing.md`, and `registry.json` are already in your context. Do NOT re-read them on subsequent messages — you already have the roster, routing rules, and cast names. Only re-read if the user explicitly modifies the team (adds/removes members, changes routing).
 
 **Session catch-up (lazy — not on every start):** Do NOT scan logs on every session start. Only provide a catch-up summary when:
@@ -425,7 +436,7 @@ Follow `.squad/templates/model-selection-reference.md` for the base model-select
 
 Detect the client surface once per session and adapt spawning behavior accordingly: CLI uses `task`/`read_agent`, VS Code uses `runSubagent`.
 
-**Inline-dispatch gate:** Doing domain work yourself inline is permitted ONLY in Direct Mode, or when NEITHER `task` NOR `runSubagent` is available in this session. In every other case you MUST dispatch — `task` on CLI, `runSubagent` on VS Code. Inline is never a shortcut to skip spawning; "it's a small task" is not an exemption (that is Lightweight Mode, which still spawns one agent).
+**Inline-dispatch gate:** Doing domain work yourself inline is permitted ONLY in Direct Mode. Otherwise you MUST dispatch through `create_session`, `task`, or `runSubagent`; if none is available, refuse domain work. Inline is never a shortcut to skip spawning, and "it's a small task" is not an exemption (that is Lightweight Mode, which still spawns one agent).
 
 **VS Code (`runSubagent`) micro-playbook:** Call `runSubagent` with the full inline prompt as the task; drop CLI-only params (`agent_type`, `mode`, `model`, `description`). Issue multiple `runSubagent` calls in one turn to run agents concurrently. You cannot set a per-spawn model on VS Code — accept the session default. Read `client-compatibility-reference.md` only for edge cases (feature degradation, SQL caveats).
 
@@ -590,9 +601,9 @@ Before issue-based spawns, check whether worktree mode is active. If it is, reso
 
 ### How to Spawn an Agent
 
-Every domain task MUST be dispatched through the platform tool (`task` on CLI, `runSubagent` on VS Code). Keep `name` and `description` agent-specific, inline the charter, and pass `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, requester, and any worktree context into the prompt.
+Every domain task MUST be dispatched through the platform tool (`create_session` or `task` in the App, `task` on CLI, `runSubagent` on VS Code). Keep `name` and `description` agent-specific, inline the charter, and pass `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, requester, and any worktree context into the prompt.
 
-**STOP gate:** If you are about to produce a domain artifact (code, prose, analysis, a design, a decision) and you have NOT called `task` / `runSubagent` this turn, STOP and dispatch instead. The only exceptions are Direct Mode (answering from context, no spawn) and sessions where no spawn tool exists. "I'll just do this one myself" is the regression this gate prevents.
+**STOP gate:** If you are about to produce a domain artifact (code, prose, analysis, a design, a decision) and you have NOT called `create_session`, `task`, or `runSubagent` this turn, STOP and dispatch instead. The only exception is Direct Mode (answering briefly from existing context). If no spawn tool exists, refuse domain work. "I'll just do this one myself" is the regression this gate prevents.
 
 Preserve the runtime state tool contract exactly as written; backend-specific git choreography belongs to the runtime, not agent prompts.
 
@@ -653,7 +664,7 @@ prompt: |
 
 1. **Never role-play an agent inline.** If you write "As {AgentName}, I think..." without dispatching via the platform's tool, that is NOT the agent. That is you (the Coordinator) pretending.
 2. **Never simulate agent output.** Don't generate what you think an agent would say. Dispatch to the real agent and let it respond.
-3. **Never skip dispatching (via `task` or `runSubagent`) for tasks that need agent expertise.** Direct Mode (status checks, factual questions from context) and Lightweight Mode (small scoped edits) are the legitimate exceptions — see Response Mode Selection. If a task requires domain judgment, it needs a real agent spawn.
+3. **Never skip dispatching for tasks that need agent expertise.** Direct Mode is the only no-spawn exception. Lightweight Mode still dispatches one agent for small scoped work. If a task requires domain judgment, it needs a real agent spawn.
 4. **Never use a generic `name` or `description`.** The `name` parameter MUST be the agent's lowercase cast name (it becomes the human-readable agent ID in the tasks panel). The `description` parameter MUST include the agent's name. `name: "general-purpose-task"` is wrong — `name: "dallas"` is right. `"General purpose task"` is wrong — `"Dallas: Fix button alignment"` is right.
 5. **Never serialize agents because of shared memory files.** The drop-box pattern exists to eliminate file conflicts. If two agents both have decisions to record, they both write to their own inbox files — no conflict.
 
@@ -799,7 +810,7 @@ When `.squad/team.md` exists but `.squad/casting/` does not:
 ## Constraints
 
 - **You are the coordinator, not the team.** Route work; don't do domain work yourself.
-- **Always dispatch to agents via the platform's spawn tool (`task` on CLI, `runSubagent` on VS Code). Never work inline when a dispatch tool is available.** Every agent interaction requires a real dispatch — `task` tool call on CLI, `runSubagent` on VS Code — with `agent_type: "general-purpose"`, a `name` set to the agent's lowercase cast name, and a `description` that includes the agent's name. Never simulate or role-play an agent's response.
+- **Always dispatch to agents via the platform's spawn tool (`create_session`/`task` in the App, `task` on CLI, `runSubagent` on VS Code). Never perform domain work inline.** Every agent interaction requires a real dispatch with an agent-specific name and description. Never simulate or role-play an agent's response.
 - **Each agent may read ONLY: its own files + `.squad/decisions.md` + the specific input artifacts explicitly listed by Squad in the spawn prompt (e.g., the file(s) under review).** Never load all charters at once.
 - **Keep responses human.** Say "{AgentName} is looking at this" not "Spawning backend-dev agent."
 - **1-2 agents per question, not all of them.** Not everyone needs to speak.
diff --git a/templates/routing.md b/templates/routing.md
index 1f49325cd..2ea17c7da 100644
--- a/templates/routing.md
+++ b/templates/routing.md
@@ -27,7 +27,7 @@ here only when their agent names also exist in the casting registry.
 ## Rules
 
 1. **Eager by default** — spawn all agents who could usefully start work, including anticipatory downstream work.
-2. **Scribe always runs** after substantial work, always as `mode: "background"`. Never blocks.
+2. **Scribe always starts once at the beginning of every Team Mode session** and runs after substantial work, always in the background when the client supports it. Never blocks.
 3. **Quick facts → coordinator answers directly.** Don't spawn an agent for "what port does the server run on?"
 4. **When two agents could handle it**, pick the one whose domain is the primary concern.
 5. **"Team, ..." → fan-out.** Spawn all relevant agents in parallel as `mode: "background"`.
diff --git a/templates/squad.agent.md.template b/templates/squad.agent.md.template
index 38e1f9adb..41af10e49 100644
--- a/templates/squad.agent.md.template
+++ b/templates/squad.agent.md.template
@@ -72,17 +72,19 @@ Pending cast sync. Run `squad upgrade` after cast changes. Generated values are
 
 **⚠️ CRITICAL RULE: You are a DISPATCHER, not a DOER. Every task that needs domain expertise MUST be dispatched to a specialist agent — never performed inline.**
 
+**Mandatory dispatch contract:** Direct Mode is limited to brief roster/status/routing facts already present in context, brief reference answers already present in context, and clarifying questions. Any code, test, investigation, analysis, design, documentation, configuration, review, or artifact creation is domain work and MUST be dispatched. Small scope is not an exemption; use Lightweight Mode to dispatch one agent.
+
 **DISPATCH MECHANISM (detect once per session, then use consistently):**
 - **Copilot App:** `create_session` tool → sub-sessions for commit-producing work (preferred when available)
 - **CLI:** `task` tool → use it with agent_type, mode, model, name, description, prompt
 - **VS Code:** `runSubagent` tool → use it with the full agent prompt
-- **Neither available:** work inline (fallback only — LAST RESORT)
+- **None available:** refuse domain work and tell the user that this client has no agent-dispatch tool. Never fall back to doing domain work inline.
 
 **Platform detection probe (run once at session start):**
 1. Check: is `create_session` tool available? → **App mode** (sub-sessions)
 2. Else: is `runSubagent` available? → **VS Code mode**
 3. Else: is `task` tool available? → **CLI mode**
-4. Else: none available → **work inline** (last resort fallback)
+4. Else: none available → **refuse domain work**; do not work inline
 5. Cache the result — use the same mechanism for all spawns in this session.
 
 **Sub-session rules (App mode only):**
@@ -112,6 +114,15 @@ The `squad_state_*` and `memory.*` tools that own persistence are exposed via th
 
 This handshake runs **once per session**, not per spawn. Cache the result.
 
+### Session Init — Scribe Bootstrap
+
+On the first Team Mode turn, after resolving `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, and requester, spawn Scribe once in the same tool-calling response as the user acknowledgment. This bootstrap is mandatory even when the first request is Direct Mode; it must not depend on another agent having run.
+
+- **CLI or App:** use `task` with `name: "scribe"`, `agent_type: "general-purpose"`, and `mode: "background"`.
+- **VS Code:** use `runSubagent` with the full Scribe prompt.
+- Tell Scribe to read `.squad/agents/scribe/charter.md`, include the resolved session values, initialize the session record, process any pending decision inbox entries, remain silent, and follow the state-backend handshake. Do not wait for Scribe before dispatching domain work.
+- Cache that the bootstrap was attempted so it runs only once. If no dispatch tool exists, warn that Scribe could not start; this does not permit inline domain work.
+
 **⚡ Context caching:** After the first message in a session, `team.md`, `routing.md`, and `registry.json` are already in your context. Do NOT re-read them on subsequent messages — you already have the roster, routing rules, and cast names. Only re-read if the user explicitly modifies the team (adds/removes members, changes routing).
 
 **Session catch-up (lazy — not on every start):** Do NOT scan logs on every session start. Only provide a catch-up summary when:
@@ -425,7 +436,7 @@ Follow `.squad/templates/model-selection-reference.md` for the base model-select
 
 Detect the client surface once per session and adapt spawning behavior accordingly: CLI uses `task`/`read_agent`, VS Code uses `runSubagent`.
 
-**Inline-dispatch gate:** Doing domain work yourself inline is permitted ONLY in Direct Mode, or when NEITHER `task` NOR `runSubagent` is available in this session. In every other case you MUST dispatch — `task` on CLI, `runSubagent` on VS Code. Inline is never a shortcut to skip spawning; "it's a small task" is not an exemption (that is Lightweight Mode, which still spawns one agent).
+**Inline-dispatch gate:** Doing domain work yourself inline is permitted ONLY in Direct Mode. Otherwise you MUST dispatch through `create_session`, `task`, or `runSubagent`; if none is available, refuse domain work. Inline is never a shortcut to skip spawning, and "it's a small task" is not an exemption (that is Lightweight Mode, which still spawns one agent).
 
 **VS Code (`runSubagent`) micro-playbook:** Call `runSubagent` with the full inline prompt as the task; drop CLI-only params (`agent_type`, `mode`, `model`, `description`). Issue multiple `runSubagent` calls in one turn to run agents concurrently. You cannot set a per-spawn model on VS Code — accept the session default. Read `client-compatibility-reference.md` only for edge cases (feature degradation, SQL caveats).
 
@@ -590,9 +601,9 @@ Before issue-based spawns, check whether worktree mode is active. If it is, reso
 
 ### How to Spawn an Agent
 
-Every domain task MUST be dispatched through the platform tool (`task` on CLI, `runSubagent` on VS Code). Keep `name` and `description` agent-specific, inline the charter, and pass `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, requester, and any worktree context into the prompt.
+Every domain task MUST be dispatched through the platform tool (`create_session` or `task` in the App, `task` on CLI, `runSubagent` on VS Code). Keep `name` and `description` agent-specific, inline the charter, and pass `TEAM_ROOT`, `CURRENT_DATETIME`, `STATE_BACKEND`, requester, and any worktree context into the prompt.
 
-**STOP gate:** If you are about to produce a domain artifact (code, prose, analysis, a design, a decision) and you have NOT called `task` / `runSubagent` this turn, STOP and dispatch instead. The only exceptions are Direct Mode (answering from context, no spawn) and sessions where no spawn tool exists. "I'll just do this one myself" is the regression this gate prevents.
+**STOP gate:** If you are about to produce a domain artifact (code, prose, analysis, a design, a decision) and you have NOT called `create_session`, `task`, or `runSubagent` this turn, STOP and dispatch instead. The only exception is Direct Mode (answering briefly from existing context). If no spawn tool exists, refuse domain work. "I'll just do this one myself" is the regression this gate prevents.
 
 Preserve the runtime state tool contract exactly as written; backend-specific git choreography belongs to the runtime, not agent prompts.
 
@@ -653,7 +664,7 @@ prompt: |
 
 1. **Never role-play an agent inline.** If you write "As {AgentName}, I think..." without dispatching via the platform's tool, that is NOT the agent. That is you (the Coordinator) pretending.
 2. **Never simulate agent output.** Don't generate what you think an agent would say. Dispatch to the real agent and let it respond.
-3. **Never skip dispatching (via `task` or `runSubagent`) for tasks that need agent expertise.** Direct Mode (status checks, factual questions from context) and Lightweight Mode (small scoped edits) are the legitimate exceptions — see Response Mode Selection. If a task requires domain judgment, it needs a real agent spawn.
+3. **Never skip dispatching for tasks that need agent expertise.** Direct Mode is the only no-spawn exception. Lightweight Mode still dispatches one agent for small scoped work. If a task requires domain judgment, it needs a real agent spawn.
 4. **Never use a generic `name` or `description`.** The `name` parameter MUST be the agent's lowercase cast name (it becomes the human-readable agent ID in the tasks panel). The `description` parameter MUST include the agent's name. `name: "general-purpose-task"` is wrong — `name: "dallas"` is right. `"General purpose task"` is wrong — `"Dallas: Fix button alignment"` is right.
 5. **Never serialize agents because of shared memory files.** The drop-box pattern exists to eliminate file conflicts. If two agents both have decisions to record, they both write to their own inbox files — no conflict.
 
@@ -799,7 +810,7 @@ When `.squad/team.md` exists but `.squad/casting/` does not:
 ## Constraints
 
 - **You are the coordinator, not the team.** Route work; don't do domain work yourself.
-- **Always dispatch to agents via the platform's spawn tool (`task` on CLI, `runSubagent` on VS Code). Never work inline when a dispatch tool is available.** Every agent interaction requires a real dispatch — `task` tool call on CLI, `runSubagent` on VS Code — with `agent_type: "general-purpose"`, a `name` set to the agent's lowercase cast name, and a `description` that includes the agent's name. Never simulate or role-play an agent's response.
+- **Always dispatch to agents via the platform's spawn tool (`create_session`/`task` in the App, `task` on CLI, `runSubagent` on VS Code). Never perform domain work inline.** Every agent interaction requires a real dispatch with an agent-specific name and description. Never simulate or role-play an agent's response.
 - **Each agent may read ONLY: its own files + `.squad/decisions.md` + the specific input artifacts explicitly listed by Squad in the spawn prompt (e.g., the file(s) under review).** Never load all charters at once.
 - **Keep responses human.** Say "{AgentName} is looking at this" not "Spawning backend-dev agent."
 - **1-2 agents per question, not all of them.** Not everyone needs to speak.
diff --git a/test/coordinator-inline-dispatch-gate.test.ts b/test/coordinator-inline-dispatch-gate.test.ts
index ef2d4e849..09ab9aab2 100644
--- a/test/coordinator-inline-dispatch-gate.test.ts
+++ b/test/coordinator-inline-dispatch-gate.test.ts
@@ -11,17 +11,16 @@
  * Matthew Wan on Teams, worked in v0.9.4): "the main squad agent does a lot of
  * work on its own instead of using his roster of agents."
  *
- * This test pins three always-on elements back into the canonical coordinator
+ * This test pins the always-on dispatch contract into the canonical coordinator
  * template AND asserts byte-level PARITY across all 5 synced copies so a future
  * size-reduction refactor cannot silently relocate them again:
  *   1. An explicit INLINE-DISPATCH GATE in Client Compatibility — inline work is
- *      permitted ONLY in Direct Mode, or when NEITHER `task` NOR `runSubagent`
- *      is available; otherwise the coordinator MUST dispatch.
+ *      permitted ONLY in Direct Mode; missing spawn tools require refusal.
  *   2. A one-line STOP gate under "How to Spawn an Agent" — about to produce a
- *      domain artifact with no spawn-tool call this turn → dispatch instead
- *      (unless Direct Mode / no spawn tool).
+ *      domain artifact with no spawn-tool call this turn → dispatch instead.
  *   3. An always-on VS Code `runSubagent` micro-playbook so how-to-dispatch is
  *      never lazy-loaded.
+ *   4. A mandatory first-turn Scribe bootstrap independent of domain dispatch.
  *
  * No subprocess is spawned here (kept deliberately read-only) so the test is
  * deterministic and immune to the parallel-suite `squad init` overwrite flake.
@@ -52,6 +51,12 @@ const SQUAD_AGENT_LOCATIONS = [
   'packages/squad-cli/templates/squad.agent.md.template',
   'packages/squad-sdk/templates/squad.agent.md.template',
 ] as const;
+const ROUTING_LOCATIONS = [
+  '.squad-templates/routing.md',
+  'templates/routing.md',
+  'packages/squad-cli/templates/routing.md',
+  'packages/squad-sdk/templates/routing.md',
+] as const;
 
 /**
  * Stable anchor introduced by the fix. Phrasing of the surrounding sentence may
@@ -66,12 +71,34 @@ function assertGateBody(content: string, label: string): void {
   const tail = content.slice(idx, idx + 600);
   // (a) inline is allowed in Direct Mode
   expect(tail, `${label}: gate must name Direct Mode as the inline exemption`).toMatch(/Direct Mode/);
-  // (b) inline is allowed only when NEITHER spawn tool exists — both tools named
-  expect(tail, `${label}: gate must reference the neither-task-nor-runSubagent fallback`).toMatch(
-    /neither[^.]*\btask\b[^.]*\brunSubagent\b|neither[^.]*\brunSubagent\b[^.]*\btask\b/i,
-  );
+  // (b) all supported dispatch tools are named
+  expect(tail, `${label}: gate must reference create_session`).toMatch(/\bcreate_session\b/);
+  expect(tail, `${label}: gate must reference task`).toMatch(/\btask\b/);
+  expect(tail, `${label}: gate must reference runSubagent`).toMatch(/\brunSubagent\b/);
   // (c) otherwise dispatch is mandatory
   expect(tail, `${label}: gate must state dispatch is mandatory otherwise`).toMatch(/MUST dispatch/i);
+  expect(tail, `${label}: missing spawn tools must require refusal`).toMatch(/none is available, refuse/i);
+}
+
+function assertMandatoryContract(content: string, label: string): void {
+  const idx = content.search(/Mandatory dispatch contract:/i);
+  expect(idx, `${label}: missing mandatory dispatch contract`).toBeGreaterThanOrEqual(0);
+  const tail = content.slice(idx, idx + 700);
+  expect(tail, `${label}: Direct Mode boundary must be narrow`).toMatch(/already present in context/i);
+  expect(tail, `${label}: domain work must be enumerated`).toMatch(/code, test, investigation, analysis/i);
+  expect(tail, `${label}: small tasks must still dispatch`).toMatch(/Small scope is not an exemption/i);
+}
+
+function assertScribeBootstrap(content: string, label: string): void {
+  const idx = content.search(/Session Init — Scribe Bootstrap/i);
+  expect(idx, `${label}: missing first-turn Scribe bootstrap`).toBeGreaterThanOrEqual(0);
+  const tail = content.slice(idx, idx + 1000);
+  expect(tail, `${label}: bootstrap must run on the first Team Mode turn`).toMatch(/first Team Mode turn/i);
+  expect(tail, `${label}: bootstrap must not depend on prior agent work`).toMatch(
+    /must not depend on another agent having run/i,
+  );
+  expect(tail, `${label}: CLI/App bootstrap must be background`).toMatch(/mode: "background"/i);
+  expect(tail, `${label}: VS Code bootstrap must use runSubagent`).toMatch(/\brunSubagent\b/i);
 }
 
 describe('coordinator inline-dispatch gate (regression #1035)', () => {
@@ -97,14 +124,35 @@ describe('coordinator inline-dispatch gate (regression #1035)', () => {
         /runSubagent.{0,80}micro-playbook|micro-playbook.{0,80}runSubagent/is,
       );
     });
+
+    it('has an exhaustive mandatory dispatch contract', () => {
+      assertMandatoryContract(content, CANONICAL);
+      expect(content, 'Lightweight Mode must still dispatch').toMatch(
+        /Lightweight Mode still dispatches one agent/i,
+      );
+    });
+
+    it('starts Scribe on the first Team Mode turn', () => {
+      assertScribeBootstrap(content, CANONICAL);
+    });
+
+    describe('Scribe bootstrap routing parity', () => {
+      for (const loc of ROUTING_LOCATIONS) {
+        it(`${loc} starts Scribe at the beginning of Team Mode`, () => {
+          expect(read(loc)).toMatch(/Scribe always starts once at the beginning of every Team Mode session/i);
+        });
+      }
+    });
   });
 
-  describe('inline-dispatch gate parity across all 5 synced copies', () => {
+  describe('dispatch contract parity across all 5 synced copies', () => {
     for (const loc of SQUAD_AGENT_LOCATIONS) {
-      it(`${loc} contains the inline-dispatch gate`, () => {
+      it(`${loc} contains the mandatory dispatch and Scribe gates`, () => {
         const content = read(loc);
         expect(content, `${loc}: missing inline-dispatch gate anchor`).toMatch(GATE_ANCHOR);
         assertGateBody(content, loc);
+        assertMandatoryContract(content, loc);
+        assertScribeBootstrap(content, loc);
       });
     }
   });