@event4u/agent-config 9.28.0 → 9.29.0

package/dist/hooks/dispatch.js

@@ -11744,8 +11744,40 @@ function load_agent_settings(options = {}) {
       _deep_merge(merged, layer);
     }
   }
+  _warn_removed_always_on_keys(merged);
   return merged;
 }
+var REMOVED_ALWAYS_ON_KEYS = [
+  "subagents.enabled",
+  "subagents.auto",
+  "subagents.host_capabilities",
+  "subagents.budget_routing",
+  "ai_team.enabled"
+];
+var _warnedRemovedAlwaysOnKeys = /* @__PURE__ */ new Set();
+function _readDottedSettingsPath(root, dotted) {
+  let node = root;
+  for (const part of dotted.split(".")) {
+    if (typeof node !== "object" || node === null || Array.isArray(node)) {
+      return void 0;
+    }
+    node = node[part];
+  }
+  return node;
+}
+function _warn_removed_always_on_keys(merged) {
+  for (const key of REMOVED_ALWAYS_ON_KEYS) {
+    if (_warnedRemovedAlwaysOnKeys.has(key)) {
+      continue;
+    }
+    if (_readDottedSettingsPath(merged, key) === void 0) {
+      continue;
+    }
+    _warnedRemovedAlwaysOnKeys.add(key);
+    process.stderr.write(`${key} was removed (always-on orchestration); ignored.
+`);
+  }
+}
 function _read_yaml(p) {
   if (!_is_file(p)) {
     return null;
@@ -14196,6 +14228,7 @@ function _build_config(raw, source_path) {
   const cli_call_budget = _build_cli_call_budget(
     _asDict(_getOr(raw, "cli_call_budget", {}))
   );
+  const quorum = _build_quorum(_get(raw, "quorum", "majority"));
   const necessity_classifier = _build_necessity_classifier(
     _asDict(_getOr(raw, "necessity_classifier", {}))
   );
@@ -14221,6 +14254,7 @@ function _build_config(raw, source_path) {
     "debate_gates"
   );
   const restate = _build_restate(_asDict(_getOr(raw, "restate", {})), "restate");
+  const critic_protocol = _build_critic_protocol(_getOr(raw, "critic_protocol", "legacy"));
   const decision_resolution = _build_decision_resolution(
     _asDict(_getOr(raw, "decision_resolution", {}))
   );
@@ -14242,6 +14276,7 @@ function _build_config(raw, source_path) {
     advisors,
     consensus_scoring: consensus,
     cli_call_budget,
+    quorum,
     necessity_classifier,
     model_downgrade,
     debate,
@@ -14250,6 +14285,7 @@ function _build_config(raw, source_path) {
     chairman,
     debate_gates,
     restate,
+    critic_protocol,
     decision_resolution,
     routing,
     low_impact,
@@ -14451,6 +14487,16 @@ function _build_restate(d, scope) {
   }
   return { enabled: Boolean(enabled4) };
 }
+var _VALID_CRITIC_PROTOCOLS = /* @__PURE__ */ new Set(["legacy", "load_bearing"]);
+function _build_critic_protocol(v) {
+  if (v === void 0 || v === null) return "legacy";
+  if (!(_isStr(v) && _VALID_CRITIC_PROTOCOLS.has(v))) {
+    throw new CouncilConfigError(
+      `\`critic_protocol\`=${_pyRepr3(v)} not in ${_sortedListRepr(_VALID_CRITIC_PROTOCOLS)}.`
+    );
+  }
+  return v;
+}
 var _VALID_RESOLUTION_MODES = /* @__PURE__ */ new Set([
   "agent",
   "council",
@@ -14726,7 +14772,7 @@ function _build_defaults(d) {
   if (!_isDict(d)) {
     throw new CouncilConfigError("`defaults` must be a mapping.");
   }
-  const mode = _get(d, "mode", "api");
+  const mode = _get(d, "mode", "auto");
   if (!(_isStr(mode) && _VALID_MODES.has(mode))) {
     throw new CouncilConfigError(
       `defaults.mode=${_pyRepr3(mode)} not in ${_sortedListRepr(_VALID_MODES)}.`
@@ -14888,7 +14934,7 @@ function _build_cost_budget(d) {
   }
   return cb;
 }
-function _build_member(name, cfg, default_mode = "api") {
+function _build_member(name, cfg, default_mode = "auto") {
   if (!_VALID_PROVIDERS.has(name)) {
     throw new CouncilConfigError(
       `members.${name}: unknown provider; valid: ${_sortedListRepr(_VALID_PROVIDERS)}.`
@@ -15005,6 +15051,7 @@ function _build_member(name, cfg, default_mode = "api") {
     prompt_cache_ttl
   };
 }
+var _DEFAULT_CLI_CALLS_PER_DAY = 50;
 function _build_cli_call_budget(d) {
   if (!_isDict(d)) {
     throw new CouncilConfigError("`cli_call_budget` must be a mapping.");
@@ -15016,6 +15063,9 @@ function _build_cli_call_budget(d) {
     );
   }
   const caps = /* @__PURE__ */ new Map();
+  for (const provider of _VALID_PROVIDERS) {
+    caps.set(provider, _DEFAULT_CLI_CALLS_PER_DAY);
+  }
   for (const [provider, value] of Object.entries(raw_caps)) {
     if (!_VALID_PROVIDERS.has(provider)) {
       throw new CouncilConfigError(
@@ -15043,6 +15093,17 @@ function _build_cli_call_budget(d) {
   }
   return { max_calls_per_day: caps, warn_at };
 }
+function _build_quorum(raw) {
+  if (raw === "majority") {
+    return "majority";
+  }
+  if (_isInt(raw) && !_isBool(raw) && raw >= 1) {
+    return raw;
+  }
+  throw new CouncilConfigError(
+    `\`quorum\`=${_pyRepr3(raw)} must be 'majority' or an integer >= 1 (got ${_pyTypeName(raw)}).`
+  );
+}
 function _build_advisor(name, cfg) {
   if (!_isDict(cfg)) {
     throw new CouncilConfigError(`advisors.${name}: must be a mapping.`);
@@ -17998,7 +18059,6 @@ var AI_TEAM_REVIEW_GATE_DEFAULTS = Object.freeze({
   max_consecutive_blocks: 3
 });
 var AI_TEAM_DEFAULTS = Object.freeze({
-  enabled: false,
   model: "auto",
   allow_delegate: false,
   max_calls_per_day: 50,
@@ -18006,13 +18066,13 @@ var AI_TEAM_DEFAULTS = Object.freeze({
   review_gate: AI_TEAM_REVIEW_GATE_DEFAULTS
 });
 var _KNOWN_KEYS = /* @__PURE__ */ new Set([
-  "enabled",
   "model",
   "allow_delegate",
   "max_calls_per_day",
   "suppress_setup_hint",
   "review_gate"
 ]);
+var _DELETED_KEYS = /* @__PURE__ */ new Set(["enabled"]);
 var _KNOWN_REVIEW_GATE_KEYS = /* @__PURE__ */ new Set([
   "managed",
   "max_consecutive_blocks"
@@ -18079,13 +18139,15 @@ function build_ai_team_config(raw) {
     throw new TeamConfigError("`ai_team` must be a mapping.");
   }
   for (const key of Object.keys(raw)) {
+    if (_DELETED_KEYS.has(key)) {
+      continue;
+    }
     if (!_KNOWN_KEYS.has(key)) {
       throw new TeamConfigError(
         `ai_team.${key}: unknown key; valid: [${[..._KNOWN_KEYS].map((k) => `'${k}'`).join(", ")}].`
       );
     }
   }
-  const enabled4 = _requireBool(raw, "enabled", AI_TEAM_DEFAULTS.enabled);
   const allow_delegate = _requireBool(raw, "allow_delegate", AI_TEAM_DEFAULTS.allow_delegate);
   const suppress_setup_hint = _requireBool(
     raw,
@@ -18113,7 +18175,7 @@ function build_ai_team_config(raw) {
     max_calls_per_day = value;
   }
   const review_gate = _build_review_gate("review_gate" in raw ? raw["review_gate"] : void 0);
-  return { enabled: enabled4, model, allow_delegate, max_calls_per_day, suppress_setup_hint, review_gate };
+  return { model, allow_delegate, max_calls_per_day, suppress_setup_hint, review_gate };
 }
 function load_ai_team_config(opts = {}) {
   const settings = opts.settings ?? load_agent_settings({ cwd: opts.cwd ?? process.cwd() });
@@ -18449,7 +18511,7 @@ function main20() {
   } catch {
     config = AI_TEAM_DEFAULTS;
   }
-  if (!config.enabled || !config.review_gate.managed) {
+  if (!config.review_gate.managed) {
     return 0;
   }
   let notice = null;
@@ -18919,7 +18981,10 @@ function sanitizeEvidence(raw) {
   return flat.length <= MAX_EVIDENCE ? flat : `${flat.slice(0, MAX_EVIDENCE - 1)}\u2026`;
 }
 var COMPLAINT_PATTERNS = [
-  /\bdu hast\b[^.!?]{0,60}\b(nicht|falsch|vergessen|ignoriert|übersehen)\b/i,
+  // No \b before the alternation: JS \b is ASCII-only, so a leading umlaut
+  // ("übersehen") never sits on a word boundary — the corpus gate's
+  // near-miss class caught that as a dead alternation branch.
+  /\bdu hast\b[^.!?]{0,60}(nicht|falsch|vergessen|ignoriert|übersehen)\b/i,
   /\bdu (ignorierst|übersiehst)\b/i,
   /\b(das|es) (war|ist) (aber )?falsch\b/i,
   /\bhat nicht (richtig|korrekt) (gearbeitet|funktioniert)\b/i,
@@ -18928,10 +18993,43 @@ var COMPLAINT_PATTERNS = [
   /\bthat'?s (wrong|not right|incorrect)\b/i,
   /\byou (worked|did (it|that)) (wrong|incorrectly)\b/i
 ];
+var COMPLAINT_EXONERATIONS = [
+  /\bdu hast nicht zufällig\b/i,
+  /\bhast du nicht zufällig\b/i,
+  /\byou didn'?t (need|have) to\b/i,
+  /\bit'?s fine\b/i,
+  /\b(kein problem|passt schon|alles gut)\b/i,
+  // Explicit absolution INSIDE the complaint span, which is why it has to be
+  // its own entry rather than relying on a neighbouring pleasantry: in
+  // "das ist fine, du hast nichts falsch gemacht" the matched span is
+  // `du hast nichts falsch`, and the `it's fine` above sits outside the
+  // ± EXONERATION_MARGIN window — correctly, since that margin exists to stop
+  // a pleasantry in one clause muting a complaint in another. `nichts falsch`
+  // is not a neighbouring pleasantry: it is the negation of the complaint
+  // itself. Caught by the detector-corpus gate, which flagged this exact
+  // string as a must-not-fire fixture that fired (PR #1231).
+  /\bnichts falsch\b/i,
+  /\bkein fehler\b/i
+];
+var EXONERATION_MARGIN = 12;
+function spanExonerated(prompt, start, end) {
+  for (const ex of COMPLAINT_EXONERATIONS) {
+    const g = new RegExp(ex.source, ex.flags.includes("g") ? ex.flags : `${ex.flags}g`);
+    let m;
+    while ((m = g.exec(prompt)) !== null) {
+      const s = m.index;
+      const e = m.index + m[0].length;
+      if (e >= start - EXONERATION_MARGIN && s <= end + EXONERATION_MARGIN) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 function detectUserReport(prompt) {
   for (const re of COMPLAINT_PATTERNS) {
     const m = re.exec(prompt);
-    if (m !== null) {
+    if (m !== null && !spanExonerated(prompt, m.index, m.index + m[0].length)) {
       return {
         defect_class: "user-reported",
         source: "user-reported",
@@ -18991,10 +19089,22 @@ function detectLanguageMirror(turn) {
     suggested_surface: `Reply opened in the language the turn was not pinned to (pinned: ${pinned}) \u2014 report which surface carried the pin and why it did not bind.`
   };
 }
+var DETECTOR_REGISTRY = [
+  {
+    defect_class: "user-reported",
+    source: "user-reported",
+    detect: (turn) => detectUserReport(turn.prompt)
+  },
+  { defect_class: "council-availability-claim", source: "self-detected", detect: detectCouncilClaim },
+  { defect_class: "language-mirror", source: "self-detected", detect: detectLanguageMirror }
+];
 function runDetectors(turn) {
   const out = [];
-  for (const d of [detectCouncilClaim, detectLanguageMirror]) {
-    const f = d(turn);
+  for (const d of DETECTOR_REGISTRY) {
+    if (d.source !== "self-detected") {
+      continue;
+    }
+    const f = d.detect(turn);
     if (f !== null) {
       out.push(f);
     }
@@ -22824,6 +22934,7 @@ var BANDS = ["low", "medium", "high"];
 var PHASES = ["refine", "memory", "analyze", "plan", "implement", "test", "verify", "report"];
 var LOOKUP_CLASSES = ["definition", "references", "string-existence", "report-run"];
 var ROUTES_TAKEN = ["primitive", "subagent"];
+var TRIGGER_ARMS = ["watermark", "saturation", "tie"];
 var PAYLOAD_HASH_RE = /^[a-f0-9]{8,64}$/i;
 var ORIGIN_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 function envelopeOutcome(d) {
@@ -22906,6 +23017,19 @@ function buildOrchestrationLine(input) {
   if (input.rules_carried != null && input.rules_used != null && input.rules_used > input.rules_carried) {
     errors.push("rules_used cannot exceed rules_carried (a worker cannot apply a rule it was not given)");
   }
+  if (input.capsule_emitted !== void 0 && typeof input.capsule_emitted !== "boolean") {
+    errors.push("capsule_emitted must be a boolean or omitted");
+  }
+  for (const [key, v] of [
+    ["capsule_entries", input.capsule_entries],
+    ["watermark_step", input.watermark_step],
+    ["saturation_step", input.saturation_step]
+  ]) {
+    if (v != null && (!isInt(v) || v < 0)) errors.push(`${key} must be a non-negative integer count`);
+  }
+  if (input.trigger_arm_earlier != null && !TRIGGER_ARMS.includes(input.trigger_arm_earlier)) {
+    errors.push(`trigger_arm_earlier must be one of ${TRIGGER_ARMS.join(" | ")} (or omitted / null when neither arm fired)`);
+  }
   if (!input.ts) errors.push("ts (ISO-8601 UTC) is required");
   if (!input.id) errors.push("id (ULID or content hash) is required");
   if (errors.length) return { line: null, errors };
@@ -22937,7 +23061,13 @@ function buildOrchestrationLine(input) {
     cache_hit: input.cache_hit ?? null,
     origin: input.origin ?? null,
     rules_carried: input.rules_carried ?? null,
-    rules_used: input.rules_used ?? null
+    rules_used: input.rules_used ?? null,
+    // capsule shadow-measurement — readers ignore unknowns per audit-log-v1
+    capsule_emitted: input.capsule_emitted ?? null,
+    capsule_entries: input.capsule_entries ?? null,
+    watermark_step: input.watermark_step ?? null,
+    saturation_step: input.saturation_step ?? null,
+    trigger_arm_earlier: input.trigger_arm_earlier ?? null
   };
   const line = {
     schema_version: 1,
@@ -23046,6 +23176,11 @@ function main37(argv = process.argv.slice(2)) {
     origin: str2(flags, "origin"),
     rules_carried: int(flags, "rules-carried"),
     rules_used: int(flags, "rules-used"),
+    capsule_emitted: bool(flags, "capsule-emitted"),
+    capsule_entries: int(flags, "capsule-entries"),
+    watermark_step: int(flags, "watermark-step"),
+    saturation_step: int(flags, "saturation-step"),
+    trigger_arm_earlier: str2(flags, "trigger-arm-earlier"),
     phase: str2(flags, "phase"),
     outcome: str2(flags, "outcome"),
     confidence_band: str2(flags, "confidence-band"),
@@ -23228,12 +23363,15 @@ import path55 from "node:path";
 import { fileURLToPath as fileURLToPath39, pathToFileURL as pathToFileURL34 } from "node:url";
 
 // src/scripts/_lib/host_capability.ts
+import process10 from "node:process";
 var SAFE_DEFAULT = {
   schema_version: 1,
   subagent_spawn: false,
   parallel_spawn: false,
   status_polling: false,
-  separate_quota_pool: false
+  separate_quota_pool: false,
+  agent_teams: false,
+  worker_respawn: false
 };
 function asBool(value) {
   return value === true;
@@ -23248,7 +23386,9 @@ function normalizeHostManifest(input) {
     subagent_spawn: asBool(src.subagent_spawn),
     parallel_spawn: asBool(src.parallel_spawn),
     status_polling: asBool(src.status_polling),
-    separate_quota_pool: asBool(src.separate_quota_pool)
+    separate_quota_pool: asBool(src.separate_quota_pool),
+    agent_teams: asBool(src.agent_teams),
+    worker_respawn: asBool(src.worker_respawn)
   };
 }
 var HOST_CAPABILITY_REGISTRY = {
@@ -23264,6 +23404,12 @@ function resolveHostCapabilities(hostId, override) {
   }
   return { ...SAFE_DEFAULT, ...row, schema_version: 1 };
 }
+function probeHostCapabilities(hostId) {
+  const base = resolveHostCapabilities(hostId);
+  const flag = process10.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+  const probedAgentTeams = typeof flag === "string" && flag !== "";
+  return { ...base, agent_teams: base.agent_teams || probedAgentTeams };
+}
 
 // src/scripts/_lib/auto_dispatch.ts
 var SIZE_FLOOR = 1;
@@ -23271,8 +23417,7 @@ function inSession(reason) {
   return { delegable: false, action: "in-session", mode: null, reason };
 }
 function classifyTask(signals, activation) {
-  if (!activation.enabled) return inSession("subagents.enabled is false");
-  if (activation.auto === "off") return inSession("subagents.auto is off");
+  if (activation.halted) return inSession("emergency.orchestration_halt is set");
   if (!activation.subagent_spawn) return inSession("host has no subagent_spawn primitive");
   if (!(signals.size_estimate > SIZE_FLOOR)) {
     return inSession(`task below size floor (${signals.size_estimate} <= ${SIZE_FLOOR})`);
@@ -23288,13 +23433,197 @@ function classifyTask(signals, activation) {
     reason = signals.parallelizable ? `declared parallelizable: ${signals.parallelizable}` : `independent slices (${slices})`;
   }
   if (mode === null) {
-    if (activation.auto === "ask") {
-      return { delegable: false, action: "ask", mode: null, reason: "no delegable signal \u2014 borderline, ask" };
+    return { delegable: false, action: "ask", mode: null, reason: "no delegable signal \u2014 borderline, ask" };
+  }
+  return { delegable: true, action: "dispatch", mode, reason };
+}
+var LOOKUP_PATTERNS = [
+  {
+    cls: "definition",
+    primitive: "code-graph-query",
+    re: /\b(where\s+is\s+\S+\s+defined|definition\s+(location|of|site)|find\s+the\s+definition|locate\s+the\s+(class|enum|function|type|interface|symbol)|confirm\w*\s+\S+\s+definition)\b/i
+  },
+  {
+    cls: "references",
+    primitive: "code-graph-query",
+    re: /\b(who\s+(calls|imports|uses|references)|call\s*sites?|import\s+(call\s*)?sites?|reverse\s+references|where\s+is\s+\S+\s+(used|imported|referenced|called)|all\s+(callers|usages|references)\s+of)\b/i
+  },
+  {
+    cls: "string-existence",
+    primitive: "fts-or-capped-grep",
+    re: /\b(does\s+(the\s+)?string\s+.*\bexist|is\s+(the\s+)?string\s+.*\b(present|used)\b|prob\w+\s+(candidate\s+)?strings?|search\s+for\s+the\s+(exact\s+)?string|(grep|check)\s+(for\s+)?(the\s+)?(literal|string)\b|does\s+\S+\s+appear\s+anywhere)/i
+  },
+  {
+    cls: "report-run",
+    primitive: "script-run-rtk",
+    re: /\b(run(ning)?\s+(the\s+)?\S*(report|check|lint\w*|coverage)\b|run(ning)?\s+(check|lint|report)_\w+|regenerate\s+the\s+\S+\s+report)/i
+  }
+];
+function classifyLookup(taskText) {
+  for (const p of LOOKUP_PATTERNS) {
+    if (p.re.test(taskText)) {
+      return {
+        lookup_class: p.cls,
+        route: "primitive",
+        primitive: p.primitive,
+        reason: `lookup-class ${p.cls} \u2014 deterministic primitive, no spawn`
+      };
     }
-    return inSession("no enumerated delegable signal matched");
   }
-  const action = activation.auto === "on" ? "dispatch" : "ask";
-  return { delegable: true, action, mode, reason };
+  return {
+    lookup_class: null,
+    route: "escalate",
+    primitive: null,
+    reason: "not lookup-shaped \u2014 regular classification path (never down-guessed)"
+  };
+}
+
+// src/scripts/_lib/judgment_ladder.ts
+var RENAME_RE = /\brename\s+\S+\s+to\s+\S+\b/i;
+var CODEMOD_RE = /\bcodemod\b/i;
+var FORMATTER_RUN_RE = /\bauto-?format(?:ting)?\b|\breformat(?:ting)?\b|\brun(?:ning)?\s+prettier\b|\brun(?:ning)?\s+eslint\s*--fix\b|\bapply\s+eslint\s*--fix\b/i;
+var SEARCH_REPLACE_RE = /\bsearch-and-replace\b|\bfind-and-replace\b|\bbulk\s+rename\b/i;
+function detectMechanicalTransform(text) {
+  const rename = RENAME_RE.exec(text);
+  if (rename) {
+    return { matched: true, reason: `rename signal ("${rename[0]}") \u2014 deterministic script, no spawn` };
+  }
+  const codemod = CODEMOD_RE.exec(text);
+  if (codemod) {
+    return { matched: true, reason: `codemod signal ("${codemod[0]}") \u2014 deterministic script, no spawn` };
+  }
+  const formatter = FORMATTER_RUN_RE.exec(text);
+  if (formatter) {
+    return { matched: true, reason: `formatter-run signal ("${formatter[0]}") \u2014 deterministic script, no spawn` };
+  }
+  const searchReplace = SEARCH_REPLACE_RE.exec(text);
+  if (searchReplace) {
+    return {
+      matched: true,
+      reason: `search-and-replace/bulk-rename signal ("${searchReplace[0]}") \u2014 deterministic script, no spawn`
+    };
+  }
+  return { matched: false, reason: "no mechanical-transform signal" };
+}
+var SINGLE_SLICE_READHEAVY_RE = /\b(?:read|review|summarize|summarise|inventory|audit|investigate|research|inspect|dig into|look into)\b[^.!?\n]{0,80}\b(?:this file|the file|this codebase|the codebase|this transcript|the transcript|this log|the log|this document|the document|this diff|the diff)\b/i;
+function detectBoundedReadHeavySlice(text) {
+  const m = SINGLE_SLICE_READHEAVY_RE.exec(text);
+  return m ? {
+    matched: true,
+    reason: `single bounded read-heavy slice ("${m[0]}") \u2014 one lite-tier subagent instead of session-context burn`
+  } : { matched: false, reason: "no single-slice read-heavy signal" };
+}
+var CROSS_LAYER_RE = /\bcross[- ]layer\b|\bcross[- ]cutting\b|\bback[- ]?end\s+and\s+front[- ]?end\b|\bfront[- ]?end\s+and\s+back[- ]?end\b/i;
+var REVIEW_WITH_CHALLENGE_RE = /\breview[- ]with[- ]challenge\b|\bchallenge[- ]and[- ]implement\b|\bimplementer\s+and\s+(?:a\s+)?(?:judge|reviewer)\s+(?:working\s+)?together\b|\bsecond\s+opinion\s+while\s+(?:building|implementing)\b/i;
+var SHARED_TASK_LIST_RE = /\bshared\s+(?:task\s+list|todo\s+list|backlog)\b|\bcoordinat(?:e|ed|ing)\s+(?:with|between|across)\s+(?:multiple\s+|several\s+)?(?:agents|workers|subagents|teammates)\b/i;
+function detectCommunicationNeed(text) {
+  const crossLayer = CROSS_LAYER_RE.exec(text);
+  if (crossLayer) {
+    return { matched: true, reason: `cross-layer communication signal ("${crossLayer[0]}")` };
+  }
+  const reviewChallenge = REVIEW_WITH_CHALLENGE_RE.exec(text);
+  if (reviewChallenge) {
+    return { matched: true, reason: `review-with-challenge signal ("${reviewChallenge[0]}")` };
+  }
+  const sharedList = SHARED_TASK_LIST_RE.exec(text);
+  if (sharedList) {
+    return { matched: true, reason: `shared-task-list signal ("${sharedList[0]}")` };
+  }
+  return { matched: false, reason: "no communication-need signal" };
+}
+var DESIGN_DECISION_RE = /\bdesign\s+decision\b|\barchitectur(?:e|al)\s+decision\b|\b(?:record(?:ing)?|decide|deciding|decision|accept(?:ed|ing)?|approv(?:e|ed|ing|al)|challeng(?:e|ed|ing)|choos(?:e|ing)|reject(?:ed|ing)?)\b[^.!?\n]{0,40}\bADR\b|\bADR\b[^.!?\n]{0,40}\b(?:record(?:ing)?|decide|deciding|decision|accept(?:ed|ing)?|approv(?:e|ed|ing|al)|challeng(?:e|ed|ing)|choos(?:e|ing)|reject(?:ed|ing)?)\b/i;
+var SECURITY_DOWNGRADE_RE = /\bsecurity\s+downgrade\b|\bdowngrade\s+(?:the\s+)?security\b|\bsecurity\s+exception\b/i;
+var RELEASE_GATE_ESCALATION_RE = /\bgate\s+escalation\b|\bescalat(?:e|ion)\s+to\s+(?:the\s+)?council\b|\b(?:escalat(?:e|ing|ion)|contest(?:ed|ing)?|dispute|disputing|override|overriding|waiv(?:e|ing)|bypass(?:ed|ing)?|challeng(?:e|ed|ing))\b[^.!?\n]{0,40}\brelease[- ]gate\b|\brelease[- ]gate\b[^.!?\n]{0,40}\b(?:escalat(?:e|ing|ion)|contest(?:ed|ing)?|dispute|disputing|override|overriding|waiv(?:e|ing)|bypass(?:ed|ing)?|challeng(?:e|ed|ing))\b/i;
+function detectContestedJudgment(text) {
+  const design = DESIGN_DECISION_RE.exec(text);
+  if (design) {
+    return { matched: true, reason: `design-decision signal ("${design[0]}")` };
+  }
+  const security = SECURITY_DOWNGRADE_RE.exec(text);
+  if (security) {
+    return { matched: true, reason: `security-downgrade signal ("${security[0]}")` };
+  }
+  const releaseGate = RELEASE_GATE_ESCALATION_RE.exec(text);
+  if (releaseGate) {
+    return { matched: true, reason: `release-gate-escalation signal ("${releaseGate[0]}")` };
+  }
+  return { matched: false, reason: "no contested-judgment signal" };
+}
+function classifyLadder(inp) {
+  if (inp.interactiveApprovalRequired === true) {
+    return {
+      rung: null,
+      verdict: "in-session",
+      reason: "interactive-approval-required \u2014 caller-stated, needs a human decision before anything may run"
+    };
+  }
+  const lookup = classifyLookup(inp.taskText);
+  if (lookup.route === "primitive") {
+    return { rung: 0, verdict: "script", reason: `lookup-class ${lookup.lookup_class} \u2014 ${lookup.reason}` };
+  }
+  const mechanical = detectMechanicalTransform(inp.taskText);
+  if (mechanical.matched) {
+    return { rung: 0, verdict: "script", reason: mechanical.reason };
+  }
+  if (inp.insideSubagentSession === true) {
+    return {
+      rung: null,
+      verdict: "in-session",
+      reason: "recursive-dispatch guard: this classification runs inside a subagent/teammate session \u2014 rungs 1-4 resolve in-session"
+    };
+  }
+  if (inp.activation.halted) {
+    return { rung: null, verdict: "in-session", reason: "emergency.orchestration_halt is set" };
+  }
+  if (!inp.activation.subagent_spawn) {
+    return { rung: null, verdict: "in-session", reason: "host has no subagent_spawn primitive" };
+  }
+  const contested = detectContestedJudgment(inp.taskText);
+  if (contested.matched) {
+    return { rung: 4, verdict: "council", reason: contested.reason };
+  }
+  const communication = detectCommunicationNeed(inp.taskText);
+  if (communication.matched) {
+    if (inp.agentTeams) {
+      return { rung: 3, verdict: "team", reason: communication.reason };
+    }
+    const fallback = classifyTask(inp.signals, inp.activation);
+    if (fallback.action === "dispatch" && fallback.mode !== null) {
+      return {
+        rung: 2,
+        verdict: "subagent",
+        mode: fallback.mode,
+        degraded_from: 3,
+        reason: `${communication.reason} \u2014 no agent_teams host capability, degraded to rung 2 (${fallback.reason})`
+      };
+    }
+    return {
+      rung: null,
+      verdict: fallback.action === "ask" ? "ask" : "in-session",
+      degraded_from: 3,
+      reason: `${communication.reason} \u2014 no agent_teams host capability, degraded below rung 2 (${fallback.reason})`
+    };
+  }
+  const classification = classifyTask(inp.signals, inp.activation);
+  if (classification.action === "dispatch" && classification.mode !== null) {
+    return { rung: 2, verdict: "subagent", mode: classification.mode, reason: classification.reason };
+  }
+  if (inp.signals.size_estimate <= SIZE_FLOOR) {
+    return {
+      rung: null,
+      verdict: classification.action === "ask" ? "ask" : "in-session",
+      reason: classification.reason
+    };
+  }
+  const single = detectBoundedReadHeavySlice(inp.taskText);
+  if (single.matched) {
+    return { rung: 1, verdict: "subagent", mode: null, reason: single.reason };
+  }
+  return {
+    rung: null,
+    verdict: classification.action === "ask" ? "ask" : "in-session",
+    reason: classification.reason
+  };
 }
 
 // src/scripts/_lib/subagent_routing.ts
@@ -23403,16 +23732,16 @@ function extractTaskSignals(text) {
 }
 function resolveActivation(workspace_root, hostId) {
   const settings = load_agent_settings({ cwd: workspace_root });
+  const emergency = settings["emergency"] ?? {};
+  const halted = emergency["orchestration_halt"] === true;
+  const host_manifest = probeHostCapabilities(hostId);
   const sub = settings["subagents"] ?? {};
-  const enabled4 = sub["enabled"] !== false;
-  const rawAuto = sub["auto"];
-  const auto = rawAuto === "on" || rawAuto === "off" ? rawAuto : "ask";
-  const host_manifest = resolveHostCapabilities(hostId, sub["host_capabilities"]);
   const downshift = sub["downshift"] !== false;
   return {
-    activation: { enabled: enabled4, auto, subagent_spawn: host_manifest.subagent_spawn },
+    activation: { halted, subagent_spawn: host_manifest.subagent_spawn },
     downshift,
-    separate_quota_pool: host_manifest.separate_quota_pool
+    separate_quota_pool: host_manifest.separate_quota_pool,
+    agentTeams: host_manifest.agent_teams
   };
 }
 function recommendSliceTier(downshift, separate_quota_pool) {
@@ -23426,23 +23755,32 @@ function recommendSliceTier(downshift, separate_quota_pool) {
   });
   return decision.tier;
 }
-function buildNudgeLine(classification, sliceCount, tier) {
+function buildNudgeLine(rung, classification, sliceCount, tier) {
   const unit = sliceCount === 1 ? "slice" : "slices";
-  return `<delegation-nudge>classifyTask verdict for this prompt: ${classification.mode} (${sliceCount} ${unit}, ${tier} tier recommended). Consider dispatching via subagent-orchestration instead of doing every slice in-session \u2014 ${classification.reason}.</delegation-nudge>`;
+  const rungLabel = rung === null ? "rung-?" : `rung-${rung}`;
+  const modeLabel = classification.mode ?? "single-slice";
+  return `<delegation-nudge>${rungLabel}: dispatch ${modeLabel} (${sliceCount} ${unit}, ${tier} tier recommended). Consider dispatching via subagent-orchestration instead of doing every slice in-session \u2014 ${classification.reason}.</delegation-nudge>`;
 }
 function classifyPrompt(prompt, workspace_root, hostId) {
   try {
     const { signals, sliceCountForLine } = extractTaskSignals(prompt);
-    const { activation, downshift, separate_quota_pool } = resolveActivation(
+    const { activation, downshift, separate_quota_pool, agentTeams } = resolveActivation(
       workspace_root,
       hostId
     );
-    const classification = classifyTask(signals, activation);
-    if (classification.mode === null) {
+    const ladder = classifyLadder({ taskText: prompt, signals, activation, agentTeams });
+    if (ladder.verdict !== "subagent") {
       return null;
     }
     const tier = recommendSliceTier(downshift, separate_quota_pool);
-    return { classification, sliceCount: sliceCountForLine, tier };
+    const sliceCount = ladder.rung === 1 ? 1 : sliceCountForLine;
+    const classification = {
+      delegable: true,
+      action: "dispatch",
+      mode: ladder.mode ?? null,
+      reason: ladder.reason
+    };
+    return { classification, sliceCount, tier, rung: ladder.rung };
   } catch {
     return null;
   }
@@ -23495,8 +23833,8 @@ function main39() {
   process.stdout.write(
     `${JSON.stringify({
       decision: "warn",
-      reason: `delegation-nudge: ${result.classification.mode} verdict (${result.sliceCount} slices, ${result.tier} tier)`,
-      additional_context: buildNudgeLine(result.classification, result.sliceCount, result.tier)
+      reason: `delegation-nudge: rung-${result.rung} verdict (${result.sliceCount} slices, ${result.tier} tier)`,
+      additional_context: buildNudgeLine(result.rung, result.classification, result.sliceCount, result.tier)
     })}
 `
   );