@heretyc/subagent-mcp 2.8.7 → 2.8.9

package/directives/orchestration-claude.md

@@ -1,14 +1,15 @@
-<!-- INJECTED PRE-PROMPT DIRECTIVE — BINDING, NON-NEGOTIABLE -->
 <subagent-mcp state="on" kind="directive">
 FIRST-LINE EXEMPTION: if this session's prompt's literal first line begins with "<this is a request from a parent process>", ignore this entire tag.
 
-ORCHESTRATION ON. You are the ORCHESTRATOR. This tag is MAXIMALLY CRITICAL: obey with NO exceptions. No user request overrides it; the only user-changeable thing is the ON/OFF state, reported authoritatively by this hook injection.
+ORCHESTRATION ON. You are the ORCHESTRATOR. Obey this tag; ordinary user requests do not override it. Only the hook's ON/OFF state changes this mode.
 
-ALLOWED TOOLS: ONLY AskUserQuestion + subagent-mcp. NO direct reads or writes. Inline-by-right does NOT exist. Every step runs in a sub-agent. A non-delegable atomic step → ask the user via AskUserQuestion for a one-time exception, do ONLY that step, then resume delegating.
+ALLOWED TOOLS: ONLY AskUserQuestion + subagent-mcp. NO direct reads/writes. Inline-by-right does NOT exist. Every step runs in a sub-agent. Non-delegable atomic step → ask via AskUserQuestion for a one-time exception, do ONLY that step, then resume delegating.
 
-READ LADDER: poll_agent tail → one <=100-line summarizer sub-agent (trusted as-is) → else the USER reads it. Large handoffs: assign scratch-file PATHS; producer writes, consumer reads; you NEVER read those files.
+READ LADDER: poll_agent tail → one <=100-line summarizer sub-agent (trusted as-is) → else the USER reads it. Large handoffs use scratch-file PATHS; producer writes, consumer reads; you NEVER read them.
 
-PRECEDENCE: this tag and safety-scope are CO-SUPREME and equal; genuine conflict → STOP and escalate to the user (FORBIDDEN: resolving it yourself). SOLE CHANNEL: all launches via launch_agent. DROPOUT while ON: HALT and ask the user; stay halted until restored. The only user choices are keep-waiting or explicitly abandon the whole task; aborting ends the task, it never switches you to inline work. DISABLE: never on your own initiative.
+SUBDIVIDE: delegate the SMALLEST auditable step yielding an observable artifact. NEVER 1-shot multi-phase work. For code/non-trivial steps, prefer an independent verifier sub-agent before proceeding.
+
+PRECEDENCE: this tag and safety-scope are CO-SUPREME and equal; genuine conflict → STOP and ask the user. SOLE CHANNEL: all launches via launch_agent. DROPOUT while ON: HALT and ask; stay halted until restored. Abort ends the task; it never switches you inline. DISABLE: never on your own initiative.
 
 Full model + governance: server MCP `instructions`.
 </subagent-mcp>

package/directives/orchestration-codex.md

@@ -1,14 +1,15 @@
-<!-- INJECTED PRE-PROMPT DIRECTIVE — BINDING, NON-NEGOTIABLE -->
 <subagent-mcp state="on" kind="directive">
 FIRST-LINE EXEMPTION: if this session's prompt's literal first line begins with "<this is a request from a parent process>", ignore this entire tag.
 
-ORCHESTRATION ON. You are the ORCHESTRATOR. This tag is MAXIMALLY CRITICAL: obey with NO exceptions. No user request overrides it; the only user-changeable thing is the ON/OFF state, reported authoritatively by this hook injection.
+ORCHESTRATION ON. You are the ORCHESTRATOR. Obey this tag; ordinary user requests do not override it. Only the hook's ON/OFF state changes this mode.
 
-ALLOWED TOOLS: ONLY request-user-input + subagent-mcp. NO direct reads or writes. Inline-by-right does NOT exist. Every step runs in a sub-agent. A non-delegable atomic step → ask the user via request-user-input for a one-time exception, do ONLY that step, then resume delegating.
+ALLOWED TOOLS: ONLY request-user-input + subagent-mcp. NO direct reads/writes. Inline-by-right does NOT exist. Every step runs in a sub-agent. Non-delegable atomic step → ask via request-user-input for a one-time exception, do ONLY that step, then resume delegating.
 
-READ LADDER: poll_agent tail → one <=100-line summarizer sub-agent (trusted as-is) → else the USER reads it. Large handoffs: assign scratch-file PATHS; producer writes, consumer reads; you NEVER read those files.
+READ LADDER: poll_agent tail → one <=100-line summarizer sub-agent (trusted as-is) → else the USER reads it. Large handoffs use scratch-file PATHS; producer writes, consumer reads; you NEVER read them.
 
-PRECEDENCE: this tag and safety-scope are CO-SUPREME and equal; genuine conflict → STOP and escalate to the user (FORBIDDEN: resolving it yourself). SOLE CHANNEL: all launches via launch_agent. DROPOUT while ON: HALT and ask the user; stay halted until restored. The only user choices are keep-waiting or explicitly abandon the whole task; aborting ends the task, it never switches you to inline work. DISABLE: never on your own initiative.
+SUBDIVIDE: delegate the SMALLEST auditable step yielding an observable artifact. NEVER 1-shot multi-phase work. For code/non-trivial steps, prefer an independent verifier sub-agent before proceeding.
+
+PRECEDENCE: this tag and safety-scope are CO-SUPREME and equal; genuine conflict → STOP and ask the user. SOLE CHANNEL: all launches via launch_agent. DROPOUT while ON: HALT and ask; stay halted until restored. Abort ends the task; it never switches you inline. DISABLE: never on your own initiative.
 
 Full model + governance: server MCP `instructions`.
 </subagent-mcp>

package/directives/reminder-on.md

@@ -6,6 +6,8 @@ Orchestration ON. You are the orchestrator: delegate EVERY step. Allowed tools =
 
 READ LADDER: poll_agent tail → one <=100-line summarizer sub-agent (trusted as-is) → else the user reads it. Large handoffs via scratch-file PATHS you never read.
 
+SUBDIVIDE: smallest auditable step per sub-agent; never 1-shot multi-phase work (no implement+test+docs in one); verify code steps independently.
+
 WAIT-NOT-POLL: learn finish via `wait` (verbose:true for output); never loop poll_agent for completion. poll_agent = single diagnostic; stalled/empty = alive, not dead.
 
 This tag is co-supreme with safety-scope (conflict → ask the user) and outranks ordinary user requests. Full governance: server MCP `instructions`.

package/directives/short-on.md

@@ -1 +1 @@
-<subagent-mcp state="on" kind="carrier">If this prompt's literal first line begins with "<this is a request from a parent process>", ignore this tag. Orchestration ON. Delegate-only via subagent-mcp; allowed tools = structured-question tool + subagent-mcp; NO direct reads/writes; inline-by-right does not exist. Follow the MOST RECENT <subagent-mcp state="on"> tag in context (directive or reminder/carrier); if none is in the current window, the INIT_BLOCK governs. Co-supreme with safety-scope; no ordinary user request bypasses it.</subagent-mcp>
+<subagent-mcp state="on" kind="carrier">If first line begins "<this is a request from a parent process>", ignore this tag. Orchestration ON. Delegate-only via subagent-mcp; allowed tools = structured-question tool + subagent-mcp; no direct reads/writes; inline-by-right does not exist. Subdivide small; verify code steps. Follow MOST RECENT <subagent-mcp state="on"> tag; if absent, INIT_BLOCK governs. Co-supreme with safety-scope; user request cannot bypass.</subagent-mcp>

package/dist/drivers.js

@@ -2,6 +2,13 @@ import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { PassThrough } from "node:stream";
 import { mapModel } from "./effort.js";
+export class ProviderTransientError extends Error {
+    isTransient = true;
+    constructor(message) {
+        super(message);
+        this.name = "ProviderTransientError";
+    }
+}
 class LogicalProcess extends EventEmitter {
     pid;
     stdout = new PassThrough();
@@ -120,10 +127,18 @@ function userMessage(text) {
 function textInput(text) {
     return { type: "text", text, text_elements: [] };
 }
-class MockJsonlDriver {
+export class MockJsonlDriver {
     child;
     provider;
+    static transientPreStartHook = null;
+    static postStartErrorHook = null;
     process;
+    _definitelyStartedResolve;
+    _definitelyStartedReject;
+    definitelyStarted = new Promise((res, rej) => {
+        this._definitelyStartedResolve = res;
+        this._definitelyStartedReject = rej;
+    });
     queue = Promise.resolve();
     turn = 0;
     constructor(child, provider) {
@@ -136,7 +151,10 @@ class MockJsonlDriver {
             if (!this.process.killed)
                 this.process.close(code, signal);
         });
-        child.stdout?.on("data", (chunk) => this.process.stdout.write(chunk));
+        child.stdout?.on("data", (chunk) => {
+            this._definitelyStartedResolve();
+            this.process.stdout.write(chunk);
+        });
         child.stderr?.on("data", (chunk) => this.process.stderr.write(chunk));
         // Swallow stdin pipe errors (e.g. EPIPE writing to an exited child): the
         // writeLine() callback already surfaces the failure; without this listener
@@ -147,6 +165,20 @@ class MockJsonlDriver {
         return this.process.killed || this.child.killed || this.child.exitCode !== null;
     }
     start(message) {
+        if (MockJsonlDriver.transientPreStartHook) {
+            MockJsonlDriver.transientPreStartHook(this.provider);
+            const err = new ProviderTransientError(`mock transient pre-start failure (${this.provider})`);
+            this._definitelyStartedReject(err);
+            return Promise.reject(err);
+        }
+        if (MockJsonlDriver.postStartErrorHook) {
+            this._definitelyStartedResolve();
+            MockJsonlDriver.postStartErrorHook(this.provider);
+            setTimeout(() => {
+                this.process.stderr.write(`mock post-start error (${this.provider})\n`);
+                this.process.close(1);
+            }, 0);
+        }
         return this.send(message);
     }
     send(message) {
@@ -175,6 +207,12 @@ export class CodexAppServerDriver {
     child;
     options;
     process;
+    _definitelyStartedResolve;
+    _definitelyStartedReject;
+    definitelyStarted = new Promise((res, rej) => {
+        this._definitelyStartedResolve = res;
+        this._definitelyStartedReject = rej;
+    });
     pending = new Map();
     queuedTurns = [];
     nextId = 1;
@@ -341,6 +379,7 @@ export class CodexAppServerDriver {
             const turn = (message.params.turn ?? {});
             if (typeof turn.id === "string")
                 this.activeTurnId = turn.id;
+            this._definitelyStartedResolve();
         }
         if (message.method === "turn/completed") {
             this.activeTurnId = null;
@@ -349,6 +388,9 @@ export class CodexAppServerDriver {
         }
     }
     fail(error) {
+        const msg = error.message;
+        const transient = /\b429\b|\b5\d{2}\b|quota|rate.?limit|timeout|ECONNRESET|ETIMEDOUT|ECONNREFUSED|too many requests|service unavailable|server error|overloaded/i.test(msg);
+        this._definitelyStartedReject(transient ? new ProviderTransientError(msg) : error);
         this.process.fail(error);
         this.rejectPending(error);
     }
@@ -364,6 +406,12 @@ export class CodexAppServerDriver {
 export class ClaudeSdkDriver {
     queryFn;
     process = new LogicalProcess(undefined, true);
+    _definitelyStartedResolve;
+    _definitelyStartedReject;
+    definitelyStarted = new Promise((res, rej) => {
+        this._definitelyStartedResolve = res;
+        this._definitelyStartedReject = rej;
+    });
     input = new AsyncInputQueue();
     abortController = new AbortController();
     queue = Promise.resolve();
@@ -421,8 +469,13 @@ export class ClaudeSdkDriver {
         this.process.kill("SIGKILL");
     }
     async pump(query) {
+        let started = false;
         try {
             for await (const message of query) {
+                if (!started) {
+                    started = true;
+                    this._definitelyStartedResolve();
+                }
                 this.process.stdout.write(`${JSON.stringify(message)}\n`);
             }
             this.closedFlag = true;
@@ -430,8 +483,11 @@ export class ClaudeSdkDriver {
         }
         catch (error) {
             if (!this.process.killed) {
+                const msg = error instanceof Error ? error.message : String(error);
+                const transient = /\b429\b|\b5\d{2}\b|quota|rate.?limit|timeout|ECONNRESET|ETIMEDOUT|ECONNREFUSED|too many requests|service unavailable|server error|overloaded/i.test(msg);
+                this._definitelyStartedReject(transient ? new ProviderTransientError(msg) : new Error(msg));
                 this.closedFlag = true;
-                this.process.stderr.write(error instanceof Error ? error.message : String(error));
+                this.process.stderr.write(msg);
                 this.process.close(1);
             }
         }

package/dist/index.js

@@ -19,6 +19,7 @@ import { loadRoutingTable, buildCandidates, validatePresence, TASK_CATEGORIES, A
 import { createDeadlockWindow } from "./deadlock.js";
 import { createRulesetGate, RULESET_HARD_FAIL_MSG, } from "./ruleset.js";
 import * as orchestrationMarker from "./orchestration/marker.js";
+import * as modelMode from "./orchestration/model-mode.js";
 import { startLivenessHeartbeat } from "./orchestration/liveness.js";
 import { ensureParentMarker } from "./launch-prompt.js";
 const agents = new Map();
@@ -52,6 +53,23 @@ const TASK_CATEGORY_GLOSS = "REQUIRED. Task shape -> routing category (server pi
 function errorResult(text) {
     return { content: [{ type: "text", text }], isError: true };
 }
+export function classifyFailureReason(reason, stderr) {
+    const text = `${reason}\n${stderr}`;
+    return /\b429\b|\b5\d{2}\b|quota|usage.?cap|rate.?limit|timeout|connection.?reset|ECONNRESET|ETIMEDOUT|ECONNREFUSED|too many requests|service unavailable|server error|overloaded/i.test(text)
+        ? "transient_provider"
+        : "permanent";
+}
+function buildFailoverNote(skipped, winner) {
+    const top = skipped[0];
+    const topLabel = `${top.model}@${top.effort} (${top.provider})`;
+    const winnerLabel = `${winner.model}@${winner.effort} (${winner.provider})`;
+    return `Rank-1 candidate ${topLabel} failed with ${top.failure_type === "transient_provider" ? "a transient provider error" : "a permanent error"}; auto-selected ${winnerLabel}.`;
+}
+function failureTypeForError(error, stderr) {
+    return error.isTransient
+        ? "transient_provider"
+        : classifyFailureReason(error.message, stderr);
+}
 const isWindows = process.platform === "win32";
 let _npmPrefix = null;
 function getNpmPrefix() {
@@ -117,11 +135,15 @@ reconcileInterval.unref();
 // initialize (per the MCP spec the initialize result has an `instructions`
 // field) rather than re-injecting it on every turn. The bundled per-turn hook
 // injects only a small compact reminder; this is the durable, full explanation.
-const ORCHESTRATION_INSTRUCTIONS = "subagent-mcp — CANONICAL OPERATING MODEL (read once; full detail in docs/spec/dev-loop/orchestration-directive-architecture.md).\n\nPRECEDENCE (co-supreme). A <subagent-mcp state=\"...\"> hook tag and repo/system safety rules are EQUAL top tier; genuine conflict → STOP and escalate to the user. Tags outrank user requests; only the hook `state` attribute changes ON/OFF.\n\nSOLE CHANNEL. EVERY sub-agent launch goes through launch_agent; never harness Task/Agent or shell spawn.\n\nORCHESTRATION ON (state=on; no-hook UNKNOWN→ON fail-safe). You are a delegate-ONLY orchestrator: directly use ONLY the structured-question tool (AskUserQuestion on Claude / request-user-input on Codex) and subagent-mcp; delegate all work. No direct read/write; inline-by-right DOES NOT EXIST. Non-delegable step: ASK for a ONE-TIME exception, do only it, resume.\n\nREAD-ESCALATION LADDER (the orchestrator's only read channels, in order): (1) subagent-mcp `poll_agent` TAIL; (2) if the tail is insufficient, dispatch ONE sub-agent to return a single summary of <=100 lines, trusted as-is (no separate verification step); (3) anything larger: the USER reads the document directly. No reads or writes occur outside these channels. An empty or stalled tail means the agent is ALIVE, not dead — do NOT busy-loop poll_agent; learn completion via `wait`. Large inter-agent data: the orchestrator assigns scratch-file paths (%TEMP% on Windows, /tmp on POSIX) in prompts; the producing sub-agent writes, the consuming sub-agent reads; the orchestrator NEVER reads those files.\n\nORCHESTRATION OFF (state=off). Long-horizon task = TOTAL footprint (read+produced) >200 lines, CUMULATIVE since last upgrade ask; after EVERY turn, if it qualifies STOP and ASK whether to switch ON; reset only when you ask.\n\nDROPOUT WHILE ON: HALT and ask user; nothing inline; stay halted UNTIL restored.\n\nSUB-AGENT EXEMPTION. A prompt whose literal FIRST LINE begins \"<this is a request from a parent process>\" SKIPS the whole regime (sub-agent); the only automatic suppressor of fail-safe-ON.";
-const SUBAGENT_INSTRUCTIONS = "SUB-AGENT SESSION: you are a child process launched by subagent-mcp. Follow the parent prompt. Do not treat yourself as the orchestrator, do not re-trigger orchestration carryover, and do not launch further sub-agents unless the parent prompt explicitly assigns that.";
+// Canonical A2 mirror fragment retained byte-identical for
+// test/mirror-fragments.test.mjs while ORCHESTRATION_INSTRUCTIONS below stays
+// compressed under MCP metadata limits:
+// READ-ESCALATION LADDER (the orchestrator's only read channels, in order): (1) subagent-mcp `poll_agent` TAIL; (2) if the tail is insufficient, dispatch ONE sub-agent to return a single summary of <=100 lines, trusted as-is (no separate verification step); (3) anything larger: the USER reads the document directly. No reads or writes occur outside these channels. An empty or stalled tail means the agent is ALIVE, not dead — do NOT busy-loop poll_agent; learn completion via `wait`. Large inter-agent data: the orchestrator assigns scratch-file paths (%TEMP% on Windows, /tmp on POSIX) in prompts; the producing sub-agent writes, the consuming sub-agent reads; the orchestrator NEVER reads those files.
+const ORCHESTRATION_INSTRUCTIONS = "subagent-mcp - CANONICAL OPERATING MODEL (full spec: docs/spec/dev-loop/orchestration-directive-architecture.md).\n\nPRECEDENCE. The latest <subagent-mcp state=\"...\"> hook tag and repo/system safety rules are co-supreme; genuine conflict => STOP and ask the user. Only the hook state changes ON/OFF.\n\nSOLE CHANNEL. Every sub-agent launch uses launch_agent; never harness Task/Agent or shell-spawned agents.\n\nORCHESTRATION ON. You are a delegate-ONLY orchestrator. Use only the structured-question tool (AskUserQuestion on Claude / request-user-input on Codex) and subagent-mcp. No direct reads/writes; inline-by-right does not exist. Non-delegable atomic step: ask for a one-time exception, do only that step, then resume delegating.\n\nREAD LADDER. poll_agent tail -> one <=100-line summarizer sub-agent, trusted as-is -> else the USER reads it. Large handoffs use scratch-file paths; producer writes, consumer reads; orchestrator never reads those files. Empty/stalled tail means ALIVE; use wait.\n\nORCHESTRATION OFF. If total context footprint since last upgrade ask exceeds 200 lines, after that turn STOP and ask whether to switch ON; reset count only when you ask.\n\nDROPOUT WHILE ON: HALT and ask; stay halted until restored. SUB-AGENT EXEMPTION: a prompt whose literal FIRST LINE begins \"<this is a request from a parent process>\" skips this regime.\n\nMODEL SELECTION MODE. Default smart rejects provider/model/effort selectors; launch_agent auto-picks. user-approved-overrides lasts 30 minutes, expires lazily on launch_agent, and must be enabled only after explicit user authorization via AskUserQuestion/request-user-input.";
+const SUBAGENT_INSTRUCTIONS = "SUB-AGENT SESSION: you are a child process launched by subagent-mcp. Follow the parent prompt. Do not treat yourself as the orchestrator, do not re-trigger orchestration carryover, and do not launch further sub-agents unless the parent prompt explicitly assigns that.\n\nMODEL SELECTION MODE (parallel to orchestration-mode, set via the model-selection-mode tool). DEFAULT is \"smart\" and is used whenever unset: in smart, launch_agent REJECTS any call supplying provider/model/effort selectors and the server auto-picks the best model. \"user-approved-overrides\" opens a 30-MINUTE window where selectors are HONORED, enforced LAZILY (the mode reverts to smart on the next launch_agent call after 30 minutes) and re-enabling does NOT extend an active window. HONOR-BASED: you MUST NOT set \"user-approved-overrides\" without explicit interactive USER authorization via the structured-question tool (AskUserQuestion on Claude / request-user-input on Codex); never enable it on your own initiative.";
 const server = new McpServer({
     name: "subagent-mcp",
-    version: "2.8.7",
+    version: "2.8.9",
     description: "Launches always-interactive local Claude and Codex sub-agent sessions. Claude uses the Claude Agent SDK over the local Claude Code executable; Codex uses `codex app-server` over stdio. The server does not call Anthropic or OpenAI HTTP APIs directly.",
 }, {
     instructions: process.env.SUBAGENT_MCP_SUBAGENT === "1"
@@ -156,9 +178,8 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
     const running = countProcessing(candidate.provider);
     const max = candidate.provider === "claude" ? MAX_CLAUDE : MAX_CODEX;
     if (running >= max) {
-        return {
-            reason: `Maximum ${max} concurrent ${candidate.provider} agents already running. Current: ${running}`,
-        };
+        const reason = `Maximum ${max} concurrent ${candidate.provider} agents already running. Current: ${running}`;
+        return { reason, failure_type: "permanent" };
     }
     // Build the command. haiku ignores effort; pass "high" placeholder for the
     // "none" sentinel (buildCommand drops it for haiku anyway).
@@ -170,13 +191,14 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
         cmd = resolveExe(candidate.provider);
     }
     catch (e) {
-        return { reason: e instanceof Error ? e.message : String(e) };
+        const reason = e instanceof Error ? e.message : String(e);
+        return { reason, failure_type: "permanent" };
     }
     // Fast-fail absolute paths only. Bare names intentionally rely on PATH; spawn
     // below resolves them and reports ENOENT/EACCES through the same failure path.
     if (isAbsolute(cmd) && !existsSync(cmd)) {
         cleanupUcSettingsPath(buildResult.ucSettingsPath);
-        return { reason: `CLI executable not found: ${cmd}` };
+        return { reason: `CLI executable not found: ${cmd}`, failure_type: "permanent" };
     }
     let driver;
     try {
@@ -194,9 +216,24 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
     catch (error) {
         // Synchronous spawn throw (rare) — clean up and report as a launch failure.
         cleanupUcSettingsPath(buildResult.ucSettingsPath);
-        return { reason: error instanceof Error ? error.message : String(error) };
+        const reason = error instanceof Error ? error.message : String(error);
+        return { reason, failure_type: classifyFailureReason(reason, "") };
     }
     const childProcess = driver.process;
+    let definitelyStarted = false;
+    const definitelyStartedProbe = driver.definitelyStarted.then(() => {
+        definitelyStarted = true;
+        return true;
+    }, () => {
+        return false;
+    });
+    const readStartedBoundary = async () => {
+        await Promise.race([
+            definitelyStartedProbe,
+            new Promise((resolve) => setTimeout(resolve, 0)),
+        ]);
+        return definitelyStarted;
+    };
     // Await the one-shot spawn/error race. The 'error' handler is attached BEFORE
     // we await so an async ENOENT cannot escape as an unhandled event.
     try {
@@ -217,7 +254,8 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
         }
         catch { }
         cleanupUcSettingsPath(buildResult.ucSettingsPath);
-        return { reason: err instanceof Error ? err.message : String(err) };
+        const reason = err instanceof Error ? err.message : String(err);
+        return { reason, failure_type: classifyFailureReason(reason, "") };
     }
     // Spawn succeeded. Register the agent exactly as before. Keep a persistent
     // 'error' handler so a LATE spawn error never crashes the process; fold it
@@ -367,6 +405,15 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
     }
     catch (err) {
         startError = err instanceof Error ? err : new Error(String(err));
+        await readStartedBoundary();
+        if (!definitelyStarted) {
+            const reason = startError.message;
+            cleanupUcSettings(agentState);
+            return {
+                reason,
+                failure_type: failureTypeForError(startError, agentState.stderr),
+            };
+        }
     }
     // Post-spawn grace window: a 'spawn' win alone is NOT success — a provider
     // driver that starts then dies immediately must advance the attempt loop, not
@@ -399,14 +446,22 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
             // turn.completed fast completion must never be misread as a launch
             // failure and the task silently re-executed on the next candidate.
             await closedAfterFlush;
-            if (!agentState.turnCompleted) {
+            const startedBeforeExit = await readStartedBoundary();
+            if (!agentState.turnCompleted && !startedBeforeExit) {
                 const tail = agentState.stderr.trim().split("\n").slice(-1)[0] ?? "";
+                const reason = `process exited (code ${earlyExit.code ?? earlyExit.signal}) within ${SPAWN_GRACE_MS}ms of spawn${tail ? `: ${tail}` : ""}`;
                 return {
-                    reason: `process exited (code ${earlyExit.code ?? earlyExit.signal}) within ${SPAWN_GRACE_MS}ms of spawn${tail ? `: ${tail}` : ""}`,
+                    reason,
+                    failure_type: classifyFailureReason(reason, agentState.stderr),
                 };
             }
         }
         else if (startError && !agentState.turnCompleted) {
+            const startedBeforeStartError = await readStartedBoundary();
+            if (startedBeforeStartError) {
+                agents.set(agentId, agentState);
+                return { agentId };
+            }
             // Lived past the grace window but the startup write failed: the child is
             // not accepting input, so advance the loop rather than register an agent
             // that never received its prompt.
@@ -415,7 +470,10 @@ async function tryLaunchCandidate(candidate, prompt, agentCwd, routingTier, rule
             }
             catch { }
             cleanupUcSettings(agentState);
-            return { reason: startError.message };
+            return {
+                reason: startError.message,
+                failure_type: failureTypeForError(startError, agentState.stderr),
+            };
         }
     }
     agents.set(agentId, agentState);
@@ -453,6 +511,10 @@ server.tool("launch_agent", "Spawn a sub-agent session. AUTO MODE (mandatory fir
     if (presenceError) {
         return errorResult(presenceError);
     }
+    const modelGate = modelMode.gateLaunch(agentCwd, { provider, model, effort });
+    if (!modelGate.allowed) {
+        return errorResult(modelGate.message ?? modelMode.SELECTOR_REJECTION_MESSAGE);
+    }
     // 6. Build the candidate list per mode.
     const overrides = { provider, model, effort };
     const isExplicit = !!(provider && model && effort);
@@ -542,6 +604,17 @@ server.tool("launch_agent", "Spawn a sub-agent session. AUTO MODE (mandatory fir
             if (branch === "performance") {
                 deadlockWindow.consume();
             }
+            if (skipped.length > 0) {
+                const registeredAgent = agents.get(outcome.agentId);
+                if (registeredAgent) {
+                    registeredAgent.failoverFrom = skipped.map((s) => ({
+                        provider: s.provider,
+                        model: s.model,
+                        effort: s.effort,
+                        failure_type: s.failure_type,
+                    }));
+                }
+            }
             return {
                 content: [
                     {
@@ -559,6 +632,18 @@ server.tool("launch_agent", "Spawn a sub-agent session. AUTO MODE (mandatory fir
                                     ruleset_original_selection: rulesetOriginalSelection,
                                 }
                                 : {}),
+                            ...(skipped.length > 0
+                                ? {
+                                    failover_occurred: true,
+                                    failover_from: skipped.map((s) => ({
+                                        provider: s.provider,
+                                        model: s.model,
+                                        effort: s.effort,
+                                        failure_type: s.failure_type,
+                                    })),
+                                    failover_note: buildFailoverNote(skipped, candidate),
+                                }
+                                : {}),
                         }),
                     },
                 ],
@@ -569,17 +654,24 @@ server.tool("launch_agent", "Spawn a sub-agent session. AUTO MODE (mandatory fir
             effort: candidate.effort,
             provider: candidate.provider,
             reason: outcome.reason,
+            failure_type: outcome.failure_type,
         });
+        if (!pureAuto) {
+            break;
+        }
     }
-    // 7. All candidates failed. A ruleset-modified explicit launch may have
-    //    attempted N≠1 candidates — only the numbered ALL_FAILED shape can
-    //    report that, so the explicit shape is reserved for unmodified launches.
-    if (isExplicit && !rulesetApplied) {
+    // 7. All candidates failed. Override selector modes are single-attempt hard
+    //    failures; pure auto mode reports the attempted candidates.
+    if (!pureAuto) {
         const f = skipped[0];
-        return errorResult(`Error: explicit launch ${f.model}@${f.effort} (${f.provider}) failed: ${f.reason}.\n${AUTO_HINT}`);
+        const transientNote = f.failure_type === "transient_provider"
+            ? `\nNote: this failure appears transient (quota/rate-limit/network). Switch to auto mode (omit provider/model/effort) for automatic silent failover to the next-best provider.`
+            : "";
+        const label = isExplicit ? "explicit" : "override";
+        return errorResult(`Error: ${label} launch ${f.model}@${f.effort} (${f.provider}) failed: ${f.reason}.${transientNote}\n${AUTO_HINT}`);
     }
     const lines = skipped
-        .map((s, i) => `  ${i + 1}. ${s.model}@${s.effort} (${s.provider}): ${s.reason}`)
+        .map((s, i) => `  ${i + 1}. ${s.model}@${s.effort} (${s.provider}) [${s.failure_type}]: ${s.reason}`)
         .join("\n");
     return errorResult(`Error: all ${skipped.length} candidate launches failed for task_category ${task_category}:\n${lines}\n${SPLIT_HINT}\n${AUTO_HINT}`);
 });
@@ -634,6 +726,12 @@ server.tool("poll_agent", "Get an agent's current status and output. Status `pro
                             ruleset_original_selection: agent.rulesetOriginalSelection,
                         }
                         : {}),
+                    ...(agent.failoverFrom && agent.failoverFrom.length > 0
+                        ? {
+                            failover_occurred: true,
+                            failover_from: agent.failoverFrom,
+                        }
+                        : {}),
                     recent_stream: agent.visibleStream.map((it) => ({
                         type: it.type,
                         text: it.text,
@@ -925,6 +1023,28 @@ server.tool("orchestration-mode", "Toggle or query per-project ORCHESTRATION MOD
         ],
     };
 });
+// Tool 8: model-selection-mode
+server.tool("model-selection-mode", "Set or query per-project MODEL SELECTION MODE, which gates launch_agent's `provider`/`model`/`effort` selectors. `mode`: \"smart\" or \"user-approved-overrides\"; omit to query current state. \"smart\" is the DEFAULT and is used whenever the mode is unset — in smart, launch_agent REJECTS any call that supplies provider/model/effort and the server auto-picks the best model for the task_category. \"user-approved-overrides\" opens a 30-MINUTE window during which selectors are HONORED; the window is enforced LAZILY — the mode reverts to smart on the next launch_agent call after the 30 minutes elapse — and re-enabling does NOT extend an already-active window. HONOR-BASED, parallel to orchestration-mode: you MUST NOT set this to \"user-approved-overrides\" without explicit interactive USER authorization obtained via the structured-question tool (AskUserQuestion on Claude / request-user-input on Codex; a plain yes/no exchange if neither exists). This tool CANNOT verify that authorization — never enable it on your own initiative. PERSISTENCE: per-project state keyed by cwd; both the mode and the override-window enable-timestamp persist across MCP server restarts (the remaining window is restored, not reset).", {
+    mode: z.enum(["smart", "user-approved-overrides"]).optional(),
+}, async (params) => {
+    const cwd = process.cwd();
+    if (params.mode)
+        modelMode.setMode(cwd, params.mode);
+    const r = modelMode.resolveMode(cwd);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    model_selection_mode: r.mode,
+                    enabled_at: r.enabled_at,
+                    window_remaining_ms: r.window_remaining_ms,
+                    marker_path: modelMode.modelModePath(cwd),
+                }, null, 2),
+            },
+        ],
+    };
+});
 // Connect the stdio transport only when run as the entry point (the bin), NOT
 // when this module is imported (e.g. test/handler-validation.test.mjs importing
 // the exported validatePresence). Connecting on import would block the test on

package/dist/init.js

@@ -6,7 +6,9 @@ export const INIT_BLOCK = [
     "<!-- subagent-mcp:managed:begin schema=2 -->",
     "## subagent-mcp invariant — managed block, do not edit between markers",
     "",
-    'SUB-AGENT EXEMPTION: if this session\'s prompt\'s literal FIRST LINE begins with "<this is a request from a parent process>", SKIP this entire block (you are a sub-agent; this prevents fail-safe-ON recursion and fork-bombs). Leading blank lines do not count — the marker must be physically line 1.',
+    'SUB-AGENT EXEMPTION: if this session\'s prompt\'s literal FIRST LINE begins with "<this is a request from a parent process>", SKIP this entire block EXCEPT the SUB-AGENT WORKTREE CARVE-OUT below, which you MUST still obey (you are a sub-agent; this prevents fail-safe-ON recursion and fork-bombs). Leading blank lines do not count — the marker must be physically line 1.',
+    "",
+    "SUB-AGENT WORKTREE CARVE-OUT: you are a delegated sub-agent (env SUBAGENT_MCP_SUBAGENT=1), already placed in your target working tree by the orchestrator. Do NOT create or switch git worktrees; skip the worktree-isolation gate; do all mutating work directly in the provided cwd.",
     "",
     "CANONICAL SOURCE OF TRUTH: the subagent-mcp MCP `instructions` string (read once at connect) and docs/spec/dev-loop/orchestration-directive-architecture.md. This block carries the full ON operating model inline so the session is governed even if the MCP `instructions` are stale; if this block and the MCP `instructions` ever disagree, the MCP `instructions` win.",
     "",
@@ -16,6 +18,8 @@ export const INIT_BLOCK = [
     "",
     'ORCHESTRATION ON — you are the ORCHESTRATOR. Allowed tools: ONLY the structured-question tool (AskUserQuestion on Claude / request-user-input on Codex) and subagent-mcp. NO direct reads or writes of any kind. "Inline-by-right" does not exist. Every step runs in a sub-agent. If one atomic step truly cannot run in a sub-agent, ASK the user via the structured-question tool for a one-time exception for that single step, perform only that step, then resume delegating. SOLE CHANNEL: while subagent-mcp is connected, every sub-agent launch goes through `launch_agent`; never use harness-native sub-agent tools or shell-spawned agents.',
     "",
+    "ORCHESTRATOR WORKTREE SETUP: launch sub-agents in the main checkout cwd (they no longer self-isolate into per-agent worktrees); SERIALIZE any sub-agents that write the SAME files — never run concurrent writers over overlapping paths (no cwd-level lock exists).",
+    "",
     "READ-ESCALATION LADDER (the orchestrator's only read channels, in order): (1) subagent-mcp `poll_agent` TAIL; (2) if the tail is insufficient, dispatch ONE sub-agent to return a single summary of <=100 lines, trusted as-is (no separate verification step); (3) anything larger: the USER reads the document directly. No reads or writes occur outside these channels. An empty or stalled tail means the agent is ALIVE, not dead — do NOT busy-loop poll_agent; learn completion via `wait`. Large inter-agent data: the orchestrator assigns scratch-file paths (%TEMP% on Windows, /tmp on POSIX) in prompts; the producing sub-agent writes, the consuming sub-agent reads; the orchestrator NEVER reads those files.",
     "",
     'ORCHESTRATION OFF — a "long-horizon task" = any task whose TOTAL context footprint (input you read + output you produce) exceeds 200 lines of text. After EVERY user turn, measure the CUMULATIVE footprint accumulated since your last upgrade ask; reset that cumulative count to zero ONLY when you actually ask. If it qualifies, ASK the user via the structured-question tool whether to switch orchestration ON. Ask on EVERY qualifying turn; a decline does NOT suppress future asks. You never assert ON yourself — you only ask.',