@heretyc/subagent-mcp 2.8.6 → 2.8.7

package/dist/effort.js

@@ -14,6 +14,9 @@ export function mapModel(provider, model) {
 }
 export function resolveEffort(provider, model, effort) {
     const isOpus48 = provider === "claude" && (model === "opus" || model === "opus-4-8");
+    if (effort === "low") {
+        throw new Error(`low effort is not supported. Valid efforts: medium, high, xhigh, max, ultracode.`);
+    }
     if (effort === "ultracode") {
         if (!isOpus48) {
             throw new Error(`ultracode effort is only available on Opus 4.8+ (got ${provider}/${model}). Use xhigh for other models.`);
@@ -24,15 +27,15 @@ export function resolveEffort(provider, model, effort) {
         return { kind: "none" };
     }
     if (provider === "claude" && ["sonnet", "opus", "opus-4-8"].includes(model)) {
-        if (["low", "medium", "high", "xhigh", "max"].includes(effort)) {
+        if (["medium", "high", "xhigh", "max"].includes(effort)) {
             return { kind: "flag", value: effort };
         }
     }
     if (provider === "codex") {
         if (effort === "max") {
-            throw new Error(`max effort is not valid for gpt-5.5 (Codex). Valid: low, medium, high, xhigh.`);
+            throw new Error(`max effort is not valid for gpt-5.5 (Codex). Valid: medium, high, xhigh.`);
         }
-        if (["low", "medium", "high", "xhigh"].includes(effort)) {
+        if (["medium", "high", "xhigh"].includes(effort)) {
             return { kind: "flag", value: effort };
         }
     }

package/dist/hooks/orchestration-claude.js

@@ -1,7 +1,6 @@
 import { realpathSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { countJsonlType, runHook, } from "../orchestration/hook-core.js";
-import { resetToolCount } from "../orchestration/pretool.js";
 /**
  * Claude Code UserPromptSubmit hook entry. Reads the JSON payload from stdin,
  * runs the provider-agnostic core with the Claude adapter, and writes the
@@ -51,9 +50,6 @@ export const claudeAdapter = {
 };
 export function runClaudeHook(payload, env, adapter = claudeAdapter) {
     try {
-        if (!adapter.isSubagent(payload, env)) {
-            resetToolCount(payload);
-        }
         return runHook(payload, env, adapter);
     }
     catch {

package/dist/index.js

@@ -20,6 +20,7 @@ import { createDeadlockWindow } from "./deadlock.js";
 import { createRulesetGate, RULESET_HARD_FAIL_MSG, } from "./ruleset.js";
 import * as orchestrationMarker from "./orchestration/marker.js";
 import { startLivenessHeartbeat } from "./orchestration/liveness.js";
+import { ensureParentMarker } from "./launch-prompt.js";
 const agents = new Map();
 const MAX_CLAUDE = 5;
 const MAX_CODEX = 5;
@@ -116,11 +117,11 @@ 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 = "BINDING IN BOTH MODES - SOLE CHANNEL: while this server is connected, EVERY sub-agent launch goes through launch_agent; harness Task/Agent tools AND any other spawn path (shell claude -p/codex exec, skills) FORBIDDEN. 5-CALL RULE: >5 tool calls needed for the request (all turns, no reset), or >5 already spent? If yes you MUST use orchestration mode + this server; OFF -> ask the user before enabling, a decline authorizes inline for that request. ORCHESTRATION MODE (orchestration-mode tool). WHAT: per-project toggle for LONG-HORIZON work that would fill the context window inline. OPERATING MODEL: when ON you are a delegate-default orchestrator: decompose, DELEGATE/offload; EVERY reply starts: route: delegate|inline - <reason>. MUST DELEGATE/OFFLOAD: pure compute; any payload >50KB or >200 lines via temp scratch-file path handoff (%TEMP% / /tmp); mixed = SPLIT (one MCP-bound step != whole-task inline); keep the orchestrator context lean. INLINE BY RIGHT - the ONLY exemption: steps bound to main-session-only capability (non-inheritable MCP tools, interactive/consent tools, verify loops = re-run existing checks); state which and why. CONFLICT ORDER: safety-scope > user instruction this turn > 5-CALL RULE/delegate-default. User tool-pin re-partitions work; never suspends mode. PERSISTENCE: per-project marker; survives restarts/sessions until disabled with user permission. CARRYOVER: inherited-ON gets a notice ONCE per marker; you MUST tell the user it auto-activated, ask keep ON?, advise fit. DISABLE: never on own initiative. You MAY propose it on task-fit mismatch (bounded/interactive/MCP-bound): explain WHAT+WHY, ask via AskUserQuestion (Claude) / request-user-input (Codex); only explicit approval may call orchestration-mode enabled:false. Declined -> continue under inline-by-right; ask once per topic, never re-nag. Per-turn injection: CLI hosts with bundled hook only; desktop hosts toggle the marker but inject nothing.";
+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.";
 const server = new McpServer({
     name: "subagent-mcp",
-    version: "2.8.6",
+    version: "2.8.7",
     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"
@@ -429,16 +430,20 @@ function sameTriples(a, b) {
     return a.every((c, i) => c.provider === b[i].provider && c.model === b[i].model && c.effort === b[i].effort);
 }
 // Tool 1: launch_agent
-server.tool("launch_agent", "Spawn a sub-agent session. AUTO MODE (mandatory first attempt unless an override is licensed below): pass only `prompt` + `task_category` and NO overrides; the server picks the best provider/model/effort for that category from its routing table, launches the top candidate, and silently falls back to the next-best on launch failure. `provider`/`model`/`effort` are overrides — licensed on 1st/2nd attempts ONLY when the task verifiably requires a specific capability; STATE that capability when overriding; if you pass `model` you must also pass `provider`, and if you pass `effort` you must pass both `provider` and `model`. SOLE CHANNEL: while this server is connected this tool is the ONLY sanctioned way to spawn sub-agents, in BOTH orchestration states — harness-native Task/Agent tools are FORBIDDEN for sub-agent launches. PROMPT RULE: the FIRST line of every `prompt` MUST be \"<this is a request from a parent process>\" (sub-agent self-identification). Unsure which task_category fits? Don't submit one amorphous task — SPLIT into atomic steps that each map to a single category, one agent per step. ultracode effort is Opus 4.8+ only. Claude uses a Claude Agent SDK logical session over the local Claude executable; Codex uses a `codex app-server` child. Children run with env SUBAGENT_MCP_SUBAGENT=1 so the orchestration hooks skip them (they are not orchestrators and don't re-trigger carryover). Launch returns status `processing` (alive); a later `stalled` is alive-but-quiet (thinking or awaiting a temp-file handoff), NOT dead — wait or re-poll, don't kill (see poll_agent). DEADLOCK RULE: you MUST ALWAYS set `deadlock=true` when 2 launch attempts for the SAME atomic task have already failed or been unsatisfactory (the 3rd attempt onward; re-wording or re-splitting the prompt does NOT make it a different task), and NEVER otherwise — from the 3rd attempt deadlock outranks any capability override: drop provider/model/effort.", {
+server.tool("launch_agent", "Spawn a sub-agent session. AUTO MODE (mandatory first attempt unless an override is licensed below): pass only `prompt` + `task_category` and NO overrides; the server picks the best provider/model/effort for that category from its routing table, launches the top candidate, and silently falls back to the next-best on launch failure. `provider`/`model`/`effort` are overrides — licensed on 1st/2nd attempts ONLY when the task verifiably requires a specific capability; STATE that capability when overriding; if you pass `model` you must also pass `provider`, and if you pass `effort` you must pass both `provider` and `model`. SOLE CHANNEL: while this server is connected this tool is the ONLY sanctioned way to spawn sub-agents, in BOTH orchestration states — harness-native Task/Agent tools are FORBIDDEN for sub-agent launches. PROMPT RULE: every sub-agent `prompt`'s first line is the self-identification marker \"<this is a request from a parent process>\"; the server now UPSERTS this marker as the true first line automatically (idempotent — it is never duplicated and your prompt body is never mutated), so you need not add it yourself. Unsure which task_category fits? Don't submit one amorphous task — SPLIT into atomic steps that each map to a single category, one agent per step. ultracode effort is Opus 4.8+ only. Claude uses a Claude Agent SDK logical session over the local Claude executable; Codex uses a `codex app-server` child. Children run with env SUBAGENT_MCP_SUBAGENT=1 so the orchestration hooks skip them (they are not orchestrators and don't re-trigger carryover). Launch returns status `processing` (alive); a later `stalled` is alive-but-quiet (thinking or awaiting a temp-file handoff), NOT dead — wait or re-poll, don't kill (see poll_agent). DEADLOCK RULE: you MUST ALWAYS set `deadlock=true` when 2 launch attempts for the SAME atomic task have already failed or been unsatisfactory (the 3rd attempt onward; re-wording or re-splitting the prompt does NOT make it a different task), and NEVER otherwise — from the 3rd attempt deadlock outranks any capability override: drop provider/model/effort.", {
     task_category: z.enum(TASK_CATEGORIES).describe(TASK_CATEGORY_GLOSS),
     prompt: z.string().min(1),
     provider: z.enum(["claude", "codex"]).optional(),
     model: z.enum(["haiku", "sonnet", "opus", "opus-4-8", "gpt-5.5"]).optional(),
-    effort: z.enum(["low", "medium", "high", "xhigh", "max", "ultracode"]).optional(),
+    effort: z.enum(["medium", "high", "xhigh", "max", "ultracode"]).optional(),
     cwd: z.string().optional(),
     deadlock: z.boolean().optional().describe("MANDATE: ALWAYS set deadlock=true when, and ONLY when, 2 launch attempts for the SAME atomic task have already failed or been unsatisfactory — the 3rd attempt onward. Re-wording the prompt does NOT make it a different task; splitting a failed task does NOT reset attempts for its unchanged parts; re-launching for the same deliverable means the prior attempt COUNTS as failed/unsatisfactory ('partial progress' is not an exemption). NEVER set it on a 1st or 2nd attempt, NEVER for a different task, NEVER speculatively. Auto mode only: cannot be combined with provider/model/effort — from the 3rd attempt deadlock outranks any capability override, so drop those params. Passing false is identical to omitting it."),
 }, async (params) => {
-    const { task_category, provider, model, effort, prompt, deadlock } = params;
+    const { task_category, provider, model, effort, deadlock } = params;
+    // D19/D20/S8: server silently upserts the parent-process marker as the TRUE
+    // first line of every sub-agent prompt (idempotent; never duplicates; never
+    // mutates the body). This is what makes the child first-line exemption fire.
+    const prompt = ensureParentMarker(params.prompt);
     const agentCwd = params.cwd || process.cwd();
     // 1-5. Param-presence validation (zod already constrains task_category, but
     //       hard-validate so the spec error text — valid list + hints, and the
@@ -897,7 +902,7 @@ server.tool("wait", "Blocks until one or more sub-agents reach a reportable stat
     };
 });
 // Tool 7: orchestration-mode
-server.tool("orchestration-mode", "Toggle or query per-project ORCHESTRATION MODE. `enabled`: true = ON, false = OFF, omit = query current state. SOLE CHANNEL: the subagent MCP is the ONLY sanctioned channel for launching sub-agents whether this mode is ON or OFF, and the 5-CALL RULE (>5 tool calls needed for the request — all turns, no reset — or >5 already spent → ON: delegate via the subagent MCP; OFF: ask the user before enabling) binds in BOTH states — toggling OFF lifts neither obligation. The FULL operating model + governance is carried in this server's MCP `instructions` (read once at initialize) — this is the operational summary only; do not act on the mode without that detail. WHAT: a per-project toggle for LONG-HORIZON work that would fill the context window if run to completion inline; when ON, act as an orchestrator with delegate-default, but steps bound to main-session-only capability stay INLINE BY RIGHT (state which + why). PERSISTENCE: a per-project marker keyed by cwd; absence of the marker = OFF = no injection; once ON it persists across restarts/sessions until a permitted disable (it does NOT reset on a new session). CARRYOVER: if ON was inherited from a PRIOR session (provenance = carried-over, not user-enabled this session), the bundled hook prepends a ONE-TIME notice (once per marker, never per turn) — you MUST then notify the user it auto-activated and confirm whether to keep it ON. DISABLE: never on your own initiative; you MAY PROPOSE turning it OFF on task-fit mismatch, but only EXPLICIT user permission (AskUserQuestion on Claude, request-user-input on Codex) may set enabled:false. Per-turn injection fires only in CLI hosts that load the bundled hook; desktop hosts toggle the marker but inject nothing (documented degradation).", {
+server.tool("orchestration-mode", "Toggle or query per-project ORCHESTRATION MODE. `enabled`: true = ON, false = OFF, omit = query current state. SOLE CHANNEL: the subagent MCP is the ONLY sanctioned channel for launching sub-agents whether this mode is ON or OFF — toggling OFF does not lift that obligation. When OFF, run the per-turn upgrade check: a long-horizon task = any whose TOTAL context footprint (input read + output produced) exceeds 200 lines, measured CUMULATIVELY since your last upgrade ask; after EVERY user turn, if it qualifies, STOP and ask the user whether to switch ON (ask every qualifying turn; a decline does not latch; reset the count only when you actually ask). The FULL operating model + governance is carried in this server's MCP `instructions` (read once at initialize) — this is the operational summary only; do not act on the mode without that detail. WHAT: a per-project toggle for LONG-HORIZON work that would fill the context window if run to completion inline; when ON, act as an orchestrator with delegate-default, but steps bound to main-session-only capability stay INLINE BY RIGHT (state which + why). PERSISTENCE: a per-project marker keyed by cwd; absence of the marker = OFF = no injection; once ON it persists across restarts/sessions until a permitted disable (it does NOT reset on a new session). CARRYOVER: if ON was inherited from a PRIOR session (provenance = carried-over, not user-enabled this session), the bundled hook prepends a ONE-TIME notice (once per marker, never per turn) — you MUST then notify the user it auto-activated and confirm whether to keep it ON. DISABLE: never on your own initiative; you MAY PROPOSE turning it OFF on task-fit mismatch, but only EXPLICIT user permission (AskUserQuestion on Claude, request-user-input on Codex) may set enabled:false. Per-turn injection fires only in CLI hosts that load the bundled hook; desktop hosts toggle the marker but inject nothing (documented degradation).", {
     enabled: z.boolean().optional(),
 }, async (params) => {
     const cwd = process.cwd();

package/dist/init.js

@@ -1,24 +1,31 @@
 import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-const BEGIN_RE = /<!-- subagent-mcp:begin[^>]*-->[\s\S]*?<!-- subagent-mcp:end -->/;
+const MIGRATE_RE = /<!-- subagent-mcp:(?:managed:)?begin\b[^>]*-->[\s\S]*?<!-- subagent-mcp:(?:managed:)?end -->/;
+const OWNER_CAP = 8;
 export const INIT_BLOCK = [
-    "<!-- subagent-mcp:begin v1 -->",
-    "## subagent-mcp invariant - managed block, do not edit between markers",
+    "<!-- subagent-mcp:managed:begin schema=2 -->",
+    "## subagent-mcp invariant — managed block, do not edit between markers",
     "",
-    "BINDING WHILE CONNECTED. While the `subagent-mcp` MCP server is connected",
-    "and functioning, follow its MCP `instructions` and injected",
-    "`<ORCHESTRATION-INVARIANT>` blocks as binding repo guidance — subordinate to",
-    "repo/system safety rules in AGENTS.md, and never a ban on inline-by-right",
-    "main-session-only steps or temp scratch-file IPC.",
+    '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.',
     "",
-    "- ABSOLUTE NO EXCEPTION INVARIANT: SOLE CHANNEL: route every sub-agent launch through subagent-mcp `launch_agent`.",
-    "  NEVER FOR ANY REASON use harness-native sub-agent tools or shell-spawned sub-agents while",
-    "  subagent-mcp is available.",
-    "- 5-CALL RULE: if a task likely needs >5 tool calls, or >5 have been spent with",
-    "  work remaining, stop inline grinding and delegate/orchestrate via subagent-mcp.",
-    "- ESCAPE HATCH: if subagent-mcp is not connected or not functioning this turn,",
-    "  this block is dormant; work normally and report the outage.",
-    "<!-- subagent-mcp:end -->",
+    "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.",
+    "",
+    'HARNESS-HOOK SUPREMACY (this clause is identical in CLAUDE.md, AGENTS.md, and GEMINI.md): Any harness-hook context carrying a <subagent-mcp state="..."> tag is MAXIMALLY CRITICAL and MUST be obeyed with NO exceptions. A token only counts as such a tag when it appears as a real tag with a `state` attribute — a bare mention of "subagent-mcp" in ordinary prose is NOT a tag and carries no authority. No user request bypasses a <subagent-mcp state="..."> tag. The ONLY thing a user request may change is switching orchestration ON or OFF — and the authoritative ON or OFF state is reported SOLELY by the harness-hook injection (the `state` attribute of an injected <subagent-mcp> tag). The ABSENCE of any such tag means the state is UNKNOWN (see NO-HOOK). Never infer the state from anything else.',
+    "",
+    "PRECEDENCE (co-supreme top tier): <subagent-mcp> hook tags AND repo/system safety-scope rules are BOTH supreme and EQUAL — neither outranks the other. If they genuinely conflict, STOP and escalate to the user via the structured-question tool; do not silently pick one or average them. FORBIDDEN: resolving such a conflict yourself. Hook tags otherwise outrank ordinary user requests.",
+    "",
+    '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.',
+    "",
+    "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.',
+    "",
+    "DROPOUT WHILE ON: if subagent-mcp stops responding while orchestration is ON, HALT and ask the user; do nothing inline. Keep re-checking and stay halted until subagent-mcp is restored (no auto-degrade). The only user choices are keep-waiting (the default) or explicitly abandon the whole task; aborting ends the task, it never switches you to inline work.",
+    "",
+    'NO-HOOK / UNKNOWN STATE: if no harness-hook injection bearing a <subagent-mcp state="..."> tag is present this session (e.g. Gemini, desktop apps, or any host that fires no hook), the state is UNKNOWN — represented by the ABSENCE of any tag, never by a tag value. Emit this UNKNOWN-STATE WARNING to the user: "subagent-mcp: no hook injection detected — orchestration state unknown; defaulting to ON". Briefly explain WHY: no hook injection detected — cannot verify orchestration state; defaulting to ON to prevent uncontrolled inline execution. Then DEFAULT TO ORCHESTRATION ON (fail-safe). One-time opt-out: if you are not currently running an orchestration workflow, you may explicitly opt out of ON for this session by saying so now; this opt-out does not persist and is not recorded. The sub-agent first-line exemption is the ONLY automatic suppressor of this default.',
+    "",
+    "DISABLE: never on your own initiative; you MAY propose OFF on task-fit mismatch via the structured-question tool, and only explicit user approval may call orchestration-mode enabled:false.",
+    "<!-- subagent-mcp:managed:end -->",
 ].join("\n");
 function detectEol(s) {
     const crlf = s.indexOf("\r\n");
@@ -39,15 +46,21 @@ function collapseBlankRuns(s, eol) {
     return s.replace(new RegExp(`(?:${eol}){3,}`, "g"), `${eol}${eol}`);
 }
 function removeManagedBlock(body, eol) {
-    const match = body.match(BEGIN_RE);
-    const next = collapseBlankRuns(body.replace(BEGIN_RE, ""), eol);
+    const match = body.match(MIGRATE_RE);
+    let stripped = body;
+    let removed = 0;
+    while (removed <= OWNER_CAP && MIGRATE_RE.test(stripped)) {
+        stripped = stripped.replace(MIGRATE_RE, "");
+        removed++;
+    }
+    const next = collapseBlankRuns(stripped, eol);
     if (!match || match.index !== 0)
         return next;
     let trimmed = next;
-    let removed = 0;
-    while (trimmed.startsWith(eol) && removed < 2) {
+    let trimmedCount = 0;
+    while (trimmed.startsWith(eol) && trimmedCount < 2) {
         trimmed = trimmed.slice(eol.length);
-        removed++;
+        trimmedCount++;
     }
     return trimmed;
 }
@@ -76,7 +89,7 @@ export function upsertInitBlock(file, opts = {}) {
     let next = body;
     let status;
     if (opts.remove) {
-        if (!exists || !BEGIN_RE.test(body)) {
+        if (!exists || !MIGRATE_RE.test(body)) {
             status = "absent";
         }
         else {
@@ -88,14 +101,32 @@ export function upsertInitBlock(file, opts = {}) {
         next = `${block}${eol}`;
         status = "created";
     }
-    else if (BEGIN_RE.test(body)) {
-        const current = body.match(BEGIN_RE)?.[0] ?? "";
-        if (current === block) {
-            status = "ok";
+    else if (MIGRATE_RE.test(body)) {
+        const matches = body.match(new RegExp(MIGRATE_RE.source, "g"));
+        if (matches && matches.length > 1) {
+            const firstIdx = body.search(MIGRATE_RE);
+            const replaced = body.replace(MIGRATE_RE, block);
+            const afterPos = firstIdx + block.length;
+            const head = replaced.slice(0, afterPos);
+            let tail = replaced.slice(afterPos);
+            let removed = 0;
+            while (removed < OWNER_CAP && MIGRATE_RE.test(tail)) {
+                tail = tail.replace(MIGRATE_RE, "");
+                removed++;
+            }
+            next = collapseBlankRuns(head + tail, eol);
+            status = "updated";
+            console.error(`collapsed ${removed} duplicate managed blocks in ${file}`);
         }
         else {
-            next = body.replace(BEGIN_RE, block);
-            status = "updated";
+            const current = body.match(MIGRATE_RE)?.[0] ?? "";
+            if (current === block) {
+                status = "ok";
+            }
+            else {
+                next = body.replace(MIGRATE_RE, block);
+                status = "updated";
+            }
         }
     }
     else {

package/dist/launch-prompt.js

@@ -0,0 +1,29 @@
+// Pure sub-agent first-line marker upsert (S8 / D20). Spec: Appendix A7 of
+// docs/spec/dev-loop/orchestration-directive-architecture.md.
+//
+// `launch_agent` routes every sub-agent prompt through ensureParentMarker before
+// spawn so the canonical child-session identifier is ALWAYS the literal first
+// line — this is what makes the §6 first-line exemption fire and prevents the §5
+// fail-safe-ON default from recursively orchestrating child sessions (fork-bomb
+// prevention). Idempotent, silent, never mutates the prompt body.
+export const MARKER = "<this is a request from a parent process>";
+// Return `prompt` with MARKER guaranteed as its literal first line.
+// - First line = position 0 up to the first "\n"; a trailing "\r" (CRLF) is
+//   stripped before comparison only.
+// - For the startsWith(MARKER) check ONLY, a leading BOM (U+FEFF) on the first
+//   line is ignored. The prompt body is NEVER mutated.
+// - Leading whitespace is NOT stripped: the spec is "literal first line begins
+//   with MARKER" (D19), so a space-prefixed or line-2 marker counts as ABSENT.
+// - Present (after BOM-strip) -> returned unchanged (no duplicate).
+// - Absent -> MARKER + "\n" + prompt.
+export function ensureParentMarker(prompt) {
+    const nl = prompt.indexOf("\n");
+    let firstLine = nl === -1 ? prompt : prompt.slice(0, nl);
+    if (firstLine.endsWith("\r"))
+        firstLine = firstLine.slice(0, -1);
+    if (firstLine.charCodeAt(0) === 0xfeff)
+        firstLine = firstLine.slice(1);
+    if (firstLine.startsWith(MARKER))
+        return prompt;
+    return MARKER + "\n" + prompt;
+}

package/dist/orchestration/hook-core.js

@@ -11,7 +11,7 @@ import * as reminder from "./reminder.js";
  * turn) READS the marker here and decides what to inject. The hook now emits in
  * BOTH marker states, on a per-prompt counter (reminder.ts): every
  * REMINDER_PERIOD-th prompt injects the LONG mode-specific
- * <ORCHESTRATION-INVARIANT> block, every prompt between injects the
+ * <subagent-mcp> reminder block, every prompt between injects the
  * one-line rule carrier. Marker ON adds the claim machinery: the claim turn
  * (fresh enable or carryover re-claim) emits the FULL directive plus the ON
  * reminder block and re-baselines the counter. (Supersedes LOCKED DECISION 2's

package/dist/orchestration/pretool.js

@@ -1,50 +1,5 @@
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { cwdHash, stateDir } from "./marker.js";
 import { serverAlive } from "./liveness.js";
-import { sessionKey } from "./hook-core.js";
-export const INLINE_TOOL_LIMIT = 5;
 const NATIVE_SUBAGENT_TOOLS = new Set(["Task", "Agent", "Explore"]);
-const QUESTION_TOOLS = new Set(["AskUserQuestion", "ExitPlanMode"]);
-const SUBAGENT_MCP_TOOL_RE = /(^|__)subagent[-_]?mcp(__|$).*(launch_agent|poll_agent|wait|list_agents|send_message|kill_agent)$/i;
-function hash(s) {
-    return createHash("sha256").update(s, "utf8").digest("hex").slice(0, 16);
-}
-function owner(payload) {
-    return sessionKey(payload) ?? "null";
-}
-function countPath(payload) {
-    const cwd = payload.cwd || process.cwd();
-    return join(stateDir, `pretool-${cwdHash(cwd)}-${hash(owner(payload))}.json`);
-}
-function readCount(payload) {
-    try {
-        const parsed = JSON.parse(readFileSync(countPath(payload), "utf8"));
-        return typeof parsed.count === "number" && parsed.count >= 0 ? parsed.count : 0;
-    }
-    catch {
-        return 0;
-    }
-}
-function writeCount(payload, count) {
-    try {
-        mkdirSync(stateDir, { recursive: true, mode: 0o700 });
-        writeFileSync(countPath(payload), JSON.stringify({ owner: owner(payload), count, updated_at: Date.now() }), { encoding: "utf8", mode: 0o600 });
-    }
-    catch {
-        // Fail open: counter persistence is advisory enforcement, not host safety.
-    }
-}
-export function resetToolCount(payload) {
-    try {
-        if (existsSync(countPath(payload)))
-            unlinkSync(countPath(payload));
-    }
-    catch {
-        // Fail open.
-    }
-}
 function decision(permissionDecision, permissionDecisionReason, additionalContext) {
     return {
         hookSpecificOutput: {
@@ -55,20 +10,15 @@ function decision(permissionDecision, permissionDecisionReason, additionalContex
         },
     };
 }
-function isSubagentMcpTool(tool) {
-    return (SUBAGENT_MCP_TOOL_RE.test(tool) ||
-        [
-            "launch_agent",
-            "poll_agent",
-            "wait",
-            "list_agents",
-            "send_message",
-            "kill_agent",
-        ].includes(tool));
-}
-function exemptFromCounter(tool) {
-    return isSubagentMcpTool(tool) || QUESTION_TOOLS.has(tool);
-}
+/**
+ * Claude PreToolUse gate. The ONLY enforcement here is the sole-channel rule:
+ * deny harness-native Task/Agent/Explore while subagent-mcp is alive so all
+ * sub-agent launches route through launch_agent. There is NO inline tool-call
+ * counter — the old inline tool-call-count injection is gone (D11/D24).
+ * Long-horizon
+ * upgrades are now agent-self-driven via the OFF-mode cumulative footprint
+ * check (no hook-side counting).
+ */
 export function runClaudePreTool(payload, env, now = Date.now()) {
     try {
         if (env.SUBAGENT_MCP_SUBAGENT === "1")
@@ -81,13 +31,7 @@ export function runClaudePreTool(payload, env, now = Date.now()) {
         if (NATIVE_SUBAGENT_TOOLS.has(tool)) {
             return decision("deny", "subagent-mcp is alive; harness-native Task/Agent/Explore is not the sanctioned sub-agent channel. Use the subagent-mcp launch_agent MCP tool with the parent-process sentinel as prompt line 1.");
         }
-        if (exemptFromCounter(tool))
-            return null;
-        const next = readCount(payload) + 1;
-        writeCount(payload, next);
-        if (next <= INLINE_TOOL_LIMIT)
-            return null;
-        return decision("ask", `5-CALL RULE: this is tool call ${next} for the current user request. If work remains, delegate through subagent-mcp launch_agent; allow only for main-session-only capability or tight verification.`, "5-CALL RULE reached. Route remaining non-main-session work through subagent-mcp launch_agent; inline only for main-session-only capability or tight verification.");
+        return null;
     }
     catch {
         return null;