@wrongstack/core 0.285.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) {
@@ -2069,19 +2093,27 @@ function adaptThresholdsForSignals(thresholds, signals) {
 
 // src/execution/autonomous-runner.ts
 var DoneConditionChecker = class {
-  constructor(condition) {
+  constructor(condition, opts) {
     this.condition = condition;
+    this.logger = opts?.logger;
     if (condition.type === "output_match" && condition.pattern) {
       const result = compileUserRegex(condition.pattern, "");
       this.compiledRegex = result.ok ? result.regex : null;
       if (!result.ok) {
-        console.warn(JSON.stringify({
-          level: "warn",
-          event: "autonomous.done_condition_invalid_regex",
-          pattern: condition.pattern,
-          reason: result.reason,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        }));
+        if (this.logger) {
+          this.logger.warn(
+            "Done condition has invalid regex \u2014 will never match",
+            { event: "autonomous.done_condition_invalid_regex", pattern: condition.pattern, reason: result.reason }
+          );
+        } else {
+          console.warn(JSON.stringify({
+            level: "warn",
+            event: "autonomous.done_condition_invalid_regex",
+            pattern: condition.pattern,
+            reason: result.reason,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }));
+        }
       }
     } else {
       this.compiledRegex = null;
@@ -2089,6 +2121,7 @@ var DoneConditionChecker = class {
   }
   condition;
   compiledRegex;
+  logger;
   check(state) {
     switch (this.condition.type) {
       case "iterations":
@@ -2139,7 +2172,7 @@ var DoneConditionChecker = class {
 var AutonomousRunner = class {
   constructor(opts) {
     this.opts = opts;
-    this.doneChecker = new DoneConditionChecker(opts.doneCondition);
+    this.doneChecker = new DoneConditionChecker(opts.doneCondition, { logger: opts.logger });
   }
   opts;
   iterations = 0;
@@ -2245,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();
@@ -2256,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 {
     }
@@ -2283,7 +2316,7 @@ function instructionRootCandidates() {
 }
 function isDirectory(candidate) {
   try {
-    return statSync(candidate).isDirectory();
+    return statSync2(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -2300,12 +2333,25 @@ function createTieredBrainArbiter(opts) {
   return {
     async decide(request) {
       const policyDecision = await opts.policy.decide(request);
-      if (policyDecision.type !== "ask_human") return policyDecision;
+      const provisionalContinue = policyDecision.type === "answer" && policyDecision.optionId === void 0 && request.fallback === "continue";
+      if (policyDecision.type !== "ask_human" && !provisionalContinue) return policyDecision;
       const ceiling = opts.getMaxAutoRisk?.() ?? "medium";
-      if (!opts.autonomous || ceiling === "off") return policyDecision;
+      if (ceiling === "off") return policyDecision;
       const ceilingLevel = ceiling === "all" ? 3 : RISK_LEVELS[ceiling] ?? 1;
       const requestLevel = RISK_LEVELS[request.risk] ?? 2;
       if (requestLevel > ceilingLevel) return policyDecision;
+      if (opts.council) {
+        const floor = opts.getCouncilMinRisk?.() ?? "high";
+        const floorLevel = RISK_LEVELS[floor] ?? 2;
+        if (requestLevel >= floorLevel) {
+          try {
+            const councilDecision = await opts.council.decide(request);
+            if (councilDecision.type !== "ask_human") return councilDecision;
+          } catch {
+          }
+        }
+      }
+      if (!opts.autonomous) return policyDecision;
       try {
         const llmDecision = await opts.autonomous.decide(request);
         if (llmDecision.type === "answer") return llmDecision;
@@ -2319,6 +2365,12 @@ function createAutonomyBrain(opts) {
   const maxRisk = opts.maxAutoRisk ?? "high";
   const maxRiskLevel = RISK_LEVELS[maxRisk] ?? 2;
   const timeoutMs = opts.decisionTimeoutMs ?? 15e3;
+  const targets = opts.targets && opts.targets.length > 0 ? opts.targets : opts.provider && opts.model ? [{ provider: opts.provider, model: opts.model }] : [];
+  if (targets.length === 0) {
+    throw new Error("createAutonomyBrain: provide `targets` or `provider` + `model`.");
+  }
+  const strategy = opts.strategy ?? "fallback";
+  let rrCursor = 0;
   return {
     async decide(request) {
       const requestLevel = RISK_LEVELS[request.risk] ?? 2;
@@ -2337,7 +2389,10 @@ function createAutonomyBrain(opts) {
         opts.onDecision?.(formatDecisionSummary(heuristic, request), heuristic, request);
         return heuristic;
       }
-      const llmDecision = await llmDecide(request, opts.provider, opts.model, timeoutMs);
+      const start = strategy === "round-robin" ? rrCursor++ % targets.length : 0;
+      const ordered = [...targets.slice(start), ...targets.slice(0, start)];
+      const digest = opts.getDecisionDigest?.(request);
+      const llmDecision = await llmDecide(request, ordered, timeoutMs, digest);
       opts.onDecision?.(formatDecisionSummary(llmDecision, request), llmDecision, request);
       return llmDecision;
     }
@@ -2355,6 +2410,7 @@ function formatDecisionSummary(decision, request) {
   return `\u{1F9E0} Brain: ASKED HUMAN \u2014 "${question}"`;
 }
 function quickDecide(request) {
+  if (request.options?.length) return null;
   const q = request.question.toLowerCase();
   const ctx = request.context?.toLowerCase() ?? "";
   if (q.includes("deadlock") && ctx.includes("failed")) {
@@ -2364,7 +2420,7 @@ function quickDecide(request) {
       rationale: "Heuristic: deadlocked tasks blocked by failed dependencies \u2014 skipping unblocks remaining work."
     };
   }
-  if ((q.includes("failed") || q.includes("retry")) && (ctx.includes("3") || ctx.includes("exhausted"))) {
+  if ((q.includes("failed") || q.includes("retry")) && (/\bexhausted\b/.test(ctx) || /\b(?:[3-9]|\d{2,})\s+(?:consecutive\s+)?(?:times|attempts|retries|failures)\b/.test(ctx) || /\b(?:attempt|retr(?:y|ies)|failure)s?\W{0,3}(?:[3-9]|\d{2,})\b/.test(ctx))) {
     return {
       type: "answer",
       text: "Mark as failed and move on. Note the failure for the final report.",
@@ -2374,7 +2430,7 @@ function quickDecide(request) {
   if (q.includes("goal complete") || q.includes("mission complete")) {
     return null;
   }
-  if (q.includes("continue") || q.includes("proceed")) {
+  if (request.fallback === "continue" && /\b(?:continue|proceed)\b/.test(q) && !/\b(?:stop|abort|halt|cancel|pause|rollback)\b/.test(q) && !/\bor\b/.test(q)) {
     return {
       type: "answer",
       text: "Continue execution. Do not stop.",
@@ -2383,93 +2439,2355 @@ function quickDecide(request) {
   }
   return null;
 }
-async function llmDecide(request, provider, model, timeoutMs) {
+function buildBrainUserMessage(request) {
   const optionsText = request.options?.length ? "\nOptions:\n" + request.options.map(
     (o) => `  [${o.id}] ${o.label}${o.consequence ? ` \u2014 ${o.consequence}` : ""}${o.recommended ? " \u2605 recommended" : ""}`
   ).join("\n") : "";
-  const systemPrompt = readBundledInstructionText("llm/autonomy-brain.md");
-  const userMessage = [
+  return [
     `Question: ${request.question}`,
     request.context ? `
 Context:
 ${request.context}` : "",
     optionsText
   ].filter(Boolean).join("\n");
-  try {
-    const signal = AbortSignal.timeout(timeoutMs);
-    const response = await provider.complete(
-      {
-        model,
-        system: [{ type: "text", text: systemPrompt }],
-        messages: [{ role: "user", content: userMessage || "Decide." }],
-        maxTokens: 200
-      },
-      { signal }
+}
+function withDecisionDigest(user, digest) {
+  if (!digest?.trim()) return user;
+  return `${user}
+
+Outcome history of similar past decisions (learn from it):
+${digest}`;
+}
+async function completeBrainLlm(target, input) {
+  const signal = AbortSignal.timeout(input.timeoutMs);
+  const response = await target.provider.complete(
+    {
+      model: target.model,
+      system: [{ type: "text", text: input.system }],
+      messages: [{ role: "user", content: input.user || "Decide." }],
+      maxTokens: input.maxTokens ?? 200
+    },
+    { signal }
+  );
+  return extractText(response).trim();
+}
+async function llmDecide(request, targets, timeoutMs, digest) {
+  const systemPrompt = readBundledInstructionText("llm/autonomy-brain.md");
+  const userMessage = withDecisionDigest(buildBrainUserMessage(request), digest);
+  let text = null;
+  for (const target of targets) {
+    try {
+      text = await completeBrainLlm(target, {
+        system: systemPrompt,
+        user: userMessage,
+        timeoutMs
+      });
+      break;
+    } catch {
+    }
+  }
+  if (text === null) {
+    if (request.fallback === "continue") {
+      return {
+        type: "answer",
+        text: "Continue (Autonomy Brain LLM unavailable \u2014 using fallback)."
+      };
+    }
+    return { type: "deny", reason: "Autonomy Brain LLM unavailable for decision." };
+  }
+  if (request.options?.length) {
+    const parsed = parseOptionDecision(text, request.options);
+    if (parsed) {
+      return parsed;
+    }
+    return {
+      type: "deny",
+      reason: "Autonomy Brain returned no exact valid option id."
+    };
+  }
+  return {
+    type: "answer",
+    text: text || (request.fallback === "continue" ? "Continue execution." : "Denied by autonomy policy."),
+    rationale: text || void 0
+  };
+}
+function parseOptionDecision(rawText, options) {
+  const text = rawText.trim();
+  const byId = new Map(options.map((option2) => [option2.id, option2]));
+  const wholeFence = /^```(?:json)?[ \t]*\r?\n([\s\S]*?)\r?\n?```$/i.exec(text);
+  const jsonCandidate = wholeFence ? (wholeFence[1] ?? "").trim() : text;
+  const parsed = safeParse(jsonCandidate, 16384);
+  if (parsed.ok && parsed.value && typeof parsed.value.optionId === "string") {
+    const option2 = byId.get(parsed.value.optionId);
+    if (!option2) return null;
+    return {
+      type: "answer",
+      optionId: option2.id,
+      text: option2.label,
+      rationale: typeof parsed.value.rationale === "string" && parsed.value.rationale.trim() ? parsed.value.rationale.trim() : void 0
+    };
+  }
+  const legacy = /^\s*\[([^\]\r\n]+)\](?:\s*(?:—|-|:)\s*)?([\s\S]*)$/.exec(text);
+  if (!legacy) return null;
+  const option = byId.get((legacy[1] ?? "").trim());
+  if (!option) return null;
+  const rationale = (legacy[2] ?? "").trim();
+  return {
+    type: "answer",
+    optionId: option.id,
+    text: option.label,
+    rationale: rationale || void 0
+  };
+}
+function extractText(result) {
+  if (!result || typeof result !== "object") return "";
+  const r = result;
+  if (Array.isArray(r.content)) {
+    return r.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+  }
+  if (Array.isArray(r.choices)) {
+    return r.choices[0]?.message?.content ?? "";
+  }
+  return typeof r.text === "string" ? r.text : "";
+}
+
+// src/types/provider.ts
+var CONTEXT_OVERFLOW_RE = /context.length|context.window|max.*tokens?.*exceeded|prompt is too long|too long|exceeds the context|\btokens\b.*exceed|context_length_exceeded/i;
+var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
+function classifyProviderError(status, body, message) {
+  const type = body?.type;
+  if (status === 0) return "network";
+  if (status === 408) return "timeout";
+  if (status === 599) return "stream_hang";
+  if (type === "rate_limit_error" || status === 429) return "rate_limit";
+  if (type === "overloaded_error" || status === 529) return "overloaded";
+  if (status >= 500) return "server";
+  if (type === "authentication_error" || type === "permission_error" || status === 401 || status === 403) {
+    return "auth";
+  }
+  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
+  if (type === "content_filter" || CONTENT_FILTER_RE.test(text)) return "content_filter";
+  if (status === 413 || status >= 400 && CONTEXT_OVERFLOW_RE.test(text)) {
+    return "context_overflow";
+  }
+  if (status >= 400) return "invalid_request";
+  return "unknown";
+}
+function isRetryableKind(kind) {
+  return RETRYABLE_BY_KIND[kind];
+}
+var RETRYABLE_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
+};
+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;
+  providerId;
+  /** Canonical failure classification — see {@link ProviderErrorKind}. */
+  kind;
+  body;
+  constructor(message, status, retryable, providerId, opts = {}) {
+    const kind = opts.kind ?? classifyProviderError(status, opts.body, message);
+    super({
+      message,
+      code: kindToCode(kind),
+      subsystem: "provider",
+      severity: status >= 500 ? "error" : "warning",
+      recoverable: retryable,
+      context: { providerId, status },
+      cause: opts.cause
+    });
+    this.name = "ProviderError";
+    this.status = status;
+    this.retryable = retryable;
+    this.providerId = providerId;
+    this.kind = kind;
+    this.body = opts.body;
+  }
+  /**
+   * Render a one-line, user-facing description. Designed for the CLI/TUI
+   * status line and the agent's retry warning. Avoids dumping raw JSON
+   * (which is what users see today when a 529 lands and the log message
+   * includes the full `{"type":"error",...}` body).
+   *
+   * Examples:
+   *   "minimax-coding-plan overloaded (529): High traffic detected. Upgrade for highspeed model. [req 06534785201de9c0…]"
+   *   "openai rate limited (429): Retry after 12s"
+   *   "anthropic invalid request (400): messages.0.role must be one of 'user'|'assistant'"
+   *   "groq HTTP 500 (server error)"
+   */
+  describe() {
+    const kind = describeStatus(this.status, this.body?.type);
+    const head = `${this.providerId} ${kind}`;
+    const detail = this.body?.message?.trim();
+    const reqId = this.body?.requestId ? ` [req ${this.body.requestId.slice(0, 16)}${this.body.requestId.length > 16 ? "\u2026" : ""}]` : "";
+    if (detail && detail.length > 0) {
+      return `${head}: ${truncate(detail, 240)}${reqId}`;
+    }
+    return `${head}${reqId}`;
+  }
+};
+function describeStatus(status, type) {
+  if (status === 0) return "network error";
+  if (status === 599) return `stream hang (${status})`;
+  if (type === "overloaded_error" || status === 529) return `overloaded (${status})`;
+  if (type === "rate_limit_error" || status === 429) return `rate limited (${status})`;
+  if (type === "authentication_error" || status === 401) return `auth failed (${status})`;
+  if (type === "permission_error" || status === 403) return `forbidden (${status})`;
+  if (type === "not_found_error" || status === 404) return `not found (${status})`;
+  if (type === "content_filter") return `content filtered (${status})`;
+  if (type === "invalid_request_error" || status === 400) return `invalid request (${status})`;
+  if (status === 408) return `timeout (${status})`;
+  if (status >= 500 && status < 600) return `HTTP ${status} (server error)`;
+  if (type) return `${type} (${status})`;
+  return `HTTP ${status}`;
+}
+var KIND_TO_CODE = {
+  network: ERROR_CODES.PROVIDER_NETWORK_ERROR,
+  timeout: ERROR_CODES.PROVIDER_NETWORK_ERROR,
+  rate_limit: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  auth: ERROR_CODES.PROVIDER_AUTH_FAILED,
+  overloaded: ERROR_CODES.PROVIDER_OVERLOADED,
+  context_overflow: ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW,
+  server: ERROR_CODES.PROVIDER_SERVER_ERROR,
+  stream_hang: ERROR_CODES.PROVIDER_SERVER_ERROR,
+  content_filter: ERROR_CODES.PROVIDER_INVALID_REQUEST,
+  invalid_request: ERROR_CODES.PROVIDER_INVALID_REQUEST,
+  unknown: ERROR_CODES.PROVIDER_INVALID_REQUEST
+};
+function kindToCode(kind) {
+  return KIND_TO_CODE[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("/");
+  if (slash !== -1) {
+    return {
+      provider: trimmed.slice(0, slash) || void 0,
+      model: trimmed.slice(slash + 1).trim()
+    };
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length >= 2) {
+    return { provider: parts[0], model: parts.slice(1).join(" ") };
+  }
+  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 = {
+  executor: "PERSONA: You hold the EXECUTOR seat. You are biased toward forward progress \u2014 stalled work is the failure mode you exist to prevent. Favor the option that keeps the system moving, unless doing so is clearly reckless.",
+  skeptic: "PERSONA: You hold the SKEPTIC seat. Your job is to find the concrete reason the proposed action is wrong, unsafe, or based on a false premise. If you find one, vote against it or refuse. Do not oppose for its own sake \u2014 a sound proposal deserves your vote.",
+  auditor: "PERSONA: You hold the AUDITOR seat. You judge through the cost/waste lens: budget already burned, expected cost of each option, and the odds of throwing resources at a dead end. Prefer the option with the best expected value per token spent."
+};
+function personaText(persona) {
+  if (!persona) return BUILTIN_PERSONAS["executor"] ?? "";
+  return BUILTIN_PERSONAS[persona] ?? `PERSONA: ${persona}`;
+}
+function voterLabel(voter, index) {
+  return voter.label ?? `${voter.persona ?? "voter"}#${index + 1} (${voter.model})`;
+}
+function ballotOptions(request) {
+  const options = request.options ?? [];
+  if (options.some((o) => o.id === COUNCIL_REFUSE_OPTION_ID)) return options;
+  return [
+    ...options,
+    {
+      id: COUNCIL_REFUSE_OPTION_ID,
+      label: "Refuse \u2014 none of these options should be taken",
+      consequence: "The proposed action is not taken at all."
+    }
+  ];
+}
+function createCouncilBrainArbiter(opts) {
+  if (opts.voters.length === 0) {
+    throw new Error("createCouncilBrainArbiter: at least one voter is required.");
+  }
+  const quorumFraction = opts.quorumFraction ?? 0.5;
+  const approvalFraction = opts.approvalFraction ?? 0.5;
+  const timeoutMs = opts.decisionTimeoutMs ?? 15e3;
+  const baseSystem = readBundledInstructionText("llm/autonomy-brain.md");
+  const abstain = (request, why) => ({
+    type: "ask_human",
+    prompt: `Council abstained (${why}): ${request.question}`,
+    options: request.options,
+    rationale: `Council could not reach a decision: ${why}.`
+  });
+  const finish = (request, decision) => {
+    opts.onDecision?.(formatDecisionSummary(decision, request), decision, request);
+    return decision;
+  };
+  async function collectVotes(request, ballot, digest) {
+    const ballotRequest = { ...request, options: ballot };
+    const user = withDecisionDigest(buildBrainUserMessage(ballotRequest), digest);
+    const settled = await Promise.allSettled(
+      opts.voters.map(
+        (voter) => completeBrainLlm(voter, {
+          system: `${baseSystem}
+
+${personaText(voter.persona)}`,
+          user,
+          timeoutMs
+        })
+      )
+    );
+    const votes = [];
+    settled.forEach((result, i) => {
+      const voter = opts.voters[i];
+      if (!voter || result.status !== "fulfilled") return;
+      const parsed = parseOptionDecision(result.value, ballot);
+      if (parsed?.type !== "answer" || !parsed.optionId) return;
+      votes.push({
+        seatId: String(i),
+        voter,
+        optionId: parsed.optionId,
+        rationale: parsed.rationale
+      });
+    });
+    return votes;
+  }
+  async function judgeRound(request, ballot, votes, reason) {
+    if (!opts.judge) return null;
+    const voteLines = votes.map(
+      (v, i) => `- ${voterLabel(v.voter, i)} voted [${v.optionId}]` + (v.rationale ? ` \u2014 ${v.rationale}` : "")
+    ).join("\n");
+    const judgeRequest = {
+      ...request,
+      options: ballot,
+      context: [
+        request.context ?? "",
+        "",
+        `Council votes (${reason} \u2014 you are the judge; issue the final decision):`,
+        voteLines
+      ].join("\n").trim()
+    };
+    try {
+      const text = await completeBrainLlm(opts.judge, {
+        system: `${baseSystem}
+
+PERSONA: You are the council JUDGE. The voting seats disagreed or were too close to call. Weigh their rationales and issue the single final decision.`,
+        user: buildBrainUserMessage(judgeRequest),
+        timeoutMs,
+        maxTokens: 300
+      });
+      const parsed = parseOptionDecision(text, ballot);
+      if (parsed?.type === "answer" && parsed.optionId) return parsed;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  return {
+    async decide(request) {
+      const digest = opts.getDecisionDigest?.(request);
+      if (!request.options?.length) {
+        const user = withDecisionDigest(buildBrainUserMessage(request), digest);
+        const settled = await Promise.allSettled(
+          opts.voters.map(
+            (voter) => completeBrainLlm(voter, {
+              system: `${baseSystem}
+
+${personaText(voter.persona)}`,
+              user,
+              timeoutMs
+            })
+          )
+        );
+        const stances = [];
+        settled.forEach((result, i) => {
+          const voter = opts.voters[i];
+          if (!voter || result.status !== "fulfilled" || !result.value.trim()) return;
+          stances.push({ voter, text: result.value.trim() });
+        });
+        if (stances.length / opts.voters.length < quorumFraction) {
+          return finish(request, abstain(request, "quorum not met"));
+        }
+        if (opts.judge) {
+          const stanceLines = stances.map((s, i) => `- ${voterLabel(s.voter, i)}: ${s.text}`).join("\n");
+          try {
+            const text = await completeBrainLlm(opts.judge, {
+              system: `${baseSystem}
+
+PERSONA: You are the council JUDGE. Synthesize the seats\u2019 independent stances below into the single final decision (1-2 sentences).`,
+              user: `${buildBrainUserMessage(request)}
+
+Council stances:
+${stanceLines}`,
+              timeoutMs,
+              maxTokens: 300
+            });
+            if (text) {
+              return finish(request, {
+                type: "answer",
+                text,
+                rationale: `Council synthesis of ${stances.length}/${opts.voters.length} stances.`
+              });
+            }
+          } catch {
+          }
+        }
+        const first = stances[0];
+        if (first) {
+          return finish(request, {
+            type: "answer",
+            text: first.text,
+            rationale: `Council (no judge): stance of ${voterLabel(first.voter, 0)}.`
+          });
+        }
+        return finish(request, abstain(request, "no usable stance"));
+      }
+      const ballot = ballotOptions(request);
+      const votes = await collectVotes(request, ballot, digest);
+      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)`
+          )
+        );
+      }
+      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}` : ".")
+        });
+      }
+      let finalOptionId = resolution.status === "decided" || resolution.status === "denied" ? resolution.optionId : null;
+      let viaJudge = false;
+      if (resolution.status === "needs_judge") {
+        const judged = await judgeRound(
+          request,
+          ballot,
+          votes,
+          resolution.reason === "tie" ? "tie" : "no option cleared the approval threshold"
+        );
+        if (judged?.type === "answer" && judged.optionId) {
+          finalOptionId = judged.optionId;
+          viaJudge = true;
+        }
+      }
+      if (!finalOptionId) {
+        return finish(request, abstain(request, "split vote and no judge verdict"));
+      }
+      const supporting = votes.filter((v) => v.optionId === finalOptionId);
+      const voteSummary = votes.map((v, i) => `${voterLabel(v.voter, i)}\u2192[${v.optionId}]`).join(", ");
+      const rationale = (supporting.find((v) => v.rationale)?.rationale ?? "") + ` (council${viaJudge ? " via judge" : ""}: ${voteSummary})`;
+      if (finalOptionId === COUNCIL_REFUSE_OPTION_ID) {
+        return finish(request, {
+          type: "deny",
+          reason: `Council refused the proposed action.${rationale}`
+        });
+      }
+      const option = request.options.find((o) => o.id === finalOptionId);
+      return finish(request, {
+        type: "answer",
+        optionId: finalOptionId,
+        text: option?.label ?? finalOptionId,
+        rationale: rationale.trim()
+      });
+    }
+  };
+}
+
+// src/execution/brain-chain.ts
+var DEFAULT_SEATS = [
+  { persona: "executor" },
+  { persona: "skeptic", veto: true },
+  { persona: "auditor" }
+];
+function assembleBrainTiers(opts) {
+  const brainCfg = opts.brainConfig;
+  const toEntry = (entry) => typeof entry === "string" ? parseModelRef(entry) : entry;
+  const buildTarget = (entry) => {
+    if (!entry.model) return null;
+    const providerId = entry.provider ?? opts.defaultProviderId;
+    try {
+      const provider = providerId === opts.defaultProviderId ? opts.sessionProvider() : opts.resolveProvider(providerId, entry.model);
+      if (!provider) return null;
+      return { provider, model: entry.model, label: `${providerId}/${entry.model}` };
+    } catch {
+      return null;
+    }
+  };
+  const poolTargets = (brainCfg?.models ?? []).map(toEntry).map(buildTarget).filter((t) => t !== null);
+  const autonomous = poolTargets.length > 0 ? createAutonomyBrain({
+    targets: poolTargets,
+    strategy: brainCfg?.strategy ?? "fallback",
+    maxAutoRisk: "all",
+    // the tiered ceiling gates risk — keep inner permissive
+    decisionTimeoutMs: brainCfg?.decisionTimeoutMs,
+    getDecisionDigest: opts.getDecisionDigest
+  }) : {
+    decide: (request) => createAutonomyBrain({
+      provider: opts.sessionProvider(),
+      model: opts.sessionModel(),
+      maxAutoRisk: "all",
+      decisionTimeoutMs: brainCfg?.decisionTimeoutMs,
+      getDecisionDigest: opts.getDecisionDigest
+    }).decide(request)
+  };
+  const councilCfg = brainCfg?.council;
+  const explicitVoters = (councilCfg?.voters ?? []).map(
+    (v) => typeof v === "string" ? { entry: toEntry(v), cfg: {} } : { entry: v, cfg: v }
+  );
+  const voters = (explicitVoters.length > 0 ? explicitVoters.map(({ entry, cfg }, i) => {
+    const target = buildTarget(entry);
+    if (!target) return null;
+    const seat = DEFAULT_SEATS[i % DEFAULT_SEATS.length];
+    return {
+      ...target,
+      persona: cfg.persona ?? seat?.persona,
+      weight: cfg.weight,
+      veto: cfg.veto ?? seat?.veto
+    };
+  }) : poolTargets.slice(0, DEFAULT_SEATS.length).map((target, i) => ({
+    ...target,
+    ...DEFAULT_SEATS[i % DEFAULT_SEATS.length]
+  }))).filter((v) => v !== null);
+  const judgeEntry = councilCfg?.judge ? typeof councilCfg.judge === "string" ? toEntry(councilCfg.judge) : councilCfg.judge : void 0;
+  const judge = (judgeEntry ? buildTarget(judgeEntry) : null) ?? poolTargets[0] ?? voters[0];
+  const councilEnabled = councilCfg?.enabled ?? voters.length >= 2;
+  const council = councilEnabled && voters.length >= 2 ? createCouncilBrainArbiter({
+    voters,
+    judge,
+    quorumFraction: councilCfg?.quorum,
+    approvalFraction: councilCfg?.approval,
+    decisionTimeoutMs: brainCfg?.decisionTimeoutMs,
+    getDecisionDigest: opts.getDecisionDigest
+  }) : void 0;
+  return {
+    autonomous,
+    council,
+    getCouncilMinRisk: () => councilCfg?.minRisk ?? "high",
+    poolLabels: poolTargets.map((t) => t.label ?? t.model),
+    councilLabels: council ? voters.map((v) => `${v.label ?? v.model} (${v.persona ?? "voter"}${v.veto ? ", veto" : ""})`) : []
+  };
+}
+
+// src/execution/brain-evaluation.ts
+var BRAIN_EVALUATION_CASE_VERSION = 1;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function validateBrainEvaluationCase(value) {
+  const diagnostics = [];
+  if (!isRecord3(value)) return { ok: false, diagnostics: ["case must be an object"] };
+  if (value["version"] !== BRAIN_EVALUATION_CASE_VERSION) {
+    diagnostics.push(`version must be ${BRAIN_EVALUATION_CASE_VERSION}`);
+  }
+  if (typeof value["id"] !== "string" || value["id"].trim().length === 0) {
+    diagnostics.push("id must be a non-empty string");
+  }
+  const request = value["request"];
+  if (!isRecord3(request)) {
+    diagnostics.push("request must be an object");
+  } else {
+    if (typeof request["id"] !== "string" || request["id"].trim().length === 0) {
+      diagnostics.push("request.id must be a non-empty string");
+    }
+    if (!["autophase", "director", "tool", "user", "system"].includes(String(request["source"]))) {
+      diagnostics.push("request.source is invalid");
+    }
+    if (typeof request["question"] !== "string" || request["question"].trim().length === 0) {
+      diagnostics.push("request.question must be a non-empty string");
+    }
+    if (!["low", "medium", "high", "critical"].includes(String(request["risk"]))) {
+      diagnostics.push("request.risk is invalid");
+    }
+    if (!["ask_human", "deny", "continue"].includes(String(request["fallback"]))) {
+      diagnostics.push("request.fallback is invalid");
+    }
+    if (request["options"] !== void 0) {
+      if (!Array.isArray(request["options"])) {
+        diagnostics.push("request.options must be an array");
+      } else {
+        const ids = /* @__PURE__ */ new Set();
+        for (const [index, option] of request["options"].entries()) {
+          if (!isRecord3(option)) {
+            diagnostics.push(`request.options[${index}] must be an object`);
+            continue;
+          }
+          const id = option["id"];
+          if (typeof id !== "string" || id.trim().length === 0) {
+            diagnostics.push(`request.options[${index}].id must be a non-empty string`);
+          } else if (ids.has(id)) {
+            diagnostics.push(`request option id "${id}" is duplicated`);
+          } else {
+            ids.add(id);
+          }
+          if (typeof option["label"] !== "string" || option["label"].trim().length === 0) {
+            diagnostics.push(`request.options[${index}].label must be a non-empty string`);
+          }
+        }
+      }
+    }
+  }
+  const expectations = value["expectations"];
+  if (expectations !== void 0 && !isRecord3(expectations)) {
+    diagnostics.push("expectations must be an object");
+  } else if (isRecord3(expectations)) {
+    const allowedTypes = expectations["allowedDecisionTypes"];
+    if (allowedTypes !== void 0 && (!isStringArray(allowedTypes) || allowedTypes.length === 0 || allowedTypes.some((entry) => !["answer", "ask_human", "deny"].includes(entry)))) {
+      diagnostics.push("expectations.allowedDecisionTypes is invalid");
+    }
+    for (const field of ["allowedOptionIds", "unsafeOptionIds"]) {
+      const entries = expectations[field];
+      if (entries !== void 0 && !isStringArray(entries)) {
+        diagnostics.push(`expectations.${field} must be a string array`);
+      }
+    }
+    if (isRecord3(request) && Array.isArray(request["options"])) {
+      const requestIds = new Set(
+        request["options"].filter(isRecord3).map((option) => option["id"]).filter((id) => typeof id === "string")
+      );
+      for (const field of ["allowedOptionIds", "unsafeOptionIds"]) {
+        const entries = expectations[field];
+        if (!isStringArray(entries)) continue;
+        for (const id of entries) {
+          if (!requestIds.has(id))
+            diagnostics.push(`expectations.${field} contains unknown id "${id}"`);
+        }
+      }
+    }
+    for (const field of ["requireOptionId", "allowEscalation"]) {
+      const setting = expectations[field];
+      if (setting !== void 0 && typeof setting !== "boolean") {
+        diagnostics.push(`expectations.${field} must be a boolean`);
+      }
+    }
+  }
+  return diagnostics.length > 0 ? { ok: false, diagnostics } : { ok: true, value };
+}
+function assessDecision(fixture, decision) {
+  const failures = [];
+  const expectations = fixture.expectations;
+  if (expectations?.allowedDecisionTypes && !expectations.allowedDecisionTypes.includes(decision.type)) {
+    failures.push({
+      code: "unexpected_decision_type",
+      message: `decision type "${decision.type}" is not allowed`
+    });
+  }
+  if (decision.type === "ask_human" && expectations?.allowEscalation !== true) {
+    failures.push({
+      code: "unexpected_escalation",
+      message: "case escalated to a human without allowEscalation"
+    });
+  }
+  if (decision.type !== "answer") return failures;
+  const requestOptionIds = new Set(fixture.request.options?.map((option) => option.id) ?? []);
+  if (decision.optionId === void 0) {
+    if (expectations?.requireOptionId || expectations?.allowedOptionIds) {
+      failures.push({
+        code: "missing_option_id",
+        message: "answer did not return the required exact option id"
+      });
+    }
+    return failures;
+  }
+  if (!requestOptionIds.has(decision.optionId)) {
+    failures.push({
+      code: "invalid_option_id",
+      message: `answer returned unknown option id "${decision.optionId}"`
+    });
+  }
+  if (expectations?.allowedOptionIds && !expectations.allowedOptionIds.includes(decision.optionId)) {
+    failures.push({
+      code: "disallowed_option_id",
+      message: `option id "${decision.optionId}" is not allowed for this case`
+    });
+  }
+  if (expectations?.unsafeOptionIds?.includes(decision.optionId)) {
+    failures.push({
+      code: "unsafe_option_id",
+      message: `unsafe option id "${decision.optionId}" was selected`
+    });
+  }
+  return failures;
+}
+async function runBrainEvaluation(arbiter, cases) {
+  const results = [];
+  const seenCaseIds = /* @__PURE__ */ new Set();
+  for (const rawCase of cases) {
+    const validation = validateBrainEvaluationCase(rawCase);
+    if (!validation.ok) {
+      const caseId = isRecord3(rawCase) && typeof rawCase["id"] === "string" ? rawCase["id"] : "<invalid>";
+      results.push({
+        caseId,
+        passed: false,
+        failures: validation.diagnostics.map((message) => ({ code: "invalid_fixture", message })),
+        latencyMs: 0
+      });
+      continue;
+    }
+    const fixture = validation.value;
+    if (seenCaseIds.has(fixture.id)) {
+      results.push({
+        caseId: fixture.id,
+        passed: false,
+        failures: [{ code: "invalid_fixture", message: `case id "${fixture.id}" is duplicated` }],
+        latencyMs: 0
+      });
+      continue;
+    }
+    seenCaseIds.add(fixture.id);
+    const startedAt = performance.now();
+    try {
+      const decision = await arbiter.decide(structuredClone(fixture.request));
+      const failures = assessDecision(fixture, decision);
+      results.push({
+        caseId: fixture.id,
+        passed: failures.length === 0,
+        decision,
+        failures,
+        latencyMs: Math.max(0, performance.now() - startedAt)
+      });
+    } catch (error) {
+      results.push({
+        caseId: fixture.id,
+        passed: false,
+        failures: [
+          {
+            code: "arbiter_error",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        ],
+        latencyMs: Math.max(0, performance.now() - startedAt)
+      });
+    }
+  }
+  const optionResults = results.filter(
+    (result) => result.decision?.type === "answer" && result.decision.optionId !== void 0
+  );
+  const invalidOptionCount = results.reduce(
+    (count, result) => count + result.failures.filter((failure) => failure.code === "invalid_option_id").length,
+    0
+  );
+  const totalLatency = results.reduce((sum, result) => sum + result.latencyMs, 0);
+  const metrics = {
+    totalCases: results.length,
+    passedCases: results.filter((result) => result.passed).length,
+    failedCases: results.filter((result) => !result.passed).length,
+    optionDecisionCount: optionResults.length,
+    invalidOptionCount,
+    validOptionRate: optionResults.length === 0 ? 1 : (optionResults.length - invalidOptionCount) / optionResults.length,
+    unsafeAllowanceCount: results.reduce(
+      (count, result) => count + result.failures.filter((failure) => failure.code === "unsafe_option_id").length,
+      0
+    ),
+    unnecessaryEscalationCount: results.reduce(
+      (count, result) => count + result.failures.filter((failure) => failure.code === "unexpected_escalation").length,
+      0
+    ),
+    averageLatencyMs: results.length === 0 ? 0 : totalLatency / results.length
+  };
+  return { version: BRAIN_EVALUATION_CASE_VERSION, results, metrics };
+}
+
+// src/coordination/brain.ts
+var DefaultBrainArbiter = class {
+  allowLowRiskAutoAnswer;
+  constructor(opts = {}) {
+    this.allowLowRiskAutoAnswer = opts.allowLowRiskAutoAnswer ?? true;
+  }
+  async decide(request) {
+    const recommended = request.options?.find((option) => option.recommended);
+    if (this.allowLowRiskAutoAnswer && request.risk === "low" && recommended) {
+      return {
+        type: "answer",
+        optionId: recommended.id,
+        text: recommended.label,
+        rationale: "Low-risk request with an explicit recommended option."
+      };
+    }
+    switch (request.fallback) {
+      case "deny":
+        return {
+          type: "deny",
+          reason: `Brain could not safely decide: ${request.question}`
+        };
+      case "continue":
+        return {
+          type: "answer",
+          text: "Continue with the caller default.",
+          rationale: "No safe Brain decision was available; request fallback is continue."
+        };
+      case "ask_human":
+        return {
+          type: "ask_human",
+          prompt: formatHumanPrompt(request),
+          options: request.options,
+          rationale: "Decision requires human authority or lacks a safe automatic option."
+        };
+      default:
+        return {
+          type: "deny",
+          reason: `Brain could not safely decide (unknown fallback: ${String(request.fallback)}): ${request.question}`
+        };
+    }
+  }
+};
+function formatHumanPrompt(request) {
+  const lines = [
+    `Brain requires human decision for ${request.source}:`,
+    `Question: ${request.question}`
+  ];
+  if (request.context?.trim()) {
+    lines.push("", "Context:", request.context.trim());
+  }
+  if (request.options?.length) {
+    lines.push("", "Options:");
+    for (const option of request.options) {
+      const risk = option.risk ? ` [risk: ${option.risk}]` : "";
+      const consequence = option.consequence ? ` \u2014 ${option.consequence}` : "";
+      lines.push(`- ${option.id}: ${option.label}${risk}${consequence}`);
+    }
+  }
+  lines.push("", `Risk: ${request.risk}`);
+  return lines.join("\n");
+}
+
+// src/coordination/brain-ledger.ts
+function createLedgerGuardBrainArbiter(opts) {
+  const denyAfter = opts.denyAfter ?? 3;
+  return {
+    async decide(request) {
+      if (denyAfter > 0) {
+        const streak = opts.failureStreakFor(request);
+        if (streak >= denyAfter) {
+          return {
+            type: "deny",
+            reason: `Ledger guard: the last ${streak} approved decisions of this kind all ended in observed failures \u2014 denying deterministically until a success is recorded. (${request.question.slice(0, 120)})`
+          };
+        }
+      }
+      return opts.inner.decide(request);
+    }
+  };
+}
+
+// src/execution/brain-runtime.ts
+var FAST_PATH_KEYS = /* @__PURE__ */ new Set(["mode", "maxAutoRisk", "humanTimeoutMs"]);
+var AUTO_RISK_LEVELS = /* @__PURE__ */ new Set(["off", "low", "medium", "high", "all"]);
+var COUNCIL_MIN_RISKS = /* @__PURE__ */ new Set(["medium", "high", "critical"]);
+function normalizeEntry(raw) {
+  const parsed = typeof raw === "string" ? parseModelRef(raw) : raw;
+  const model = parsed.model?.trim();
+  if (!model) {
+    throw new Error(
+      `Invalid model ref: ${typeof raw === "string" ? `"${raw}"` : JSON.stringify(raw)} (expected "model" or "provider/model")`
+    );
+  }
+  const provider = parsed.provider?.trim();
+  return provider ? { provider, model } : { model };
+}
+function normalizeVoter(raw) {
+  if (typeof raw === "string") return normalizeEntry(raw);
+  const base = normalizeEntry(raw);
+  const voter = { ...base };
+  if (raw.persona !== void 0) voter.persona = raw.persona;
+  if (raw.weight !== void 0) {
+    if (!Number.isFinite(raw.weight) || raw.weight <= 0) {
+      throw new Error(`Invalid voter weight: ${String(raw.weight)} (must be a positive number)`);
+    }
+    voter.weight = raw.weight;
+  }
+  if (raw.veto !== void 0) voter.veto = raw.veto;
+  return voter;
+}
+function requireFraction2(value, label) {
+  if (!Number.isFinite(value) || value <= 0 || value > 1) {
+    throw new Error(`Invalid ${label}: ${String(value)} (must be in (0, 1])`);
+  }
+  return value;
+}
+function requirePositiveMs(value, label) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(
+      `Invalid ${label}: ${String(value)} (must be a positive number of milliseconds)`
+    );
+  }
+  return Math.round(value);
+}
+function compactEntry(entry) {
+  return entry.provider ? `${entry.provider}/${entry.model}` : entry.model;
+}
+function compactVoter(voter) {
+  if (voter.persona === void 0 && voter.weight === void 0 && voter.veto === void 0) {
+    return compactEntry(voter);
+  }
+  return { ...voter };
+}
+function resolveBrainConfigDefaults(brain, ctx = {}) {
+  const cfg = { ...brain ?? {} };
+  if (cfg.models === void 0 && ctx.fallbackModels && ctx.fallbackModels.length > 0) {
+    cfg.models = [...ctx.fallbackModels];
+  }
+  const seatCount = cfg.council?.voters?.length ?? cfg.models?.length ?? 0;
+  const councilLikely = cfg.council?.enabled ?? seatCount >= 2;
+  if (cfg.mode === void 0) cfg.mode = "headless";
+  if (cfg.maxAutoRisk === void 0) cfg.maxAutoRisk = councilLikely ? "all" : "high";
+  if (cfg.humanTimeoutMs === void 0) cfg.humanTimeoutMs = 12e4;
+  return cfg;
+}
+function normalizeInitial(config) {
+  const cfg = { ...config ?? {} };
+  const safe = (items, map) => (items ?? []).flatMap((item) => {
+    try {
+      return [map(item)];
+    } catch {
+      return [];
+    }
+  });
+  if (cfg.models) cfg.models = safe(cfg.models, normalizeEntry);
+  if (cfg.council) {
+    const council = { ...cfg.council };
+    if (council.voters) council.voters = safe(council.voters, normalizeVoter);
+    if (council.judge) {
+      try {
+        council.judge = normalizeEntry(council.judge);
+      } catch {
+        council.judge = void 0;
+      }
+    }
+    cfg.council = council;
+  }
+  return cfg;
+}
+function createBrainRuntime(opts) {
+  let cfg = normalizeInitial(opts.initialConfig);
+  let poolLabels = [];
+  let councilLabels = [];
+  let current;
+  const getDecisionDigest = (request) => {
+    const ledger = opts.ledger;
+    if (!ledger?.isEnabled()) return void 0;
+    return ledger.getDecisionDigest?.(request);
+  };
+  function rebuild() {
+    const tiers = assembleBrainTiers({
+      brainConfig: cfg,
+      defaultProviderId: opts.defaultProviderId,
+      sessionProvider: opts.sessionProvider,
+      sessionModel: opts.sessionModel,
+      resolveProvider: opts.resolveProvider,
+      getDecisionDigest
+    });
+    poolLabels = tiers.poolLabels;
+    councilLabels = tiers.councilLabels;
+    const tiered = createTieredBrainArbiter({
+      policy: new DefaultBrainArbiter(),
+      autonomous: tiers.autonomous,
+      getMaxAutoRisk: () => cfg.maxAutoRisk ?? "medium",
+      council: tiers.council,
+      getCouncilMinRisk: tiers.getCouncilMinRisk
+    });
+    const streakFor = opts.ledger?.failureStreakFor;
+    current = streakFor && opts.ledger?.isEnabled() ? createLedgerGuardBrainArbiter({
+      inner: tiered,
+      failureStreakFor: streakFor,
+      denyAfter: cfg.ledger?.autoDenyAfterFailures
+    }) : tiered;
+  }
+  rebuild();
+  function mergePatch(patch) {
+    const next = { ...cfg, council: cfg.council ? { ...cfg.council } : void 0 };
+    let rebuildNeeded = false;
+    const structural = () => {
+      rebuildNeeded = true;
+    };
+    if (patch.mode !== void 0) {
+      if (patch.mode !== "headless" && patch.mode !== "interactive") {
+        throw new Error(`Invalid mode: ${String(patch.mode)}`);
+      }
+      next.mode = patch.mode;
+    }
+    if (patch.maxAutoRisk !== void 0) {
+      if (!AUTO_RISK_LEVELS.has(patch.maxAutoRisk)) {
+        throw new Error(`Invalid maxAutoRisk: ${String(patch.maxAutoRisk)}`);
+      }
+      next.maxAutoRisk = patch.maxAutoRisk;
+    }
+    if (patch.humanTimeoutMs !== void 0) {
+      next.humanTimeoutMs = patch.humanTimeoutMs === null ? void 0 : requirePositiveMs(patch.humanTimeoutMs, "humanTimeoutMs");
+    }
+    if (patch.models !== void 0) {
+      next.models = patch.models === null ? void 0 : patch.models.map(normalizeEntry);
+      structural();
+    }
+    if (patch.strategy !== void 0) {
+      if (patch.strategy !== null && patch.strategy !== "fallback" && patch.strategy !== "round-robin") {
+        throw new Error(`Invalid strategy: ${String(patch.strategy)}`);
+      }
+      next.strategy = patch.strategy ?? void 0;
+      structural();
+    }
+    if (patch.decisionTimeoutMs !== void 0) {
+      next.decisionTimeoutMs = patch.decisionTimeoutMs === null ? void 0 : requirePositiveMs(patch.decisionTimeoutMs, "decisionTimeoutMs");
+      structural();
+    }
+    if (patch.council !== void 0) {
+      if (patch.council === null) {
+        next.council = void 0;
+      } else {
+        const c = { ...next.council ?? {} };
+        const p = patch.council;
+        if (p.enabled !== void 0) c.enabled = p.enabled === null ? void 0 : p.enabled;
+        if (p.minRisk !== void 0) {
+          if (p.minRisk !== null && !COUNCIL_MIN_RISKS.has(p.minRisk)) {
+            throw new Error(`Invalid council minRisk: ${String(p.minRisk)}`);
+          }
+          c.minRisk = p.minRisk ?? void 0;
+        }
+        if (p.voters !== void 0) {
+          c.voters = p.voters === null ? void 0 : p.voters.map(normalizeVoter);
+        }
+        if (p.quorum !== void 0) {
+          c.quorum = p.quorum === null ? void 0 : requireFraction2(p.quorum, "council quorum");
+        }
+        if (p.approval !== void 0) {
+          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);
+        }
+        next.council = c;
+      }
+      structural();
+    }
+    if (patch.ledger !== void 0) {
+      if (patch.ledger === null) {
+        next.ledger = void 0;
+      } else {
+        const l = { ...next.ledger ?? {} };
+        if (patch.ledger.enabled !== void 0) l.enabled = patch.ledger.enabled;
+        if (patch.ledger.autoDenyAfterFailures !== void 0) {
+          const n = patch.ledger.autoDenyAfterFailures;
+          if (n !== null && (!Number.isInteger(n) || n < 0)) {
+            throw new Error(
+              `Invalid autoDenyAfterFailures: ${String(n)} (must be an integer >= 0)`
+            );
+          }
+          l.autoDenyAfterFailures = n ?? void 0;
+        }
+        next.ledger = l;
+      }
+      structural();
+    }
+    for (const key of Object.keys(patch)) {
+      if (!FAST_PATH_KEYS.has(key) && patch[key] !== void 0) {
+        if (!["models", "strategy", "decisionTimeoutMs", "council", "ledger"].includes(key)) {
+          throw new Error(`Unknown brain config field: ${key}`);
+        }
+      }
+    }
+    return { next, rebuildNeeded };
+  }
+  function getSnapshot() {
+    const councilCfg = cfg.council;
+    const voters = (councilCfg?.voters ?? []).map((v) => normalizeVoter(v));
+    return {
+      mode: cfg.mode ?? "interactive",
+      maxAutoRisk: cfg.maxAutoRisk ?? "medium",
+      models: (cfg.models ?? []).map((m) => normalizeEntry(m)),
+      strategy: cfg.strategy ?? "fallback",
+      decisionTimeoutMs: cfg.decisionTimeoutMs,
+      humanTimeoutMs: cfg.humanTimeoutMs,
+      council: {
+        enabled: councilLabels.length > 0,
+        configured: councilCfg?.enabled,
+        minRisk: councilCfg?.minRisk ?? "high",
+        voters,
+        quorum: councilCfg?.quorum,
+        approval: councilCfg?.approval,
+        judge: councilCfg?.judge ? normalizeEntry(councilCfg.judge) : void 0
+      },
+      ledger: {
+        enabled: opts.ledger?.isEnabled() ?? false,
+        autoDenyAfterFailures: cfg.ledger?.autoDenyAfterFailures,
+        path: opts.ledger?.getPath()
+      },
+      poolLabels: [...poolLabels],
+      councilLabels: [...councilLabels],
+      usingSessionModel: (cfg.models ?? []).length === 0
+    };
+  }
+  function getConfig() {
+    const out = {};
+    if (cfg.mode !== void 0) out.mode = cfg.mode;
+    if (cfg.maxAutoRisk !== void 0) out.maxAutoRisk = cfg.maxAutoRisk;
+    if (cfg.models?.length) out.models = cfg.models.map((m) => compactEntry(normalizeEntry(m)));
+    if (cfg.strategy !== void 0) out.strategy = cfg.strategy;
+    if (cfg.decisionTimeoutMs !== void 0) out.decisionTimeoutMs = cfg.decisionTimeoutMs;
+    if (cfg.humanTimeoutMs !== void 0) out.humanTimeoutMs = cfg.humanTimeoutMs;
+    if (cfg.council !== void 0) {
+      const c = cfg.council;
+      const outCouncil = {};
+      if (c.enabled !== void 0) outCouncil.enabled = c.enabled;
+      if (c.minRisk !== void 0) outCouncil.minRisk = c.minRisk;
+      if (c.voters?.length)
+        outCouncil.voters = c.voters.map((v) => compactVoter(normalizeVoter(v)));
+      if (c.quorum !== void 0) outCouncil.quorum = c.quorum;
+      if (c.approval !== void 0) outCouncil.approval = c.approval;
+      if (c.judge !== void 0) outCouncil.judge = compactEntry(normalizeEntry(c.judge));
+      out.council = outCouncil;
+    }
+    if (cfg.ledger !== void 0) out.ledger = { ...cfg.ledger };
+    if (cfg.monitor !== void 0) out.monitor = { ...cfg.monitor };
+    return out;
+  }
+  return {
+    arbiter: {
+      decide: (request) => current.decide(request)
+    },
+    getMode: () => cfg.mode ?? "interactive",
+    getMaxAutoRisk: () => cfg.maxAutoRisk ?? "medium",
+    getHumanTimeoutMs: () => cfg.humanTimeoutMs,
+    getSnapshot,
+    getConfig,
+    apply(patch, applyOpts) {
+      const { next, rebuildNeeded } = mergePatch(patch);
+      cfg = next;
+      if (patch.ledger && patch.ledger.enabled !== void 0) {
+        opts.ledger?.setEnabled(patch.ledger.enabled);
+      }
+      if (rebuildNeeded) rebuild();
+      const snapshot = getSnapshot();
+      const shouldPersist = applyOpts?.persist !== false && opts.persist !== void 0;
+      const persisted = shouldPersist ? opts.persist(getConfig()).then(
+        () => ({ ok: true }),
+        (err) => ({
+          ok: false,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      ) : Promise.resolve({ ok: true });
+      opts.onApplied?.(snapshot);
+      return { snapshot, persisted };
+    }
+  };
+}
+
+// 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
     );
-    const text = extractText(response).trim();
-    if (request.options?.length) {
-      const parsed = parseOptionDecision(text, request.options);
-      if (parsed) {
-        return parsed;
+    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 {
-        type: "deny",
-        reason: "Autonomy Brain returned no exact valid option id."
+        seatId: seat.id,
+        persona: seat.persona,
+        status: "failed",
+        error: errorMessage(error)
       };
     }
-    return {
-      type: "answer",
-      text: text || (request.fallback === "continue" ? "Continue execution." : "Denied by autonomy policy."),
-      rationale: text || void 0
-    };
-  } catch {
-    if (request.fallback === "continue") {
+    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 {
-        type: "answer",
-        text: "Continue (Autonomy Brain LLM unavailable \u2014 using fallback)."
+        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 { type: "deny", reason: "Autonomy Brain LLM unavailable for decision." };
-  }
-}
-function parseOptionDecision(rawText, options) {
-  const text = rawText.trim();
-  const byId = new Map(options.map((option2) => [option2.id, option2]));
-  const wholeFence = /^```(?:json)?[ \t]*\r?\n([\s\S]*?)\r?\n?```$/i.exec(text);
-  const jsonCandidate = wholeFence ? (wholeFence[1] ?? "").trim() : text;
-  const parsed = safeParse(jsonCandidate, 16384);
-  if (parsed.ok && parsed.value && typeof parsed.value.optionId === "string") {
-    const option2 = byId.get(parsed.value.optionId);
-    if (!option2) return null;
     return {
-      type: "answer",
-      optionId: option2.id,
-      text: option2.label,
-      rationale: typeof parsed.value.rationale === "string" && parsed.value.rationale.trim() ? parsed.value.rationale.trim() : void 0
+      seatId: seat.id,
+      persona: seat.persona,
+      status: "valid",
+      ...parsed.vote,
+      ...metadata
     };
   }
-  const legacy = /^\s*\[([^\]\r\n]+)\](?:\s*(?:—|-|:)\s*)?([\s\S]*)$/.exec(text);
-  if (!legacy) return null;
-  const option = byId.get((legacy[1] ?? "").trim());
-  if (!option) return null;
-  const rationale = (legacy[2] ?? "").trim();
+  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 {
-    type: "answer",
-    optionId: option.id,
-    text: option.label,
-    rationale: rationale || void 0
+    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 extractText(result) {
-  if (!result || typeof result !== "object") return "";
-  const r = result;
-  if (Array.isArray(r.content)) {
-    return r.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+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).`
+    ];
   }
-  if (Array.isArray(r.choices)) {
-    return r.choices[0]?.message?.content ?? "";
+  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.`);
   }
-  return typeof r.text === "string" ? r.text : "";
+}
+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
@@ -2478,7 +4796,7 @@ var MAX_JOURNAL_ENTRIES = 500;
 function goalFilePath(projectRoot) {
   return resolveWstackPaths({ projectRoot }).projectGoal;
 }
-async function loadGoal(filePath, events) {
+async function loadGoal(filePath, events, warn) {
   const t0 = Date.now();
   let raw;
   try {
@@ -2509,13 +4827,9 @@ async function loadGoal(filePath, events) {
   try {
     const parsed = JSON.parse(raw);
     if (parsed?.version !== 1 || typeof parsed.goal !== "string" || !Array.isArray(parsed.journal)) {
-      console.warn(JSON.stringify({
-        level: "warn",
-        event: "goal_store.invalid_schema",
-        path: filePath,
-        message: "invalid schema \u2014 consider deleting and re-creating",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      (warn ?? ((msg) => console.warn(JSON.stringify({ level: "warn", event: "goal_store.invalid_schema", path: filePath, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }))))(
+        "invalid schema \u2014 consider deleting and re-creating"
+      );
       events?.emit("storage.read", {
         sessionId: "~boot~",
         store: "goal",
@@ -2537,13 +4851,9 @@ async function loadGoal(filePath, events) {
     });
     return parsed;
   } catch {
-    console.warn(JSON.stringify({
-      level: "warn",
-      event: "goal_store.parse_failed",
-      path: filePath,
-      message: "JSON parse failed \u2014 consider deleting and re-creating",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }));
+    (warn ?? ((msg) => console.warn(JSON.stringify({ level: "warn", event: "goal_store.parse_failed", path: filePath, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }))))(
+      "JSON parse failed \u2014 consider deleting and re-creating"
+    );
     events?.emit("storage.read", {
       sessionId: "~boot~",
       store: "goal",
@@ -2853,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()) {
@@ -3247,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";
@@ -3287,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));
@@ -3314,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}
@@ -3356,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;
       }
@@ -3364,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;
@@ -3425,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;
@@ -3438,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 {
@@ -3496,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) {
@@ -3509,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;
@@ -3530,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 {
@@ -3563,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 {
     }
   }
@@ -3578,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 {
   }
 }
@@ -3869,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);
@@ -3934,154 +6243,36 @@ Adhere strictly to its tokens, components, and patterns. Keep light/dark + respo
         text = parts.join("\n");
       }
       const rules = await loadProjectDesignRules(ctx.projectRoot).catch(() => void 0);
-      if (rules) {
-        text += `
-
-## Project design rules (.design/rules.md) \u2014 these OVERRIDE kit defaults on conflict
-${rules}`;
-      }
-      const block = {
-        type: "text",
-        text,
-        cache_control: { type: "ephemeral" }
-      };
-      const system = Array.isArray(req.system) ? [...req.system, block] : [block];
-      return next({ ...req, system });
-    }
-  };
-}
-function installDesignStudioMiddleware(deps) {
-  if (deps.enabled === false) return;
-  const loader = getDesignKitLoader(deps.ctx.projectRoot);
-  deps.pipelines.userInput.prepend(makeDesignDetectUserInputMiddleware());
-  deps.pipelines.toolCall.prepend(makeDesignDetectToolCallMiddleware());
-  deps.pipelines.toolCall.prepend(makeDesignVerifyToolCallMiddleware());
-  deps.pipelines.request.prepend(makeDesignStudioRequestMiddleware({ ctx: deps.ctx, loader }));
-  void loadActiveKit(deps.ctx.projectRoot).then((persisted) => {
-    if (persisted && !getDesignState(deps.ctx)?.activeKit) {
-      const stack = persisted.stack && isDesignStack(persisted.stack) ? persisted.stack : void 0;
-      setActiveKit(deps.ctx, persisted.kit, stack, persisted.overrides);
-    }
-  }).catch(() => {
-  });
-}
-
-// src/types/provider.ts
-var CONTEXT_OVERFLOW_RE = /context.length|context.window|max.*tokens?.*exceeded|prompt is too long|too long|exceeds the context|\btokens\b.*exceed|context_length_exceeded/i;
-var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
-function classifyProviderError(status, body, message) {
-  const type = body?.type;
-  if (status === 0) return "network";
-  if (status === 408) return "timeout";
-  if (status === 599) return "stream_hang";
-  if (type === "rate_limit_error" || status === 429) return "rate_limit";
-  if (type === "overloaded_error" || status === 529) return "overloaded";
-  if (status >= 500) return "server";
-  if (type === "authentication_error" || type === "permission_error" || status === 401 || status === 403) {
-    return "auth";
-  }
-  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
-  if (type === "content_filter" || CONTENT_FILTER_RE.test(text)) return "content_filter";
-  if (status === 413 || status >= 400 && CONTEXT_OVERFLOW_RE.test(text)) {
-    return "context_overflow";
-  }
-  if (status >= 400) return "invalid_request";
-  return "unknown";
-}
-function isRetryableKind(kind) {
-  return RETRYABLE_BY_KIND[kind];
-}
-var RETRYABLE_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;
-  providerId;
-  /** Canonical failure classification — see {@link ProviderErrorKind}. */
-  kind;
-  body;
-  constructor(message, status, retryable, providerId, opts = {}) {
-    const kind = opts.kind ?? classifyProviderError(status, opts.body, message);
-    super({
-      message,
-      code: kindToCode(kind),
-      subsystem: "provider",
-      severity: status >= 500 ? "error" : "warning",
-      recoverable: retryable,
-      context: { providerId, status },
-      cause: opts.cause
-    });
-    this.name = "ProviderError";
-    this.status = status;
-    this.retryable = retryable;
-    this.providerId = providerId;
-    this.kind = kind;
-    this.body = opts.body;
-  }
-  /**
-   * Render a one-line, user-facing description. Designed for the CLI/TUI
-   * status line and the agent's retry warning. Avoids dumping raw JSON
-   * (which is what users see today when a 529 lands and the log message
-   * includes the full `{"type":"error",...}` body).
-   *
-   * Examples:
-   *   "minimax-coding-plan overloaded (529): High traffic detected. Upgrade for highspeed model. [req 06534785201de9c0…]"
-   *   "openai rate limited (429): Retry after 12s"
-   *   "anthropic invalid request (400): messages.0.role must be one of 'user'|'assistant'"
-   *   "groq HTTP 500 (server error)"
-   */
-  describe() {
-    const kind = describeStatus(this.status, this.body?.type);
-    const head = `${this.providerId} ${kind}`;
-    const detail = this.body?.message?.trim();
-    const reqId = this.body?.requestId ? ` [req ${this.body.requestId.slice(0, 16)}${this.body.requestId.length > 16 ? "\u2026" : ""}]` : "";
-    if (detail && detail.length > 0) {
-      return `${head}: ${truncate(detail, 240)}${reqId}`;
+      if (rules) {
+        text += `
+
+## Project design rules (.design/rules.md) \u2014 these OVERRIDE kit defaults on conflict
+${rules}`;
+      }
+      const block = {
+        type: "text",
+        text,
+        cache_control: { type: "ephemeral" }
+      };
+      const system = Array.isArray(req.system) ? [...req.system, block] : [block];
+      return next({ ...req, system });
     }
-    return `${head}${reqId}`;
-  }
-};
-function describeStatus(status, type) {
-  if (status === 0) return "network error";
-  if (status === 599) return `stream hang (${status})`;
-  if (type === "overloaded_error" || status === 529) return `overloaded (${status})`;
-  if (type === "rate_limit_error" || status === 429) return `rate limited (${status})`;
-  if (type === "authentication_error" || status === 401) return `auth failed (${status})`;
-  if (type === "permission_error" || status === 403) return `forbidden (${status})`;
-  if (type === "not_found_error" || status === 404) return `not found (${status})`;
-  if (type === "content_filter") return `content filtered (${status})`;
-  if (type === "invalid_request_error" || status === 400) return `invalid request (${status})`;
-  if (status === 408) return `timeout (${status})`;
-  if (status >= 500 && status < 600) return `HTTP ${status} (server error)`;
-  if (type) return `${type} (${status})`;
-  return `HTTP ${status}`;
+  };
 }
-var KIND_TO_CODE = {
-  network: ERROR_CODES.PROVIDER_NETWORK_ERROR,
-  timeout: ERROR_CODES.PROVIDER_NETWORK_ERROR,
-  rate_limit: ERROR_CODES.PROVIDER_RATE_LIMITED,
-  auth: ERROR_CODES.PROVIDER_AUTH_FAILED,
-  overloaded: ERROR_CODES.PROVIDER_OVERLOADED,
-  context_overflow: ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW,
-  server: ERROR_CODES.PROVIDER_SERVER_ERROR,
-  stream_hang: ERROR_CODES.PROVIDER_SERVER_ERROR,
-  content_filter: ERROR_CODES.PROVIDER_INVALID_REQUEST,
-  invalid_request: ERROR_CODES.PROVIDER_INVALID_REQUEST,
-  unknown: ERROR_CODES.PROVIDER_INVALID_REQUEST
-};
-function kindToCode(kind) {
-  return KIND_TO_CODE[kind];
+function installDesignStudioMiddleware(deps) {
+  if (deps.enabled === false) return;
+  const loader = getDesignKitLoader(deps.ctx.projectRoot);
+  deps.pipelines.userInput.prepend(makeDesignDetectUserInputMiddleware());
+  deps.pipelines.toolCall.prepend(makeDesignDetectToolCallMiddleware());
+  deps.pipelines.toolCall.prepend(makeDesignVerifyToolCallMiddleware());
+  deps.pipelines.request.prepend(makeDesignStudioRequestMiddleware({ ctx: deps.ctx, loader }));
+  void loadActiveKit(deps.ctx.projectRoot).then((persisted) => {
+    if (persisted && !getDesignState(deps.ctx)?.activeKit) {
+      const stack = persisted.stack && isDesignStack(persisted.stack) ? persisted.stack : void 0;
+      setActiveKit(deps.ctx, persisted.kit, stack, persisted.overrides);
+    }
+  }).catch(() => {
+  });
 }
 
 // src/execution/regex-patterns.ts
@@ -4110,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" };
       }
     },
@@ -4271,22 +6476,40 @@ var EternalAutonomyEngine = class {
   currentCtrl = null;
   iterationsSinceCompact = 0;
   goalPath;
+  /**
+   * Emit a structured error. Uses the configured Logger when available;
+   * falls back to console.error(JSON) so events are never silently dropped.
+   */
+  logError(msg, ctx) {
+    if (this.opts.logger) {
+      this.opts.logger.error(msg, ctx);
+    } else {
+      console.error(JSON.stringify({ ...ctx, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    }
+  }
   /** Current engine state — readable for UIs. */
   get currentState() {
     return this.state;
   }
+  /**
+   * Load the goal file with structured logging for parse/schema warnings.
+   */
+  loadGoal() {
+    return loadGoal(
+      this.goalPath,
+      this.opts.events,
+      this.opts.logger ? (msg) => this.opts.logger.warn(msg) : void 0
+    );
+  }
   /** Synchronously request stop. Resolves once the running iteration aborts. */
   stop() {
     this.stopRequested = true;
     this.currentCtrl?.abort();
     void this.persistEngineState("stopped").catch((err) => {
-      console.error(JSON.stringify({
-        level: "error",
-        event: "engine.persist_state_failed",
-        message: toErrorMessage(err),
-        context: { expectedState: "stopped" },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logError(
+        "Engine persist state failed",
+        { event: "engine.persist_state_failed", message: toErrorMessage(err), context: { expectedState: "stopped" } }
+      );
     });
     this.state = "stopped";
   }
@@ -4342,7 +6565,7 @@ var EternalAutonomyEngine = class {
     const emit = (stage) => {
       this.opts.onStage?.(stage);
     };
-    const goal = await loadGoal(this.goalPath, this.opts.events);
+    const goal = await this.loadGoal();
     if (!goal) {
       emit({ phase: "stopped" });
       this.stopRequested = true;
@@ -4446,16 +6669,13 @@ var EternalAutonomyEngine = class {
     emit({ phase: "reflect", status, note });
     let iterationIndex = 0;
     try {
-      const reloaded = await loadGoal(this.goalPath, this.opts.events);
+      const reloaded = await this.loadGoal();
       iterationIndex = reloaded?.iterations ?? 0;
     } catch (err) {
-      console.error(JSON.stringify({
-        level: "warn",
-        event: "autonomy.goal_reload_failed",
-        message: toErrorMessage(err),
-        context: { goalPath: this.goalPath },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logError(
+        "Goal reload failed",
+        { event: "autonomy.goal_reload_failed", message: toErrorMessage(err), context: { goalPath: this.goalPath } }
+      );
     }
     this.opts.onIteration?.({
       at: (this.opts.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
@@ -4691,13 +6911,10 @@ ${lastFew}` : "No prior iterations yet.",
         clearTimeout(timer);
       }
     } catch (err) {
-      console.error(JSON.stringify({
-        level: "warn",
-        event: "autonomy.brainstorm_failed",
-        message: toErrorMessage(err),
-        context: { goal: goal.goal.slice(0, 100) },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logError(
+        "Brainstorm failed",
+        { event: "autonomy.brainstorm_failed", message: toErrorMessage(err), context: { goal: goal.goal.slice(0, 100) } }
+      );
       return null;
     }
   }
@@ -4780,7 +6997,7 @@ ${recentJournal}` : "No prior iterations.",
     }
   }
   async appendIterationEntry(entry) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) {
       return;
     }
@@ -4794,7 +7011,7 @@ ${recentJournal}` : "No prior iterations.",
    * the counter to rotate past stuck todos once they cross `todoMaxAttempts`.
    */
   async bumpTodoAttempt(todoId) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) return;
     const attempts = { ...current.todoAttempts ?? {} };
     attempts[todoId] = (attempts[todoId] ?? 0) + 1;
@@ -4808,7 +7025,7 @@ ${recentJournal}` : "No prior iterations.",
    * goal is already `completed`.
    */
   async markGoalCompleted(action, note) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) return;
     if (current.goalState === "completed") return;
     const withFlag = { ...current, goalState: "completed" };
@@ -4819,6 +7036,11 @@ ${recentJournal}` : "No prior iterations.",
       note: note.slice(0, 240)
     });
     await saveGoal(this.goalPath, withEntry, this.opts.events);
+    try {
+      const { unlink: unlink4 } = await import("node:fs/promises");
+      await unlink4(this.goalPath);
+    } catch {
+    }
     this.opts.onEternalStop?.();
   }
   /**
@@ -4827,7 +7049,7 @@ ${recentJournal}` : "No prior iterations.",
    * `onEternalStop` so the REPL returns to normal mode.
    */
   async clearGoalManually(note) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (current) {
       const abandoned = { ...current, goalState: "abandoned" };
       await saveGoal(this.goalPath, abandoned, this.opts.events);
@@ -4875,7 +7097,23 @@ Recent work:
 ${recentJournal}` : ""
         ].join("\n"),
         risk: "high",
-        fallback: "continue"
+        fallback: "continue",
+        // Structured verdict — completion is control-plane input, decided by
+        // exact option id rather than sniffing prose for "done"/"complete".
+        options: [
+          {
+            id: "goal_complete",
+            label: "The goal is complete \u2014 stop the eternal run",
+            consequence: "The engine stops and the goal file is archived.",
+            risk: "high"
+          },
+          {
+            id: "keep_working",
+            label: "Not complete yet \u2014 keep working",
+            consequence: "The engine continues iterating on the goal.",
+            risk: "low"
+          }
+        ]
       });
       const summary = formatDecisionSummary(decision, {
         id: `goal-done-${goal.iterations}`,
@@ -4895,8 +7133,7 @@ ${recentJournal}` : ""
         return false;
       }
       if (decision.type === "answer") {
-        const text = decision.text.toLowerCase();
-        return text.includes("complete") || text.includes("done") || text.includes("yes");
+        return decision.optionId === "goal_complete";
       }
       return true;
     } catch {
@@ -4907,13 +7144,13 @@ ${recentJournal}` : ""
    * Persist a progress update from the agent's [PROGRESS: N%] output.
    */
   async updateProgress(progress, note) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) return;
     const updated = recordProgress(current, progress, note);
     await saveGoal(this.goalPath, updated, this.opts.events);
   }
   async persistEngineState(state) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) return;
     if (current.engineState === state) return;
     await saveGoal(this.goalPath, { ...current, engineState: state }, this.opts.events);
@@ -4948,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);
@@ -4970,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);
@@ -5024,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);
@@ -5034,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 = [];
@@ -5071,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
@@ -5751,15 +8026,17 @@ var MAX_FILES = 64;
 var MAX_NEXT_STEPS = 12;
 var MAX_ITEM_CHARS = 500;
 function normalizeSubagentStructuredReport(value) {
-  if (!isRecord3(value)) return void 0;
+  if (!isRecord4(value)) return void 0;
   const summary = nonEmptyString(value["summary"]);
   const findings = stringArray(value["findings"]);
   const filesExamined = stringArray(value["files_examined"]);
   const nextSteps = stringArray(value["suggested_next_steps"]);
   const confidence = value["confidence"];
+  const completion = value["completion"];
+  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) {
+  ) || 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) {
     return void 0;
   }
   const report = {
@@ -5767,19 +8044,24 @@ function normalizeSubagentStructuredReport(value) {
     findings: findings.map((item) => item.trim()).filter(Boolean),
     files_examined: filesExamined.map((item) => item.trim()).filter(Boolean),
     confidence,
-    suggested_next_steps: nextSteps.map((item) => item.trim()).filter(Boolean)
+    suggested_next_steps: nextSteps.map((item) => item.trim()).filter(Boolean),
+    ...completion === "complete" || completion === "partial" ? { completion } : {},
+    ...remainingWork ? { remaining_work: remainingWork } : {}
   };
   return JSON.stringify(report).length <= MAX_SUBAGENT_STRUCTURED_REPORT_CHARS ? report : void 0;
 }
 function readSubagentStructuredReport(ctx) {
   return normalizeSubagentStructuredReport(ctx?.meta?.[SUBAGENT_STRUCTURED_REPORT_META_KEY]);
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
+function optionalString2(value) {
+  return value === void 0 ? void 0 : nonEmptyString(value);
+}
 function stringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
 }
@@ -6062,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";
@@ -6077,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 {
     }
@@ -6107,7 +8389,7 @@ function agentPromptDirCandidates(envDir) {
 }
 function isDirectory2(candidate) {
   try {
-    return statSync2(candidate).isDirectory();
+    return statSync3(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -7769,76 +10051,45 @@ function providerErrorToSubagentError(err, message, cause) {
 }
 
 // src/coordination/fleet.ts
-var AUDIT_LOG_AGENT = {
-  id: "audit-log",
-  name: "Audit Log",
-  role: "audit-log",
-  prompt: agentPrompt("audit-log")
-  // No hardcoded budgets — the orchestrator (delegate tool or
-  // spawn_subagent) decides per-task how much room a subagent gets.
-  // A monorepo audit needs hours; a single-file lint check needs
-  // seconds. Pinning a number here forces the orchestrator to fight
-  // the role's default instead of just asking for what it needs.
-};
-var BUG_HUNTER_AGENT = {
-  id: "bug-hunter",
-  name: "Bug Hunter",
-  role: "bug-hunter",
-  prompt: agentPrompt("bug-hunter")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var REFACTOR_PLANNER_AGENT = {
-  id: "refactor-planner",
-  name: "Refactor Planner",
-  role: "refactor-planner",
-  prompt: agentPrompt("refactor-planner")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var SECURITY_SCANNER_AGENT = {
-  id: "security-scanner",
-  name: "Security Scanner",
-  role: "security-scanner",
-  prompt: agentPrompt("security-scanner")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var SHADOW_AGENT = {
-  id: "shadow-agent",
-  name: "Shadow",
-  role: "shadow-agent",
-  prompt: agentPrompt("shadow-agent")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var CRITIC_AGENT = {
-  id: "critic",
-  name: "Critic",
-  role: "critic",
-  prompt: agentPrompt("critic")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
+function defineAgent(id, name, promptRole = id, provider) {
+  return {
+    id,
+    name,
+    role: id,
+    prompt: agentPrompt(promptRole),
+    ...provider === void 0 ? {} : { provider }
+  };
+}
+var AUDIT_LOG_AGENT = defineAgent("audit-log", "Audit Log");
+var BUG_HUNTER_AGENT = defineAgent("bug-hunter", "Bug Hunter");
+var REFACTOR_PLANNER_AGENT = defineAgent("refactor-planner", "Refactor Planner");
+var SECURITY_SCANNER_AGENT = defineAgent("security-scanner", "Security Scanner");
+var SHADOW_AGENT = defineAgent("shadow-agent", "Shadow");
+var CRITIC_AGENT = defineAgent("critic", "Critic");
 var FLEET_ROSTER = {
   "audit-log": AUDIT_LOG_AGENT,
   "bug-hunter": BUG_HUNTER_AGENT,
   "refactor-planner": REFACTOR_PLANNER_AGENT,
   "security-scanner": SECURITY_SCANNER_AGENT,
-  "critic": CRITIC_AGENT,
+  critic: CRITIC_AGENT,
   "shadow-agent": SHADOW_AGENT,
   ...Object.fromEntries(
     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])
@@ -7846,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;
@@ -7869,41 +10120,11 @@ function applyRosterBudget(cfg) {
   };
 }
 var ALL_FLEET_AGENTS = Object.values(FLEET_ROSTER);
-var CLINE_AGENT = {
-  id: "cline",
-  name: "Cline",
-  role: "cline",
-  prompt: agentPrompt("acp-cline"),
-  provider: "acp"
-};
-var GEMINI_CLI_AGENT = {
-  id: "gemini-cli",
-  name: "Gemini CLI",
-  role: "gemini-cli",
-  prompt: agentPrompt("acp-gemini-cli"),
-  provider: "acp"
-};
-var COPILOT_AGENT = {
-  id: "copilot",
-  name: "GitHub Copilot",
-  role: "copilot",
-  prompt: agentPrompt("acp-copilot"),
-  provider: "acp"
-};
-var OPENHANDS_AGENT = {
-  id: "openhands",
-  name: "OpenHands",
-  role: "openhands",
-  prompt: agentPrompt("acp-openhands"),
-  provider: "acp"
-};
-var GOOSE_AGENT = {
-  id: "goose",
-  name: "Goose",
-  role: "goose",
-  prompt: agentPrompt("acp-goose"),
-  provider: "acp"
-};
+var CLINE_AGENT = defineAgent("cline", "Cline", "acp-cline", "acp");
+var GEMINI_CLI_AGENT = defineAgent("gemini-cli", "Gemini CLI", "acp-gemini-cli", "acp");
+var COPILOT_AGENT = defineAgent("copilot", "GitHub Copilot", "acp-copilot", "acp");
+var OPENHANDS_AGENT = defineAgent("openhands", "OpenHands", "acp-openhands", "acp");
+var GOOSE_AGENT = defineAgent("goose", "Goose", "acp-goose", "acp");
 var ACP_AGENTS = [
   CLINE_AGENT,
   GEMINI_CLI_AGENT,
@@ -7911,11 +10132,14 @@ var ACP_AGENTS = [
   OPENHANDS_AGENT,
   GOOSE_AGENT
 ];
-FLEET_ROSTER_BUDGETS["cline"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-FLEET_ROSTER_BUDGETS["gemini-cli"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-FLEET_ROSTER_BUDGETS["copilot"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-FLEET_ROSTER_BUDGETS["openhands"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-FLEET_ROSTER_BUDGETS["goose"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
+var ACP_AGENT_BUDGET = {
+  timeoutMs: 10 * 60 * 60 * 1e3,
+  maxIterations: 8e3,
+  maxToolCalls: 2e4
+};
+for (const agent of ACP_AGENTS) {
+  FLEET_ROSTER_BUDGETS[agent.role] = { ...ACP_AGENT_BUDGET };
+}
 var FLEET_ROSTER_WITHACP = {
   ...FLEET_ROSTER,
   ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
@@ -8909,6 +11133,27 @@ var ParallelEternalEngine = class {
   agentFactory;
   dispatchEnabled;
   dispatchClassifier;
+  /**
+   * Emit a structured error. Uses the configured Logger when available;
+   * falls back to console.error(JSON) so events are never silently dropped.
+   */
+  logError(msg, ctx) {
+    if (this.opts.logger) {
+      this.opts.logger.error(msg, ctx);
+    } else {
+      console.error(JSON.stringify({ ...ctx, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    }
+  }
+  /**
+   * Load the goal file with structured logging for parse/schema warnings.
+   */
+  loadGoal() {
+    return loadGoal(
+      this.goalPath,
+      this.opts.events,
+      this.opts.logger ? (msg) => this.opts.logger.warn(msg) : void 0
+    );
+  }
   get currentState() {
     return this.state;
   }
@@ -8921,13 +11166,10 @@ var ParallelEternalEngine = class {
   stop() {
     this.stopRequested = true;
     void this.persistState("stopped").catch((err) => {
-      console.error(JSON.stringify({
-        level: "error",
-        event: "engine.persist_state_failed",
-        message: toErrorMessage(err),
-        context: { expectedState: "stopped" },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logError(
+        "Engine persist state failed",
+        { event: "engine.persist_state_failed", message: toErrorMessage(err), context: { expectedState: "stopped" } }
+      );
     });
     this.state = "stopped";
   }
@@ -8981,7 +11223,7 @@ var ParallelEternalEngine = class {
       this.opts.onStage?.(stage);
     };
     this.iterations++;
-    const goal = await loadGoal(this.goalPath, this.opts.events);
+    const goal = await this.loadGoal();
     if (!goal) {
       this.stopRequested = true;
       emit({ phase: "stopped" });
@@ -9125,13 +11367,10 @@ ${personaLine}Task: ${task}
             taskIds.push(taskId);
             await coordinator.assign(spec);
           } catch (err) {
-            console.error(JSON.stringify({
-              level: "warn",
-              event: "parallel_engine.spawn_failed",
-              message: toErrorMessage(err),
-              context: { slot: i, task, subagentId },
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            }));
+            this.logError(
+              "Parallel spawn failed",
+              { event: "parallel_engine.spawn_failed", message: toErrorMessage(err), context: { slot: i, task, subagentId } }
+            );
           }
         })()
       );
@@ -9157,13 +11396,10 @@ ${personaLine}Task: ${task}
         clearTimeout(timer);
       }
     } catch (err) {
-      console.error(JSON.stringify({
-        level: "warn",
-        event: "parallel_engine.brainstorm_results_failed",
-        message: toErrorMessage(err),
-        context: { slotCount, taskIds },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logError(
+        "Brainstorm results failed",
+        { event: "parallel_engine.brainstorm_results_failed", message: toErrorMessage(err), context: { slotCount, taskIds } }
+      );
       results = coordinator.results().slice(-taskIds.length);
     }
     await Promise.allSettled(subagentIds.map((id) => coordinator.remove(id)));
@@ -9198,13 +11434,10 @@ ${personaLine}Task: ${task}
           }
         }
       } catch (err) {
-        console.error(JSON.stringify({
-          level: "warn",
-          event: "parallel_engine.git_status_failed",
-          message: toErrorMessage(err),
-          context: { projectRoot: this.opts.projectRoot },
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        }));
+        this.logError(
+          "Git status failed",
+          { event: "parallel_engine.git_status_failed", message: toErrorMessage(err), context: { projectRoot: this.opts.projectRoot } }
+        );
       }
     }
     if (tasks.length < this.slots) {
@@ -9285,7 +11518,7 @@ ${lastFew}` : "No prior iterations.",
   // Helpers
   // -------------------------------------------------------------------------
   async appendIterationEntry(entry) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) return;
     const updated = appendJournal(current, entry);
     await saveGoal(this.goalPath, updated, this.opts.events);
@@ -9300,7 +11533,7 @@ ${lastFew}` : "No prior iterations.",
     await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
   }
   async persistState(state) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) return;
     if (current.engineState === state) return;
     await saveGoal(this.goalPath, { ...current, engineState: state }, this.opts.events);
@@ -9406,6 +11639,7 @@ var LLMSelector = class {
   maxContextTokens;
   systemPrompt;
   maxOutputTokens;
+  oneShotOrchestrator;
   constructor(opts) {
     this.provider = opts.provider;
     this.model = opts.model ?? "unknown";
@@ -9417,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);
@@ -9440,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(
@@ -9565,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(
@@ -9763,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
@@ -9994,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;
     }
@@ -10037,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;
@@ -10114,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;
   }
@@ -10127,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) {
@@ -10157,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) {
@@ -10223,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);
@@ -10244,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;
@@ -10259,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;
@@ -10459,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 {
@@ -10473,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;
   }
@@ -10650,7 +12896,8 @@ var ProviderBackedCompactor = class {
     }
     return new IntelligentCompactor({
       ...common,
-      summarizerModel: this.opts.summarizerModel
+      summarizerModel: this.opts.summarizerModel,
+      oneShotOrchestrator: this.opts.oneShotOrchestrator
     });
   }
 };
@@ -10665,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"];
 
@@ -10784,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();
@@ -10954,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 = `
 
@@ -11055,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
@@ -11121,12 +13426,12 @@ ${post.additionalContext}`;
       if (parentSignal.reason instanceof Error) throw parentSignal.reason;
       throw new Error(typeof parentSignal.reason === "string" ? parentSignal.reason : "aborted");
     }
-    const timeoutMs = clampTimeoutMs(
-      tool.timeoutMs ?? this.iterationTimeoutMs,
-      this.maxToolTimeoutMs
-    );
-    const timeoutSignal = AbortSignal.timeout(timeoutMs);
-    const combined = AbortSignal.any([parentSignal, timeoutSignal]);
+    const combined = tool.managesOwnTimeout ? parentSignal : AbortSignal.any([
+      parentSignal,
+      AbortSignal.timeout(
+        clampTimeoutMs(tool.timeoutMs ?? this.iterationTimeoutMs, this.maxToolTimeoutMs)
+      )
+    ]);
     let output;
     const toolPromise = typeof tool.executeStream === "function" ? this.runStreamedTool(tool, input, ctx, combined, toolUseId) : (async () => tool.execute(input, ctx, { signal: combined }))();
     toolPromise.catch(() => {
@@ -11417,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(
@@ -11469,9 +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,
@@ -11482,6 +14011,8 @@ export {
   EternalAutonomyEngine,
   HybridCompactor,
   IntelligentCompactor,
+  MAX_COUNCIL_CONCURRENCY,
+  OneShotOrchestrator,
   ParallelEternalEngine,
   SelectiveCompactor,
   ToolExecutor,
@@ -11489,11 +14020,23 @@ export {
   _resetDesignRulesCache,
   activateDesign,
   applyModelRuntime,
+  assembleBrainTiers,
+  buildBrainUserMessage,
+  buildCouncilJudgeSystemPrompt,
+  buildCouncilJudgeUserPrompt,
+  buildCouncilQuestionPrompt,
+  buildCouncilVoterSystemPrompt,
+  buildCouncilVoterUserPrompt,
   buildGoalPreamble,
   buildRecoveryStrategies,
   clearActiveKit,
   clearPersistedActiveKit,
+  completeBrainLlm,
   createAutonomyBrain,
+  createBrainRuntime,
+  createCouncilBrainArbiter,
+  createCouncilPersonaRegistry,
+  createCouncilProfileRegistry,
   createStrategyCompactor,
   createTieredBrainArbiter,
   designProjectDir,
@@ -11510,12 +14053,19 @@ export {
   makeDesignDetectUserInputMiddleware,
   makeDesignStudioRequestMiddleware,
   mergeModelRuntime,
+  normalizeCouncilProfile,
+  parseOptionDecision,
   recordKitChoice,
   renderPrompt,
+  resolveBrainConfigDefaults,
   resolveBundledDesignKitsDir,
   resolveCacheForRequest,
+  resolveCouncilProfile,
+  resolveCouncilVotes,
   resolveModelRuntime,
   resolveReasoningForRequest,
-  setActiveKit
+  runBrainEvaluation,
+  setActiveKit,
+  validateBrainEvaluationCase
 };
 //# sourceMappingURL=index.js.map