@wrongstack/core 0.286.0 → 0.287.0

package/dist/execution/index.js

@@ -580,8 +580,8 @@ function subjectForToolInput(toolName, input, subjectKey) {
 }
 
 // src/utils/tool-wire-compact.ts
-var TOOL_DESCRIPTION_MAX_CHARS = 640;
-var SCHEMA_DESCRIPTION_MAX_CHARS = 180;
+var TOOL_DESCRIPTION_MAX_CHARS = 400;
+var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
 var compactCache = /* @__PURE__ */ new WeakMap();
 function compactToolDefinitionForWire(tool, opts = {}) {
   const useDefaultOptions = opts.descriptionMaxChars === void 0 && opts.schemaDescriptionMaxChars === void 0;
@@ -1501,14 +1501,34 @@ function resolveToolResultRenderMode(modes, toolName) {
 
 // src/utils/wstack-paths.ts
 import { createHash } from "node:crypto";
+import * as fs2 from "node:fs";
 import * as os from "node:os";
 import * as path2 from "node:path";
+function canonicalProjectRoot(absRoot) {
+  const checkoutRoot = path2.resolve(absRoot);
+  const dotGit = path2.join(checkoutRoot, ".git");
+  try {
+    if (!fs2.statSync(dotGit).isFile()) return checkoutRoot;
+    const gitDirLine = fs2.readFileSync(dotGit, "utf8").trim();
+    const match = /^gitdir:\s*(.+)$/i.exec(gitDirLine);
+    if (!match?.[1]) return checkoutRoot;
+    const gitDir = path2.resolve(checkoutRoot, match[1].trim());
+    const commonDirFile = path2.join(gitDir, "commondir");
+    if (!fs2.statSync(commonDirFile).isFile()) return checkoutRoot;
+    const commonDir = path2.resolve(gitDir, fs2.readFileSync(commonDirFile, "utf8").trim());
+    if (path2.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
+    return path2.dirname(commonDir);
+  } catch {
+    return checkoutRoot;
+  }
+}
 function projectHash(absRoot) {
-  return createHash("sha256").update(path2.resolve(absRoot)).digest("hex").slice(0, 12);
+  return createHash("sha256").update(canonicalProjectRoot(absRoot)).digest("hex").slice(0, 12);
 }
 function projectSlug(absRoot) {
-  const base = slugify2(path2.basename(absRoot));
-  const hash = createHash("sha256").update(path2.resolve(absRoot)).digest("hex").slice(0, 6);
+  const identityRoot = canonicalProjectRoot(absRoot);
+  const base = slugify2(path2.basename(identityRoot));
+  const hash = createHash("sha256").update(identityRoot).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
 function slugify2(name) {
@@ -1775,6 +1795,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   failureMode;
   policyProvider;
   sessionBridge;
+  onCompact;
   /**
    * Once a compaction attempt reduces nothing (preserveK protects everything,
    * no oversized tool_results remain to elide), retrying on every iteration
@@ -1821,6 +1842,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
     this.failureMode = opts.failureMode ?? "throw_on_hard";
     this.policyProvider = opts.policyProvider;
     this.sessionBridge = opts.sessionBridge;
+    this.onCompact = opts.onCompact;
   }
   /** Allow callers (e.g. model-switch in WebUI) to update the context window
    *  denominator when the active model changes. */
@@ -1943,6 +1965,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
     try {
       const report = await this.compactor.compact(ctx, { aggressive });
       this.recordAttempt(pressure.level, pressure.tokens, report);
+      this.onCompact?.(report);
       this.events?.emit("compaction.fired", {
         sessionId: ctx.session.id,
         level: pressure.level,
@@ -1971,7 +1994,8 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
       });
       ctx.clearFileTracking();
       const afterTokens = report.fullRequestTokensAfter ?? report.after;
-      const afterLoad = this._maxContext > 0 ? afterTokens / this._maxContext : 0;
+      const afterBudget = computeContextWindowBudget(ctx, afterTokens, this._maxContext);
+      const afterLoad = afterBudget.load;
       const stillHard = afterLoad >= pressure.hardThreshold;
       const fatal = stillHard && (this.failureMode === "throw" || this.failureMode === "throw_on_hard" && pressure.level === "hard");
       if (stillHard) {
@@ -2254,7 +2278,7 @@ var AutonomousRunner = class {
 };
 
 // src/utils/instruction-file.ts
-import { readFileSync, statSync } from "node:fs";
+import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 import * as path3 from "node:path";
 import { fileURLToPath } from "node:url";
 var textCache = /* @__PURE__ */ new Map();
@@ -2265,7 +2289,7 @@ function readBundledInstructionText(relativePath) {
   let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      resolved = readFileSync(path3.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync2(path3.join(root, relativePath), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -2292,7 +2316,7 @@ function instructionRootCandidates() {
 }
 function isDirectory(candidate) {
   try {
-    return statSync(candidate).isDirectory();
+    return statSync2(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -2565,6 +2589,22 @@ var RETRYABLE_BY_KIND = {
   invalid_request: false,
   unknown: false
 };
+function isFallbackWorthy(kind) {
+  return FALLBACK_WORTHY_BY_KIND[kind];
+}
+var FALLBACK_WORTHY_BY_KIND = {
+  rate_limit: true,
+  overloaded: true,
+  server: true,
+  timeout: true,
+  network: true,
+  stream_hang: true,
+  auth: false,
+  context_overflow: false,
+  content_filter: false,
+  invalid_request: false,
+  unknown: false
+};
 var ProviderError = class extends WrongStackError {
   status;
   retryable;
@@ -2646,6 +2686,10 @@ function kindToCode(kind) {
 }
 
 // src/core/fallback-model.ts
+function visibleProviderModels(config, providerId, providerModels) {
+  const entry = config.providers?.[providerId];
+  return entry?.models !== void 0 ? [...entry.models] : providerModels;
+}
 function parseModelRef(ref) {
   const trimmed = ref.trim();
   const slash = trimmed.indexOf("/");
@@ -2661,8 +2705,174 @@ function parseModelRef(ref) {
   }
   return { model: trimmed };
 }
+function formatModelRef(ref, defaultProvider) {
+  const provider = ref.provider ?? defaultProvider;
+  return provider ? `${provider}/${ref.model}` : ref.model;
+}
+function normalizeModelRef(ref, defaultProvider) {
+  const parsed = parseModelRef(ref);
+  return formatModelRef(parsed, defaultProvider);
+}
+function fallbackProfileChain(config, profileName) {
+  if (!profileName) return [];
+  const chain = config.fallbackProfiles?.[profileName];
+  return Array.isArray(chain) ? chain.filter((ref) => parseModelRef(ref).model) : [];
+}
+function providerHasKey(entry) {
+  if (!entry) return false;
+  if (typeof entry.apiKey === "string" && entry.apiKey.length > 0) return true;
+  if (Array.isArray(entry.apiKeys) && entry.apiKeys.some((k) => k?.apiKey)) return true;
+  if (Array.isArray(entry.envVars) && entry.envVars.some((v) => !!process.env[v])) return true;
+  return false;
+}
+var SMART_DEFAULT_MAX = 4;
+function smartDefaultFallbackChain(config) {
+  const leaderProvider = config.provider;
+  const leaderModel = config.model;
+  const providers = config.providers ?? {};
+  const favoriteSet = new Set(
+    (config.favoriteModels ?? []).map((ref) => normalizeModelRef(ref, leaderProvider))
+  );
+  const hasFavorites = favoriteSet.size > 0;
+  const favoritesOnly = config.favoriteModelsOnly === true;
+  const seen = /* @__PURE__ */ new Set();
+  const favoriteRefs = [];
+  const sameProvider = [];
+  const crossProvider = [];
+  const ids = Object.keys(providers).sort(
+    (a, b) => a === leaderProvider ? -1 : b === leaderProvider ? 1 : a.localeCompare(b)
+  );
+  for (const id of ids) {
+    const entry = providers[id];
+    if (!providerHasKey(entry)) continue;
+    const models = visibleProviderModels(config, id, entry?.models ?? []);
+    for (const model of models) {
+      if (id === leaderProvider && model === leaderModel) continue;
+      const ref = `${id}/${model}`;
+      if (seen.has(ref)) continue;
+      seen.add(ref);
+      if (favoriteSet.has(ref)) {
+        favoriteRefs.push(ref);
+        continue;
+      }
+      if (favoritesOnly && hasFavorites) continue;
+      (id === leaderProvider ? sameProvider : crossProvider).push(ref);
+    }
+  }
+  return [...favoriteRefs, ...sameProvider, ...crossProvider].slice(0, SMART_DEFAULT_MAX);
+}
+function effectiveFallbackChain(config) {
+  const explicit = config.fallbackModels ?? [];
+  const filteredExplicit = explicit.filter((ref) => {
+    const parsed = parseModelRef(ref);
+    if (!parsed.model) return false;
+    const providerId = parsed.provider ?? config.provider;
+    const entry = config.providers?.[providerId];
+    if (!entry?.models) return true;
+    return entry.models.includes(parsed.model);
+  });
+  if (filteredExplicit.length > 0) return filteredExplicit;
+  if (config.fallbackAuto === false) return [];
+  return smartDefaultFallbackChain(config);
+}
 var DEFAULT_PRIMARY_COOLDOWN_MAX_MS = 10 * 6e4;
 
+// src/execution/council-resolution.ts
+function resolveCouncilVotes(input) {
+  validateInput(input);
+  const seatById = new Map(input.seats.map((seat) => [seat.id, seat]));
+  const validVotes = [];
+  const votedSeatIds = /* @__PURE__ */ new Set();
+  for (const vote of input.votes) {
+    if (!seatById.has(vote.seatId) || votedSeatIds.has(vote.seatId)) continue;
+    votedSeatIds.add(vote.seatId);
+    validVotes.push(vote);
+  }
+  if (validVotes.length / input.seats.length < input.quorumFraction) {
+    return {
+      status: "abstained",
+      reason: "quorum_not_met",
+      validVoteCount: validVotes.length,
+      seatCount: input.seats.length
+    };
+  }
+  const veto = validVotes.find(
+    (vote) => vote.optionId === input.refusalOptionId && seatById.get(vote.seatId)?.veto === true
+  );
+  if (veto) {
+    return {
+      status: "denied",
+      method: "veto",
+      optionId: veto.optionId,
+      seatId: veto.seatId
+    };
+  }
+  const weightByOption = /* @__PURE__ */ new Map();
+  let castWeight = 0;
+  for (const vote of validVotes) {
+    const weight = seatById.get(vote.seatId)?.weight ?? 1;
+    castWeight += weight;
+    weightByOption.set(vote.optionId, (weightByOption.get(vote.optionId) ?? 0) + weight);
+  }
+  let winner;
+  let contested = false;
+  for (const [optionId, weight] of weightByOption) {
+    if (!winner || weight > winner.weight) {
+      winner = { optionId, weight };
+      contested = false;
+    } else if (weight === winner.weight) {
+      contested = true;
+    }
+  }
+  const decisive = winner !== void 0 && !contested && winner.weight > input.approvalFraction * castWeight;
+  if (!decisive || !winner) {
+    return {
+      status: "needs_judge",
+      reason: contested ? "tie" : "approval_threshold_not_met",
+      castWeight
+    };
+  }
+  if (winner.optionId === input.refusalOptionId) {
+    return {
+      status: "denied",
+      method: "refusal",
+      optionId: winner.optionId,
+      winningWeight: winner.weight,
+      castWeight
+    };
+  }
+  return {
+    status: "decided",
+    method: "majority",
+    optionId: winner.optionId,
+    winningWeight: winner.weight,
+    castWeight
+  };
+}
+function validateInput(input) {
+  if (input.seats.length === 0) {
+    throw new Error("resolveCouncilVotes: at least one seat is required.");
+  }
+  requireFraction(input.quorumFraction, "quorumFraction");
+  requireFraction(input.approvalFraction, "approvalFraction");
+  const seatIds = /* @__PURE__ */ new Set();
+  for (const seat of input.seats) {
+    if (!seat.id.trim()) throw new Error("resolveCouncilVotes: seat id must not be empty.");
+    if (seatIds.has(seat.id)) {
+      throw new Error(`resolveCouncilVotes: duplicate seat id "${seat.id}".`);
+    }
+    seatIds.add(seat.id);
+    if (seat.weight !== void 0 && (!Number.isFinite(seat.weight) || seat.weight <= 0)) {
+      throw new Error(`resolveCouncilVotes: invalid weight for seat "${seat.id}".`);
+    }
+  }
+}
+function requireFraction(value, label) {
+  if (!Number.isFinite(value) || value <= 0 || value > 1) {
+    throw new Error(`resolveCouncilVotes: ${label} must be in (0, 1].`);
+  }
+}
+
 // src/execution/council-brain.ts
 var COUNCIL_REFUSE_OPTION_ID = "council_refuse";
 var BUILTIN_PERSONAS = {
@@ -2727,7 +2937,12 @@ ${personaText(voter.persona)}`,
       if (!voter || result.status !== "fulfilled") return;
       const parsed = parseOptionDecision(result.value, ballot);
       if (parsed?.type !== "answer" || !parsed.optionId) return;
-      votes.push({ voter, optionId: parsed.optionId, rationale: parsed.rationale });
+      votes.push({
+        seatId: String(i),
+        voter,
+        optionId: parsed.optionId,
+        rationale: parsed.rationale
+      });
     });
     return votes;
   }
@@ -2823,44 +3038,44 @@ ${stanceLines}`,
       }
       const ballot = ballotOptions(request);
       const votes = await collectVotes(request, ballot, digest);
-      if (votes.length / opts.voters.length < quorumFraction) {
-        return finish(request, abstain(request, `quorum not met (${votes.length}/${opts.voters.length} votes)`));
+      const resolution = resolveCouncilVotes({
+        seats: opts.voters.map((voter, i) => ({
+          id: String(i),
+          weight: voter.weight,
+          veto: voter.veto
+        })),
+        votes: votes.map((vote) => ({ seatId: vote.seatId, optionId: vote.optionId })),
+        refusalOptionId: COUNCIL_REFUSE_OPTION_ID,
+        quorumFraction,
+        approvalFraction
+      });
+      if (resolution.status === "abstained") {
+        return finish(
+          request,
+          abstain(
+            request,
+            `quorum not met (${resolution.validVoteCount}/${resolution.seatCount} votes)`
+          )
+        );
       }
-      const vetoRefusal = votes.find(
-        (v) => v.voter.veto === true && v.optionId === COUNCIL_REFUSE_OPTION_ID
-      );
-      if (vetoRefusal) {
+      if (resolution.status === "denied" && resolution.method === "veto") {
+        const vetoRefusal = votes.find((vote) => vote.seatId === resolution.seatId);
+        if (!vetoRefusal) {
+          return finish(request, abstain(request, "veto ballot could not be resolved"));
+        }
         return finish(request, {
           type: "deny",
           reason: `Council veto by ${voterLabel(vetoRefusal.voter, 0)}` + (vetoRefusal.rationale ? `: ${vetoRefusal.rationale}` : ".")
         });
       }
-      const weightByOption = /* @__PURE__ */ new Map();
-      let castWeight = 0;
-      for (const v of votes) {
-        const w = v.voter.weight ?? 1;
-        castWeight += w;
-        weightByOption.set(v.optionId, (weightByOption.get(v.optionId) ?? 0) + w);
-      }
-      let winner = null;
-      let contested = false;
-      for (const [optionId, weight] of weightByOption) {
-        if (!winner || weight > winner.weight) {
-          winner = { optionId, weight };
-          contested = false;
-        } else if (weight === winner.weight) {
-          contested = true;
-        }
-      }
-      const decisive = winner !== null && !contested && winner.weight > approvalFraction * castWeight;
-      let finalOptionId = decisive && winner ? winner.optionId : null;
+      let finalOptionId = resolution.status === "decided" || resolution.status === "denied" ? resolution.optionId : null;
       let viaJudge = false;
-      if (!finalOptionId) {
+      if (resolution.status === "needs_judge") {
         const judged = await judgeRound(
           request,
           ballot,
           votes,
-          contested ? "tie" : "no option cleared the approval threshold"
+          resolution.reason === "tie" ? "tie" : "no option cleared the approval threshold"
         );
         if (judged?.type === "answer" && judged.optionId) {
           finalOptionId = judged.optionId;
@@ -3298,7 +3513,7 @@ function normalizeVoter(raw) {
   if (raw.veto !== void 0) voter.veto = raw.veto;
   return voter;
 }
-function requireFraction(value, label) {
+function requireFraction2(value, label) {
   if (!Number.isFinite(value) || value <= 0 || value > 1) {
     throw new Error(`Invalid ${label}: ${String(value)} (must be in (0, 1])`);
   }
@@ -3446,10 +3661,10 @@ function createBrainRuntime(opts) {
           c.voters = p.voters === null ? void 0 : p.voters.map(normalizeVoter);
         }
         if (p.quorum !== void 0) {
-          c.quorum = p.quorum === null ? void 0 : requireFraction(p.quorum, "council quorum");
+          c.quorum = p.quorum === null ? void 0 : requireFraction2(p.quorum, "council quorum");
         }
         if (p.approval !== void 0) {
-          c.approval = p.approval === null ? void 0 : requireFraction(p.approval, "council approval");
+          c.approval = p.approval === null ? void 0 : requireFraction2(p.approval, "council approval");
         }
         if (p.judge !== void 0) {
           c.judge = p.judge === null ? void 0 : normalizeEntry(p.judge);
@@ -3570,6 +3785,1011 @@ function createBrainRuntime(opts) {
   };
 }
 
+// src/execution/council-personas.ts
+var PERSONA_ID_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var BUILTIN_COUNCIL_PERSONAS = Object.freeze([
+  freezePersona({
+    id: "executor",
+    name: "Executor",
+    description: "Tests whether a proposal is practical and keeps useful work moving.",
+    instruction: "Evaluate operational feasibility, concrete progress, and the cost of delay. Favor decisive action when evidence supports it, but reject action whose prerequisites are missing.",
+    tags: ["delivery", "feasibility", "progress"]
+  }),
+  freezePersona({
+    id: "skeptic",
+    name: "Skeptic",
+    description: "Challenges assumptions and looks for concrete failure modes.",
+    instruction: "Identify unsupported assumptions, unsafe premises, irreversible consequences, and credible failure modes. Oppose or refuse only when you can name a concrete reason.",
+    defaultVeto: true,
+    tags: ["risk", "assumptions", "failure-modes"]
+  }),
+  freezePersona({
+    id: "auditor",
+    name: "Auditor",
+    description: "Evaluates cost, waste, evidence quality, and expected value.",
+    instruction: "Compare resource cost, opportunity cost, evidence quality, reversibility, and expected value. Prefer the option that achieves the objective with the least avoidable waste.",
+    tags: ["cost", "evidence", "efficiency"]
+  }),
+  freezePersona({
+    id: "security",
+    name: "Security Reviewer",
+    description: "Examines trust boundaries, abuse cases, and security impact.",
+    instruction: "Evaluate trust boundaries, attacker-controlled inputs, privilege changes, data exposure, abuse cases, and recovery options. Treat unmitigated high-impact security risk as grounds to refuse.",
+    defaultVeto: true,
+    tags: ["security", "trust", "abuse-cases"]
+  }),
+  freezePersona({
+    id: "maintainer",
+    name: "Maintainer",
+    description: "Evaluates complexity, compatibility, and long-term ownership.",
+    instruction: "Evaluate behavioral compatibility, conceptual complexity, testability, migration cost, and future maintenance. Prefer the smallest design that remains clear and extensible.",
+    tags: ["maintenance", "compatibility", "simplicity"]
+  }),
+  freezePersona({
+    id: "user-advocate",
+    name: "User Advocate",
+    description: "Evaluates the decision from the affected user\u2019s perspective.",
+    instruction: "Evaluate usability, surprise, accessibility, failure recovery, and whether the outcome solves the user\u2019s stated need. Prefer understandable behavior with safe recovery paths.",
+    tags: ["users", "usability", "accessibility"]
+  })
+]);
+var CouncilPersonaRegistry = class _CouncilPersonaRegistry {
+  byId;
+  constructor(personas = []) {
+    const entries = /* @__PURE__ */ new Map();
+    for (const persona of personas) {
+      const normalized = freezePersona(persona);
+      if (entries.has(normalized.id)) {
+        throw new Error(`CouncilPersonaRegistry: duplicate persona id "${normalized.id}".`);
+      }
+      entries.set(normalized.id, normalized);
+    }
+    this.byId = entries;
+  }
+  has(id) {
+    return this.byId.has(id);
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  require(id) {
+    const persona = this.get(id);
+    if (!persona) throw new Error(`CouncilPersonaRegistry: unknown persona "${id}".`);
+    return persona;
+  }
+  list() {
+    return Object.freeze([...this.byId.values()]);
+  }
+  /** Return a new registry; the current registry is never mutated. */
+  with(persona, opts = {}) {
+    const normalized = freezePersona(persona);
+    if (this.has(normalized.id) && opts.replace !== true) {
+      throw new Error(`CouncilPersonaRegistry: persona "${normalized.id}" already exists.`);
+    }
+    return new _CouncilPersonaRegistry([
+      ...this.list().filter((entry) => entry.id !== normalized.id),
+      normalized
+    ]);
+  }
+};
+var DEFAULT_COUNCIL_PERSONA_REGISTRY = new CouncilPersonaRegistry(
+  BUILTIN_COUNCIL_PERSONAS
+);
+function createCouncilPersonaRegistry(additional = []) {
+  let registry = DEFAULT_COUNCIL_PERSONA_REGISTRY;
+  for (const persona of additional) registry = registry.with(persona);
+  return registry;
+}
+function freezePersona(persona) {
+  const id = persona.id.trim();
+  const name = persona.name.trim();
+  const description = persona.description.trim();
+  const instruction = persona.instruction.trim();
+  if (!PERSONA_ID_RE.test(id)) {
+    throw new Error(`CouncilPersonaRegistry: invalid persona id "${persona.id}".`);
+  }
+  if (!name) throw new Error(`CouncilPersonaRegistry: persona "${id}" requires a name.`);
+  if (!description) {
+    throw new Error(`CouncilPersonaRegistry: persona "${id}" requires a description.`);
+  }
+  if (!instruction) {
+    throw new Error(`CouncilPersonaRegistry: persona "${id}" requires an instruction.`);
+  }
+  if (persona.defaultWeight !== void 0 && (!Number.isFinite(persona.defaultWeight) || persona.defaultWeight <= 0)) {
+    throw new Error(`CouncilPersonaRegistry: persona "${id}" has an invalid default weight.`);
+  }
+  const tags = Object.freeze(
+    [...new Set((persona.tags ?? []).map((tag) => tag.trim()).filter(Boolean))]
+  );
+  return Object.freeze({
+    id,
+    name,
+    description,
+    instruction,
+    ...persona.defaultWeight !== void 0 ? { defaultWeight: persona.defaultWeight } : {},
+    ...persona.defaultVeto !== void 0 ? { defaultVeto: persona.defaultVeto } : {},
+    ...tags.length > 0 ? { tags } : {}
+  });
+}
+
+// src/execution/council-profiles.ts
+var PROFILE_ID_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var DISTINCTNESS_VALUES = /* @__PURE__ */ new Set([
+  "none",
+  "model",
+  "provider"
+]);
+var DEFAULT_COUNCIL_QUORUM_FRACTION = 0.5;
+var DEFAULT_COUNCIL_APPROVAL_FRACTION = 0.5;
+var DEFAULT_COUNCIL_VOTER_MAX_TOKENS = 300;
+var DEFAULT_COUNCIL_JUDGE_MAX_TOKENS = 500;
+var DEFAULT_COUNCIL_PER_CALL_TIMEOUT_MS = 3e4;
+var DEFAULT_COUNCIL_OVERALL_TIMEOUT_MS = 9e4;
+var BUILTIN_COUNCIL_PROFILES = Object.freeze([
+  Object.freeze({
+    id: "balanced",
+    name: "Balanced",
+    description: "Three complementary lenses plus an independent judge for general decisions.",
+    seats: Object.freeze([
+      Object.freeze({ persona: "executor", target: Object.freeze({ role: "planner" }) }),
+      Object.freeze({ persona: "skeptic", target: Object.freeze({ role: "critic" }) }),
+      Object.freeze({ persona: "auditor", target: Object.freeze({ role: "analyst" }) })
+    ]),
+    judge: Object.freeze({ role: "reviewer" }),
+    quorumFraction: 0.5,
+    approvalFraction: 0.5,
+    distinctness: "model"
+  }),
+  Object.freeze({
+    id: "fast",
+    name: "Fast",
+    description: "Two-seat panel without a judge for quick, low-cost decisions.",
+    seats: Object.freeze([
+      Object.freeze({ persona: "executor", target: Object.freeze({ role: "planner" }) }),
+      Object.freeze({ persona: "skeptic", target: Object.freeze({ role: "critic" }) })
+    ]),
+    judge: false,
+    quorumFraction: 0.5,
+    approvalFraction: 0.5,
+    distinctness: "none",
+    voterMaxTokens: 200,
+    perCallTimeoutMs: 2e4,
+    overallTimeoutMs: 3e4
+  }),
+  Object.freeze({
+    id: "risk-review",
+    name: "Risk Review",
+    description: "Security, assumptions, maintenance, and cost review for high-impact choices.",
+    seats: Object.freeze([
+      Object.freeze({ persona: "skeptic", target: Object.freeze({ role: "critic" }) }),
+      Object.freeze({ persona: "security", target: Object.freeze({ role: "security-reviewer" }) }),
+      Object.freeze({ persona: "maintainer", target: Object.freeze({ role: "reviewer" }) }),
+      Object.freeze({ persona: "auditor", target: Object.freeze({ role: "analyst" }) })
+    ]),
+    judge: Object.freeze({ role: "architect" }),
+    quorumFraction: 0.75,
+    approvalFraction: 0.5,
+    distinctness: "provider",
+    judgeMaxTokens: 700,
+    overallTimeoutMs: 12e4
+  })
+]);
+var CouncilProfileRegistry = class _CouncilProfileRegistry {
+  byId;
+  personas;
+  constructor(profiles = [], personas = DEFAULT_COUNCIL_PERSONA_REGISTRY) {
+    this.personas = personas;
+    const entries = /* @__PURE__ */ new Map();
+    for (const profile of profiles) {
+      const normalized = normalizeCouncilProfile(profile, personas);
+      if (entries.has(normalized.id)) {
+        throw new Error(`CouncilProfileRegistry: duplicate profile id "${normalized.id}".`);
+      }
+      entries.set(normalized.id, normalized);
+    }
+    this.byId = entries;
+  }
+  has(id) {
+    return this.byId.has(id);
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  require(id) {
+    const profile = this.get(id);
+    if (!profile) throw new Error(`CouncilProfileRegistry: unknown profile "${id}".`);
+    return profile;
+  }
+  list() {
+    return Object.freeze([...this.byId.values()]);
+  }
+  /** Return a new registry; the current registry is never mutated. */
+  with(profile, opts = {}) {
+    const personas = opts.personas ?? this.personas;
+    const normalized = normalizeCouncilProfile(profile, personas);
+    if (this.has(normalized.id) && opts.replace !== true) {
+      throw new Error(`CouncilProfileRegistry: profile "${normalized.id}" already exists.`);
+    }
+    return new _CouncilProfileRegistry(
+      [
+        ...this.list().filter((entry) => entry.id !== normalized.id),
+        profile
+      ],
+      personas
+    );
+  }
+};
+var DEFAULT_COUNCIL_PROFILE_REGISTRY = new CouncilProfileRegistry(
+  BUILTIN_COUNCIL_PROFILES
+);
+function createCouncilProfileRegistry(additional = [], personas = DEFAULT_COUNCIL_PERSONA_REGISTRY) {
+  return new CouncilProfileRegistry([...BUILTIN_COUNCIL_PROFILES, ...additional], personas);
+}
+function resolveCouncilProfile(profile, opts = {}) {
+  const personas = opts.personas ?? DEFAULT_COUNCIL_PERSONA_REGISTRY;
+  if (profile && typeof profile !== "string") return normalizeCouncilProfile(profile, personas);
+  const id = profile ?? opts.defaultProfile ?? "balanced";
+  return (opts.registry ?? DEFAULT_COUNCIL_PROFILE_REGISTRY).require(id);
+}
+function normalizeCouncilProfile(profile, personas = DEFAULT_COUNCIL_PERSONA_REGISTRY) {
+  const id = profile.id.trim();
+  if (!PROFILE_ID_RE.test(id)) {
+    throw new Error(`CouncilProfileRegistry: invalid profile id "${profile.id}".`);
+  }
+  if (profile.seats.length === 0) {
+    throw new Error(`CouncilProfileRegistry: profile "${id}" requires at least one seat.`);
+  }
+  const usedIds = /* @__PURE__ */ new Set();
+  const seats = profile.seats.map((seat) => {
+    const persona = personas.require(seat.persona.trim());
+    const explicitSeatId = seat.id?.trim();
+    if (explicitSeatId && usedIds.has(explicitSeatId)) {
+      throw new Error(`CouncilProfileRegistry: duplicate seat id "${explicitSeatId}".`);
+    }
+    const seatId = uniqueSeatId(explicitSeatId || persona.id, usedIds);
+    const label = seat.label?.trim() || persona.name;
+    const weight = seat.weight ?? persona.defaultWeight ?? 1;
+    if (!Number.isFinite(weight) || weight <= 0) {
+      throw new Error(`CouncilProfileRegistry: seat "${seatId}" has an invalid weight.`);
+    }
+    return Object.freeze({
+      id: seatId,
+      label,
+      persona: persona.id,
+      ...seat.target ? { target: freezeTarget(seat.target, `seat "${seatId}"`) } : {},
+      weight,
+      veto: seat.veto ?? persona.defaultVeto ?? false
+    });
+  });
+  const quorumFraction = fraction(
+    profile.quorumFraction ?? DEFAULT_COUNCIL_QUORUM_FRACTION,
+    "quorumFraction",
+    id
+  );
+  const approvalFraction = fraction(
+    profile.approvalFraction ?? DEFAULT_COUNCIL_APPROVAL_FRACTION,
+    "approvalFraction",
+    id
+  );
+  const distinctness = profile.distinctness ?? "model";
+  if (!DISTINCTNESS_VALUES.has(distinctness)) {
+    throw new Error(`CouncilProfileRegistry: profile "${id}" has invalid distinctness.`);
+  }
+  const voterMaxTokens = positiveInteger(
+    profile.voterMaxTokens ?? DEFAULT_COUNCIL_VOTER_MAX_TOKENS,
+    "voterMaxTokens",
+    id
+  );
+  const judgeMaxTokens = positiveInteger(
+    profile.judgeMaxTokens ?? DEFAULT_COUNCIL_JUDGE_MAX_TOKENS,
+    "judgeMaxTokens",
+    id
+  );
+  const perCallTimeoutMs = positiveInteger(
+    profile.perCallTimeoutMs ?? DEFAULT_COUNCIL_PER_CALL_TIMEOUT_MS,
+    "perCallTimeoutMs",
+    id
+  );
+  const overallTimeoutMs = positiveInteger(
+    profile.overallTimeoutMs ?? DEFAULT_COUNCIL_OVERALL_TIMEOUT_MS,
+    "overallTimeoutMs",
+    id
+  );
+  if (overallTimeoutMs < perCallTimeoutMs) {
+    throw new Error(
+      `CouncilProfileRegistry: profile "${id}" overallTimeoutMs must be at least perCallTimeoutMs.`
+    );
+  }
+  return Object.freeze({
+    id,
+    name: profile.name?.trim() || id,
+    description: profile.description?.trim() || "",
+    seats: Object.freeze(seats),
+    judge: profile.judge ? freezeTarget(profile.judge, "judge") : false,
+    quorumFraction,
+    approvalFraction,
+    distinctness,
+    voterMaxTokens,
+    judgeMaxTokens,
+    perCallTimeoutMs,
+    overallTimeoutMs
+  });
+}
+function uniqueSeatId(base, used) {
+  if (!PROFILE_ID_RE.test(base)) {
+    throw new Error(`CouncilProfileRegistry: invalid seat id "${base}".`);
+  }
+  let id = base;
+  let suffix = 2;
+  while (used.has(id)) id = `${base}-${suffix++}`;
+  used.add(id);
+  return id;
+}
+function freezeTarget(target, label) {
+  const providerId = optionalText(target.providerId);
+  const model = optionalText(target.model);
+  const role = optionalText(target.role);
+  const fallbackProfile = optionalText(target.fallbackProfile);
+  const fallbackModels = Object.freeze(
+    [...new Set((target.fallbackModels ?? []).map((ref) => ref.trim()).filter(Boolean))]
+  );
+  if (!providerId && !model && !role && !fallbackProfile && fallbackModels.length === 0) {
+    throw new Error(`CouncilProfileRegistry: ${label} target is empty.`);
+  }
+  return Object.freeze({
+    ...providerId ? { providerId } : {},
+    ...model ? { model } : {},
+    ...role ? { role } : {},
+    ...fallbackProfile ? { fallbackProfile } : {},
+    ...fallbackModels.length > 0 ? { fallbackModels } : {}
+  });
+}
+function optionalText(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function fraction(value, field, profileId) {
+  if (!Number.isFinite(value) || value <= 0 || value > 1) {
+    throw new Error(`CouncilProfileRegistry: profile "${profileId}" ${field} must be in (0, 1].`);
+  }
+  return value;
+}
+function positiveInteger(value, field, profileId) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(
+      `CouncilProfileRegistry: profile "${profileId}" ${field} must be a positive integer.`
+    );
+  }
+  return value;
+}
+
+// src/execution/council-prompts.ts
+var COUNCIL_VOTER_PROMPT_PATH = "llm/council-voter.md";
+var COUNCIL_JUDGE_PROMPT_PATH = "llm/council-judge.md";
+function buildCouncilVoterSystemPrompt(persona) {
+  const template = requiredInstruction(COUNCIL_VOTER_PROMPT_PATH);
+  return renderInstructionTemplate(template, {
+    personaInstruction: persona.instruction
+  });
+}
+function buildCouncilJudgeSystemPrompt() {
+  return requiredInstruction(COUNCIL_JUDGE_PROMPT_PATH);
+}
+function buildCouncilQuestionPrompt(question, opts = {}) {
+  const text = question.question.trim();
+  if (!text) throw new Error("buildCouncilQuestionPrompt: question must not be empty.");
+  const options = normalizeOptions(question.options);
+  return [
+    "<council-question>",
+    `Question: ${text}`,
+    question.context?.trim() ? `Context:
+${question.context.trim()}` : "",
+    options.length > 0 ? `Options (JSON):
+${JSON.stringify(options)}` : "Options: none",
+    opts.refusalOptionId ? `Refusal option id: ${opts.refusalOptionId}` : "Refusal option id: not supplied",
+    "</council-question>"
+  ].filter(Boolean).join("\n\n");
+}
+function buildCouncilVoterUserPrompt(question, seat, opts = {}) {
+  return [
+    buildCouncilQuestionPrompt(question, opts),
+    "<seat-metadata>",
+    `Seat id: ${seat.id}`,
+    `Seat label: ${seat.label}`,
+    `Persona id: ${seat.persona}`,
+    "</seat-metadata>"
+  ].join("\n");
+}
+function buildCouncilJudgeUserPrompt(question, votes, opts = {}) {
+  const ballots = votes.map((vote) => ({
+    seatId: vote.seatId,
+    persona: vote.persona,
+    status: vote.status,
+    ...vote.optionId ? { optionId: vote.optionId } : {},
+    ...vote.stance ? { stance: vote.stance } : {},
+    ...vote.rationale ? { rationale: vote.rationale } : {}
+  }));
+  return [
+    buildCouncilQuestionPrompt(question, { refusalOptionId: opts.refusalOptionId }),
+    "<council-ballots>",
+    opts.reason?.trim() ? `Reason judging is required: ${opts.reason.trim()}` : "",
+    JSON.stringify(ballots),
+    "</council-ballots>"
+  ].filter(Boolean).join("\n\n");
+}
+function normalizeOptions(options) {
+  if (!options) return [];
+  const seen = /* @__PURE__ */ new Set();
+  return options.map((option) => {
+    const id = option.id.trim();
+    const label = option.label.trim();
+    if (!id) throw new Error("buildCouncilQuestionPrompt: option id must not be empty.");
+    if (!label) throw new Error(`buildCouncilQuestionPrompt: option "${id}" needs a label.`);
+    if (seen.has(id)) throw new Error(`buildCouncilQuestionPrompt: duplicate option id "${id}".`);
+    seen.add(id);
+    return {
+      id,
+      label,
+      ...option.consequence?.trim() ? { consequence: option.consequence.trim() } : {}
+    };
+  });
+}
+function requiredInstruction(path11) {
+  const text = readBundledInstructionText(path11);
+  if (!text) throw new Error(`Council instruction file is unavailable: ${path11}`);
+  return text;
+}
+
+// src/execution/council-orchestrator.ts
+var COUNCIL_REFUSAL_OPTION_ID = "council_refuse";
+var DEFAULT_COUNCIL_MAX_CONCURRENCY = 3;
+var MAX_COUNCIL_CONCURRENCY = 8;
+var CouncilOrchestrator = class {
+  caller;
+  personas;
+  profiles;
+  defaultProfile;
+  maxConcurrency;
+  refusalOptionId;
+  constructor(opts) {
+    this.caller = opts.caller;
+    this.personas = opts.personas ?? DEFAULT_COUNCIL_PERSONA_REGISTRY;
+    this.profiles = opts.profiles ?? DEFAULT_COUNCIL_PROFILE_REGISTRY;
+    this.defaultProfile = opts.defaultProfile;
+    this.maxConcurrency = validateConcurrency(
+      opts.maxConcurrency ?? DEFAULT_COUNCIL_MAX_CONCURRENCY
+    );
+    this.refusalOptionId = opts.refusalOptionId?.trim() || COUNCIL_REFUSAL_OPTION_ID;
+  }
+  async ask(question) {
+    const startedAt = Date.now();
+    const profile = resolveCouncilProfile(question.profile, {
+      registry: this.profiles,
+      personas: this.personas,
+      defaultProfile: this.defaultProfile
+    });
+    validateRefusalCollision(question, this.refusalOptionId);
+    const timeoutSignal = AbortSignal.timeout(profile.overallTimeoutMs);
+    const signal = question.signal ? AbortSignal.any([question.signal, timeoutSignal]) : timeoutSignal;
+    const usage = {
+      calls: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0
+    };
+    const votes = await mapConcurrent(
+      profile.seats,
+      Math.min(this.maxConcurrency, profile.seats.length),
+      async (seat) => {
+        try {
+          return await this.callSeat(question, profile, seat, signal, usage);
+        } catch (error) {
+          return {
+            seatId: seat.id,
+            persona: seat.persona,
+            status: signal.aborted ? "cancelled" : "failed",
+            error: errorMessage(error)
+          };
+        }
+      }
+    );
+    const warnings = distinctnessWarnings(votes, profile);
+    const errors = votes.filter((vote) => vote.status === "failed" || vote.status === "invalid").map((vote) => `${vote.seatId}: ${vote.error ?? vote.status}`);
+    if (question.signal?.aborted) {
+      return resultEnvelope({
+        status: "cancelled",
+        reason: "Council call cancelled.",
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    if (timeoutSignal.aborted) {
+      return resultEnvelope({
+        status: "failed",
+        reason: "Council overall timeout exceeded.",
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors: [...errors, "Council overall timeout exceeded."]
+      });
+    }
+    if (!question.options || question.options.length === 0) {
+      return this.resolveOpenQuestion(
+        question,
+        profile,
+        votes,
+        signal,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      );
+    }
+    return this.resolveOptionQuestion(
+      question,
+      profile,
+      votes,
+      signal,
+      usage,
+      startedAt,
+      warnings,
+      errors
+    );
+  }
+  async callSeat(question, profile, seat, signal, usage) {
+    if (signal.aborted) return cancelledVote(seat);
+    let persona;
+    try {
+      persona = this.personas.require(seat.persona);
+    } catch (error) {
+      return {
+        seatId: seat.id,
+        persona: seat.persona,
+        status: "failed",
+        error: errorMessage(error)
+      };
+    }
+    const result = await this.safeCall({
+      system: buildCouncilVoterSystemPrompt(persona),
+      userPrompt: buildCouncilVoterUserPrompt(question, seat, {
+        refusalOptionId: question.options?.length ? this.refusalOptionId : void 0
+      }),
+      target: seat.target,
+      maxTokens: profile.voterMaxTokens,
+      timeoutMs: profile.perCallTimeoutMs,
+      signal,
+      usage
+    });
+    const metadata = callMetadata(result);
+    if (result.error) {
+      return {
+        seatId: seat.id,
+        persona: seat.persona,
+        status: signal.aborted ? "cancelled" : "failed",
+        ...metadata,
+        error: result.error
+      };
+    }
+    const parsed = parseVote(result.text, question, this.refusalOptionId);
+    if (!parsed.ok) {
+      return {
+        seatId: seat.id,
+        persona: seat.persona,
+        status: "invalid",
+        ...metadata,
+        error: parsed.error
+      };
+    }
+    return {
+      seatId: seat.id,
+      persona: seat.persona,
+      status: "valid",
+      ...parsed.vote,
+      ...metadata
+    };
+  }
+  async resolveOptionQuestion(question, profile, votes, signal, usage, startedAt, warnings, errors) {
+    const validVotes = votes.filter(
+      (vote) => vote.status === "valid" && typeof vote.optionId === "string"
+    );
+    const resolution = resolveCouncilVotes({
+      seats: profile.seats.map((seat) => ({
+        id: seat.id,
+        weight: seat.weight,
+        veto: seat.veto
+      })),
+      votes: validVotes.map((vote) => ({ seatId: vote.seatId, optionId: vote.optionId })),
+      refusalOptionId: this.refusalOptionId,
+      quorumFraction: profile.quorumFraction,
+      approvalFraction: profile.approvalFraction
+    });
+    if (resolution.status === "abstained") {
+      return resultEnvelope({
+        status: "abstained",
+        reason: "Council quorum was not met.",
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    if (resolution.status === "denied") {
+      return resultEnvelope({
+        status: "denied",
+        optionId: resolution.optionId,
+        reason: `Council denied the proposal via ${resolution.method}.`,
+        resolution: resolution.method,
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    if (resolution.status === "decided") {
+      return resultEnvelope({
+        status: "decided",
+        optionId: resolution.optionId,
+        answer: optionLabel(question, resolution.optionId),
+        resolution: "majority",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    if (!profile.judge) {
+      return resultEnvelope({
+        status: "abstained",
+        reason: `Council requires a judge (${resolution.reason}), but this profile has none.`,
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    const judged = await this.callJudge(
+      question,
+      profile,
+      votes,
+      profile.judge,
+      resolution.reason,
+      signal,
+      usage
+    );
+    if (!judged.ok) {
+      return resultEnvelope({
+        status: signal.aborted ? "cancelled" : "abstained",
+        reason: judged.error,
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors: [...errors, judged.error],
+        judgeUsed: true
+      });
+    }
+    if (judged.value.optionId === this.refusalOptionId) {
+      return resultEnvelope({
+        status: "denied",
+        optionId: this.refusalOptionId,
+        reason: judged.value.rationale ?? "Council judge refused all options.",
+        resolution: "judge",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors,
+        judgeUsed: true
+      });
+    }
+    return resultEnvelope({
+      status: "decided",
+      optionId: judged.value.optionId,
+      answer: optionLabel(question, judged.value.optionId),
+      reason: judged.value.rationale,
+      resolution: "judge",
+      votes,
+      profile,
+      usage,
+      startedAt,
+      warnings,
+      errors,
+      judgeUsed: true
+    });
+  }
+  async resolveOpenQuestion(question, profile, votes, signal, usage, startedAt, warnings, errors) {
+    const valid = votes.filter(
+      (vote) => vote.status === "valid" && typeof vote.stance === "string"
+    );
+    if (valid.length / profile.seats.length < profile.quorumFraction) {
+      return resultEnvelope({
+        status: "abstained",
+        reason: "Council quorum was not met.",
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    if (!profile.judge) {
+      const first = valid[0];
+      if (!first) {
+        return resultEnvelope({
+          status: "failed",
+          reason: "Council produced no valid stance.",
+          resolution: "none",
+          votes,
+          profile,
+          usage,
+          startedAt,
+          warnings,
+          errors
+        });
+      }
+      return resultEnvelope({
+        status: "decided",
+        answer: first.stance,
+        reason: first.rationale,
+        resolution: "first_stance",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    const judged = await this.callJudge(
+      question,
+      profile,
+      votes,
+      profile.judge,
+      "open_question_synthesis",
+      signal,
+      usage
+    );
+    if (!judged.ok) {
+      return resultEnvelope({
+        status: signal.aborted ? "cancelled" : "failed",
+        reason: judged.error,
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors: [...errors, judged.error],
+        judgeUsed: true
+      });
+    }
+    return resultEnvelope({
+      status: "decided",
+      answer: judged.value.answer,
+      reason: judged.value.rationale,
+      resolution: "judge",
+      votes,
+      profile,
+      usage,
+      startedAt,
+      warnings,
+      errors,
+      judgeUsed: true
+    });
+  }
+  async callJudge(question, profile, votes, target, reason, signal, usage) {
+    const result = await this.safeCall({
+      system: buildCouncilJudgeSystemPrompt(),
+      userPrompt: buildCouncilJudgeUserPrompt(question, votes, {
+        reason,
+        refusalOptionId: question.options?.length ? this.refusalOptionId : void 0
+      }),
+      target,
+      maxTokens: profile.judgeMaxTokens,
+      timeoutMs: profile.perCallTimeoutMs,
+      signal,
+      usage
+    });
+    if (result.error) return { ok: false, error: result.error };
+    return parseJudge(result.text, question, this.refusalOptionId);
+  }
+  async safeCall(input) {
+    try {
+      const result = await this.caller.call({
+        system: input.system,
+        userPrompt: input.userPrompt,
+        responseFormat: { type: "json_object" },
+        maxTokens: input.maxTokens,
+        timeoutMs: input.timeoutMs,
+        signal: input.signal,
+        ...input.target?.providerId ? { providerId: input.target.providerId } : {},
+        ...input.target?.model ? { model: input.target.model } : {},
+        ...input.target?.role ? { role: input.target.role } : {},
+        ...input.target?.fallbackProfile ? { fallbackProfile: input.target.fallbackProfile } : {},
+        ...input.target?.fallbackModels ? { fallbackModels: [...input.target.fallbackModels] } : {}
+      });
+      addUsage(input.usage, result);
+      return result;
+    } catch (error) {
+      input.usage.calls += 1;
+      return emptyCallResult(errorMessage(error));
+    }
+  }
+};
+function parseVote(text, question, refusalOptionId) {
+  const parsed = parseObject(text);
+  if (!parsed.ok) return parsed;
+  const rationale = optionalString(parsed.value["rationale"]);
+  if (question.options && question.options.length > 0) {
+    const optionId = optionalString(parsed.value["optionId"]);
+    const allowed = /* @__PURE__ */ new Set([...question.options.map((option) => option.id.trim()), refusalOptionId]);
+    if (!optionId || !allowed.has(optionId)) {
+      return { ok: false, error: "Voter returned an unknown or missing optionId." };
+    }
+    return { ok: true, vote: { optionId, ...rationale ? { rationale } : {} } };
+  }
+  const stance = optionalString(parsed.value["stance"]);
+  if (!stance) return { ok: false, error: "Voter returned an empty or missing stance." };
+  return { ok: true, vote: { stance, ...rationale ? { rationale } : {} } };
+}
+function parseJudge(text, question, refusalOptionId) {
+  const parsed = parseObject(text);
+  if (!parsed.ok) return parsed;
+  const rationale = optionalString(parsed.value["rationale"]);
+  if (question.options && question.options.length > 0) {
+    const optionId = optionalString(parsed.value["optionId"]);
+    const allowed = /* @__PURE__ */ new Set([...question.options.map((option) => option.id.trim()), refusalOptionId]);
+    if (!optionId || !allowed.has(optionId)) {
+      return { ok: false, error: "Judge returned an unknown or missing optionId." };
+    }
+    return { ok: true, value: { optionId, ...rationale ? { rationale } : {} } };
+  }
+  const answer = optionalString(parsed.value["answer"]);
+  if (!answer) return { ok: false, error: "Judge returned an empty or missing answer." };
+  return { ok: true, value: { answer, ...rationale ? { rationale } : {} } };
+}
+function parseObject(text) {
+  const trimmed = text.trim();
+  const first = trimmed.indexOf("{");
+  const last = trimmed.lastIndexOf("}");
+  if (first < 0 || last < first) return { ok: false, error: "LLM response did not contain JSON." };
+  try {
+    const value = JSON.parse(trimmed.slice(first, last + 1));
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return { ok: false, error: "LLM response JSON must be an object." };
+    }
+    return { ok: true, value };
+  } catch (error) {
+    return { ok: false, error: `Invalid LLM response JSON: ${errorMessage(error)}` };
+  }
+}
+function resultEnvelope(input) {
+  const validVoteCount = input.votes.filter((vote) => vote.status === "valid").length;
+  return {
+    status: input.status,
+    ...input.answer ? { answer: input.answer } : {},
+    ...input.optionId ? { optionId: input.optionId } : {},
+    ...input.reason ? { reason: input.reason } : {},
+    resolution: input.resolution,
+    votes: Object.freeze([...input.votes]),
+    configuredSeatCount: input.profile.seats.length,
+    validVoteCount,
+    distinctTargetCount: distinctTargetCount(input.votes, input.profile),
+    judgeUsed: input.judgeUsed ?? false,
+    usage: usageResult(input.usage, input.startedAt),
+    ...input.warnings.length > 0 ? { warnings: Object.freeze([...input.warnings]) } : {},
+    ...input.errors.length > 0 ? { errors: Object.freeze([...input.errors]) } : {}
+  };
+}
+function callMetadata(result) {
+  return {
+    ...result.provider ? { provider: result.provider } : {},
+    ...result.model ? { model: result.model } : {},
+    ...result.fromFallback ? { fromFallback: true } : {},
+    durationMs: result.durationMs
+  };
+}
+function addUsage(usage, result) {
+  usage.calls += 1;
+  usage.inputTokens += result.tokens.input;
+  usage.outputTokens += result.tokens.output;
+  usage.totalTokens += result.tokens.total;
+}
+function usageResult(usage, startedAt) {
+  return Object.freeze({ ...usage, durationMs: Math.max(0, Date.now() - startedAt) });
+}
+function cancelledVote(seat) {
+  return { seatId: seat.id, persona: seat.persona, status: "cancelled", error: "Cancelled." };
+}
+function distinctTargetCount(votes, profile) {
+  const keys = votes.filter((vote) => vote.status === "valid").map(
+    (vote) => profile.distinctness === "provider" ? vote.provider : `${vote.provider ?? ""}/${vote.model ?? ""}`
+  ).filter(Boolean);
+  return new Set(keys).size;
+}
+function distinctnessWarnings(votes, profile) {
+  if (profile.distinctness === "none") return [];
+  const valid = votes.filter((vote) => vote.status === "valid");
+  const distinct = distinctTargetCount(valid, profile);
+  if (valid.length > 1 && distinct < valid.length) {
+    return [
+      `Council distinctness policy "${profile.distinctness}" was not met: ${distinct} distinct target(s) served ${valid.length} valid vote(s).`
+    ];
+  }
+  return [];
+}
+function optionLabel(question, optionId) {
+  if (!optionId) return void 0;
+  return question.options?.find((option) => option.id.trim() === optionId)?.label.trim();
+}
+function validateRefusalCollision(question, refusalOptionId) {
+  if (question.options?.some((option) => option.id.trim() === refusalOptionId)) {
+    throw new Error(`CouncilOrchestrator: option id "${refusalOptionId}" is reserved.`);
+  }
+}
+function validateConcurrency(value) {
+  if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_COUNCIL_CONCURRENCY) {
+    throw new Error(
+      `CouncilOrchestrator: maxConcurrency must be an integer in [1, ${MAX_COUNCIL_CONCURRENCY}].`
+    );
+  }
+  return value;
+}
+async function mapConcurrent(items, concurrency, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+  const run = async () => {
+    while (true) {
+      const index = next++;
+      if (index >= items.length) return;
+      const item = items[index];
+      if (item !== void 0) results[index] = await worker(item, index);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => run()));
+  return results;
+}
+function emptyCallResult(error) {
+  return {
+    text: "",
+    model: "",
+    provider: "",
+    tokens: { input: 0, output: 0, total: 0 },
+    durationMs: 0,
+    fromFallback: false,
+    error
+  };
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/storage/goal-store.ts
 import * as fsp from "node:fs/promises";
 var MAX_JOURNAL_ENTRIES = 500;
@@ -3943,7 +5163,7 @@ function eliseOldToolResults(messages, opts) {
     }
     if (newContent) {
       next ??= messages.slice();
-      next[i] = { ...msg, content: newContent };
+      next[i] = { ...msg, content: newContent, _estTokens: void 0 };
       changed = true;
     }
     if (compactionDebugEnabled()) {
@@ -4337,7 +5557,7 @@ function isDesignStack(v) {
 
 // src/execution/design-kit-loader.ts
 import { existsSync } from "node:fs";
-import * as fs2 from "node:fs/promises";
+import * as fs3 from "node:fs/promises";
 import * as path4 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var KIT_FILE = "KIT.md";
@@ -4377,17 +5597,17 @@ function parseKitFrontmatter(raw) {
     else out[key] = items;
   };
   for (const line of lines) {
-    const item = /^\s*-\s+(.*)$/.exec(line);
-    if (listKey && item) {
-      const parsed = parseList(item[1] ?? "");
+    const bulletMatch = /^\s*-\s+(.*)$/.exec(line);
+    if (listKey && bulletMatch) {
+      const parsed = parseList(bulletMatch[1] ?? "");
       if (listKey === "stacks") out.stacks.push(...parsed.filter(isDesignStack));
       else out[listKey].push(...parsed);
       continue;
     }
-    const m = /^([a-zA-Z_]+):\s*(.*)$/.exec(line);
-    if (!m) continue;
-    const key = m[1] ?? "";
-    const rest = (m[2] ?? "").trim();
+    const kvMatch = /^([a-zA-Z_]+):\s*(.*)$/.exec(line);
+    if (!kvMatch) continue;
+    const key = kvMatch[1] ?? "";
+    const rest = (kvMatch[2] ?? "").trim();
     if (key === "tags" || key === "stacks" || key === "themes") {
       if (rest) {
         setList(key, parseList(rest));
@@ -4404,24 +5624,23 @@ function parseKitFrontmatter(raw) {
 }
 function narrowStackSections(body, stack) {
   if (!stack) return body;
-  const re = /^##\s+Stack:\s*([a-z-]+)\s*$/gim;
-  const matches = [];
-  let m;
-  while ((m = re.exec(body)) !== null) {
-    matches.push({ id: (m[1] ?? "").trim(), start: m.index });
-  }
-  if (matches.length === 0) return body;
-  const firstStart = matches[0]?.start ?? body.length;
-  let result = body.slice(0, firstStart).trimEnd();
-  for (let i = 0; i < matches.length; i++) {
-    const cur = matches[i];
-    if (!cur) continue;
-    const next = matches[i + 1];
-    const sectionEnd = next ? next.start : body.length;
-    if (cur.id === stack) {
+  const stackHeading = /^##\s+Stack:\s*([a-z-]+)\s*$/gim;
+  const sections = [];
+  let match;
+  while ((match = stackHeading.exec(body)) !== null) {
+    sections.push({ id: (match[1] ?? "").trim(), start: match.index });
+  }
+  if (sections.length === 0) return body;
+  const preambleEnd = sections[0].start;
+  let result = body.slice(0, preambleEnd).trimEnd();
+  let sectionEnd;
+  for (let i = 0; i < sections.length; i++) {
+    const current = sections[i];
+    sectionEnd = i + 1 < sections.length ? sections[i + 1].start : body.length;
+    if (current.id === stack) {
       result += `
 
-${body.slice(cur.start, sectionEnd).trimEnd()}`;
+${body.slice(current.start, sectionEnd).trimEnd()}`;
     }
   }
   return `${result}
@@ -4446,7 +5665,7 @@ var DefaultDesignKitLoader = class {
     for (const { dir, source } of this.dirs) {
       let entries;
       try {
-        entries = await fs2.readdir(dir, { withFileTypes: true });
+        entries = await fs3.readdir(dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -4454,7 +5673,7 @@ var DefaultDesignKitLoader = class {
         if (!e.isDirectory()) continue;
         const kitFile = path4.join(dir, e.name, KIT_FILE);
         try {
-          const raw = await fs2.readFile(kitFile, "utf8");
+          const raw = await fs3.readFile(kitFile, "utf8");
           const fm = parseKitFrontmatter(raw);
           const id = fm.id ?? e.name;
           if (!fm.name) continue;
@@ -4515,7 +5734,7 @@ var DefaultDesignKitLoader = class {
     if (cached !== void 0) return cached;
     const m = await this.find(id);
     if (!m) throw new Error(`Design kit "${id}" not found`);
-    const raw = await fs2.readFile(m.path, "utf8");
+    const raw = await fs3.readFile(m.path, "utf8");
     const body = narrowStackSections(stripFrontmatter(raw), stack);
     this.bodyCache.set(key, body);
     return body;
@@ -4528,7 +5747,7 @@ var DefaultDesignKitLoader = class {
     if (m) {
       const tokensPath = path4.join(path4.dirname(m.path), TOKENS_FILE);
       try {
-        const raw = await fs2.readFile(tokensPath, "utf8");
+        const raw = await fs3.readFile(tokensPath, "utf8");
         const parsed = JSON.parse(raw);
         tokens = parsed;
       } catch {
@@ -4586,7 +5805,7 @@ function _resetDesignKitLoaderMemo() {
 
 // src/execution/design-project-store.ts
 import { existsSync as existsSync2 } from "node:fs";
-import * as fs3 from "node:fs/promises";
+import * as fs4 from "node:fs/promises";
 import * as path5 from "node:path";
 var DESIGN_DIR = ".design";
 function designProjectDir(projectRoot) {
@@ -4599,7 +5818,7 @@ async function loadProjectDesignRules(projectRoot) {
   let rules;
   for (const name of RULE_FILES) {
     try {
-      const txt = await fs3.readFile(path5.join(designProjectDir(projectRoot), name), "utf8");
+      const txt = await fs4.readFile(path5.join(designProjectDir(projectRoot), name), "utf8");
       if (txt.trim()) {
         rules = txt.trim();
         break;
@@ -4620,7 +5839,7 @@ function parseOverrides(value) {
 }
 async function loadActiveKit(projectRoot) {
   try {
-    const raw = await fs3.readFile(path5.join(designProjectDir(projectRoot), "active.json"), "utf8");
+    const raw = await fs4.readFile(path5.join(designProjectDir(projectRoot), "active.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.kit === "string") {
       return {
@@ -4653,11 +5872,11 @@ function applyTokenOverrides(tokens, overrides) {
 }
 async function ensureDesignDir(projectRoot) {
   const dir = designProjectDir(projectRoot);
-  await fs3.mkdir(dir, { recursive: true });
+  await fs4.mkdir(dir, { recursive: true });
   const gi = path5.join(dir, ".gitignore");
   if (!existsSync2(gi)) {
     try {
-      await fs3.writeFile(gi, "*\n");
+      await fs4.writeFile(gi, "*\n");
     } catch {
     }
   }
@@ -4668,17 +5887,17 @@ async function recordKitChoice(projectRoot, kit, stack, source, isoTime, overrid
     const dir = await ensureDesignDir(projectRoot);
     const record = { kit, stack: stack ?? null };
     if (overrides && Object.keys(overrides).length > 0) record.overrides = overrides;
-    await fs3.writeFile(path5.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
+    await fs4.writeFile(path5.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
 `);
     const line = `- ${isoTime} \xB7 kit=${kit}${stack ? ` stack=${stack}` : ""} \xB7 via=${source}
 `;
-    await fs3.appendFile(path5.join(dir, "decisions.md"), line);
+    await fs4.appendFile(path5.join(dir, "decisions.md"), line);
   } catch {
   }
 }
 async function clearPersistedActiveKit(projectRoot) {
   try {
-    await fs3.rm(path5.join(designProjectDir(projectRoot), "active.json"), { force: true });
+    await fs4.rm(path5.join(designProjectDir(projectRoot), "active.json"), { force: true });
   } catch {
   }
 }
@@ -4959,10 +6178,10 @@ function makeDesignVerifyToolCallMiddleware() {
         const p = typeof input?.path === "string" ? input.path : "";
         if (!p || !detectFrontendFile(p)) return out;
         const ctx = out.ctx;
-        const { default: fs8 } = await import("node:fs/promises");
+        const { default: fs9 } = await import("node:fs/promises");
         const { default: nodePath } = await import("node:path");
         const abs = nodePath.isAbsolute(p) ? p : nodePath.join(ctx.projectRoot, p);
-        const text = await fs8.readFile(abs, "utf8").catch(() => "");
+        const text = await fs9.readFile(abs, "utf8").catch(() => "");
         if (!text) return out;
         const loader = getDesignKitLoader(ctx.projectRoot);
         const rawTokens = await loader.readTokens(state.activeKit);
@@ -5082,11 +6301,25 @@ function buildRecoveryStrategies(opts) {
     },
     {
       label: "rate_limit_backoff",
-      async attempt(err) {
+      async attempt(err, ctx) {
         if (!(err instanceof ProviderError) || err.kind !== "rate_limit") return null;
         const delayMs = err.body?.retryAfterMs ?? 5e3;
         const delay = Math.min(6e4, Math.max(1e3, delayMs));
-        await new Promise((r) => setTimeout(r, delay));
+        if (ctx?.signal) {
+          await new Promise((resolve4) => {
+            if (ctx.signal.aborted) {
+              resolve4();
+              return;
+            }
+            const timer = setTimeout(resolve4, delay);
+            ctx.signal.addEventListener("abort", () => {
+              clearTimeout(timer);
+              resolve4();
+            }, { once: true });
+          });
+        } else {
+          await new Promise((r) => setTimeout(r, delay));
+        }
         return { action: "retry", reason: "rate_limit_backoff" };
       }
     },
@@ -5952,16 +7185,18 @@ var IntelligentCompactor = class {
   eliseThreshold;
   summarizerPrompt;
   summarizerModel;
+  oneShotOrchestrator;
   constructor(opts) {
     this.provider = opts.provider;
-    this.warnThreshold = opts.warnThreshold ?? 0.6;
-    this.softThreshold = opts.softThreshold ?? 0.75;
-    this.hardThreshold = opts.hardThreshold ?? 0.9;
+    this.warnThreshold = opts.warnThreshold ?? 0.5;
+    this.softThreshold = opts.softThreshold ?? 0.65;
+    this.hardThreshold = opts.hardThreshold ?? 0.8;
     this.maxContext = opts.maxContext ?? 128e3;
     this.preserveK = opts.preserveK ?? 4;
-    this.eliseThreshold = opts.eliseThreshold ?? 500;
+    this.eliseThreshold = opts.eliseThreshold ?? 300;
     this.summarizerPrompt = opts.summarizerPrompt ?? readBundledInstructionText("llm/intelligent-compactor-summarizer.md");
     this.summarizerModel = opts.summarizerModel;
+    this.oneShotOrchestrator = opts.oneShotOrchestrator;
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = estimateMessages(ctx.messages);
@@ -5974,7 +7209,7 @@ var IntelligentCompactor = class {
     let collapsedDigest;
     if (aggressive) {
       const phase2 = await this.summarizeAncientTurns(ctx);
-      if (phase2.saved > 0) reductions.push({ phase: "summary", saved: phase2.saved });
+      reductions.push({ phase: "summary", saved: Math.max(0, phase2.saved) });
       collapsedDigest = phase2.digest;
     } else if (load >= this.warnThreshold) {
       const saved2 = this.elide(ctx);
@@ -6028,9 +7263,15 @@ var IntelligentCompactor = class {
     } catch {
       summaryText = buildLosslessDigest(toSummarize) || `${toSummarize.length} earlier turns (semantic content preserved)`;
     }
+    const smartDigest = buildSmartDigest(toSummarize);
+    const enriched = smartDigest ? `[CRITICAL]
+${smartDigest}
+
+[SUMMARY]
+${summaryText}` : summaryText;
     const summaryMsg = {
       role: "system",
-      content: `[prior_turns_summary: ${summaryText}]`
+      content: `[prior_turns_summary: ${enriched}]`
     };
     const summaryTokens = estimateMessages([summaryMsg]);
     const tail = ctx.messages.slice(boundary);
@@ -6038,27 +7279,41 @@ var IntelligentCompactor = class {
     return { saved: Math.max(0, removedTokens - summaryTokens), digest: summaryText };
   }
   async callSummarizer(messages, ctx) {
-    const prompt = [
-      { type: "text", text: this.summarizerPrompt },
-      { type: "text", text: "\n\nConversation to summarize:\n" },
-      ...this.messagesToText(messages)
-    ];
-    const req = {
-      model: this.summarizerModel ?? ctx.model,
-      system: prompt,
-      messages: [],
-      maxTokens: 1024
-    };
-    const ac = ctx.signal ? void 0 : new AbortController();
-    const signal = ctx.signal ?? ac?.signal;
-    let res;
-    try {
-      res = await this.provider.complete(req, { signal });
-    } finally {
-      ac?.abort();
+    if (this.oneShotOrchestrator) {
+      const result = await this.oneShotOrchestrator.call({
+        system: this.summarizerPrompt,
+        messages: [{ role: "user", content: this.messagesToSummary(messages) }],
+        model: this.summarizerModel ?? "deepseek-chat",
+        timeoutMs: 3e4,
+        maxTokens: 1024,
+        signal: ctx.signal,
+        fallbackProfile: "summary"
+      });
+      if (result.text && !result.error) return result.text;
+    } else {
+      const prompt = [
+        { type: "text", text: this.summarizerPrompt },
+        { type: "text", text: "\n\nConversation to summarize:\n" },
+        ...this.messagesToText(messages)
+      ];
+      const req = {
+        model: this.summarizerModel ?? ctx.model,
+        system: prompt,
+        messages: [],
+        maxTokens: 1024
+      };
+      const ac = ctx.signal ? void 0 : new AbortController();
+      const signal = ctx.signal ?? ac?.signal;
+      let res;
+      try {
+        res = await this.provider.complete(req, { signal });
+      } finally {
+        ac?.abort();
+      }
+      const textBlocks = res.content.filter(isTextBlock);
+      return textBlocks.map((b) => b.text).join("\n").trim() || "(empty summary)";
     }
-    const textBlocks = res.content.filter(isTextBlock);
-    return textBlocks.map((b) => b.text).join("\n").trim() || "(empty summary)";
+    return "(empty summary)";
   }
   messagesToText(messages) {
     const lines = [];
@@ -6075,6 +7330,22 @@ var IntelligentCompactor = class {
     }
     return [{ type: "text", text: lines.join("\n") }];
   }
+  /** Compact string summary of messages (no TextBlock wrapper). */
+  messagesToSummary(messages) {
+    const lines = [];
+    for (const m of messages) {
+      const role = m.role.padEnd(10, " ");
+      if (typeof m.content === "string") {
+        lines.push(`[${role}]: ${m.content.slice(0, 500)}`);
+      } else if (Array.isArray(m.content)) {
+        const textParts = m.content.filter(isTextBlock).map((b) => b.text);
+        if (textParts.length > 0) {
+          lines.push(`[${role}]: ${textParts.join(" ").slice(0, 500)}`);
+        }
+      }
+    }
+    return lines.join("\n");
+  }
 };
 
 // src/execution/model-runtime.ts
@@ -6762,7 +8033,7 @@ function normalizeSubagentStructuredReport(value) {
   const nextSteps = stringArray(value["suggested_next_steps"]);
   const confidence = value["confidence"];
   const completion = value["completion"];
-  const remainingWork = optionalString(value["remaining_work"]);
+  const remainingWork = optionalString2(value["remaining_work"]);
   if (!summary || summary.length > MAX_SUMMARY_CHARS || !findings || findings.length > MAX_FINDINGS || !filesExamined || filesExamined.length > MAX_FILES || !nextSteps || nextSteps.length > MAX_NEXT_STEPS || [...findings, ...filesExamined, ...nextSteps].some(
     (item) => item.trim().length > MAX_ITEM_CHARS
   ) || typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1 || completion !== void 0 && completion !== "complete" && completion !== "partial" || completion === "partial" && !remainingWork || remainingWork !== void 0 && remainingWork.length > MAX_SUMMARY_CHARS) {
@@ -6788,7 +8059,7 @@ function isRecord4(value) {
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-function optionalString(value) {
+function optionalString2(value) {
   return value === void 0 ? void 0 : nonEmptyString(value);
 }
 function stringArray(value) {
@@ -7073,7 +8344,7 @@ var TOOLS = {
 };
 
 // src/coordination/agents/agent-prompts.ts
-import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
 import * as os2 from "node:os";
 import * as path6 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
@@ -7088,7 +8359,7 @@ function agentPrompt(id) {
   let resolved = "";
   for (const dir of agentPromptDirCandidates(envDir)) {
     try {
-      resolved = readFileSync2(path6.join(dir, fileName), "utf8").trimEnd();
+      resolved = readFileSync3(path6.join(dir, fileName), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -7118,7 +8389,7 @@ function agentPromptDirCandidates(envDir) {
 }
 function isDirectory2(candidate) {
   try {
-    return statSync2(candidate).isDirectory();
+    return statSync3(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -8806,19 +10077,19 @@ var FLEET_ROSTER = {
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
   )
 };
-var DEFAULT_IDLE_TIMEOUT_MS = 15 * 60 * 1e3;
+var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
 var FLEET_ROSTER_BUDGETS = {
-  "audit-log": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 5e3, maxToolCalls: 15e3 },
-  "bug-hunter": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
-  "refactor-planner": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 6e3, maxToolCalls: 18e3 },
-  "security-scanner": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
-  critic: { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 12e3 },
+  "audit-log": { timeoutMs: 3 * 60 * 60 * 1e3, maxIterations: 2500, maxToolCalls: 7500 },
+  "bug-hunter": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 1e4 },
+  "refactor-planner": { timeoutMs: 4 * 60 * 60 * 1e3, maxIterations: 3e3, maxToolCalls: 9e3 },
+  "security-scanner": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 1e4 },
+  critic: { timeoutMs: 3 * 60 * 60 * 1e3, maxIterations: 2e3, maxToolCalls: 6e3 },
   "shadow-agent": {
     idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
-    maxIterations: 2e3,
-    maxToolCalls: 5e3,
-    maxTokens: 6e4,
-    maxCostUsd: 1
+    maxIterations: 1e3,
+    maxToolCalls: 2500,
+    maxTokens: 3e4,
+    maxCostUsd: 0.5
   },
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
@@ -8826,8 +10097,8 @@ var FLEET_ROSTER_BUDGETS = {
 };
 var GENERIC_SUBAGENT_BUDGET = {
   idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
-  maxIterations: 5e3,
-  maxToolCalls: 15e3
+  maxIterations: 2500,
+  maxToolCalls: 7500
 };
 function applyRosterBudget(cfg) {
   const roleBudget = cfg.role ? FLEET_ROSTER_BUDGETS[cfg.role] : void 0;
@@ -10368,6 +11639,7 @@ var LLMSelector = class {
   maxContextTokens;
   systemPrompt;
   maxOutputTokens;
+  oneShotOrchestrator;
   constructor(opts) {
     this.provider = opts.provider;
     this.model = opts.model ?? "unknown";
@@ -10379,6 +11651,7 @@ var LLMSelector = class {
     this.maxContextTokens = opts.maxContextTokens ?? 4e4;
     this.systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     this.maxOutputTokens = opts.maxOutputTokens ?? 1024;
+    this.oneShotOrchestrator = opts.oneShotOrchestrator;
   }
   async select(messages, maxToKeep) {
     const effectiveBudget = Math.min(maxToKeep, this.maxContextTokens);
@@ -10402,12 +11675,23 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
     let raw;
     const ac = new AbortController();
     try {
-      const timeoutSignal = AbortSignal.timeout(3e4);
-      const res = await this.provider.complete(req, {
-        signal: AbortSignal.any([ac.signal, timeoutSignal])
-      });
-      const textBlocks = res.content.filter(isTextBlock);
-      raw = textBlocks.map((b) => b.text).join("\n").trim();
+      if (this.oneShotOrchestrator) {
+        const result = await this.oneShotOrchestrator.call({
+          system: systemText + budgetInstruction,
+          userPrompt: historyText,
+          maxTokens: this.maxOutputTokens,
+          timeoutMs: 3e4
+        });
+        if (result.error) throw new Error(result.error);
+        raw = result.text;
+      } else {
+        const timeoutSignal = AbortSignal.timeout(3e4);
+        const res = await this.provider.complete(req, {
+          signal: AbortSignal.any([ac.signal, timeoutSignal])
+        });
+        const textBlocks = res.content.filter(isTextBlock);
+        raw = textBlocks.map((b) => b.text).join("\n").trim();
+      }
     } catch (err) {
       if (err instanceof Error) {
         console.warn(
@@ -10527,12 +11811,12 @@ var SelectiveCompactor = class {
   constructor(opts) {
     this.provider = opts.provider;
     this.selector = opts.selector ?? new LLMSelector({ provider: opts.provider, model: opts.selectorModel, maxOutputTokens: opts.selectorMaxOutputTokens });
-    this.warnThreshold = opts.warnThreshold ?? 0.6;
-    this.softThreshold = opts.softThreshold ?? 0.75;
-    this.hardThreshold = opts.hardThreshold ?? 0.9;
+    this.warnThreshold = opts.warnThreshold ?? 0.5;
+    this.softThreshold = opts.softThreshold ?? 0.65;
+    this.hardThreshold = opts.hardThreshold ?? 0.8;
     this.maxContext = opts.maxContext ?? 128e3;
     this.preserveK = opts.preserveK ?? 4;
-    this.eliseThreshold = opts.eliseThreshold ?? 500;
+    this.eliseThreshold = opts.eliseThreshold ?? 300;
     this.summarizerModel = opts.summarizerModel ?? opts.selectorModel;
     if (this.summarizerModel === void 0 && (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1")) {
       console.warn(
@@ -10725,7 +12009,7 @@ Summarize the following message range:`;
 };
 
 // src/execution/skill-loader.ts
-import * as fs4 from "node:fs/promises";
+import * as fs5 from "node:fs/promises";
 import * as path7 from "node:path";
 
 // src/skills/foreign-sources.ts
@@ -10956,7 +12240,7 @@ async function entryIsDirectory(dir, entry) {
   if (entry.isDirectory()) return true;
   if (entry.isSymbolicLink()) {
     try {
-      return (await fs4.stat(path7.join(dir, entry.name))).isDirectory();
+      return (await fs5.stat(path7.join(dir, entry.name))).isDirectory();
     } catch {
       return false;
     }
@@ -10999,12 +12283,12 @@ var DefaultSkillLoader = class {
     const seen = /* @__PURE__ */ new Set();
     for (const { dir, source, originTool } of this.dirs) {
       try {
-        const entries = await fs4.readdir(dir, { withFileTypes: true });
+        const entries = await fs5.readdir(dir, { withFileTypes: true });
         for (const e of entries) {
           if (!await entryIsDirectory(dir, e)) continue;
           const skillFile = path7.join(dir, e.name, "SKILL.md");
           try {
-            const raw = await fs4.readFile(skillFile, "utf8");
+            const raw = await fs5.readFile(skillFile, "utf8");
             const fm = parseSkillFrontmatter(raw);
             if (!fm.name || !fm.description) continue;
             if (!isValidSkillNameFormat(fm.name)) continue;
@@ -11076,7 +12360,7 @@ var DefaultSkillLoader = class {
     if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
-    const body = await fs4.readFile(m.path, "utf8");
+    const body = await fs5.readFile(m.path, "utf8");
     this.bodyCache.set(key, body);
     return body;
   }
@@ -11089,9 +12373,9 @@ var DefaultSkillLoader = class {
     const savePath = path7.join(path7.dirname(m.path), "SKILL.save.md");
     let result;
     try {
-      result = await fs4.readFile(savePath, "utf8");
+      result = await fs5.readFile(savePath, "utf8");
     } catch {
-      const full = await fs4.readFile(m.path, "utf8");
+      const full = await fs5.readFile(m.path, "utf8");
       const body = stripFrontmatter2(full);
       const compact = compactSkillBody(body);
       if (compact) {
@@ -11119,11 +12403,11 @@ function parseDescriptionFromText(desc) {
 }
 
 // src/execution/prompt-loader.ts
-import * as fs6 from "node:fs/promises";
+import * as fs7 from "node:fs/promises";
 import * as path9 from "node:path";
 
 // src/storage/prompt-store.ts
-import * as fs5 from "node:fs/promises";
+import * as fs6 from "node:fs/promises";
 import * as path8 from "node:path";
 var SCHEMA_VERSION = 2;
 function migratePromptEntry(raw) {
@@ -11185,12 +12469,12 @@ var DefaultPromptStore = class {
     await ensureDir(this.dir);
     const entries = [];
     try {
-      const files = await fs5.readdir(this.dir);
+      const files = await fs6.readdir(this.dir);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
         try {
           const raw = JSON.parse(
-            await fs5.readFile(path8.join(this.dir, file), "utf8")
+            await fs6.readFile(path8.join(this.dir, file), "utf8")
           );
           const migrated = migratePromptEntry(raw.entry);
           if (migrated) entries.push(migrated);
@@ -11206,7 +12490,7 @@ var DefaultPromptStore = class {
   async get(id) {
     const file = path8.join(this.dir, `${id}.json`);
     try {
-      const raw = JSON.parse(await fs5.readFile(file, "utf8"));
+      const raw = JSON.parse(await fs6.readFile(file, "utf8"));
       return migratePromptEntry(raw.entry);
     } catch {
       return null;
@@ -11221,7 +12505,7 @@ var DefaultPromptStore = class {
   async delete(id) {
     const file = path8.join(this.dir, `${id}.json`);
     try {
-      await fs5.unlink(file);
+      await fs6.unlink(file);
       return true;
     } catch {
       return false;
@@ -11421,7 +12705,7 @@ var DefaultPromptLoader = class {
     const files = await walkJson(dir);
     for (const file of files) {
       try {
-        const parsed = JSON.parse(await fs6.readFile(file, "utf8"));
+        const parsed = JSON.parse(await fs7.readFile(file, "utf8"));
         const migrated = migratePromptEntry(parsed);
         if (migrated) out.push({ ...migrated, source: "builtin" });
       } catch {
@@ -11435,7 +12719,7 @@ async function walkJson(dir) {
   const out = [];
   let entries;
   try {
-    entries = await fs6.readdir(dir, { withFileTypes: true });
+    entries = await fs7.readdir(dir, { withFileTypes: true });
   } catch {
     return out;
   }
@@ -11612,7 +12896,8 @@ var ProviderBackedCompactor = class {
     }
     return new IntelligentCompactor({
       ...common,
-      summarizerModel: this.opts.summarizerModel
+      summarizerModel: this.opts.summarizerModel,
+      oneShotOrchestrator: this.opts.oneShotOrchestrator
     });
   }
 };
@@ -11627,9 +12912,12 @@ function readPolicy(ctx) {
 // src/execution/tool-executor.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import * as fs7 from "node:fs/promises";
+import * as fs8 from "node:fs/promises";
 import * as path10 from "node:path";
 
+// src/types/tool-executor.ts
+var GOVERNED_TOOL_EXECUTOR_META_KEY = "toolExecutor.executeGoverned";
+
 // src/types/tool-markers.ts
 var MALFORMED_ARG_MARKERS = ["__raw", "__raw_arguments", "_raw"];
 
@@ -11746,6 +13034,18 @@ var ToolExecutor = class _ToolExecutor {
    * Returns the execution results and the remaining output budget.
    */
   async executeBatch(toolUses, ctx, strategy) {
+    return this.withGovernedExecutionBridge(
+      ctx,
+      () => this.executeBatchInternal(toolUses, ctx, strategy)
+    );
+  }
+  /**
+   * Internal batch implementation. Nested meta-tool calls enter here through
+   * the governed bridge so they traverse the same validation, hooks,
+   * permission/capability, timeout, scrubbing, and audit path without
+   * replacing the bridge that is already active for the outer call.
+   */
+  async executeBatchInternal(toolUses, ctx, strategy) {
     let budget = this.opts.perIterationOutputCapBytes ?? 1e5;
     const runOne = async (use0) => {
       const start = Date.now();
@@ -11916,8 +13216,9 @@ ${errorDetails}`,
           );
           if (post.additionalContext) {
             if (post.contextAs === "separate") {
-              const block = { type: "text", text: post.additionalContext };
-              ctx.state.appendMessage({ role: "user", content: [block] });
+              ctx.pendingPostToolContext = ctx.pendingPostToolContext ? `${ctx.pendingPostToolContext}
+
+${post.additionalContext}` : post.additionalContext;
             } else {
               const appended = `
 
@@ -12017,14 +13318,56 @@ ${post.additionalContext}`;
     };
   }
   /**
-   * Execute a single tool with timeout, permission check, and output capping.
-   * Emits `tool.started` via the injected EventBus (if any) right before
-   * invoking the tool — closes the observability gap between "model decided
-   * to call a tool" and "tool.executed".
+   * Install the executor-owned bridge used by meta-tools for nested calls.
+   * The bridge deliberately returns the governed, scrubbed ToolResultBlock
+   * content rather than the raw tool value. This prevents a meta-tool from
+   * bypassing output controls while preserving structured success/failure.
+   */
+  async withGovernedExecutionBridge(ctx, run) {
+    const previous = ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY];
+    if (typeof previous === "function") return run();
+    const bridge = async (toolName, input) => {
+      const nestedUse = {
+        type: "tool_use",
+        id: `nested-${randomUUID3()}`,
+        name: toolName,
+        input
+      };
+      const batch = await this.executeBatchInternal([nestedUse], ctx, "sequential");
+      const output = batch.outputs[0];
+      if (!output) {
+        return { success: false, error: `tool "${toolName}" produced no result` };
+      }
+      if (output.result.type === "tool_confirm_pending") {
+        return {
+          success: false,
+          error: `tool "${toolName}" requires separate confirmation; call it directly`
+        };
+      }
+      if (output.result.is_error) {
+        return { success: false, error: String(output.result.content) };
+      }
+      return { success: true, result: output.result.content };
+    };
+    ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY] = bridge;
+    try {
+      return await run();
+    } finally {
+      if (previous === void 0) delete ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY];
+      else ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY] = previous;
+    }
+  }
+  /**
+   * Execute a single tool with timeout and output capping after its permission
+   * decision has already been resolved by executeBatch/the confirmation flow.
+   * Also installs the governed bridge because confirmed tools are re-run
+   * through this method after a pending confirmation.
    */
   async executeTool(tool, use, ctx, budget) {
-    const text = await this.produceToolOutput(tool, use, ctx, budget);
-    return this.settleToolOutput(tool, use, text, budget);
+    return this.withGovernedExecutionBridge(ctx, async () => {
+      const text = await this.produceToolOutput(tool, use, ctx, budget);
+      return this.settleToolOutput(tool, use, text, budget);
+    });
   }
   /**
    * Async "produce" phase: run the tool, serialize, scrub, and spill an
@@ -12379,11 +13722,11 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
   }
   try {
     const dir = path10.join(wstackGlobalRoot(), "tool-output");
-    await fs7.mkdir(dir, { recursive: true });
+    await fs8.mkdir(dir, { recursive: true });
     const safeTool = toolName.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40) || "tool";
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const filePath = path10.join(dir, `${stamp}-${safeTool}-${randomUUID3()}.log`);
-    await fs7.writeFile(filePath, content, "utf8");
+    await fs8.writeFile(filePath, content, "utf8");
     const marker = `[full tool output: ${bytes} bytes at ${filePath}; read/grep that file selectively instead of re-running or requesting more output]`;
     const fixedBytes = Buffer.byteLength(marker + TOOL_OUTPUT_ARTIFACT_OMISSION, "utf8");
     const previewBytes = Math.min(
@@ -12431,11 +13774,233 @@ function sliceUtf8Suffix(text, maxBytes) {
   if (first >= 56320 && first <= 57343) start++;
   return text.slice(start);
 }
+
+// src/execution/one-shot-llm.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_TOKENS = 1024;
+var OneShotOrchestrator = class {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Make a one-shot LLM call. Resolves provider+model, applies fallback
+   * chain on transient errors, and returns a structured result.
+   *
+   * Never throws — all errors are captured in `OneShotLLMResult.error`.
+   */
+  async call(input) {
+    const startedAt = performance.now();
+    const config = this.opts.getConfig();
+    const target = this.resolveTarget(input, config);
+    if (!target) {
+      return {
+        text: "",
+        model: input.model ?? config.model ?? "unknown",
+        provider: input.providerId ?? config.provider ?? "unknown",
+        tokens: { input: 0, output: 0, total: 0 },
+        durationMs: Math.round(performance.now() - startedAt),
+        fromFallback: false,
+        error: "No provider or model could be resolved. Check your config."
+      };
+    }
+    let provider;
+    try {
+      provider = await this.opts.buildProvider(target.providerId, target.model);
+    } catch (err) {
+      return {
+        text: "",
+        model: target.model,
+        provider: target.providerId,
+        tokens: { input: 0, output: 0, total: 0 },
+        durationMs: Math.round(performance.now() - startedAt),
+        fromFallback: false,
+        error: `Cannot build provider "${target.providerId}": ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const request = this.buildRequest(input, target.model);
+    const signal = this.resolveSignal(input);
+    const chain = this.resolveFallbackChain(input, config, target);
+    let servingProviderId = provider.id;
+    let servingModel = target.model;
+    let fromFallback = false;
+    const primaryAttempt = await this.tryCall(provider, request, signal);
+    let result = primaryAttempt.response;
+    let lastError = primaryAttempt.error;
+    let fallbackEligible = primaryAttempt.fallbackEligible;
+    if (!result && fallbackEligible && chain.length > 0) {
+      for (const ref of chain) {
+        const parsed = parseModelRef(ref);
+        if (!parsed.model) continue;
+        const fbProviderId = parsed.provider ?? config.provider;
+        if (fbProviderId === provider.id && parsed.model === target.model) continue;
+        servingProviderId = fbProviderId;
+        servingModel = parsed.model;
+        let fbProvider;
+        try {
+          fbProvider = await this.opts.buildProvider(fbProviderId, parsed.model);
+        } catch (err) {
+          lastError = err;
+          continue;
+        }
+        servingProviderId = fbProvider.id;
+        const attempt = await this.tryCall(
+          fbProvider,
+          this.buildRequest(input, parsed.model),
+          signal
+        );
+        if (attempt.response) {
+          result = attempt.response;
+          fromFallback = true;
+          break;
+        }
+        lastError = attempt.error;
+        fallbackEligible = attempt.fallbackEligible;
+        if (!fallbackEligible) break;
+      }
+    }
+    const elapsed = Math.round(performance.now() - startedAt);
+    if (result) {
+      const textBlocks = result.content.filter(isTextBlock);
+      const text = textBlocks.map((b) => b.text).join("\n").trim();
+      return {
+        text: text || "(empty response)",
+        model: result.model ?? servingModel,
+        provider: servingProviderId,
+        tokens: {
+          input: result.usage?.input ?? 0,
+          output: result.usage?.output ?? 0,
+          total: (result.usage?.input ?? 0) + (result.usage?.output ?? 0)
+        },
+        durationMs: elapsed,
+        fromFallback,
+        stopReason: result.stopReason
+      };
+    }
+    return {
+      text: "",
+      model: servingModel,
+      provider: servingProviderId,
+      tokens: { input: 0, output: 0, total: 0 },
+      durationMs: elapsed,
+      fromFallback,
+      error: lastError instanceof Error ? lastError.message : String(lastError ?? "Unknown error")
+    };
+  }
+  // ── Private helpers ─────────────────────────────────────────────
+  /**
+   * Resolve the target provider + model from input + config.
+   * Priority: role-based routing > explicit providerId+model > defaults.
+   */
+  resolveTarget(input, config) {
+    if (input.role && this.opts.modelRouter) {
+      const pick = this.opts.modelRouter.pickForTask(input.role, "");
+      if (pick) {
+        return { providerId: pick.provider, model: pick.model };
+      }
+    }
+    if (input.providerId && input.model) {
+      return { providerId: input.providerId, model: input.model };
+    }
+    if (input.model) {
+      return { providerId: config.provider, model: input.model };
+    }
+    if (input.providerId) {
+      return { providerId: input.providerId, model: config.model };
+    }
+    if (config.provider && config.model) {
+      return { providerId: config.provider, model: config.model };
+    }
+    return void 0;
+  }
+  /**
+   * Build a Provider Request from the input.
+   */
+  buildRequest(input, model) {
+    const messages = [...input.messages ?? []];
+    if (input.userPrompt) {
+      messages.push({ role: "user", content: input.userPrompt });
+    }
+    const system = asTextBlocks(input.system);
+    return {
+      model,
+      ...system.length > 0 ? { system } : {},
+      messages,
+      maxTokens: input.maxTokens ?? DEFAULT_MAX_TOKENS,
+      ...input.temperature !== void 0 ? { temperature: input.temperature } : {},
+      ...input.responseFormat ? { responseFormat: input.responseFormat } : {}
+    };
+  }
+  /**
+   * Resolve the abort signal. Provider calls always receive the per-call
+   * timeout, composed with external cancellation when the caller supplies it.
+   */
+  resolveSignal(input) {
+    const timeoutSignal = AbortSignal.timeout(input.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    return input.signal ? AbortSignal.any([input.signal, timeoutSignal]) : timeoutSignal;
+  }
+  /**
+   * Build the fallback model chain from input + config + current target.
+   */
+  resolveFallbackChain(input, config, target) {
+    if (input.fallbackModels && input.fallbackModels.length > 0) {
+      return input.fallbackModels;
+    }
+    if (input.fallbackProfile) {
+      const profile = fallbackProfileChain(config, input.fallbackProfile);
+      if (profile.length > 0) return profile;
+    }
+    if (config.fallbackAuto !== false) {
+      return effectiveFallbackChain(config).filter((ref) => {
+        const parsed = parseModelRef(ref);
+        const fbProvider = parsed.provider ?? config.provider;
+        return !(fbProvider === target.providerId && parsed.model === target.model);
+      });
+    }
+    return [];
+  }
+  /** Attempt a provider call while preserving the actual failure for callers. */
+  async tryCall(provider, request, signal) {
+    try {
+      return {
+        response: await provider.complete(request, { signal }),
+        fallbackEligible: false
+      };
+    } catch (err) {
+      return {
+        error: err,
+        fallbackEligible: !signal.aborted && (!(err instanceof ProviderError) || isFallbackWorthy(err.kind))
+      };
+    }
+  }
+};
+function asTextBlocks(system) {
+  if (!system) return [];
+  if (Array.isArray(system)) return system;
+  return [{ type: "text", text: system }];
+}
 export {
   AutoCompactionMiddleware,
   AutonomousRunner,
   BRAIN_EVALUATION_CASE_VERSION,
+  BUILTIN_COUNCIL_PERSONAS,
+  BUILTIN_COUNCIL_PROFILES,
+  COUNCIL_JUDGE_PROMPT_PATH,
+  COUNCIL_REFUSAL_OPTION_ID,
   COUNCIL_REFUSE_OPTION_ID,
+  COUNCIL_VOTER_PROMPT_PATH,
+  CouncilOrchestrator,
+  CouncilPersonaRegistry,
+  CouncilProfileRegistry,
+  DEFAULT_COUNCIL_APPROVAL_FRACTION,
+  DEFAULT_COUNCIL_JUDGE_MAX_TOKENS,
+  DEFAULT_COUNCIL_MAX_CONCURRENCY,
+  DEFAULT_COUNCIL_OVERALL_TIMEOUT_MS,
+  DEFAULT_COUNCIL_PERSONA_REGISTRY,
+  DEFAULT_COUNCIL_PER_CALL_TIMEOUT_MS,
+  DEFAULT_COUNCIL_PROFILE_REGISTRY,
+  DEFAULT_COUNCIL_QUORUM_FRACTION,
+  DEFAULT_COUNCIL_VOTER_MAX_TOKENS,
   DEFAULT_RECOVERY_STRATEGIES,
   DefaultDesignKitLoader,
   DefaultErrorHandler,
@@ -12446,6 +14011,8 @@ export {
   EternalAutonomyEngine,
   HybridCompactor,
   IntelligentCompactor,
+  MAX_COUNCIL_CONCURRENCY,
+  OneShotOrchestrator,
   ParallelEternalEngine,
   SelectiveCompactor,
   ToolExecutor,
@@ -12455,6 +14022,11 @@ export {
   applyModelRuntime,
   assembleBrainTiers,
   buildBrainUserMessage,
+  buildCouncilJudgeSystemPrompt,
+  buildCouncilJudgeUserPrompt,
+  buildCouncilQuestionPrompt,
+  buildCouncilVoterSystemPrompt,
+  buildCouncilVoterUserPrompt,
   buildGoalPreamble,
   buildRecoveryStrategies,
   clearActiveKit,
@@ -12463,6 +14035,8 @@ export {
   createAutonomyBrain,
   createBrainRuntime,
   createCouncilBrainArbiter,
+  createCouncilPersonaRegistry,
+  createCouncilProfileRegistry,
   createStrategyCompactor,
   createTieredBrainArbiter,
   designProjectDir,
@@ -12479,12 +14053,15 @@ export {
   makeDesignDetectUserInputMiddleware,
   makeDesignStudioRequestMiddleware,
   mergeModelRuntime,
+  normalizeCouncilProfile,
   parseOptionDecision,
   recordKitChoice,
   renderPrompt,
   resolveBrainConfigDefaults,
   resolveBundledDesignKitsDir,
   resolveCacheForRequest,
+  resolveCouncilProfile,
+  resolveCouncilVotes,
   resolveModelRuntime,
   resolveReasoningForRequest,
   runBrainEvaluation,