@wrongstack/core 0.285.0 → 0.286.0

package/dist/execution/index.js

@@ -2069,19 +2069,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 +2097,7 @@ var DoneConditionChecker = class {
   }
   condition;
   compiledRegex;
+  logger;
   check(state) {
     switch (this.condition.type) {
       case "iterations":
@@ -2139,7 +2148,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;
@@ -2300,12 +2309,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 +2341,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 +2365,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 +2386,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 +2396,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 +2406,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,94 +2415,1160 @@ 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
+};
+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 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 };
+}
+var DEFAULT_PRIMARY_COOLDOWN_MAX_MS = 10 * 6e4;
+
+// 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({ 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);
+      if (votes.length / opts.voters.length < quorumFraction) {
+        return finish(request, abstain(request, `quorum not met (${votes.length}/${opts.voters.length} votes)`));
+      }
+      const vetoRefusal = votes.find(
+        (v) => v.voter.veto === true && v.optionId === COUNCIL_REFUSE_OPTION_ID
+      );
+      if (vetoRefusal) {
+        return finish(request, {
+          type: "deny",
+          reason: `Council veto by ${voterLabel(vetoRefusal.voter, 0)}` + (vetoRefusal.rationale ? `: ${vetoRefusal.rationale}` : ".")
+        });
+      }
+      const weightByOption = /* @__PURE__ */ new Map();
+      let castWeight = 0;
+      for (const v of votes) {
+        const w = v.voter.weight ?? 1;
+        castWeight += w;
+        weightByOption.set(v.optionId, (weightByOption.get(v.optionId) ?? 0) + w);
+      }
+      let winner = null;
+      let contested = false;
+      for (const [optionId, weight] of weightByOption) {
+        if (!winner || weight > winner.weight) {
+          winner = { optionId, weight };
+          contested = false;
+        } else if (weight === winner.weight) {
+          contested = true;
+        }
+      }
+      const decisive = winner !== null && !contested && winner.weight > approvalFraction * castWeight;
+      let finalOptionId = decisive && winner ? winner.optionId : null;
+      let viaJudge = false;
+      if (!finalOptionId) {
+        const judged = await judgeRound(
+          request,
+          ballot,
+          votes,
+          contested ? "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 text = extractText(response).trim();
-    if (request.options?.length) {
-      const parsed = parseOptionDecision(text, request.options);
-      if (parsed) {
-        return parsed;
+  }
+  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 requireFraction(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)}`);
       }
-      return {
-        type: "deny",
-        reason: "Autonomy Brain returned no exact valid option id."
-      };
+      next.maxAutoRisk = patch.maxAutoRisk;
     }
-    return {
-      type: "answer",
-      text: text || (request.fallback === "continue" ? "Continue execution." : "Denied by autonomy policy."),
-      rationale: text || void 0
-    };
-  } catch {
-    if (request.fallback === "continue") {
-      return {
-        type: "answer",
-        text: "Continue (Autonomy Brain LLM unavailable \u2014 using fallback)."
-      };
+    if (patch.humanTimeoutMs !== void 0) {
+      next.humanTimeoutMs = patch.humanTimeoutMs === null ? void 0 : requirePositiveMs(patch.humanTimeoutMs, "humanTimeoutMs");
     }
-    return { type: "deny", reason: "Autonomy Brain LLM unavailable for decision." };
+    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 : requireFraction(p.quorum, "council quorum");
+        }
+        if (p.approval !== void 0) {
+          c.approval = p.approval === null ? void 0 : requireFraction(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 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;
+  function getSnapshot() {
+    const councilCfg = cfg.council;
+    const voters = (councilCfg?.voters ?? []).map((v) => normalizeVoter(v));
     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
+      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
     };
   }
-  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();
+  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 {
-    type: "answer",
-    optionId: option.id,
-    text: option.label,
-    rationale: rationale || void 0
+    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 };
+    }
   };
 }
-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/storage/goal-store.ts
 import * as fsp from "node:fs/promises";
@@ -2478,7 +3576,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 +3607,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 +3631,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",
@@ -3966,124 +5056,6 @@ function installDesignStudioMiddleware(deps) {
   });
 }
 
-// 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}`;
-    }
-    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/execution/regex-patterns.ts
 var NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
 
@@ -4271,22 +5243,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 +5332,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 +5436,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 +5678,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 +5764,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 +5778,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 +5792,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 +5803,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 +5816,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 +5864,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 +5900,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 +5911,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);
@@ -5751,15 +6755,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 = optionalString(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 +6773,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 optionalString(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;
 }
@@ -7769,58 +8780,27 @@ 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])
@@ -7832,7 +8812,7 @@ var FLEET_ROSTER_BUDGETS = {
   "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 },
+  critic: { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 12e3 },
   "shadow-agent": {
     idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
     maxIterations: 2e3,
@@ -7869,41 +8849,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 +8861,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 +9862,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 +9895,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 +9952,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 +10096,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 +10125,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 +10163,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 +10247,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 +10262,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);
@@ -11121,12 +12083,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(() => {
@@ -11472,6 +12434,8 @@ function sliceUtf8Suffix(text, maxBytes) {
 export {
   AutoCompactionMiddleware,
   AutonomousRunner,
+  BRAIN_EVALUATION_CASE_VERSION,
+  COUNCIL_REFUSE_OPTION_ID,
   DEFAULT_RECOVERY_STRATEGIES,
   DefaultDesignKitLoader,
   DefaultErrorHandler,
@@ -11489,11 +12453,16 @@ export {
   _resetDesignRulesCache,
   activateDesign,
   applyModelRuntime,
+  assembleBrainTiers,
+  buildBrainUserMessage,
   buildGoalPreamble,
   buildRecoveryStrategies,
   clearActiveKit,
   clearPersistedActiveKit,
+  completeBrainLlm,
   createAutonomyBrain,
+  createBrainRuntime,
+  createCouncilBrainArbiter,
   createStrategyCompactor,
   createTieredBrainArbiter,
   designProjectDir,
@@ -11510,12 +12479,16 @@ export {
   makeDesignDetectUserInputMiddleware,
   makeDesignStudioRequestMiddleware,
   mergeModelRuntime,
+  parseOptionDecision,
   recordKitChoice,
   renderPrompt,
+  resolveBrainConfigDefaults,
   resolveBundledDesignKitsDir,
   resolveCacheForRequest,
   resolveModelRuntime,
   resolveReasoningForRequest,
-  setActiveKit
+  runBrainEvaluation,
+  setActiveKit,
+  validateBrainEvaluationCase
 };
 //# sourceMappingURL=index.js.map