@wrongstack/core 0.284.1 → 0.286.0

package/dist/execution/index.js

@@ -1,25 +1,20 @@
-import { randomUUID, randomInt, createHash, randomBytes } from 'crypto';
-import * as fs from 'fs/promises';
-import * as path3 from 'path';
-import * as os from 'os';
-import { readFileSync, statSync, existsSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { execFile } from 'child_process';
-import { promisify, isDeepStrictEqual } from 'util';
-import { EventEmitter } from 'events';
-
 // src/utils/assert-never.ts
 function assertNever(x, message) {
   const err = new Error(
-    `Unhandled case: ${JSON.stringify(x)}`
+    message ?? `Unhandled case: ${JSON.stringify(x)}`
   );
   err.name = "AssertNeverError";
   throw err;
 }
+
+// src/utils/atomic-write.ts
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path3.dirname(targetPath);
+  const dir = path.dirname(targetPath);
   await fs.mkdir(dir, { recursive: true });
-  const tmp = path3.join(dir, `.${path3.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const tmp = path.join(dir, `.${path.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
       await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
@@ -81,11 +76,13 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve5) => setTimeout(resolve5, delays[i]));
+      await new Promise((resolve4) => setTimeout(resolve4, delays[i]));
     }
   }
   throw lastErr;
 }
+
+// src/utils/context-evidence.ts
 var MAX_DIGEST_CHARS = 4e3;
 function createContextEvidenceState() {
   return {
@@ -170,7 +167,7 @@ function toErrorMessage(err) {
 // src/utils/expect-defined.ts
 function expectDefined(value, label) {
   if (value === null || value === void 0) {
-    const err = new Error("Expected value to be defined");
+    const err = new Error(label ? `Expected ${label} to be defined` : "Expected value to be defined");
     err.name = "ExpectDefinedError";
     throw err;
   }
@@ -184,10 +181,10 @@ function validateAgainstSchema(value, schema) {
   return { ok: errors.length === 0, errors };
 }
 var MAX_SCHEMA_DEPTH = 64;
-function walk(value, schema, path12, errors, depth) {
+function walk(value, schema, path11, errors, depth) {
   if (depth > MAX_SCHEMA_DEPTH) {
     errors.push({
-      path: path12 || "<root>",
+      path: path11 || "<root>",
       message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
     });
     return;
@@ -195,7 +192,7 @@ function walk(value, schema, path12, errors, depth) {
   if (schema.enum !== void 0) {
     if (!enumIncludes(schema.enum, value)) {
       errors.push({
-        path: path12 || "<root>",
+        path: path11 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -204,7 +201,7 @@ function walk(value, schema, path12, errors, depth) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path12 || "<root>",
+        path: path11 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
       });
       return;
@@ -216,7 +213,7 @@ function walk(value, schema, path12, errors, depth) {
       if (!(req in obj)) {
         const expected = schema.properties?.[req]?.type;
         errors.push({
-          path: joinPath(path12, req),
+          path: joinPath(path11, req),
           message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
         });
       }
@@ -224,14 +221,14 @@ function walk(value, schema, path12, errors, depth) {
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path12, key), errors, depth + 1);
+          walk(obj[key], subSchema, joinPath(path11, key), errors, depth + 1);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path12}[${i}]`, errors, depth + 1);
+      walk(value[i], schema.items, `${path11}[${i}]`, errors, depth + 1);
     }
   }
 }
@@ -508,6 +505,9 @@ function safeParse(input, maxBytes = 5e6) {
 function slugify(name, fallback = "prompt", maxLen = 64) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/g, "") || fallback;
 }
+
+// src/utils/ulid.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
 var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 var ENCODING_LEN = ENCODING.length;
 var TIME_LEN = 10;
@@ -523,7 +523,7 @@ function encodeTime(now, len) {
   return str;
 }
 function encodeRandom(len) {
-  const bytes = randomBytes(len);
+  const bytes = randomBytes2(len);
   let str = "";
   for (let i = 0; i < len; i++) {
     str += ENCODING[bytes[i] % ENCODING_LEN];
@@ -536,7 +536,7 @@ function ulid(seedTime = Date.now()) {
 
 // src/utils/sleep.ts
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
 // src/utils/string.ts
@@ -1498,12 +1498,17 @@ function normalizeToolResultRenderMode(value) {
 function resolveToolResultRenderMode(modes, toolName) {
   return normalizeToolResultRenderMode(modes?.[toolName]) ?? DEFAULT_TOOL_RESULT_RENDER_MODE;
 }
+
+// src/utils/wstack-paths.ts
+import { createHash } from "node:crypto";
+import * as os from "node:os";
+import * as path2 from "node:path";
 function projectHash(absRoot) {
-  return createHash("sha256").update(path3.resolve(absRoot)).digest("hex").slice(0, 12);
+  return createHash("sha256").update(path2.resolve(absRoot)).digest("hex").slice(0, 12);
 }
 function projectSlug(absRoot) {
-  const base = slugify2(path3.basename(absRoot));
-  const hash = createHash("sha256").update(path3.resolve(absRoot)).digest("hex").slice(0, 6);
+  const base = slugify2(path2.basename(absRoot));
+  const hash = createHash("sha256").update(path2.resolve(absRoot)).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
 function slugify2(name) {
@@ -1511,61 +1516,61 @@ function slugify2(name) {
 }
 function wstackGlobalRoot() {
   const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path3.resolve(fromEnv);
-  return path3.join(os.homedir(), ".wrongstack");
+  if (fromEnv && fromEnv.trim().length > 0) return path2.resolve(fromEnv);
+  return path2.join(os.homedir(), ".wrongstack");
 }
 function resolveWstackPaths(opts) {
-  const globalRoot = opts.globalRoot ?? (opts.userHome ? path3.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
+  const globalRoot = opts.globalRoot ?? (opts.userHome ? path2.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
   const homeDir = opts.userHome ?? os.homedir();
   const hash = projectHash(opts.projectRoot);
   const slug = projectSlug(opts.projectRoot);
-  const projectDir = path3.join(globalRoot, "projects", slug);
+  const projectDir = path2.join(globalRoot, "projects", slug);
   return {
     globalRoot,
     projectRoot: opts.projectRoot,
     homeDir,
     configDir: globalRoot,
-    globalConfig: path3.join(globalRoot, "config.json"),
-    secretsKey: path3.join(globalRoot, ".key"),
-    globalMemory: path3.join(globalRoot, "memory.md"),
-    globalSkills: path3.join(globalRoot, "skills"),
-    globalClaudeSkills: path3.join(homeDir, ".claude", "skills"),
-    globalDesignKits: path3.join(globalRoot, "design-kits"),
-    globalPrompts: path3.join(globalRoot, "prompts"),
-    globalInstructions: path3.join(globalRoot, "instructions"),
-    promptUsage: path3.join(globalRoot, "prompt-usage.json"),
-    cacheDir: path3.join(globalRoot, "cache"),
-    modelsCache: path3.join(globalRoot, "cache", "models.dev.json"),
-    modelsOverlayCache: path3.join(globalRoot, "cache", "models-overlay.json"),
-    historyFile: path3.join(globalRoot, "history"),
-    logFile: path3.join(globalRoot, "logs", "wrongstack.log"),
+    globalConfig: path2.join(globalRoot, "config.json"),
+    secretsKey: path2.join(globalRoot, ".key"),
+    globalMemory: path2.join(globalRoot, "memory.md"),
+    globalSkills: path2.join(globalRoot, "skills"),
+    globalClaudeSkills: path2.join(homeDir, ".claude", "skills"),
+    globalDesignKits: path2.join(globalRoot, "design-kits"),
+    globalPrompts: path2.join(globalRoot, "prompts"),
+    globalInstructions: path2.join(globalRoot, "instructions"),
+    promptUsage: path2.join(globalRoot, "prompt-usage.json"),
+    cacheDir: path2.join(globalRoot, "cache"),
+    modelsCache: path2.join(globalRoot, "cache", "models.dev.json"),
+    modelsOverlayCache: path2.join(globalRoot, "cache", "models-overlay.json"),
+    historyFile: path2.join(globalRoot, "history"),
+    logFile: path2.join(globalRoot, "logs", "wrongstack.log"),
     projectDir,
-    projectCodebaseIndex: path3.join(projectDir, "codebase-index"),
-    projectMemory: path3.join(projectDir, "memory.md"),
-    projectSessions: path3.join(projectDir, "sessions"),
-    projectTrust: path3.join(projectDir, "trust.json"),
-    projectMeta: path3.join(projectDir, "meta.json"),
-    projectLocalConfig: path3.join(projectDir, "config.local.json"),
-    inProjectConfig: path3.join(opts.projectRoot, ".wrongstack", "config.json"),
-    inProjectAgentsFile: path3.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
-    inProjectSkills: path3.join(opts.projectRoot, ".wrongstack", "skills"),
-    inProjectClaudeSkills: path3.join(opts.projectRoot, ".claude", "skills"),
-    inProjectPrompts: path3.join(opts.projectRoot, ".wrongstack", "prompts"),
-    inProjectInstructions: path3.join(opts.projectRoot, ".wrongstack", "instructions"),
-    inProjectDesignKits: path3.join(opts.projectRoot, ".wrongstack", "design-kits"),
-    inProjectWorktrees: path3.join(opts.projectRoot, ".wrongstack", "worktrees"),
+    projectCodebaseIndex: path2.join(projectDir, "codebase-index"),
+    projectMemory: path2.join(projectDir, "memory.md"),
+    projectSessions: path2.join(projectDir, "sessions"),
+    projectTrust: path2.join(projectDir, "trust.json"),
+    projectMeta: path2.join(projectDir, "meta.json"),
+    projectLocalConfig: path2.join(projectDir, "config.local.json"),
+    inProjectConfig: path2.join(opts.projectRoot, ".wrongstack", "config.json"),
+    inProjectAgentsFile: path2.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
+    inProjectSkills: path2.join(opts.projectRoot, ".wrongstack", "skills"),
+    inProjectClaudeSkills: path2.join(opts.projectRoot, ".claude", "skills"),
+    inProjectPrompts: path2.join(opts.projectRoot, ".wrongstack", "prompts"),
+    inProjectInstructions: path2.join(opts.projectRoot, ".wrongstack", "instructions"),
+    inProjectDesignKits: path2.join(opts.projectRoot, ".wrongstack", "design-kits"),
+    inProjectWorktrees: path2.join(opts.projectRoot, ".wrongstack", "worktrees"),
     projectHash: hash,
     projectSlug: slug,
-    projectGoal: path3.join(projectDir, "goal.json"),
-    projectInputHistory: path3.join(projectDir, "input-history.json"),
-    projectSpecs: path3.join(projectDir, "specs"),
-    projectTaskGraphs: path3.join(projectDir, "task-graphs"),
-    projectSddSession: path3.join(projectDir, "sdd-session.json"),
-    projectPlan: path3.join(projectDir, "plan.json"),
-    projectAutophase: path3.join(projectDir, "autophase"),
-    projectSddBoards: path3.join(projectDir, "sdd-boards"),
-    syncConfig: path3.join(globalRoot, "sync.json"),
-    projectStatus: (projectHash2) => path3.join(globalRoot, "projects", projectHash2, "status.json")
+    projectGoal: path2.join(projectDir, "goal.json"),
+    projectInputHistory: path2.join(projectDir, "input-history.json"),
+    projectSpecs: path2.join(projectDir, "specs"),
+    projectTaskGraphs: path2.join(projectDir, "task-graphs"),
+    projectSddSession: path2.join(projectDir, "sdd-session.json"),
+    projectPlan: path2.join(projectDir, "plan.json"),
+    projectAutophase: path2.join(projectDir, "autophase"),
+    projectSddBoards: path2.join(projectDir, "sdd-boards"),
+    syncConfig: path2.join(globalRoot, "sync.json"),
+    projectStatus: (projectHash2) => path2.join(globalRoot, "projects", projectHash2, "status.json")
   };
 }
 
@@ -2064,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;
@@ -2084,6 +2097,7 @@ var DoneConditionChecker = class {
   }
   condition;
   compiledRegex;
+  logger;
   check(state) {
     switch (this.condition.type) {
       case "iterations":
@@ -2134,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;
@@ -2238,6 +2252,11 @@ var AutonomousRunner = class {
     this.stopped = true;
   }
 };
+
+// src/utils/instruction-file.ts
+import { readFileSync, statSync } from "node:fs";
+import * as path3 from "node:path";
+import { fileURLToPath } from "node:url";
 var textCache = /* @__PURE__ */ new Map();
 var rootCandidates;
 function readBundledInstructionText(relativePath) {
@@ -2290,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;
@@ -2309,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;
@@ -2327,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;
     }
@@ -2345,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")) {
@@ -2354,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.",
@@ -2364,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.",
@@ -2373,46 +2415,54 @@ 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 }
-    );
-    const text = extractText(response).trim();
-    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."
-      };
+}
+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 {
     }
-    return {
-      type: "answer",
-      text: text || (request.fallback === "continue" ? "Continue execution." : "Denied by autonomy policy."),
-      rationale: text || void 0
-    };
-  } catch {
+  }
+  if (text === null) {
     if (request.fallback === "continue") {
       return {
         type: "answer",
@@ -2421,6 +2471,21 @@ ${request.context}` : "",
     }
     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();
@@ -2456,20 +2521,1066 @@ function extractText(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 ?? "";
+  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 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)}`);
+      }
+      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 : 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 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
+    };
   }
-  return typeof r.text === "string" ? r.text : "";
+  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/storage/goal-store.ts
+import * as fsp from "node:fs/promises";
 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 {
-    raw = await fs.readFile(filePath, "utf8");
+    raw = await fsp.readFile(filePath, "utf8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") {
@@ -2496,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",
@@ -2524,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",
@@ -3231,6 +4334,12 @@ var DESIGN_STACKS = ["web", "react-native", "flutter", "swiftui", "compose"];
 function isDesignStack(v) {
   return DESIGN_STACKS.includes(v);
 }
+
+// src/execution/design-kit-loader.ts
+import { existsSync } from "node:fs";
+import * as fs2 from "node:fs/promises";
+import * as path4 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var KIT_FILE = "KIT.md";
 var TOKENS_FILE = "tokens.json";
 var FOUNDATIONS_ID = "_foundations";
@@ -3337,15 +4446,15 @@ var DefaultDesignKitLoader = class {
     for (const { dir, source } of this.dirs) {
       let entries;
       try {
-        entries = await fs.readdir(dir, { withFileTypes: true });
+        entries = await fs2.readdir(dir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const e of entries) {
         if (!e.isDirectory()) continue;
-        const kitFile = path3.join(dir, e.name, KIT_FILE);
+        const kitFile = path4.join(dir, e.name, KIT_FILE);
         try {
-          const raw = await fs.readFile(kitFile, "utf8");
+          const raw = await fs2.readFile(kitFile, "utf8");
           const fm = parseKitFrontmatter(raw);
           const id = fm.id ?? e.name;
           if (!fm.name) continue;
@@ -3406,7 +4515,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 fs.readFile(m.path, "utf8");
+    const raw = await fs2.readFile(m.path, "utf8");
     const body = narrowStackSections(stripFrontmatter(raw), stack);
     this.bodyCache.set(key, body);
     return body;
@@ -3417,9 +4526,9 @@ var DefaultDesignKitLoader = class {
     const m = await this.find(id);
     let tokens;
     if (m) {
-      const tokensPath = path3.join(path3.dirname(m.path), TOKENS_FILE);
+      const tokensPath = path4.join(path4.dirname(m.path), TOKENS_FILE);
       try {
-        const raw = await fs.readFile(tokensPath, "utf8");
+        const raw = await fs2.readFile(tokensPath, "utf8");
         const parsed = JSON.parse(raw);
         tokens = parsed;
       } catch {
@@ -3444,12 +4553,12 @@ var DefaultDesignKitLoader = class {
 };
 function resolveBundledDesignKitsDir() {
   try {
-    const here = path3.dirname(fileURLToPath(import.meta.url));
+    const here = path4.dirname(fileURLToPath2(import.meta.url));
     const candidates = [
-      path3.join(here, "design-kits"),
-      path3.join(here, "..", "design-kits"),
-      path3.join(here, "..", "..", "design-kits"),
-      path3.join(here, "..", "..", "..", "design-kits")
+      path4.join(here, "design-kits"),
+      path4.join(here, "..", "design-kits"),
+      path4.join(here, "..", "..", "design-kits"),
+      path4.join(here, "..", "..", "..", "design-kits")
     ];
     for (const c of candidates) {
       if (existsSync(c)) return c;
@@ -3474,9 +4583,14 @@ function getDesignKitLoader(projectRoot) {
 function _resetDesignKitLoaderMemo() {
   loaderMemo.clear();
 }
+
+// src/execution/design-project-store.ts
+import { existsSync as existsSync2 } from "node:fs";
+import * as fs3 from "node:fs/promises";
+import * as path5 from "node:path";
 var DESIGN_DIR = ".design";
 function designProjectDir(projectRoot) {
-  return path3.join(projectRoot, DESIGN_DIR);
+  return path5.join(projectRoot, DESIGN_DIR);
 }
 var RULE_FILES = ["rules.md", "RULES.md", "design.md"];
 var rulesCache = /* @__PURE__ */ new Map();
@@ -3485,7 +4599,7 @@ async function loadProjectDesignRules(projectRoot) {
   let rules;
   for (const name of RULE_FILES) {
     try {
-      const txt = await fs.readFile(path3.join(designProjectDir(projectRoot), name), "utf8");
+      const txt = await fs3.readFile(path5.join(designProjectDir(projectRoot), name), "utf8");
       if (txt.trim()) {
         rules = txt.trim();
         break;
@@ -3506,7 +4620,7 @@ function parseOverrides(value) {
 }
 async function loadActiveKit(projectRoot) {
   try {
-    const raw = await fs.readFile(path3.join(designProjectDir(projectRoot), "active.json"), "utf8");
+    const raw = await fs3.readFile(path5.join(designProjectDir(projectRoot), "active.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.kit === "string") {
       return {
@@ -3539,11 +4653,11 @@ function applyTokenOverrides(tokens, overrides) {
 }
 async function ensureDesignDir(projectRoot) {
   const dir = designProjectDir(projectRoot);
-  await fs.mkdir(dir, { recursive: true });
-  const gi = path3.join(dir, ".gitignore");
-  if (!existsSync(gi)) {
+  await fs3.mkdir(dir, { recursive: true });
+  const gi = path5.join(dir, ".gitignore");
+  if (!existsSync2(gi)) {
     try {
-      await fs.writeFile(gi, "*\n");
+      await fs3.writeFile(gi, "*\n");
     } catch {
     }
   }
@@ -3554,17 +4668,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 fs.writeFile(path3.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
+    await fs3.writeFile(path5.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
 `);
     const line = `- ${isoTime} \xB7 kit=${kit}${stack ? ` stack=${stack}` : ""} \xB7 via=${source}
 `;
-    await fs.appendFile(path3.join(dir, "decisions.md"), line);
+    await fs3.appendFile(path5.join(dir, "decisions.md"), line);
   } catch {
   }
 }
 async function clearPersistedActiveKit(projectRoot) {
   try {
-    await fs.rm(path3.join(designProjectDir(projectRoot), "active.json"), { force: true });
+    await fs3.rm(path5.join(designProjectDir(projectRoot), "active.json"), { force: true });
   } catch {
   }
 }
@@ -3680,12 +4794,12 @@ function verifyFiles(tokens, files) {
   const violations = [];
   let onPalette = 0;
   let offPalette = 0;
-  for (const { path: path12, text } of files) {
+  for (const { path: path11, text } of files) {
     const lines = text.split("\n");
     lines.forEach((lineText, i) => {
       const lineNo = i + 1;
       const flag = (snippet, reason) => {
-        violations.push({ file: path12, line: lineNo, snippet: snippet.slice(0, 80), reason });
+        violations.push({ file: path11, line: lineNo, snippet: snippet.slice(0, 80), reason });
       };
       for (const re of [HEX_RE, FUNC_COLOR_RE]) {
         re.lastIndex = 0;
@@ -3845,8 +4959,8 @@ 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('fs/promises');
-        const { default: nodePath } = await import('path');
+        const { default: fs8 } = 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(() => "");
         if (!text) return out;
@@ -3942,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;
 
@@ -4219,6 +5215,10 @@ var DefaultErrorHandler = class {
     return null;
   }
 };
+
+// src/execution/eternal-autonomy.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 var execFileP = promisify(execFile);
 var BRAINSTORM_DONE = /* @__PURE__ */ Symbol("brainstorm-done");
 var GOAL_COMPLETE_MARKER = /^\s*\[goal[_\s-]*complete\]\s*$/im;
@@ -4243,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";
   }
@@ -4314,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;
@@ -4418,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(),
@@ -4663,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;
     }
   }
@@ -4697,8 +5709,8 @@ ${recentJournal}` : "No prior iterations.",
       "   \u2022 When this iteration's Task is finished (real artifact / passing",
       "     test / applied diff / clean output), emit `[done]` on its own line.",
       "   \u2022 Do not stop on the first obstacle \u2014 try at least 3 distinct",
-      "     approaches before giving up. YOLO is active for normal project work;",
-      "     destructive-gated confirmations still belong to the permission flow.",
+      "     approaches before giving up. YOLO is active unless an explicit",
+      "     deny rule blocks the call.",
       "",
       "2. UPDATE TODO STATE (when Source is `todo`)",
       "   \u2022 Mark this todo `in_progress` via the todos tool before tool work.",
@@ -4752,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;
     }
@@ -4766,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;
@@ -4780,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" };
@@ -4791,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?.();
   }
   /**
@@ -4799,13 +5816,13 @@ ${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);
     }
     try {
-      const { unlink: unlink4 } = await import('fs/promises');
+      const { unlink: unlink4 } = await import("node:fs/promises");
       await unlink4(this.goalPath);
     } catch {
     }
@@ -4847,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}`,
@@ -4867,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 {
@@ -4879,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);
@@ -5063,8 +6095,8 @@ function resolveModelRuntime(settings, reasoning, capabilities) {
     return { reasoning: void 0, cache: void 0, parameters: void 0, warnings };
   }
   const reasoningField = resolveReasoningForRequest(settings, reasoning, warnings);
-  const cacheField = resolveCacheForRequest(settings);
-  const paramsField = resolveParametersForRequest(settings.parameters, capabilities);
+  const cacheField = resolveCacheForRequest(settings, warnings);
+  const paramsField = resolveParametersForRequest(settings.parameters, capabilities, warnings);
   return {
     reasoning: reasoningField,
     cache: cacheField,
@@ -5089,7 +6121,8 @@ function resolveReasoningForRequest(settings, rc, warnings) {
       warnings.push('reasoning "off" requested, but this model does not support disabling thinking; the setting was omitted.');
     }
   } else if (cfg.mode === "on") {
-    if (!capKnown) ; else if (!supportsReasoning && rc?.default === "disabled") {
+    if (!capKnown) {
+    } else if (!supportsReasoning && rc?.default === "disabled") {
       warnings.push('reasoning "on" requested, but this model has reasoning disabled by default and does not advertise support; the setting was omitted.');
     } else {
       out.enabled = true;
@@ -5168,6 +6201,9 @@ function applyModelRuntime(req, opts) {
   return next;
 }
 
+// src/execution/parallel-eternal-engine.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
 // src/coordination/subagent-budget.ts
 var TIMEOUT_PREEMPT_FRACTION = 0.85;
 var DECISION_TIMEOUT_MS = 6e4;
@@ -5475,13 +6511,13 @@ var SubagentBudget = class _SubagentBudget {
     if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
-    return new Promise((resolve5) => {
+    return new Promise((resolve4) => {
       let resolved = false;
       const respond = (d) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(fallback);
-        resolve5(d);
+        resolve4(d);
       };
       const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
       const sessionId = this.currentSessionId();
@@ -5624,12 +6660,24 @@ var ToolCapabilities = {
   SHELL_RESTRICTED: "shell.restricted",
   /** Can run a restricted project formatter/linter-style command. */
   SHELL_EXEC: "shell.exec",
+  /** Can read files inside the project (and possibly outside via symlinks if not guarded). */
+  FS_READ: "fs.read",
   /** Can write / modify / delete files inside the project. */
   FS_WRITE: "fs.write",
   /** Can write files outside the current project root (very high risk). */
   FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
+  /** Can perform outbound network requests. */
+  NET_OUTBOUND: "net.outbound",
+  /** Can mutate in-memory session todos only. */
+  SESSION_TODO: "session.todo",
+  /** Can mutate in-memory session mode only. */
+  SESSION_MODE: "session.mode",
+  /** Can inspect registered tool metadata. */
+  TOOL_META: "tool.meta",
   /** Can invoke arbitrary registered tools through a meta-tool. */
   TOOL_MUTATE_ANY: "tool.mutate.any",
+  /** Can read persistent memory. */
+  MEMORY_READ: "memory.read",
   /** Can write persistent memory. */
   MEMORY_WRITE: "memory.write",
   /** Can delete persistent memory. */
@@ -5638,6 +6686,16 @@ var ToolCapabilities = {
   MCP_PROXY: "mcp.proxy",
   /** Can spawn or manage subagents / multi-agent tasks. */
   SUBAGENT_SPAWN: "subagent.spawn",
+  /** Can inspect fleet/subagent coordination state without mutating it. */
+  COORDINATION_FLEET_READ: "coordination.fleet.read",
+  /** Can publish attributed, schema-checked events onto the fleet bus. */
+  COORDINATION_FLEET_EMIT: "coordination.fleet.emit",
+  /** Can submit a task-local structured result to the parent Director. */
+  COORDINATION_RESULT_SUBMIT: "coordination.result.submit",
+  /** Can read or write inter-agent mailbox messages. */
+  COORDINATION_MAIL: "coordination.mail",
+  /** Can schedule, inspect, or cancel in-session cron jobs. */
+  COORDINATION_CRON: "coordination.cron",
   /** Can mutate global or session configuration / trust state. */
   CONFIG_MUTATE: "config.mutate",
   /** Can install packages or run package managers with side effects. */
@@ -5657,6 +6715,22 @@ var DANGEROUS_FOR_SUBAGENTS = [
   ToolCapabilities.CONFIG_MUTATE,
   ToolCapabilities.PACKAGE_INSTALL
 ];
+var WIDE_SUBAGENT_CAPABILITIES = [
+  ToolCapabilities.FS_READ,
+  ToolCapabilities.FS_WRITE,
+  ToolCapabilities.NET_OUTBOUND,
+  ToolCapabilities.SESSION_TODO,
+  ToolCapabilities.TOOL_META,
+  ToolCapabilities.MEMORY_READ,
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.SHELL_RESTRICTED,
+  ToolCapabilities.SHELL_EXEC,
+  ToolCapabilities.PACKAGE_INSTALL,
+  // Read-only fleet visibility (fleet_status) — peer awareness has no blast
+  // radius and every fleet worker should coordinate around its peers.
+  ToolCapabilities.COORDINATION_FLEET_READ,
+  ToolCapabilities.COORDINATION_RESULT_SUBMIT
+];
 function hasDangerousCapabilityForSubagents(toolOrCaps) {
   if (!toolOrCaps) return false;
   const input = toolOrCaps;
@@ -5681,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 = {
@@ -5697,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;
 }
@@ -5990,6 +7071,12 @@ var TOOLS = {
   /** Web research. */
   research: ["read", "grep", "glob", "search", "fetch", "mailbox"]
 };
+
+// src/coordination/agents/agent-prompts.ts
+import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import * as os2 from "node:os";
+import * as path6 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 var promptCache = /* @__PURE__ */ new Map();
 var candidateCache = /* @__PURE__ */ new Map();
 function agentPrompt(id) {
@@ -6001,7 +7088,7 @@ function agentPrompt(id) {
   let resolved = "";
   for (const dir of agentPromptDirCandidates(envDir)) {
     try {
-      resolved = readFileSync(path3.join(dir, fileName), "utf8").trimEnd();
+      resolved = readFileSync2(path6.join(dir, fileName), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -6010,20 +7097,20 @@ function agentPrompt(id) {
   return resolved;
 }
 function agentPromptDirCandidates(envDir) {
-  const globalRoot = process.env["WRONGSTACK_HOME"] || path3.join(os.homedir(), ".wrongstack");
+  const globalRoot = process.env["WRONGSTACK_HOME"] || path6.join(os2.homedir(), ".wrongstack");
   const candKey = `${envDir}\0${globalRoot}`;
   const cached = candidateCache.get(candKey);
   if (cached !== void 0) return cached;
-  const here = path3.dirname(fileURLToPath(import.meta.url));
+  const here = path6.dirname(fileURLToPath3(import.meta.url));
   const explicitDir = envDir || void 0;
   const candidates = [
-    ...explicitDir ? [path3.resolve(explicitDir)] : [],
-    path3.join(globalRoot, "instructions", "agents"),
-    path3.resolve(here, "../../../../instructions/agents"),
-    path3.resolve(here, "../../../instructions/agents"),
-    path3.resolve(here, "../../instructions/agents"),
-    path3.resolve(here, "../instructions/agents"),
-    path3.resolve(here, "instructions/agents")
+    ...explicitDir ? [path6.resolve(explicitDir)] : [],
+    path6.join(globalRoot, "instructions", "agents"),
+    path6.resolve(here, "../../../../instructions/agents"),
+    path6.resolve(here, "../../../instructions/agents"),
+    path6.resolve(here, "../../instructions/agents"),
+    path6.resolve(here, "../instructions/agents"),
+    path6.resolve(here, "instructions/agents")
   ];
   const ordered = candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
   candidateCache.set(candKey, ordered);
@@ -6031,7 +7118,7 @@ function agentPromptDirCandidates(envDir) {
 }
 function isDirectory2(candidate) {
   try {
-    return statSync(candidate).isDirectory();
+    return statSync2(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -7609,6 +8696,10 @@ async function dispatchAgent(task, opts = {}) {
   };
 }
 
+// src/coordination/multi-agent-coordinator.ts
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+
 // src/coordination/coordinator/error-classifier.ts
 function classifySubagentError(err, hints = {}) {
   if (err instanceof AgentError && err.cause) {
@@ -7689,46 +8780,39 @@ function providerErrorToSubagentError(err, message, cause) {
 }
 
 // src/coordination/fleet.ts
-({
-  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.
-});
-({
-  prompt: agentPrompt("bug-hunter")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-});
-({
-  prompt: agentPrompt("refactor-planner")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-});
-({
-  prompt: agentPrompt("security-scanner")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-});
-({
-  prompt: agentPrompt("shadow-agent")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-});
-({
-  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,
+  "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 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 },
+  critic: { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 12e3 },
   "shadow-agent": {
     idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
     maxIterations: 2e3,
@@ -7764,41 +8848,12 @@ function applyRosterBudget(cfg) {
     maxCostUsd: cfg.maxCostUsd ?? defaultBudget.maxCostUsd
   };
 }
-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 ALL_FLEET_AGENTS = Object.values(FLEET_ROSTER);
+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,
@@ -7806,14 +8861,18 @@ 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]))
-});
+};
 
 // src/coordination/subagent-nicknames.ts
 var NICKNAME_POOL = {
@@ -7872,7 +8931,7 @@ var NICKNAME_POOL = {
   "mendeleev": { name: "Mendeleev", domain: "chemistry" }
 };
 var ALL_NICKNAMES = Object.entries(NICKNAME_POOL);
-Object.fromEntries(
+var NAME_TO_KEY = Object.fromEntries(
   ALL_NICKNAMES.map(([key, entry]) => [entry.name, key])
 );
 var DOMAIN_PREFERENCES = {
@@ -8190,7 +9249,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve4, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -8199,7 +9258,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve5(result);
+              resolve4(result);
             }
           };
           this.on("task.completed", handler);
@@ -8224,13 +9283,13 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       const done = new Set(completed.map((r) => r.taskId));
       return { completed, pending: taskIds.filter((id) => !done.has(id)) };
     }
-    return new Promise((resolve5) => {
+    return new Promise((resolve4) => {
       let timer;
       const handler = ({ result }) => {
         if (!ids.has(result.taskId)) return;
         if (timer) clearTimeout(timer);
         this.off("task.completed", handler);
-        resolve5({
+        resolve4({
           completed: [result],
           pending: taskIds.filter((id) => id !== result.taskId)
         });
@@ -8238,7 +9297,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       if (opts?.timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.off("task.completed", handler);
-          resolve5({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve4({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.on("task.completed", handler);
@@ -8520,12 +9579,12 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             }
             return new Promise((resolveDecision) => {
               let settled = false;
-              const resolve5 = (d) => {
+              const resolve4 = (d) => {
                 if (settled) return;
                 settled = true;
                 resolveDecision(d);
               };
-              const fallback = setTimeout(() => resolve5("stop"), DECISION_TIMEOUT_MS);
+              const fallback = setTimeout(() => resolve4("stop"), DECISION_TIMEOUT_MS);
               const sessionId = this.currentSessionId();
               budget._events?.emit("budget.threshold_reached", {
                 ...sessionId ? { sessionId } : {},
@@ -8543,11 +9602,11 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
                 // disagreeing, resolves as a stop). Async grants still resolve.
                 extend: (extra) => {
                   clearTimeout(fallback);
-                  queueMicrotask(() => resolve5({ extend: extra }));
+                  queueMicrotask(() => resolve4({ extend: extra }));
                 },
                 deny: () => {
                   clearTimeout(fallback);
-                  resolve5("stop");
+                  resolve4("stop");
                 }
               });
             });
@@ -8683,8 +9742,9 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     const subagent = this.subagents.get(result.subagentId);
     if (subagent && subagent.status !== "stopped") {
-      result.status === "failed" || result.status === "timeout";
+      const failed = result.status === "failed" || result.status === "timeout";
       subagent.status = "idle";
+      void failed;
       subagent.currentTask = void 0;
       if (subagent.abortController.signal.aborted) {
         subagent.abortController = new AbortController();
@@ -8802,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;
   }
@@ -8814,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";
   }
@@ -8833,7 +9911,7 @@ var ParallelEternalEngine = class {
     this.state = "running";
     await this.persistState("running");
     const config = {
-      coordinatorId: `parallel-${randomUUID().slice(0, 8)}`,
+      coordinatorId: `parallel-${randomUUID2().slice(0, 8)}`,
       maxConcurrent: this.slots,
       doneCondition: { type: "all_tasks_done" }
     };
@@ -8874,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" });
@@ -8887,7 +9965,7 @@ var ParallelEternalEngine = class {
     }
     if (!this.coordinator) {
       const config = {
-        coordinatorId: `parallel-${randomUUID().slice(0, 8)}`,
+        coordinatorId: `parallel-${randomUUID2().slice(0, 8)}`,
         maxConcurrent: this.slots,
         doneCondition: { type: "all_tasks_done" }
       };
@@ -8961,8 +10039,7 @@ ${recentJournal}` : "No prior iterations.",
       "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
       "\u2022 Execute the assigned task end-to-end using multiple tool calls.",
       "\u2022 Emit `[done]` on its own line when the task is complete.",
-      "\u2022 Do not ask before routine in-project tool use \u2014 YOLO is active for normal project work.",
-      "\u2022 If a destructive-gated confirmation appears, wait for the permission flow.",
+      "\u2022 Do not ask before tool use \u2014 YOLO is active unless an explicit deny rule blocks the call.",
       "\u2022 If the overall Mission is accomplished, emit `[GOAL_COMPLETE]` followed by a verification recipe.",
       "\u2022 Keep output concise \u2014 summarize findings, do not transcribe files."
     ].join("\n");
@@ -8974,7 +10051,7 @@ ${recentJournal}` : "No prior iterations.",
       const task = expectDefined(tasks[i]);
       const route = routes[i] ?? null;
       const subagentId = `parallel-${this.iterations}-${i}`;
-      const taskId = randomUUID();
+      const taskId = randomUUID2();
       const personaLine = route ? `Acting agent: ${route.definition.config.name} \u2014 ${route.definition.capability.summary}
 ` : "";
       const spec = {
@@ -9019,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 } }
+            );
           }
         })()
       );
@@ -9051,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)));
@@ -9092,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) {
@@ -9109,8 +10177,8 @@ ${personaLine}Task: ${task}
     return tasks.length > 0 ? tasks.slice(0, this.slots) : null;
   }
   async readGitStatus() {
-    const { execFile: execFile2 } = await import('child_process');
-    const { promisify: promisify2 } = await import('util');
+    const { execFile: execFile2 } = await import("node:child_process");
+    const { promisify: promisify2 } = await import("node:util");
     const execFileP2 = promisify2(execFile2);
     const { stdout } = await execFileP2("git", ["status", "--porcelain"], {
       cwd: this.opts.projectRoot,
@@ -9179,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);
@@ -9194,12 +10262,15 @@ ${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);
   }
 };
+
+// src/execution/retry-policy.ts
+import { randomInt } from "node:crypto";
 var MAX_RETRY_AFTER_MS = 6e4;
 var MAX_ATTEMPTS_BY_KIND = {
   rate_limit: 5,
@@ -9653,6 +10724,10 @@ Summarize the following message range:`;
   }
 };
 
+// src/execution/skill-loader.ts
+import * as fs4 from "node:fs/promises";
+import * as path7 from "node:path";
+
 // src/skills/foreign-sources.ts
 var FOREIGN_SKILL_TOOLS = [
   { id: "agents", subdir: "skills" },
@@ -9768,6 +10843,56 @@ function isValidSkillNameFormat(name) {
 
 // src/skills/limits.ts
 var SKILL_LIMITS = {
+  /**
+   * Per-skill body cap when injecting a full skill body into the system prompt
+   * (eager mode), and when returning a skill body from the `skill` tool.
+   * ~4k tokens. Oversized bodies are truncated at a paragraph boundary.
+   *
+   * Consumers: `system-prompt-builder.capSkillBody`, `skill` tool body return.
+   */
+  MAX_SKILL_BODY_CHARS: 16e3,
+  /**
+   * Per-resource cap when the `skill` tool loads a bundled file
+   * (`scripts/`, `references/`, `assets/`). ~8k tokens.
+   *
+   * Consumer: `skill` tool `loadResource`.
+   */
+  MAX_RESOURCE_CHARS: 32e3,
+  /**
+   * Maximum number of bundled resource paths the `skill` tool lists in one
+   * response. Caps a pathological skill (huge `assets/` tree) from blowing up
+   * the tool result.
+   *
+   * Consumer: `skill` tool resource listing.
+   */
+  MAX_LISTED_RESOURCES: 100,
+  /**
+   * Max size of a single installed skill file (SKILL.md or a bundled resource).
+   * Guards against a malicious registry skill shipping a multi-MB blob that
+   * then flows into the prompt. 100KB.
+   *
+   * Consumer: `SkillInstaller.install` / `importFromDir`.
+   */
+  MAX_SKILL_FILE_SIZE: 100 * 1024,
+  /**
+   * Max size of a GitHub tarball downloaded by the skill installer. Guards
+   * against a repo accidentally (or maliciously) shipping a giant tarball that
+   * would be extracted into a temp dir. 50MB.
+   *
+   * Consumer: `downloadGitHubTarball`.
+   */
+  MAX_TARBALL_SIZE: 50 * 1024 * 1024,
+  /**
+   * Default total char budget for skill bodies injected in eager mode when
+   * `config.skills.eagerMaxChars` is unset. ~6k tokens. Skills are injected
+   * highest-priority first; once the budget is exhausted the remaining skills
+   * are listed as a manifest the agent loads via the `skill` tool. Set very
+   * high to effectively disable budgeting.
+   *
+   * Consumer: `DefaultSystemPromptBuilder.buildMemoryAndSkills` (default for
+   * `skillEagerMaxChars`).
+   */
+  EAGER_DEFAULT_MAX_CHARS: 24e3,
   /**
    * Auto-compact body limits (the token-saving fallback used when a skill has
    * no hand-crafted `SKILL.save.md`). The Overview and Rules sections are
@@ -9777,7 +10902,24 @@ var SKILL_LIMITS = {
    */
   COMPACT_OVERVIEW_MAX: 200,
   COMPACT_RULES_MAX: 350,
-  COMPACT_TOTAL_MAX: 450};
+  COMPACT_TOTAL_MAX: 450,
+  /**
+   * Max length of a skill name (agentskills.io spec). Enforced by the
+   * frontmatter validator's format regex plus this length bound.
+   *
+   * Consumer: `isValidSkillNameFormat`.
+   */
+  SKILL_NAME_MAX_LEN: 64,
+  /**
+   * Soft line limit for a SKILL.md body, per the bundled `skill-creator` rule.
+   * Not enforced in code (a skill can exceed it) — surfaced by `/skill-gen
+   * validate` and the `skill-creator` skill as guidance to move deep material
+   * into `references/`.
+   *
+   * Consumer: `skill-creator` skill, `/skill-gen validate` advisory.
+   */
+  SKILL_BODY_LINE_LIMIT: 500
+};
 
 // src/execution/skill-loader.ts
 function stripFrontmatter2(raw) {
@@ -9814,7 +10956,7 @@ async function entryIsDirectory(dir, entry) {
   if (entry.isDirectory()) return true;
   if (entry.isSymbolicLink()) {
     try {
-      return (await fs.stat(path3.join(dir, entry.name))).isDirectory();
+      return (await fs4.stat(path7.join(dir, entry.name))).isDirectory();
     } catch {
       return false;
     }
@@ -9835,7 +10977,7 @@ var DefaultSkillLoader = class {
       for (const tool of FOREIGN_SKILL_TOOLS) {
         if (!foreignIds.includes(tool.id)) continue;
         dirs.push({
-          dir: path3.join(root, "." + tool.id, tool.subdir),
+          dir: path7.join(root, "." + tool.id, tool.subdir),
           source: "foreign",
           originTool: tool.id
         });
@@ -9857,12 +10999,12 @@ var DefaultSkillLoader = class {
     const seen = /* @__PURE__ */ new Set();
     for (const { dir, source, originTool } of this.dirs) {
       try {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
+        const entries = await fs4.readdir(dir, { withFileTypes: true });
         for (const e of entries) {
           if (!await entryIsDirectory(dir, e)) continue;
-          const skillFile = path3.join(dir, e.name, "SKILL.md");
+          const skillFile = path7.join(dir, e.name, "SKILL.md");
           try {
-            const raw = await fs.readFile(skillFile, "utf8");
+            const raw = await fs4.readFile(skillFile, "utf8");
             const fm = parseSkillFrontmatter(raw);
             if (!fm.name || !fm.description) continue;
             if (!isValidSkillNameFormat(fm.name)) continue;
@@ -9934,7 +11076,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 fs.readFile(m.path, "utf8");
+    const body = await fs4.readFile(m.path, "utf8");
     this.bodyCache.set(key, body);
     return body;
   }
@@ -9944,12 +11086,12 @@ 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 savePath = path3.join(path3.dirname(m.path), "SKILL.save.md");
+    const savePath = path7.join(path7.dirname(m.path), "SKILL.save.md");
     let result;
     try {
-      result = await fs.readFile(savePath, "utf8");
+      result = await fs4.readFile(savePath, "utf8");
     } catch {
-      const full = await fs.readFile(m.path, "utf8");
+      const full = await fs4.readFile(m.path, "utf8");
       const body = stripFrontmatter2(full);
       const compact = compactSkillBody(body);
       if (compact) {
@@ -9975,6 +11117,14 @@ function parseDescriptionFromText(desc) {
   }
   return { trigger, scope };
 }
+
+// src/execution/prompt-loader.ts
+import * as fs6 from "node:fs/promises";
+import * as path9 from "node:path";
+
+// src/storage/prompt-store.ts
+import * as fs5 from "node:fs/promises";
+import * as path8 from "node:path";
 var SCHEMA_VERSION = 2;
 function migratePromptEntry(raw) {
   if (!raw || typeof raw !== "object") return null;
@@ -10035,12 +11185,12 @@ var DefaultPromptStore = class {
     await ensureDir(this.dir);
     const entries = [];
     try {
-      const files = await fs.readdir(this.dir);
+      const files = await fs5.readdir(this.dir);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
         try {
           const raw = JSON.parse(
-            await fs.readFile(path3.join(this.dir, file), "utf8")
+            await fs5.readFile(path8.join(this.dir, file), "utf8")
           );
           const migrated = migratePromptEntry(raw.entry);
           if (migrated) entries.push(migrated);
@@ -10054,9 +11204,9 @@ var DefaultPromptStore = class {
     );
   }
   async get(id) {
-    const file = path3.join(this.dir, `${id}.json`);
+    const file = path8.join(this.dir, `${id}.json`);
     try {
-      const raw = JSON.parse(await fs.readFile(file, "utf8"));
+      const raw = JSON.parse(await fs5.readFile(file, "utf8"));
       return migratePromptEntry(raw.entry);
     } catch {
       return null;
@@ -10064,14 +11214,14 @@ var DefaultPromptStore = class {
   }
   async save(entry) {
     await ensureDir(this.dir);
-    const file = path3.join(this.dir, `${entry.id}.json`);
+    const file = path8.join(this.dir, `${entry.id}.json`);
     const raw = { version: SCHEMA_VERSION, entry };
     await atomicWrite(file, JSON.stringify(raw, null, 2));
   }
   async delete(id) {
-    const file = path3.join(this.dir, `${id}.json`);
+    const file = path8.join(this.dir, `${id}.json`);
     try {
-      await fs.unlink(file);
+      await fs5.unlink(file);
       return true;
     } catch {
       return false;
@@ -10158,7 +11308,7 @@ var DefaultPromptLoader = class {
   constructor(opts) {
     this.projectStore = typeof opts.paths.inProjectPrompts === "string" ? new DefaultPromptStore(opts.paths.inProjectPrompts) : void 0;
     this.userStore = typeof opts.paths.globalPrompts === "string" ? new DefaultPromptStore(opts.paths.globalPrompts) : void 0;
-    this.builtinDir = opts.bundledDir ? path3.join(opts.bundledDir, "prompts") : void 0;
+    this.builtinDir = opts.bundledDir ? path9.join(opts.bundledDir, "prompts") : void 0;
   }
   async list() {
     if (this.cache) return this.cache;
@@ -10271,7 +11421,7 @@ var DefaultPromptLoader = class {
     const files = await walkJson(dir);
     for (const file of files) {
       try {
-        const parsed = JSON.parse(await fs.readFile(file, "utf8"));
+        const parsed = JSON.parse(await fs6.readFile(file, "utf8"));
         const migrated = migratePromptEntry(parsed);
         if (migrated) out.push({ ...migrated, source: "builtin" });
       } catch {
@@ -10285,12 +11435,12 @@ async function walkJson(dir) {
   const out = [];
   let entries;
   try {
-    entries = await fs.readdir(dir, { withFileTypes: true });
+    entries = await fs6.readdir(dir, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const e of entries) {
-    const full = path3.join(dir, e.name);
+    const full = path9.join(dir, e.name);
     if (e.isDirectory()) {
       out.push(...await walkJson(full));
     } else if (e.name.endsWith(".json") && e.name !== "index.json" && e.name !== "schema.json") {
@@ -10474,6 +11624,12 @@ function readPolicy(ctx) {
   return candidate;
 }
 
+// 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 path10 from "node:path";
+
 // src/types/tool-markers.ts
 var MALFORMED_ARG_MARKERS = ["__raw", "__raw_arguments", "_raw"];
 
@@ -10693,12 +11849,33 @@ ${errorDetails}`,
       }
       if (effectivePermission === "confirm") {
         if (this.opts.confirmAwaiter) {
-          const choice = await this.opts.confirmAwaiter(tool, use.input, use.id, tool.name);
+          const awaiter = this.opts.confirmAwaiter;
+          const choice = await new Promise(
+            (resolve4, reject) => {
+              const signal = ctx.signal;
+              const onAbort = () => resolve4("abort");
+              if (signal.aborted) {
+                resolve4("abort");
+                return;
+              }
+              signal.addEventListener("abort", onAbort, { once: true });
+              awaiter(tool, use.input, use.id, tool.name).then(
+                (c) => {
+                  signal.removeEventListener("abort", onAbort);
+                  resolve4(c);
+                },
+                (e) => {
+                  signal.removeEventListener("abort", onAbort);
+                  reject(e);
+                }
+              );
+            }
+          );
           if (choice !== "yes" && choice !== "always") {
             const result = {
               type: "tool_result",
               tool_use_id: use.id,
-              content: `Tool "${tool.name}" denied by user.`,
+              content: choice === "abort" ? `Tool "${tool.name}" was not executed \u2014 the run was aborted while awaiting confirmation.` : `Tool "${tool.name}" denied by user.`,
               is_error: true
             };
             budget = this.budgetForString(result.content, budget);
@@ -10804,6 +11981,9 @@ ${post.additionalContext}`;
           is_error: true
         };
         budget = this.budgetForString(result.content, budget);
+        void category;
+        void retryable;
+        void detail;
         return { result, tool, durationMs: 0 };
       }
     };
@@ -10903,22 +12083,40 @@ ${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(() => {
+    });
     try {
-      output = typeof tool.executeStream === "function" ? await this.runStreamedTool(tool, input, ctx, combined, toolUseId) : await tool.execute(input, ctx, { signal: combined });
+      output = await new Promise((resolve4, reject) => {
+        const onAbort = () => {
+          setTimeout(() => reject(abortReasonToError(combined.reason)), 0);
+        };
+        combined.addEventListener("abort", onAbort, { once: true });
+        toolPromise.then(
+          (v) => {
+            combined.removeEventListener("abort", onAbort);
+            resolve4(v);
+          },
+          (e) => {
+            combined.removeEventListener("abort", onAbort);
+            reject(e);
+          }
+        );
+      });
     } catch (err) {
       if (combined.aborted) await this.runToolCleanup(tool, input, ctx);
       throw err;
     }
     if (combined.aborted) {
       await this.runToolCleanup(tool, input, ctx);
-      throw combined.reason instanceof Error ? combined.reason : new Error(typeof combined.reason === "string" ? combined.reason : "tool timeout");
+      throw abortReasonToError(combined.reason);
     }
     return output;
   }
@@ -11079,6 +12277,9 @@ function clampTimeoutMs(timeoutMs, maxTimeoutMs) {
   const finiteMax = Number.isFinite(maxTimeoutMs) && maxTimeoutMs > 0 ? maxTimeoutMs : fallback;
   return Math.max(1, Math.min(finiteTimeout, finiteMax));
 }
+function abortReasonToError(reason) {
+  return reason instanceof Error ? reason : new Error(typeof reason === "string" ? reason : "tool timeout");
+}
 function hasMalformedArguments(input) {
   if (!input || typeof input !== "object" || Array.isArray(input)) return false;
   const obj = input;
@@ -11177,12 +12378,12 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
     return content;
   }
   try {
-    const dir = path3.join(wstackGlobalRoot(), "tool-output");
-    await fs.mkdir(dir, { recursive: true });
+    const dir = path10.join(wstackGlobalRoot(), "tool-output");
+    await fs7.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 = path3.join(dir, `${stamp}-${safeTool}-${randomUUID()}.log`);
-    await fs.writeFile(filePath, content, "utf8");
+    const filePath = path10.join(dir, `${stamp}-${safeTool}-${randomUUID3()}.log`);
+    await fs7.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(
@@ -11230,7 +12431,64 @@ function sliceUtf8Suffix(text, maxBytes) {
   if (first >= 56320 && first <= 57343) start++;
   return text.slice(start);
 }
-
-export { AutoCompactionMiddleware, AutonomousRunner, DEFAULT_RECOVERY_STRATEGIES, DefaultDesignKitLoader, DefaultErrorHandler, DefaultPromptLoader, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, ParallelEternalEngine, SelectiveCompactor, ToolExecutor, _resetDesignKitLoaderMemo, _resetDesignRulesCache, activateDesign, applyModelRuntime, buildGoalPreamble, buildRecoveryStrategies, clearActiveKit, clearPersistedActiveKit, createAutonomyBrain, createStrategyCompactor, createTieredBrainArbiter, designProjectDir, detectFrontendFile, detectFrontendIntent, formatDecisionSummary, getDesignKitLoader, getDesignState, installDesignStudioMiddleware, loadActiveKit, loadProjectDesignRules, makeAutonomyPromptContributor, makeDesignDetectToolCallMiddleware, makeDesignDetectUserInputMiddleware, makeDesignStudioRequestMiddleware, mergeModelRuntime, recordKitChoice, renderPrompt, resolveBundledDesignKitsDir, resolveCacheForRequest, resolveModelRuntime, resolveReasoningForRequest, setActiveKit };
+export {
+  AutoCompactionMiddleware,
+  AutonomousRunner,
+  BRAIN_EVALUATION_CASE_VERSION,
+  COUNCIL_REFUSE_OPTION_ID,
+  DEFAULT_RECOVERY_STRATEGIES,
+  DefaultDesignKitLoader,
+  DefaultErrorHandler,
+  DefaultPromptLoader,
+  DefaultRetryPolicy,
+  DefaultSkillLoader,
+  DoneConditionChecker,
+  EternalAutonomyEngine,
+  HybridCompactor,
+  IntelligentCompactor,
+  ParallelEternalEngine,
+  SelectiveCompactor,
+  ToolExecutor,
+  _resetDesignKitLoaderMemo,
+  _resetDesignRulesCache,
+  activateDesign,
+  applyModelRuntime,
+  assembleBrainTiers,
+  buildBrainUserMessage,
+  buildGoalPreamble,
+  buildRecoveryStrategies,
+  clearActiveKit,
+  clearPersistedActiveKit,
+  completeBrainLlm,
+  createAutonomyBrain,
+  createBrainRuntime,
+  createCouncilBrainArbiter,
+  createStrategyCompactor,
+  createTieredBrainArbiter,
+  designProjectDir,
+  detectFrontendFile,
+  detectFrontendIntent,
+  formatDecisionSummary,
+  getDesignKitLoader,
+  getDesignState,
+  installDesignStudioMiddleware,
+  loadActiveKit,
+  loadProjectDesignRules,
+  makeAutonomyPromptContributor,
+  makeDesignDetectToolCallMiddleware,
+  makeDesignDetectUserInputMiddleware,
+  makeDesignStudioRequestMiddleware,
+  mergeModelRuntime,
+  parseOptionDecision,
+  recordKitChoice,
+  renderPrompt,
+  resolveBrainConfigDefaults,
+  resolveBundledDesignKitsDir,
+  resolveCacheForRequest,
+  resolveModelRuntime,
+  resolveReasoningForRequest,
+  runBrainEvaluation,
+  setActiveKit,
+  validateBrainEvaluationCase
+};
 //# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map