@wrongstack/core 0.286.0 → 0.287.0

package/dist/tools/index.js

@@ -257,6 +257,99 @@ import * as fs2 from "node:fs/promises";
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+
+// src/utils/string.ts
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+
+// src/types/errors.ts
+var ERROR_CODES = {
+  // Provider
+  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
+  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
+  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
+  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
+  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
+  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
+  PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
+  // Tool
+  TOOL_NOT_FOUND: "TOOL_NOT_FOUND",
+  TOOL_PERMISSION_DENIED: "TOOL_PERMISSION_DENIED",
+  TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED",
+  TOOL_TIMEOUT: "TOOL_TIMEOUT",
+  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
+  // Config
+  CONFIG_INVALID: "CONFIG_INVALID",
+  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+  CONFIG_PARSE_FAILED: "CONFIG_PARSE_FAILED",
+  CONFIG_MIGRATION_NEEDED: "CONFIG_MIGRATION_NEEDED",
+  // Plugin
+  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
+  PLUGIN_API_MISMATCH: "PLUGIN_API_MISMATCH",
+  PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY",
+  // Agent
+  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
+  AGENT_ABORTED: "AGENT_ABORTED",
+  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
+  // Session
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_CORRUPTED: "SESSION_CORRUPTED",
+  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
+  // Container / Registry
+  CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
+  CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
+  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
+  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
+  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
+  REGISTRY_INVALID: "REGISTRY_INVALID",
+  // File system
+  FS_READ_FAILED: "FS_READ_FAILED",
+  FS_WRITE_FAILED: "FS_WRITE_FAILED",
+  FS_MKDIR_FAILED: "FS_MKDIR_FAILED",
+  FS_DELETE_FAILED: "FS_DELETE_FAILED",
+  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
+  // SDD (Spec-Driven Development)
+  SDD_VALIDATION_FAILED: "SDD_VALIDATION_FAILED",
+  SDD_PARSE_FAILED: "SDD_PARSE_FAILED",
+  SDD_INVALID_STATE: "SDD_INVALID_STATE",
+  SDD_NOT_READY: "SDD_NOT_READY",
+  // General
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  PARSE_FAILED: "PARSE_FAILED",
+  UNKNOWN: "UNKNOWN"
+};
+var WrongStackError = class extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+
+// src/utils/atomic-write.ts
 async function atomicWrite(targetPath, content, opts = {}) {
   const dir = path.dirname(targetPath);
   await fs.mkdir(dir, { recursive: true });
@@ -319,7 +412,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve) => setTimeout(resolve, delays[i]));
+      await new Promise((resolve2) => setTimeout(resolve2, delays[i]));
     }
   }
   throw lastErr;
@@ -344,13 +437,13 @@ async function updateJsonObjectFile(filePath, mutator) {
   await writeJsonObjectFile(filePath, next);
   return next;
 }
-function setJsonPath(root, path2, value) {
-  if (path2.length === 0) {
+function setJsonPath(root, path3, value) {
+  if (path3.length === 0) {
     if (!isJsonObject(value)) throw new Error("Root config value must be an object");
     return value;
   }
-  const parent = ensureJsonParent(root, path2);
-  const leaf = lastPathSegment(path2);
+  const parent = ensureJsonParent(root, path3);
+  const leaf = lastPathSegment(path3);
   if (typeof leaf === "number") {
     if (!Array.isArray(parent)) throw new Error(`Cannot set numeric segment ${leaf} on non-array parent`);
     parent[leaf] = value;
@@ -363,16 +456,16 @@ function setJsonPath(root, path2, value) {
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function lastPathSegment(path2) {
-  const segment = path2[path2.length - 1];
+function lastPathSegment(path3) {
+  const segment = path3[path3.length - 1];
   if (segment === void 0) throw new Error("Invalid empty JSON path");
   return segment;
 }
-function ensureJsonParent(root, path2) {
+function ensureJsonParent(root, path3) {
   let current = root;
-  for (let i = 0; i < path2.length - 1; i += 1) {
-    const segment = path2[i];
-    const nextSegment = path2[i + 1];
+  for (let i = 0; i < path3.length - 1; i += 1) {
+    const segment = path3[i];
+    const nextSegment = path3[i + 1];
     if (segment === void 0) throw new Error("Invalid empty JSON path segment");
     const nextContainer = typeof nextSegment === "number" ? [] : {};
     if (typeof segment === "number") {
@@ -639,7 +732,1786 @@ function badge(state) {
       return dim(state);
   }
 }
+
+// src/execution/council-personas.ts
+var PERSONA_ID_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var BUILTIN_COUNCIL_PERSONAS = Object.freeze([
+  freezePersona({
+    id: "executor",
+    name: "Executor",
+    description: "Tests whether a proposal is practical and keeps useful work moving.",
+    instruction: "Evaluate operational feasibility, concrete progress, and the cost of delay. Favor decisive action when evidence supports it, but reject action whose prerequisites are missing.",
+    tags: ["delivery", "feasibility", "progress"]
+  }),
+  freezePersona({
+    id: "skeptic",
+    name: "Skeptic",
+    description: "Challenges assumptions and looks for concrete failure modes.",
+    instruction: "Identify unsupported assumptions, unsafe premises, irreversible consequences, and credible failure modes. Oppose or refuse only when you can name a concrete reason.",
+    defaultVeto: true,
+    tags: ["risk", "assumptions", "failure-modes"]
+  }),
+  freezePersona({
+    id: "auditor",
+    name: "Auditor",
+    description: "Evaluates cost, waste, evidence quality, and expected value.",
+    instruction: "Compare resource cost, opportunity cost, evidence quality, reversibility, and expected value. Prefer the option that achieves the objective with the least avoidable waste.",
+    tags: ["cost", "evidence", "efficiency"]
+  }),
+  freezePersona({
+    id: "security",
+    name: "Security Reviewer",
+    description: "Examines trust boundaries, abuse cases, and security impact.",
+    instruction: "Evaluate trust boundaries, attacker-controlled inputs, privilege changes, data exposure, abuse cases, and recovery options. Treat unmitigated high-impact security risk as grounds to refuse.",
+    defaultVeto: true,
+    tags: ["security", "trust", "abuse-cases"]
+  }),
+  freezePersona({
+    id: "maintainer",
+    name: "Maintainer",
+    description: "Evaluates complexity, compatibility, and long-term ownership.",
+    instruction: "Evaluate behavioral compatibility, conceptual complexity, testability, migration cost, and future maintenance. Prefer the smallest design that remains clear and extensible.",
+    tags: ["maintenance", "compatibility", "simplicity"]
+  }),
+  freezePersona({
+    id: "user-advocate",
+    name: "User Advocate",
+    description: "Evaluates the decision from the affected user\u2019s perspective.",
+    instruction: "Evaluate usability, surprise, accessibility, failure recovery, and whether the outcome solves the user\u2019s stated need. Prefer understandable behavior with safe recovery paths.",
+    tags: ["users", "usability", "accessibility"]
+  })
+]);
+var CouncilPersonaRegistry = class _CouncilPersonaRegistry {
+  byId;
+  constructor(personas = []) {
+    const entries = /* @__PURE__ */ new Map();
+    for (const persona of personas) {
+      const normalized = freezePersona(persona);
+      if (entries.has(normalized.id)) {
+        throw new Error(`CouncilPersonaRegistry: duplicate persona id "${normalized.id}".`);
+      }
+      entries.set(normalized.id, normalized);
+    }
+    this.byId = entries;
+  }
+  has(id) {
+    return this.byId.has(id);
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  require(id) {
+    const persona = this.get(id);
+    if (!persona) throw new Error(`CouncilPersonaRegistry: unknown persona "${id}".`);
+    return persona;
+  }
+  list() {
+    return Object.freeze([...this.byId.values()]);
+  }
+  /** Return a new registry; the current registry is never mutated. */
+  with(persona, opts = {}) {
+    const normalized = freezePersona(persona);
+    if (this.has(normalized.id) && opts.replace !== true) {
+      throw new Error(`CouncilPersonaRegistry: persona "${normalized.id}" already exists.`);
+    }
+    return new _CouncilPersonaRegistry([
+      ...this.list().filter((entry) => entry.id !== normalized.id),
+      normalized
+    ]);
+  }
+};
+var DEFAULT_COUNCIL_PERSONA_REGISTRY = new CouncilPersonaRegistry(
+  BUILTIN_COUNCIL_PERSONAS
+);
+function freezePersona(persona) {
+  const id = persona.id.trim();
+  const name = persona.name.trim();
+  const description = persona.description.trim();
+  const instruction = persona.instruction.trim();
+  if (!PERSONA_ID_RE.test(id)) {
+    throw new Error(`CouncilPersonaRegistry: invalid persona id "${persona.id}".`);
+  }
+  if (!name) throw new Error(`CouncilPersonaRegistry: persona "${id}" requires a name.`);
+  if (!description) {
+    throw new Error(`CouncilPersonaRegistry: persona "${id}" requires a description.`);
+  }
+  if (!instruction) {
+    throw new Error(`CouncilPersonaRegistry: persona "${id}" requires an instruction.`);
+  }
+  if (persona.defaultWeight !== void 0 && (!Number.isFinite(persona.defaultWeight) || persona.defaultWeight <= 0)) {
+    throw new Error(`CouncilPersonaRegistry: persona "${id}" has an invalid default weight.`);
+  }
+  const tags = Object.freeze(
+    [...new Set((persona.tags ?? []).map((tag) => tag.trim()).filter(Boolean))]
+  );
+  return Object.freeze({
+    id,
+    name,
+    description,
+    instruction,
+    ...persona.defaultWeight !== void 0 ? { defaultWeight: persona.defaultWeight } : {},
+    ...persona.defaultVeto !== void 0 ? { defaultVeto: persona.defaultVeto } : {},
+    ...tags.length > 0 ? { tags } : {}
+  });
+}
+
+// src/execution/council-profiles.ts
+var PROFILE_ID_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var DISTINCTNESS_VALUES = /* @__PURE__ */ new Set([
+  "none",
+  "model",
+  "provider"
+]);
+var DEFAULT_COUNCIL_QUORUM_FRACTION = 0.5;
+var DEFAULT_COUNCIL_APPROVAL_FRACTION = 0.5;
+var DEFAULT_COUNCIL_VOTER_MAX_TOKENS = 300;
+var DEFAULT_COUNCIL_JUDGE_MAX_TOKENS = 500;
+var DEFAULT_COUNCIL_PER_CALL_TIMEOUT_MS = 3e4;
+var DEFAULT_COUNCIL_OVERALL_TIMEOUT_MS = 9e4;
+var BUILTIN_COUNCIL_PROFILES = Object.freeze([
+  Object.freeze({
+    id: "balanced",
+    name: "Balanced",
+    description: "Three complementary lenses plus an independent judge for general decisions.",
+    seats: Object.freeze([
+      Object.freeze({ persona: "executor", target: Object.freeze({ role: "planner" }) }),
+      Object.freeze({ persona: "skeptic", target: Object.freeze({ role: "critic" }) }),
+      Object.freeze({ persona: "auditor", target: Object.freeze({ role: "analyst" }) })
+    ]),
+    judge: Object.freeze({ role: "reviewer" }),
+    quorumFraction: 0.5,
+    approvalFraction: 0.5,
+    distinctness: "model"
+  }),
+  Object.freeze({
+    id: "fast",
+    name: "Fast",
+    description: "Two-seat panel without a judge for quick, low-cost decisions.",
+    seats: Object.freeze([
+      Object.freeze({ persona: "executor", target: Object.freeze({ role: "planner" }) }),
+      Object.freeze({ persona: "skeptic", target: Object.freeze({ role: "critic" }) })
+    ]),
+    judge: false,
+    quorumFraction: 0.5,
+    approvalFraction: 0.5,
+    distinctness: "none",
+    voterMaxTokens: 200,
+    perCallTimeoutMs: 2e4,
+    overallTimeoutMs: 3e4
+  }),
+  Object.freeze({
+    id: "risk-review",
+    name: "Risk Review",
+    description: "Security, assumptions, maintenance, and cost review for high-impact choices.",
+    seats: Object.freeze([
+      Object.freeze({ persona: "skeptic", target: Object.freeze({ role: "critic" }) }),
+      Object.freeze({ persona: "security", target: Object.freeze({ role: "security-reviewer" }) }),
+      Object.freeze({ persona: "maintainer", target: Object.freeze({ role: "reviewer" }) }),
+      Object.freeze({ persona: "auditor", target: Object.freeze({ role: "analyst" }) })
+    ]),
+    judge: Object.freeze({ role: "architect" }),
+    quorumFraction: 0.75,
+    approvalFraction: 0.5,
+    distinctness: "provider",
+    judgeMaxTokens: 700,
+    overallTimeoutMs: 12e4
+  })
+]);
+var CouncilProfileRegistry = class _CouncilProfileRegistry {
+  byId;
+  personas;
+  constructor(profiles = [], personas = DEFAULT_COUNCIL_PERSONA_REGISTRY) {
+    this.personas = personas;
+    const entries = /* @__PURE__ */ new Map();
+    for (const profile of profiles) {
+      const normalized = normalizeCouncilProfile(profile, personas);
+      if (entries.has(normalized.id)) {
+        throw new Error(`CouncilProfileRegistry: duplicate profile id "${normalized.id}".`);
+      }
+      entries.set(normalized.id, normalized);
+    }
+    this.byId = entries;
+  }
+  has(id) {
+    return this.byId.has(id);
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  require(id) {
+    const profile = this.get(id);
+    if (!profile) throw new Error(`CouncilProfileRegistry: unknown profile "${id}".`);
+    return profile;
+  }
+  list() {
+    return Object.freeze([...this.byId.values()]);
+  }
+  /** Return a new registry; the current registry is never mutated. */
+  with(profile, opts = {}) {
+    const personas = opts.personas ?? this.personas;
+    const normalized = normalizeCouncilProfile(profile, personas);
+    if (this.has(normalized.id) && opts.replace !== true) {
+      throw new Error(`CouncilProfileRegistry: profile "${normalized.id}" already exists.`);
+    }
+    return new _CouncilProfileRegistry(
+      [
+        ...this.list().filter((entry) => entry.id !== normalized.id),
+        profile
+      ],
+      personas
+    );
+  }
+};
+var DEFAULT_COUNCIL_PROFILE_REGISTRY = new CouncilProfileRegistry(
+  BUILTIN_COUNCIL_PROFILES
+);
+function resolveCouncilProfile(profile, opts = {}) {
+  const personas = opts.personas ?? DEFAULT_COUNCIL_PERSONA_REGISTRY;
+  if (profile && typeof profile !== "string") return normalizeCouncilProfile(profile, personas);
+  const id = profile ?? opts.defaultProfile ?? "balanced";
+  return (opts.registry ?? DEFAULT_COUNCIL_PROFILE_REGISTRY).require(id);
+}
+function normalizeCouncilProfile(profile, personas = DEFAULT_COUNCIL_PERSONA_REGISTRY) {
+  const id = profile.id.trim();
+  if (!PROFILE_ID_RE.test(id)) {
+    throw new Error(`CouncilProfileRegistry: invalid profile id "${profile.id}".`);
+  }
+  if (profile.seats.length === 0) {
+    throw new Error(`CouncilProfileRegistry: profile "${id}" requires at least one seat.`);
+  }
+  const usedIds = /* @__PURE__ */ new Set();
+  const seats = profile.seats.map((seat) => {
+    const persona = personas.require(seat.persona.trim());
+    const explicitSeatId = seat.id?.trim();
+    if (explicitSeatId && usedIds.has(explicitSeatId)) {
+      throw new Error(`CouncilProfileRegistry: duplicate seat id "${explicitSeatId}".`);
+    }
+    const seatId = uniqueSeatId(explicitSeatId || persona.id, usedIds);
+    const label = seat.label?.trim() || persona.name;
+    const weight = seat.weight ?? persona.defaultWeight ?? 1;
+    if (!Number.isFinite(weight) || weight <= 0) {
+      throw new Error(`CouncilProfileRegistry: seat "${seatId}" has an invalid weight.`);
+    }
+    return Object.freeze({
+      id: seatId,
+      label,
+      persona: persona.id,
+      ...seat.target ? { target: freezeTarget(seat.target, `seat "${seatId}"`) } : {},
+      weight,
+      veto: seat.veto ?? persona.defaultVeto ?? false
+    });
+  });
+  const quorumFraction = fraction(
+    profile.quorumFraction ?? DEFAULT_COUNCIL_QUORUM_FRACTION,
+    "quorumFraction",
+    id
+  );
+  const approvalFraction = fraction(
+    profile.approvalFraction ?? DEFAULT_COUNCIL_APPROVAL_FRACTION,
+    "approvalFraction",
+    id
+  );
+  const distinctness = profile.distinctness ?? "model";
+  if (!DISTINCTNESS_VALUES.has(distinctness)) {
+    throw new Error(`CouncilProfileRegistry: profile "${id}" has invalid distinctness.`);
+  }
+  const voterMaxTokens = positiveInteger(
+    profile.voterMaxTokens ?? DEFAULT_COUNCIL_VOTER_MAX_TOKENS,
+    "voterMaxTokens",
+    id
+  );
+  const judgeMaxTokens = positiveInteger(
+    profile.judgeMaxTokens ?? DEFAULT_COUNCIL_JUDGE_MAX_TOKENS,
+    "judgeMaxTokens",
+    id
+  );
+  const perCallTimeoutMs = positiveInteger(
+    profile.perCallTimeoutMs ?? DEFAULT_COUNCIL_PER_CALL_TIMEOUT_MS,
+    "perCallTimeoutMs",
+    id
+  );
+  const overallTimeoutMs = positiveInteger(
+    profile.overallTimeoutMs ?? DEFAULT_COUNCIL_OVERALL_TIMEOUT_MS,
+    "overallTimeoutMs",
+    id
+  );
+  if (overallTimeoutMs < perCallTimeoutMs) {
+    throw new Error(
+      `CouncilProfileRegistry: profile "${id}" overallTimeoutMs must be at least perCallTimeoutMs.`
+    );
+  }
+  return Object.freeze({
+    id,
+    name: profile.name?.trim() || id,
+    description: profile.description?.trim() || "",
+    seats: Object.freeze(seats),
+    judge: profile.judge ? freezeTarget(profile.judge, "judge") : false,
+    quorumFraction,
+    approvalFraction,
+    distinctness,
+    voterMaxTokens,
+    judgeMaxTokens,
+    perCallTimeoutMs,
+    overallTimeoutMs
+  });
+}
+function uniqueSeatId(base, used) {
+  if (!PROFILE_ID_RE.test(base)) {
+    throw new Error(`CouncilProfileRegistry: invalid seat id "${base}".`);
+  }
+  let id = base;
+  let suffix = 2;
+  while (used.has(id)) id = `${base}-${suffix++}`;
+  used.add(id);
+  return id;
+}
+function freezeTarget(target, label) {
+  const providerId = optionalText(target.providerId);
+  const model = optionalText(target.model);
+  const role = optionalText(target.role);
+  const fallbackProfile = optionalText(target.fallbackProfile);
+  const fallbackModels = Object.freeze(
+    [...new Set((target.fallbackModels ?? []).map((ref) => ref.trim()).filter(Boolean))]
+  );
+  if (!providerId && !model && !role && !fallbackProfile && fallbackModels.length === 0) {
+    throw new Error(`CouncilProfileRegistry: ${label} target is empty.`);
+  }
+  return Object.freeze({
+    ...providerId ? { providerId } : {},
+    ...model ? { model } : {},
+    ...role ? { role } : {},
+    ...fallbackProfile ? { fallbackProfile } : {},
+    ...fallbackModels.length > 0 ? { fallbackModels } : {}
+  });
+}
+function optionalText(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function fraction(value, field, profileId) {
+  if (!Number.isFinite(value) || value <= 0 || value > 1) {
+    throw new Error(`CouncilProfileRegistry: profile "${profileId}" ${field} must be in (0, 1].`);
+  }
+  return value;
+}
+function positiveInteger(value, field, profileId) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(
+      `CouncilProfileRegistry: profile "${profileId}" ${field} must be a positive integer.`
+    );
+  }
+  return value;
+}
+
+// src/utils/instruction-file.ts
+import { readFileSync, statSync } from "node:fs";
+import * as path2 from "node:path";
+import { fileURLToPath } from "node:url";
+var textCache = /* @__PURE__ */ new Map();
+var rootCandidates;
+function readBundledInstructionText(relativePath) {
+  const cached = textCache.get(relativePath);
+  if (cached !== void 0) return cached;
+  let resolved = "";
+  for (const root of instructionRootCandidates()) {
+    try {
+      resolved = readFileSync(path2.join(root, relativePath), "utf8").trimEnd();
+      break;
+    } catch {
+    }
+  }
+  textCache.set(relativePath, resolved);
+  return resolved;
+}
+function renderInstructionTemplate(template, values) {
+  return template.replace(
+    /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g,
+    (match, key) => Object.hasOwn(values, key) ? values[key] ?? "" : match
+  );
+}
+function instructionRootCandidates() {
+  if (rootCandidates !== void 0) return rootCandidates;
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path2.resolve(here, "../../instructions"),
+    path2.resolve(here, "../instructions"),
+    path2.resolve(here, "instructions")
+  ];
+  rootCandidates = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
+  return rootCandidates;
+}
+function isDirectory(candidate) {
+  try {
+    return statSync(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/execution/council-prompts.ts
+var COUNCIL_VOTER_PROMPT_PATH = "llm/council-voter.md";
+var COUNCIL_JUDGE_PROMPT_PATH = "llm/council-judge.md";
+function buildCouncilVoterSystemPrompt(persona) {
+  const template = requiredInstruction(COUNCIL_VOTER_PROMPT_PATH);
+  return renderInstructionTemplate(template, {
+    personaInstruction: persona.instruction
+  });
+}
+function buildCouncilJudgeSystemPrompt() {
+  return requiredInstruction(COUNCIL_JUDGE_PROMPT_PATH);
+}
+function buildCouncilQuestionPrompt(question, opts = {}) {
+  const text = question.question.trim();
+  if (!text) throw new Error("buildCouncilQuestionPrompt: question must not be empty.");
+  const options = normalizeOptions(question.options);
+  return [
+    "<council-question>",
+    `Question: ${text}`,
+    question.context?.trim() ? `Context:
+${question.context.trim()}` : "",
+    options.length > 0 ? `Options (JSON):
+${JSON.stringify(options)}` : "Options: none",
+    opts.refusalOptionId ? `Refusal option id: ${opts.refusalOptionId}` : "Refusal option id: not supplied",
+    "</council-question>"
+  ].filter(Boolean).join("\n\n");
+}
+function buildCouncilVoterUserPrompt(question, seat, opts = {}) {
+  return [
+    buildCouncilQuestionPrompt(question, opts),
+    "<seat-metadata>",
+    `Seat id: ${seat.id}`,
+    `Seat label: ${seat.label}`,
+    `Persona id: ${seat.persona}`,
+    "</seat-metadata>"
+  ].join("\n");
+}
+function buildCouncilJudgeUserPrompt(question, votes, opts = {}) {
+  const ballots = votes.map((vote) => ({
+    seatId: vote.seatId,
+    persona: vote.persona,
+    status: vote.status,
+    ...vote.optionId ? { optionId: vote.optionId } : {},
+    ...vote.stance ? { stance: vote.stance } : {},
+    ...vote.rationale ? { rationale: vote.rationale } : {}
+  }));
+  return [
+    buildCouncilQuestionPrompt(question, { refusalOptionId: opts.refusalOptionId }),
+    "<council-ballots>",
+    opts.reason?.trim() ? `Reason judging is required: ${opts.reason.trim()}` : "",
+    JSON.stringify(ballots),
+    "</council-ballots>"
+  ].filter(Boolean).join("\n\n");
+}
+function normalizeOptions(options) {
+  if (!options) return [];
+  const seen = /* @__PURE__ */ new Set();
+  return options.map((option) => {
+    const id = option.id.trim();
+    const label = option.label.trim();
+    if (!id) throw new Error("buildCouncilQuestionPrompt: option id must not be empty.");
+    if (!label) throw new Error(`buildCouncilQuestionPrompt: option "${id}" needs a label.`);
+    if (seen.has(id)) throw new Error(`buildCouncilQuestionPrompt: duplicate option id "${id}".`);
+    seen.add(id);
+    return {
+      id,
+      label,
+      ...option.consequence?.trim() ? { consequence: option.consequence.trim() } : {}
+    };
+  });
+}
+function requiredInstruction(path3) {
+  const text = readBundledInstructionText(path3);
+  if (!text) throw new Error(`Council instruction file is unavailable: ${path3}`);
+  return text;
+}
+
+// src/execution/council-resolution.ts
+function resolveCouncilVotes(input) {
+  validateInput(input);
+  const seatById = new Map(input.seats.map((seat) => [seat.id, seat]));
+  const validVotes = [];
+  const votedSeatIds = /* @__PURE__ */ new Set();
+  for (const vote of input.votes) {
+    if (!seatById.has(vote.seatId) || votedSeatIds.has(vote.seatId)) continue;
+    votedSeatIds.add(vote.seatId);
+    validVotes.push(vote);
+  }
+  if (validVotes.length / input.seats.length < input.quorumFraction) {
+    return {
+      status: "abstained",
+      reason: "quorum_not_met",
+      validVoteCount: validVotes.length,
+      seatCount: input.seats.length
+    };
+  }
+  const veto = validVotes.find(
+    (vote) => vote.optionId === input.refusalOptionId && seatById.get(vote.seatId)?.veto === true
+  );
+  if (veto) {
+    return {
+      status: "denied",
+      method: "veto",
+      optionId: veto.optionId,
+      seatId: veto.seatId
+    };
+  }
+  const weightByOption = /* @__PURE__ */ new Map();
+  let castWeight = 0;
+  for (const vote of validVotes) {
+    const weight = seatById.get(vote.seatId)?.weight ?? 1;
+    castWeight += weight;
+    weightByOption.set(vote.optionId, (weightByOption.get(vote.optionId) ?? 0) + weight);
+  }
+  let winner;
+  let contested = false;
+  for (const [optionId, weight] of weightByOption) {
+    if (!winner || weight > winner.weight) {
+      winner = { optionId, weight };
+      contested = false;
+    } else if (weight === winner.weight) {
+      contested = true;
+    }
+  }
+  const decisive = winner !== void 0 && !contested && winner.weight > input.approvalFraction * castWeight;
+  if (!decisive || !winner) {
+    return {
+      status: "needs_judge",
+      reason: contested ? "tie" : "approval_threshold_not_met",
+      castWeight
+    };
+  }
+  if (winner.optionId === input.refusalOptionId) {
+    return {
+      status: "denied",
+      method: "refusal",
+      optionId: winner.optionId,
+      winningWeight: winner.weight,
+      castWeight
+    };
+  }
+  return {
+    status: "decided",
+    method: "majority",
+    optionId: winner.optionId,
+    winningWeight: winner.weight,
+    castWeight
+  };
+}
+function validateInput(input) {
+  if (input.seats.length === 0) {
+    throw new Error("resolveCouncilVotes: at least one seat is required.");
+  }
+  requireFraction(input.quorumFraction, "quorumFraction");
+  requireFraction(input.approvalFraction, "approvalFraction");
+  const seatIds = /* @__PURE__ */ new Set();
+  for (const seat of input.seats) {
+    if (!seat.id.trim()) throw new Error("resolveCouncilVotes: seat id must not be empty.");
+    if (seatIds.has(seat.id)) {
+      throw new Error(`resolveCouncilVotes: duplicate seat id "${seat.id}".`);
+    }
+    seatIds.add(seat.id);
+    if (seat.weight !== void 0 && (!Number.isFinite(seat.weight) || seat.weight <= 0)) {
+      throw new Error(`resolveCouncilVotes: invalid weight for seat "${seat.id}".`);
+    }
+  }
+}
+function requireFraction(value, label) {
+  if (!Number.isFinite(value) || value <= 0 || value > 1) {
+    throw new Error(`resolveCouncilVotes: ${label} must be in (0, 1].`);
+  }
+}
+
+// src/execution/council-orchestrator.ts
+var COUNCIL_REFUSAL_OPTION_ID = "council_refuse";
+var DEFAULT_COUNCIL_MAX_CONCURRENCY = 3;
+var MAX_COUNCIL_CONCURRENCY = 8;
+var CouncilOrchestrator = class {
+  caller;
+  personas;
+  profiles;
+  defaultProfile;
+  maxConcurrency;
+  refusalOptionId;
+  constructor(opts) {
+    this.caller = opts.caller;
+    this.personas = opts.personas ?? DEFAULT_COUNCIL_PERSONA_REGISTRY;
+    this.profiles = opts.profiles ?? DEFAULT_COUNCIL_PROFILE_REGISTRY;
+    this.defaultProfile = opts.defaultProfile;
+    this.maxConcurrency = validateConcurrency(
+      opts.maxConcurrency ?? DEFAULT_COUNCIL_MAX_CONCURRENCY
+    );
+    this.refusalOptionId = opts.refusalOptionId?.trim() || COUNCIL_REFUSAL_OPTION_ID;
+  }
+  async ask(question) {
+    const startedAt = Date.now();
+    const profile = resolveCouncilProfile(question.profile, {
+      registry: this.profiles,
+      personas: this.personas,
+      defaultProfile: this.defaultProfile
+    });
+    validateRefusalCollision(question, this.refusalOptionId);
+    const timeoutSignal = AbortSignal.timeout(profile.overallTimeoutMs);
+    const signal = question.signal ? AbortSignal.any([question.signal, timeoutSignal]) : timeoutSignal;
+    const usage = {
+      calls: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0
+    };
+    const votes = await mapConcurrent(
+      profile.seats,
+      Math.min(this.maxConcurrency, profile.seats.length),
+      async (seat) => {
+        try {
+          return await this.callSeat(question, profile, seat, signal, usage);
+        } catch (error) {
+          return {
+            seatId: seat.id,
+            persona: seat.persona,
+            status: signal.aborted ? "cancelled" : "failed",
+            error: errorMessage(error)
+          };
+        }
+      }
+    );
+    const warnings = distinctnessWarnings(votes, profile);
+    const errors = votes.filter((vote) => vote.status === "failed" || vote.status === "invalid").map((vote) => `${vote.seatId}: ${vote.error ?? vote.status}`);
+    if (question.signal?.aborted) {
+      return resultEnvelope({
+        status: "cancelled",
+        reason: "Council call cancelled.",
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    if (timeoutSignal.aborted) {
+      return resultEnvelope({
+        status: "failed",
+        reason: "Council overall timeout exceeded.",
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors: [...errors, "Council overall timeout exceeded."]
+      });
+    }
+    if (!question.options || question.options.length === 0) {
+      return this.resolveOpenQuestion(
+        question,
+        profile,
+        votes,
+        signal,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      );
+    }
+    return this.resolveOptionQuestion(
+      question,
+      profile,
+      votes,
+      signal,
+      usage,
+      startedAt,
+      warnings,
+      errors
+    );
+  }
+  async callSeat(question, profile, seat, signal, usage) {
+    if (signal.aborted) return cancelledVote(seat);
+    let persona;
+    try {
+      persona = this.personas.require(seat.persona);
+    } catch (error) {
+      return {
+        seatId: seat.id,
+        persona: seat.persona,
+        status: "failed",
+        error: errorMessage(error)
+      };
+    }
+    const result = await this.safeCall({
+      system: buildCouncilVoterSystemPrompt(persona),
+      userPrompt: buildCouncilVoterUserPrompt(question, seat, {
+        refusalOptionId: question.options?.length ? this.refusalOptionId : void 0
+      }),
+      target: seat.target,
+      maxTokens: profile.voterMaxTokens,
+      timeoutMs: profile.perCallTimeoutMs,
+      signal,
+      usage
+    });
+    const metadata = callMetadata(result);
+    if (result.error) {
+      return {
+        seatId: seat.id,
+        persona: seat.persona,
+        status: signal.aborted ? "cancelled" : "failed",
+        ...metadata,
+        error: result.error
+      };
+    }
+    const parsed = parseVote(result.text, question, this.refusalOptionId);
+    if (!parsed.ok) {
+      return {
+        seatId: seat.id,
+        persona: seat.persona,
+        status: "invalid",
+        ...metadata,
+        error: parsed.error
+      };
+    }
+    return {
+      seatId: seat.id,
+      persona: seat.persona,
+      status: "valid",
+      ...parsed.vote,
+      ...metadata
+    };
+  }
+  async resolveOptionQuestion(question, profile, votes, signal, usage, startedAt, warnings, errors) {
+    const validVotes = votes.filter(
+      (vote) => vote.status === "valid" && typeof vote.optionId === "string"
+    );
+    const resolution = resolveCouncilVotes({
+      seats: profile.seats.map((seat) => ({
+        id: seat.id,
+        weight: seat.weight,
+        veto: seat.veto
+      })),
+      votes: validVotes.map((vote) => ({ seatId: vote.seatId, optionId: vote.optionId })),
+      refusalOptionId: this.refusalOptionId,
+      quorumFraction: profile.quorumFraction,
+      approvalFraction: profile.approvalFraction
+    });
+    if (resolution.status === "abstained") {
+      return resultEnvelope({
+        status: "abstained",
+        reason: "Council quorum was not met.",
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    if (resolution.status === "denied") {
+      return resultEnvelope({
+        status: "denied",
+        optionId: resolution.optionId,
+        reason: `Council denied the proposal via ${resolution.method}.`,
+        resolution: resolution.method,
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    if (resolution.status === "decided") {
+      return resultEnvelope({
+        status: "decided",
+        optionId: resolution.optionId,
+        answer: optionLabel(question, resolution.optionId),
+        resolution: "majority",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    if (!profile.judge) {
+      return resultEnvelope({
+        status: "abstained",
+        reason: `Council requires a judge (${resolution.reason}), but this profile has none.`,
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    const judged = await this.callJudge(
+      question,
+      profile,
+      votes,
+      profile.judge,
+      resolution.reason,
+      signal,
+      usage
+    );
+    if (!judged.ok) {
+      return resultEnvelope({
+        status: signal.aborted ? "cancelled" : "abstained",
+        reason: judged.error,
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors: [...errors, judged.error],
+        judgeUsed: true
+      });
+    }
+    if (judged.value.optionId === this.refusalOptionId) {
+      return resultEnvelope({
+        status: "denied",
+        optionId: this.refusalOptionId,
+        reason: judged.value.rationale ?? "Council judge refused all options.",
+        resolution: "judge",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors,
+        judgeUsed: true
+      });
+    }
+    return resultEnvelope({
+      status: "decided",
+      optionId: judged.value.optionId,
+      answer: optionLabel(question, judged.value.optionId),
+      reason: judged.value.rationale,
+      resolution: "judge",
+      votes,
+      profile,
+      usage,
+      startedAt,
+      warnings,
+      errors,
+      judgeUsed: true
+    });
+  }
+  async resolveOpenQuestion(question, profile, votes, signal, usage, startedAt, warnings, errors) {
+    const valid = votes.filter(
+      (vote) => vote.status === "valid" && typeof vote.stance === "string"
+    );
+    if (valid.length / profile.seats.length < profile.quorumFraction) {
+      return resultEnvelope({
+        status: "abstained",
+        reason: "Council quorum was not met.",
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    if (!profile.judge) {
+      const first = valid[0];
+      if (!first) {
+        return resultEnvelope({
+          status: "failed",
+          reason: "Council produced no valid stance.",
+          resolution: "none",
+          votes,
+          profile,
+          usage,
+          startedAt,
+          warnings,
+          errors
+        });
+      }
+      return resultEnvelope({
+        status: "decided",
+        answer: first.stance,
+        reason: first.rationale,
+        resolution: "first_stance",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    const judged = await this.callJudge(
+      question,
+      profile,
+      votes,
+      profile.judge,
+      "open_question_synthesis",
+      signal,
+      usage
+    );
+    if (!judged.ok) {
+      return resultEnvelope({
+        status: signal.aborted ? "cancelled" : "failed",
+        reason: judged.error,
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors: [...errors, judged.error],
+        judgeUsed: true
+      });
+    }
+    return resultEnvelope({
+      status: "decided",
+      answer: judged.value.answer,
+      reason: judged.value.rationale,
+      resolution: "judge",
+      votes,
+      profile,
+      usage,
+      startedAt,
+      warnings,
+      errors,
+      judgeUsed: true
+    });
+  }
+  async callJudge(question, profile, votes, target, reason, signal, usage) {
+    const result = await this.safeCall({
+      system: buildCouncilJudgeSystemPrompt(),
+      userPrompt: buildCouncilJudgeUserPrompt(question, votes, {
+        reason,
+        refusalOptionId: question.options?.length ? this.refusalOptionId : void 0
+      }),
+      target,
+      maxTokens: profile.judgeMaxTokens,
+      timeoutMs: profile.perCallTimeoutMs,
+      signal,
+      usage
+    });
+    if (result.error) return { ok: false, error: result.error };
+    return parseJudge(result.text, question, this.refusalOptionId);
+  }
+  async safeCall(input) {
+    try {
+      const result = await this.caller.call({
+        system: input.system,
+        userPrompt: input.userPrompt,
+        responseFormat: { type: "json_object" },
+        maxTokens: input.maxTokens,
+        timeoutMs: input.timeoutMs,
+        signal: input.signal,
+        ...input.target?.providerId ? { providerId: input.target.providerId } : {},
+        ...input.target?.model ? { model: input.target.model } : {},
+        ...input.target?.role ? { role: input.target.role } : {},
+        ...input.target?.fallbackProfile ? { fallbackProfile: input.target.fallbackProfile } : {},
+        ...input.target?.fallbackModels ? { fallbackModels: [...input.target.fallbackModels] } : {}
+      });
+      addUsage(input.usage, result);
+      return result;
+    } catch (error) {
+      input.usage.calls += 1;
+      return emptyCallResult(errorMessage(error));
+    }
+  }
+};
+function parseVote(text, question, refusalOptionId) {
+  const parsed = parseObject(text);
+  if (!parsed.ok) return parsed;
+  const rationale = optionalString(parsed.value["rationale"]);
+  if (question.options && question.options.length > 0) {
+    const optionId = optionalString(parsed.value["optionId"]);
+    const allowed = /* @__PURE__ */ new Set([...question.options.map((option) => option.id.trim()), refusalOptionId]);
+    if (!optionId || !allowed.has(optionId)) {
+      return { ok: false, error: "Voter returned an unknown or missing optionId." };
+    }
+    return { ok: true, vote: { optionId, ...rationale ? { rationale } : {} } };
+  }
+  const stance = optionalString(parsed.value["stance"]);
+  if (!stance) return { ok: false, error: "Voter returned an empty or missing stance." };
+  return { ok: true, vote: { stance, ...rationale ? { rationale } : {} } };
+}
+function parseJudge(text, question, refusalOptionId) {
+  const parsed = parseObject(text);
+  if (!parsed.ok) return parsed;
+  const rationale = optionalString(parsed.value["rationale"]);
+  if (question.options && question.options.length > 0) {
+    const optionId = optionalString(parsed.value["optionId"]);
+    const allowed = /* @__PURE__ */ new Set([...question.options.map((option) => option.id.trim()), refusalOptionId]);
+    if (!optionId || !allowed.has(optionId)) {
+      return { ok: false, error: "Judge returned an unknown or missing optionId." };
+    }
+    return { ok: true, value: { optionId, ...rationale ? { rationale } : {} } };
+  }
+  const answer = optionalString(parsed.value["answer"]);
+  if (!answer) return { ok: false, error: "Judge returned an empty or missing answer." };
+  return { ok: true, value: { answer, ...rationale ? { rationale } : {} } };
+}
+function parseObject(text) {
+  const trimmed = text.trim();
+  const first = trimmed.indexOf("{");
+  const last = trimmed.lastIndexOf("}");
+  if (first < 0 || last < first) return { ok: false, error: "LLM response did not contain JSON." };
+  try {
+    const value = JSON.parse(trimmed.slice(first, last + 1));
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return { ok: false, error: "LLM response JSON must be an object." };
+    }
+    return { ok: true, value };
+  } catch (error) {
+    return { ok: false, error: `Invalid LLM response JSON: ${errorMessage(error)}` };
+  }
+}
+function resultEnvelope(input) {
+  const validVoteCount = input.votes.filter((vote) => vote.status === "valid").length;
+  return {
+    status: input.status,
+    ...input.answer ? { answer: input.answer } : {},
+    ...input.optionId ? { optionId: input.optionId } : {},
+    ...input.reason ? { reason: input.reason } : {},
+    resolution: input.resolution,
+    votes: Object.freeze([...input.votes]),
+    configuredSeatCount: input.profile.seats.length,
+    validVoteCount,
+    distinctTargetCount: distinctTargetCount(input.votes, input.profile),
+    judgeUsed: input.judgeUsed ?? false,
+    usage: usageResult(input.usage, input.startedAt),
+    ...input.warnings.length > 0 ? { warnings: Object.freeze([...input.warnings]) } : {},
+    ...input.errors.length > 0 ? { errors: Object.freeze([...input.errors]) } : {}
+  };
+}
+function callMetadata(result) {
+  return {
+    ...result.provider ? { provider: result.provider } : {},
+    ...result.model ? { model: result.model } : {},
+    ...result.fromFallback ? { fromFallback: true } : {},
+    durationMs: result.durationMs
+  };
+}
+function addUsage(usage, result) {
+  usage.calls += 1;
+  usage.inputTokens += result.tokens.input;
+  usage.outputTokens += result.tokens.output;
+  usage.totalTokens += result.tokens.total;
+}
+function usageResult(usage, startedAt) {
+  return Object.freeze({ ...usage, durationMs: Math.max(0, Date.now() - startedAt) });
+}
+function cancelledVote(seat) {
+  return { seatId: seat.id, persona: seat.persona, status: "cancelled", error: "Cancelled." };
+}
+function distinctTargetCount(votes, profile) {
+  const keys = votes.filter((vote) => vote.status === "valid").map(
+    (vote) => profile.distinctness === "provider" ? vote.provider : `${vote.provider ?? ""}/${vote.model ?? ""}`
+  ).filter(Boolean);
+  return new Set(keys).size;
+}
+function distinctnessWarnings(votes, profile) {
+  if (profile.distinctness === "none") return [];
+  const valid = votes.filter((vote) => vote.status === "valid");
+  const distinct = distinctTargetCount(valid, profile);
+  if (valid.length > 1 && distinct < valid.length) {
+    return [
+      `Council distinctness policy "${profile.distinctness}" was not met: ${distinct} distinct target(s) served ${valid.length} valid vote(s).`
+    ];
+  }
+  return [];
+}
+function optionLabel(question, optionId) {
+  if (!optionId) return void 0;
+  return question.options?.find((option) => option.id.trim() === optionId)?.label.trim();
+}
+function validateRefusalCollision(question, refusalOptionId) {
+  if (question.options?.some((option) => option.id.trim() === refusalOptionId)) {
+    throw new Error(`CouncilOrchestrator: option id "${refusalOptionId}" is reserved.`);
+  }
+}
+function validateConcurrency(value) {
+  if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_COUNCIL_CONCURRENCY) {
+    throw new Error(
+      `CouncilOrchestrator: maxConcurrency must be an integer in [1, ${MAX_COUNCIL_CONCURRENCY}].`
+    );
+  }
+  return value;
+}
+async function mapConcurrent(items, concurrency, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+  const run = async () => {
+    while (true) {
+      const index = next++;
+      if (index >= items.length) return;
+      const item = items[index];
+      if (item !== void 0) results[index] = await worker(item, index);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => run()));
+  return results;
+}
+function emptyCallResult(error) {
+  return {
+    text: "",
+    model: "",
+    provider: "",
+    tokens: { input: 0, output: 0, total: 0 },
+    durationMs: 0,
+    fromFallback: false,
+    error
+  };
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/tools/council-tool.ts
+var COUNCIL_TOOL_NAME = "council";
+var MAX_COUNCIL_TOOL_OPTIONS = 12;
+var MAX_COUNCIL_QUESTION_CHARS = 2e4;
+var MAX_COUNCIL_CONTEXT_CHARS = 8e4;
+var INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    question: {
+      type: "string",
+      description: "The decision or open question for the Council.",
+      maxLength: MAX_COUNCIL_QUESTION_CHARS
+    },
+    context: {
+      type: "string",
+      description: "Optional evidence and constraints. Treated as untrusted quoted data.",
+      maxLength: MAX_COUNCIL_CONTEXT_CHARS
+    },
+    options: {
+      type: "array",
+      maxItems: MAX_COUNCIL_TOOL_OPTIONS,
+      items: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Stable option id." },
+          label: { type: "string", description: "Human-readable option label." },
+          consequence: { type: "string", description: "Optional consequence or trade-off." }
+        },
+        required: ["id", "label"],
+        additionalProperties: false
+      },
+      description: "Optional bounded list of choices. Omit for an open-ended Council answer."
+    },
+    profile: {
+      type: "string",
+      description: "Registered Council profile id. Defaults to the host-configured profile."
+    }
+  },
+  required: ["question"],
+  additionalProperties: false
+};
+function createCouncilTool(opts) {
+  const orchestrator = new CouncilOrchestrator(opts);
+  return {
+    name: COUNCIL_TOOL_NAME,
+    description: "Ask an independent, multi-persona Council to evaluate a decision or synthesize an answer. Uses bounded parallel voters, quorum/veto/weighted resolution, optional judging, model routing, fallback chains, and cancellation.",
+    usageHint: "Use for consequential or disputed decisions that benefit from independent lenses. Provide `options` for a vote or omit them for an open answer. Keep context evidence-focused; the Council treats it as untrusted data.",
+    category: "meta",
+    inputSchema: INPUT_SCHEMA,
+    permission: "auto",
+    mutating: false,
+    riskTier: "safe",
+    managesOwnTimeout: true,
+    maxOutputBytes: 256e3,
+    async execute(input, _ctx, { signal }) {
+      const question = {
+        question: input.question,
+        ...input.context ? { context: input.context } : {},
+        ...input.options ? { options: input.options } : {},
+        ...input.profile ? { profile: input.profile } : {},
+        signal
+      };
+      return orchestrator.ask(question);
+    },
+    validate: validateCouncilToolInput
+  };
+}
+function validateCouncilToolInput(input) {
+  const errors = [];
+  const question = input.question?.trim() ?? "";
+  if (!question) errors.push("`question` must not be empty.");
+  if (question.length > MAX_COUNCIL_QUESTION_CHARS) {
+    errors.push(`\`question\` must not exceed ${MAX_COUNCIL_QUESTION_CHARS} characters.`);
+  }
+  if ((input.context?.length ?? 0) > MAX_COUNCIL_CONTEXT_CHARS) {
+    errors.push(`\`context\` must not exceed ${MAX_COUNCIL_CONTEXT_CHARS} characters.`);
+  }
+  if ((input.options?.length ?? 0) > MAX_COUNCIL_TOOL_OPTIONS) {
+    errors.push(`\`options\` must not contain more than ${MAX_COUNCIL_TOOL_OPTIONS} items.`);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const option of input.options ?? []) {
+    const id = option.id.trim();
+    if (!id) errors.push("Every option must have a non-empty `id`.");
+    if (!option.label.trim()) errors.push(`Option "${id || "<empty>"}" must have a label.`);
+    if (ids.has(id)) errors.push(`Duplicate option id "${id}".`);
+    ids.add(id);
+  }
+  return errors;
+}
+
+// src/types/blocks.ts
+function isTextBlock(b) {
+  return b.type === "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 isFallbackWorthy(kind) {
+  return FALLBACK_WORTHY_BY_KIND[kind];
+}
+var FALLBACK_WORTHY_BY_KIND = {
+  rate_limit: true,
+  overloaded: true,
+  server: true,
+  timeout: true,
+  network: true,
+  stream_hang: true,
+  auth: false,
+  context_overflow: false,
+  content_filter: false,
+  invalid_request: false,
+  unknown: false
+};
+var ProviderError = class extends WrongStackError {
+  status;
+  retryable;
+  providerId;
+  /** Canonical failure classification — see {@link ProviderErrorKind}. */
+  kind;
+  body;
+  constructor(message, status, retryable, providerId, opts = {}) {
+    const kind = opts.kind ?? classifyProviderError(status, opts.body, message);
+    super({
+      message,
+      code: kindToCode(kind),
+      subsystem: "provider",
+      severity: status >= 500 ? "error" : "warning",
+      recoverable: retryable,
+      context: { providerId, status },
+      cause: opts.cause
+    });
+    this.name = "ProviderError";
+    this.status = status;
+    this.retryable = retryable;
+    this.providerId = providerId;
+    this.kind = kind;
+    this.body = opts.body;
+  }
+  /**
+   * Render a one-line, user-facing description. Designed for the CLI/TUI
+   * status line and the agent's retry warning. Avoids dumping raw JSON
+   * (which is what users see today when a 529 lands and the log message
+   * includes the full `{"type":"error",...}` body).
+   *
+   * Examples:
+   *   "minimax-coding-plan overloaded (529): High traffic detected. Upgrade for highspeed model. [req 06534785201de9c0…]"
+   *   "openai rate limited (429): Retry after 12s"
+   *   "anthropic invalid request (400): messages.0.role must be one of 'user'|'assistant'"
+   *   "groq HTTP 500 (server error)"
+   */
+  describe() {
+    const kind = describeStatus(this.status, this.body?.type);
+    const head = `${this.providerId} ${kind}`;
+    const detail = this.body?.message?.trim();
+    const reqId = this.body?.requestId ? ` [req ${this.body.requestId.slice(0, 16)}${this.body.requestId.length > 16 ? "\u2026" : ""}]` : "";
+    if (detail && detail.length > 0) {
+      return `${head}: ${truncate(detail, 240)}${reqId}`;
+    }
+    return `${head}${reqId}`;
+  }
+};
+function describeStatus(status, type) {
+  if (status === 0) return "network error";
+  if (status === 599) return `stream hang (${status})`;
+  if (type === "overloaded_error" || status === 529) return `overloaded (${status})`;
+  if (type === "rate_limit_error" || status === 429) return `rate limited (${status})`;
+  if (type === "authentication_error" || status === 401) return `auth failed (${status})`;
+  if (type === "permission_error" || status === 403) return `forbidden (${status})`;
+  if (type === "not_found_error" || status === 404) return `not found (${status})`;
+  if (type === "content_filter") return `content filtered (${status})`;
+  if (type === "invalid_request_error" || status === 400) return `invalid request (${status})`;
+  if (status === 408) return `timeout (${status})`;
+  if (status >= 500 && status < 600) return `HTTP ${status} (server error)`;
+  if (type) return `${type} (${status})`;
+  return `HTTP ${status}`;
+}
+var KIND_TO_CODE = {
+  network: ERROR_CODES.PROVIDER_NETWORK_ERROR,
+  timeout: ERROR_CODES.PROVIDER_NETWORK_ERROR,
+  rate_limit: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  auth: ERROR_CODES.PROVIDER_AUTH_FAILED,
+  overloaded: ERROR_CODES.PROVIDER_OVERLOADED,
+  context_overflow: ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW,
+  server: ERROR_CODES.PROVIDER_SERVER_ERROR,
+  stream_hang: ERROR_CODES.PROVIDER_SERVER_ERROR,
+  content_filter: ERROR_CODES.PROVIDER_INVALID_REQUEST,
+  invalid_request: ERROR_CODES.PROVIDER_INVALID_REQUEST,
+  unknown: ERROR_CODES.PROVIDER_INVALID_REQUEST
+};
+function kindToCode(kind) {
+  return KIND_TO_CODE[kind];
+}
+
+// src/core/fallback-model.ts
+function visibleProviderModels(config, providerId, providerModels) {
+  const entry = config.providers?.[providerId];
+  return entry?.models !== void 0 ? [...entry.models] : providerModels;
+}
+function parseModelRef(ref) {
+  const trimmed = ref.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash !== -1) {
+    return {
+      provider: trimmed.slice(0, slash) || void 0,
+      model: trimmed.slice(slash + 1).trim()
+    };
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length >= 2) {
+    return { provider: parts[0], model: parts.slice(1).join(" ") };
+  }
+  return { model: trimmed };
+}
+function formatModelRef(ref, defaultProvider) {
+  const provider = ref.provider ?? defaultProvider;
+  return provider ? `${provider}/${ref.model}` : ref.model;
+}
+function normalizeModelRef(ref, defaultProvider) {
+  const parsed = parseModelRef(ref);
+  return formatModelRef(parsed, defaultProvider);
+}
+function fallbackProfileChain(config, profileName) {
+  if (!profileName) return [];
+  const chain = config.fallbackProfiles?.[profileName];
+  return Array.isArray(chain) ? chain.filter((ref) => parseModelRef(ref).model) : [];
+}
+function providerHasKey(entry) {
+  if (!entry) return false;
+  if (typeof entry.apiKey === "string" && entry.apiKey.length > 0) return true;
+  if (Array.isArray(entry.apiKeys) && entry.apiKeys.some((k) => k?.apiKey)) return true;
+  if (Array.isArray(entry.envVars) && entry.envVars.some((v) => !!process.env[v])) return true;
+  return false;
+}
+var SMART_DEFAULT_MAX = 4;
+function smartDefaultFallbackChain(config) {
+  const leaderProvider = config.provider;
+  const leaderModel = config.model;
+  const providers = config.providers ?? {};
+  const favoriteSet = new Set(
+    (config.favoriteModels ?? []).map((ref) => normalizeModelRef(ref, leaderProvider))
+  );
+  const hasFavorites = favoriteSet.size > 0;
+  const favoritesOnly = config.favoriteModelsOnly === true;
+  const seen = /* @__PURE__ */ new Set();
+  const favoriteRefs = [];
+  const sameProvider = [];
+  const crossProvider = [];
+  const ids = Object.keys(providers).sort(
+    (a, b) => a === leaderProvider ? -1 : b === leaderProvider ? 1 : a.localeCompare(b)
+  );
+  for (const id of ids) {
+    const entry = providers[id];
+    if (!providerHasKey(entry)) continue;
+    const models = visibleProviderModels(config, id, entry?.models ?? []);
+    for (const model of models) {
+      if (id === leaderProvider && model === leaderModel) continue;
+      const ref = `${id}/${model}`;
+      if (seen.has(ref)) continue;
+      seen.add(ref);
+      if (favoriteSet.has(ref)) {
+        favoriteRefs.push(ref);
+        continue;
+      }
+      if (favoritesOnly && hasFavorites) continue;
+      (id === leaderProvider ? sameProvider : crossProvider).push(ref);
+    }
+  }
+  return [...favoriteRefs, ...sameProvider, ...crossProvider].slice(0, SMART_DEFAULT_MAX);
+}
+function effectiveFallbackChain(config) {
+  const explicit = config.fallbackModels ?? [];
+  const filteredExplicit = explicit.filter((ref) => {
+    const parsed = parseModelRef(ref);
+    if (!parsed.model) return false;
+    const providerId = parsed.provider ?? config.provider;
+    const entry = config.providers?.[providerId];
+    if (!entry?.models) return true;
+    return entry.models.includes(parsed.model);
+  });
+  if (filteredExplicit.length > 0) return filteredExplicit;
+  if (config.fallbackAuto === false) return [];
+  return smartDefaultFallbackChain(config);
+}
+var DEFAULT_PRIMARY_COOLDOWN_MAX_MS = 10 * 6e4;
+
+// src/execution/one-shot-llm.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_TOKENS = 1024;
+var OneShotOrchestrator = class {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Make a one-shot LLM call. Resolves provider+model, applies fallback
+   * chain on transient errors, and returns a structured result.
+   *
+   * Never throws — all errors are captured in `OneShotLLMResult.error`.
+   */
+  async call(input) {
+    const startedAt = performance.now();
+    const config = this.opts.getConfig();
+    const target = this.resolveTarget(input, config);
+    if (!target) {
+      return {
+        text: "",
+        model: input.model ?? config.model ?? "unknown",
+        provider: input.providerId ?? config.provider ?? "unknown",
+        tokens: { input: 0, output: 0, total: 0 },
+        durationMs: Math.round(performance.now() - startedAt),
+        fromFallback: false,
+        error: "No provider or model could be resolved. Check your config."
+      };
+    }
+    let provider;
+    try {
+      provider = await this.opts.buildProvider(target.providerId, target.model);
+    } catch (err) {
+      return {
+        text: "",
+        model: target.model,
+        provider: target.providerId,
+        tokens: { input: 0, output: 0, total: 0 },
+        durationMs: Math.round(performance.now() - startedAt),
+        fromFallback: false,
+        error: `Cannot build provider "${target.providerId}": ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const request = this.buildRequest(input, target.model);
+    const signal = this.resolveSignal(input);
+    const chain = this.resolveFallbackChain(input, config, target);
+    let servingProviderId = provider.id;
+    let servingModel = target.model;
+    let fromFallback = false;
+    const primaryAttempt = await this.tryCall(provider, request, signal);
+    let result = primaryAttempt.response;
+    let lastError = primaryAttempt.error;
+    let fallbackEligible = primaryAttempt.fallbackEligible;
+    if (!result && fallbackEligible && chain.length > 0) {
+      for (const ref of chain) {
+        const parsed = parseModelRef(ref);
+        if (!parsed.model) continue;
+        const fbProviderId = parsed.provider ?? config.provider;
+        if (fbProviderId === provider.id && parsed.model === target.model) continue;
+        servingProviderId = fbProviderId;
+        servingModel = parsed.model;
+        let fbProvider;
+        try {
+          fbProvider = await this.opts.buildProvider(fbProviderId, parsed.model);
+        } catch (err) {
+          lastError = err;
+          continue;
+        }
+        servingProviderId = fbProvider.id;
+        const attempt = await this.tryCall(
+          fbProvider,
+          this.buildRequest(input, parsed.model),
+          signal
+        );
+        if (attempt.response) {
+          result = attempt.response;
+          fromFallback = true;
+          break;
+        }
+        lastError = attempt.error;
+        fallbackEligible = attempt.fallbackEligible;
+        if (!fallbackEligible) break;
+      }
+    }
+    const elapsed = Math.round(performance.now() - startedAt);
+    if (result) {
+      const textBlocks = result.content.filter(isTextBlock);
+      const text = textBlocks.map((b) => b.text).join("\n").trim();
+      return {
+        text: text || "(empty response)",
+        model: result.model ?? servingModel,
+        provider: servingProviderId,
+        tokens: {
+          input: result.usage?.input ?? 0,
+          output: result.usage?.output ?? 0,
+          total: (result.usage?.input ?? 0) + (result.usage?.output ?? 0)
+        },
+        durationMs: elapsed,
+        fromFallback,
+        stopReason: result.stopReason
+      };
+    }
+    return {
+      text: "",
+      model: servingModel,
+      provider: servingProviderId,
+      tokens: { input: 0, output: 0, total: 0 },
+      durationMs: elapsed,
+      fromFallback,
+      error: lastError instanceof Error ? lastError.message : String(lastError ?? "Unknown error")
+    };
+  }
+  // ── Private helpers ─────────────────────────────────────────────
+  /**
+   * Resolve the target provider + model from input + config.
+   * Priority: role-based routing > explicit providerId+model > defaults.
+   */
+  resolveTarget(input, config) {
+    if (input.role && this.opts.modelRouter) {
+      const pick = this.opts.modelRouter.pickForTask(input.role, "");
+      if (pick) {
+        return { providerId: pick.provider, model: pick.model };
+      }
+    }
+    if (input.providerId && input.model) {
+      return { providerId: input.providerId, model: input.model };
+    }
+    if (input.model) {
+      return { providerId: config.provider, model: input.model };
+    }
+    if (input.providerId) {
+      return { providerId: input.providerId, model: config.model };
+    }
+    if (config.provider && config.model) {
+      return { providerId: config.provider, model: config.model };
+    }
+    return void 0;
+  }
+  /**
+   * Build a Provider Request from the input.
+   */
+  buildRequest(input, model) {
+    const messages = [...input.messages ?? []];
+    if (input.userPrompt) {
+      messages.push({ role: "user", content: input.userPrompt });
+    }
+    const system = asTextBlocks(input.system);
+    return {
+      model,
+      ...system.length > 0 ? { system } : {},
+      messages,
+      maxTokens: input.maxTokens ?? DEFAULT_MAX_TOKENS,
+      ...input.temperature !== void 0 ? { temperature: input.temperature } : {},
+      ...input.responseFormat ? { responseFormat: input.responseFormat } : {}
+    };
+  }
+  /**
+   * Resolve the abort signal. Provider calls always receive the per-call
+   * timeout, composed with external cancellation when the caller supplies it.
+   */
+  resolveSignal(input) {
+    const timeoutSignal = AbortSignal.timeout(input.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    return input.signal ? AbortSignal.any([input.signal, timeoutSignal]) : timeoutSignal;
+  }
+  /**
+   * Build the fallback model chain from input + config + current target.
+   */
+  resolveFallbackChain(input, config, target) {
+    if (input.fallbackModels && input.fallbackModels.length > 0) {
+      return input.fallbackModels;
+    }
+    if (input.fallbackProfile) {
+      const profile = fallbackProfileChain(config, input.fallbackProfile);
+      if (profile.length > 0) return profile;
+    }
+    if (config.fallbackAuto !== false) {
+      return effectiveFallbackChain(config).filter((ref) => {
+        const parsed = parseModelRef(ref);
+        const fbProvider = parsed.provider ?? config.provider;
+        return !(fbProvider === target.providerId && parsed.model === target.model);
+      });
+    }
+    return [];
+  }
+  /** Attempt a provider call while preserving the actual failure for callers. */
+  async tryCall(provider, request, signal) {
+    try {
+      return {
+        response: await provider.complete(request, { signal }),
+        fallbackEligible: false
+      };
+    } catch (err) {
+      return {
+        error: err,
+        fallbackEligible: !signal.aborted && (!(err instanceof ProviderError) || isFallbackWorthy(err.kind))
+      };
+    }
+  }
+};
+function asTextBlocks(system) {
+  if (!system) return [];
+  if (Array.isArray(system)) return system;
+  return [{ type: "text", text: system }];
+}
+
+// src/tools/one-shot-llm-tool.ts
+var ONE_SHOT_LLM_TOOL_NAME = "llm";
+var INPUT_SCHEMA2 = {
+  type: "object",
+  properties: {
+    system: {
+      type: "string",
+      description: "System prompt guiding the LLM behaviour."
+    },
+    userPrompt: {
+      type: "string",
+      description: "Single user turn \u2014 appended as a user-role message."
+    },
+    messages: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          role: {
+            type: "string",
+            enum: ["system", "user", "assistant", "tool"],
+            description: "Message author role."
+          },
+          content: {
+            type: "string",
+            description: "Message text content."
+          }
+        },
+        required: ["role", "content"],
+        additionalProperties: true
+      },
+      description: "Conversation messages for few-shot examples or multi-turn context. Appended before userPrompt when both are set."
+    },
+    model: {
+      type: "string",
+      description: 'Model id (e.g. "deepseek-chat", "gpt-4o-mini"). Defaults to session model.'
+    },
+    providerId: {
+      type: "string",
+      description: 'Provider id (e.g. "anthropic", "openai"). Defaults to session provider.'
+    },
+    role: {
+      type: "string",
+      description: "Roster role for model-matrix routing. Overrides model/providerId."
+    },
+    fallbackProfile: {
+      type: "string",
+      description: "Named fallback profile from config.fallbackProfiles."
+    },
+    fallbackModels: {
+      type: "array",
+      items: { type: "string" },
+      description: 'Explicit fallback model chain (e.g. ["anthropic/claude-haiku", "openai/gpt-4o-mini"]).'
+    },
+    maxTokens: {
+      type: "number",
+      description: "Maximum output tokens (default 1024)."
+    },
+    responseFormat: {
+      oneOf: [
+        { type: "string", enum: ["text", "json_object"], description: "Simple response format." },
+        {
+          type: "object",
+          properties: {
+            type: { type: "string", enum: ["json_schema"], description: "Structured JSON output." },
+            json_schema: {
+              type: "object",
+              description: "JSON Schema definition for the structured output."
+            }
+          },
+          required: ["type"],
+          additionalProperties: false
+        }
+      ],
+      description: 'Response format: "text" (default), "json_object", or { type: "json_schema", json_schema: {...} }.'
+    },
+    temperature: {
+      type: "number",
+      description: "Sampling temperature."
+    },
+    timeoutMs: {
+      type: "number",
+      description: "Hard timeout in ms (default 30s)."
+    }
+  }
+};
+function createOneShotLLMTool(opts) {
+  const orchestrator = new OneShotOrchestrator({
+    buildProvider: opts.buildProvider,
+    getConfig: opts.getConfig,
+    modelRouter: opts.modelRouter,
+    logger: opts.logger
+  });
+  return {
+    name: ONE_SHOT_LLM_TOOL_NAME,
+    description: "Make a one-shot LLM call with a system prompt and user input. Supports provider selection, model routing by role, fallback chains, and timeout. Returns the response text, model info, token usage, and whether a fallback was used. Use this for summarization, classification, extraction, and any single-turn LLM task.",
+    usageHint: "Provide `system` for the instruction and `userPrompt` for the input. Either set `model`+`providerId`, or have defaults configured on the tool. Set `fallbackProfile` or `fallbackModels` for resilience. Check `error` on the result for failure details.",
+    inputSchema: INPUT_SCHEMA2,
+    permission: "auto",
+    mutating: false,
+    async execute(input, _ctx, { signal }) {
+      if (!input.model && !input.providerId && !opts.defaultModel && !opts.defaultProvider) {
+        return {
+          text: "",
+          model: "",
+          provider: "",
+          tokens: { input: 0, output: 0, total: 0 },
+          durationMs: 0,
+          fromFallback: false,
+          error: "Either provide `model` and `providerId` in the call, or configure defaultProvider/defaultModel when creating the tool. The `llm` tool does not infer provider/model from the session by default."
+        };
+      }
+      const effectiveInput = {
+        ...input,
+        signal: input.signal ? AbortSignal.any([input.signal, signal]) : signal,
+        model: input.model ?? opts.defaultModel,
+        providerId: input.providerId ?? opts.defaultProvider
+      };
+      return orchestrator.call(effectiveInput);
+    }
+  };
+}
 export {
-  createMcpControlTool
+  COUNCIL_TOOL_NAME,
+  MAX_COUNCIL_CONTEXT_CHARS,
+  MAX_COUNCIL_QUESTION_CHARS,
+  MAX_COUNCIL_TOOL_OPTIONS,
+  ONE_SHOT_LLM_TOOL_NAME,
+  createCouncilTool,
+  createMcpControlTool,
+  createOneShotLLMTool
 };
 //# sourceMappingURL=index.js.map