@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-PFCMSSUF.js

@@ -0,0 +1,1640 @@
+import {
+  readBundledInstructionText,
+  renderInstructionTemplate
+} from "./chunk-5S437PRC.js";
+import {
+  evaluateModelCalendar
+} from "./chunk-WQQON3SV.js";
+import {
+  estimateRequestTokens
+} from "./chunk-HMLIGAU7.js";
+import {
+  ProviderError,
+  isFallbackWorthy
+} from "./chunk-3ECENVHL.js";
+import {
+  isTextBlock
+} from "./chunk-O37BQ65S.js";
+
+// src/execution/council-orchestrator-helpers.ts
+var COUNCIL_REFUSAL_OPTION_ID = "council_refuse";
+var DEFAULT_COUNCIL_MAX_CONCURRENCY = 3;
+var MAX_COUNCIL_CONCURRENCY = 8;
+var OVERALL_TIMEOUT_REASON = "Council overall timeout exceeded.";
+var CALL_CANCELLED_REASON = "Cancelled.";
+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;
+}
+function validateRefusalCollision(question, refusalOptionId) {
+  if (question.options?.some((option) => option.id.trim() === refusalOptionId)) {
+    throw new Error(`CouncilOrchestrator: option id "${refusalOptionId}" is reserved.`);
+  }
+}
+function optionLabel(question, optionId) {
+  if (!optionId) return void 0;
+  return question.options?.find((option) => option.id.trim() === optionId)?.label.trim();
+}
+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 distinctTargetKeys(votes, profile) {
+  const keys = [];
+  for (const vote of votes) {
+    if (vote.status !== "valid") continue;
+    const provider = vote.provider?.trim() ?? "";
+    const model = vote.model?.trim() ?? "";
+    if (profile.distinctness === "provider") {
+      if (provider) keys.push(provider);
+    } else if (provider || model) {
+      keys.push(`${provider}/${model}`);
+    }
+  }
+  return keys;
+}
+function distinctTargetCount(votes, profile) {
+  return new Set(distinctTargetKeys(votes, profile)).size;
+}
+function distinctnessWarnings(votes, profile) {
+  if (profile.distinctness === "none") return [];
+  const keys = distinctTargetKeys(votes, profile);
+  const distinct = new Set(keys).size;
+  if (keys.length > 1 && distinct < keys.length) {
+    return [
+      `Council distinctness policy "${profile.distinctness}" was not met: ${distinct} distinct target(s) served ${keys.length} valid vote(s).`
+    ];
+  }
+  return [];
+}
+function cancelledVote(seat) {
+  return {
+    seatId: seat.id,
+    persona: seat.persona,
+    status: "cancelled",
+    ...seat.target?.providerId ? { provider: seat.target.providerId } : {},
+    ...seat.target?.model ? { model: seat.target.model } : {},
+    durationMs: 0,
+    error: CALL_CANCELLED_REASON
+  };
+}
+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 += Math.max(1, result.attempts ?? 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 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]) } : {}
+  };
+}
+
+// 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 BUILTIN_COUNCIL_PERSONA_IDS = Object.freeze(
+  BUILTIN_COUNCIL_PERSONAS.map((persona) => persona.id)
+);
+var CouncilPersonaRegistry = class _CouncilPersonaRegistry {
+  byId;
+  constructor(personas = []) {
+    const entries = /* @__PURE__ */ new Map();
+    for (const persona of personas) {
+      const normalized = freezePersona(persona);
+      if (entries.has(normalized.id)) {
+        throw new Error(`CouncilPersonaRegistry: duplicate persona id "${normalized.id}".`);
+      }
+      entries.set(normalized.id, normalized);
+    }
+    this.byId = entries;
+  }
+  has(id) {
+    return this.byId.has(id);
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  require(id) {
+    const persona = this.get(id);
+    if (!persona) throw new Error(`CouncilPersonaRegistry: unknown persona "${id}".`);
+    return persona;
+  }
+  list() {
+    return Object.freeze([...this.byId.values()]);
+  }
+  /** Return a new registry; the current registry is never mutated. */
+  with(persona, opts = {}) {
+    const normalized = freezePersona(persona);
+    if (this.has(normalized.id) && opts.replace !== true) {
+      throw new Error(`CouncilPersonaRegistry: persona "${normalized.id}" already exists.`);
+    }
+    return new _CouncilPersonaRegistry([
+      ...this.list().filter((entry) => entry.id !== normalized.id),
+      normalized
+    ]);
+  }
+};
+var DEFAULT_COUNCIL_PERSONA_REGISTRY = new CouncilPersonaRegistry(
+  BUILTIN_COUNCIL_PERSONAS
+);
+function createCouncilPersonaRegistry(additional = []) {
+  let registry = DEFAULT_COUNCIL_PERSONA_REGISTRY;
+  for (const persona of additional) registry = registry.with(persona);
+  return registry;
+}
+function freezePersona(persona) {
+  const id = persona.id.trim();
+  const name = persona.name.trim();
+  const description = persona.description.trim();
+  const instruction = persona.instruction.trim();
+  if (!PERSONA_ID_RE.test(id)) {
+    throw new Error(`CouncilPersonaRegistry: invalid persona id "${persona.id}".`);
+  }
+  if (!name) throw new Error(`CouncilPersonaRegistry: persona "${id}" requires a name.`);
+  if (!description) {
+    throw new Error(`CouncilPersonaRegistry: persona "${id}" requires a description.`);
+  }
+  if (!instruction) {
+    throw new Error(`CouncilPersonaRegistry: persona "${id}" requires an instruction.`);
+  }
+  if (persona.defaultWeight !== void 0 && (!Number.isFinite(persona.defaultWeight) || persona.defaultWeight <= 0)) {
+    throw new Error(`CouncilPersonaRegistry: persona "${id}" has an invalid default weight.`);
+  }
+  const tags = Object.freeze(
+    [...new Set((persona.tags ?? []).map((tag) => tag.trim()).filter(Boolean))]
+  );
+  return Object.freeze({
+    id,
+    name,
+    description,
+    instruction,
+    ...persona.defaultWeight !== void 0 ? { defaultWeight: persona.defaultWeight } : {},
+    ...persona.defaultVeto !== void 0 ? { defaultVeto: persona.defaultVeto } : {},
+    ...tags.length > 0 ? { tags } : {}
+  });
+}
+
+// src/execution/council-profiles.ts
+var PROFILE_ID_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var DISTINCTNESS_VALUES = /* @__PURE__ */ new Set([
+  "none",
+  "model",
+  "provider"
+]);
+var DEFAULT_COUNCIL_QUORUM_FRACTION = 0.5;
+var DEFAULT_COUNCIL_APPROVAL_FRACTION = 0.5;
+var DEFAULT_COUNCIL_VOTER_MAX_TOKENS = 300;
+var DEFAULT_COUNCIL_JUDGE_MAX_TOKENS = 500;
+var DEFAULT_COUNCIL_PER_CALL_TIMEOUT_MS = 3e4;
+var DEFAULT_COUNCIL_OVERALL_TIMEOUT_MS = 9e4;
+var BUILTIN_COUNCIL_PROFILES = Object.freeze([
+  Object.freeze({
+    id: "balanced",
+    name: "Balanced",
+    description: "Three complementary lenses plus an independent judge for general decisions.",
+    seats: Object.freeze([
+      Object.freeze({ persona: "executor", target: Object.freeze({ role: "planner" }) }),
+      Object.freeze({ persona: "skeptic", target: Object.freeze({ role: "critic" }) }),
+      Object.freeze({ persona: "auditor", target: Object.freeze({ role: "analyst" }) })
+    ]),
+    judge: Object.freeze({ role: "reviewer" }),
+    quorumFraction: 0.5,
+    approvalFraction: 0.5,
+    distinctness: "model"
+  }),
+  Object.freeze({
+    id: "fast",
+    name: "Fast",
+    description: "Two-seat panel without a judge for quick, low-cost decisions.",
+    seats: Object.freeze([
+      Object.freeze({ persona: "executor", target: Object.freeze({ role: "planner" }) }),
+      Object.freeze({ persona: "skeptic", target: Object.freeze({ role: "critic" }) })
+    ]),
+    judge: false,
+    quorumFraction: 0.5,
+    approvalFraction: 0.5,
+    distinctness: "none",
+    voterMaxTokens: 200,
+    perCallTimeoutMs: 2e4,
+    overallTimeoutMs: 3e4
+  }),
+  Object.freeze({
+    id: "risk-review",
+    name: "Risk Review",
+    description: "Security, assumptions, maintenance, and cost review for high-impact choices.",
+    seats: Object.freeze([
+      Object.freeze({ persona: "skeptic", target: Object.freeze({ role: "critic" }) }),
+      Object.freeze({ persona: "security", target: Object.freeze({ role: "security-reviewer" }) }),
+      Object.freeze({ persona: "maintainer", target: Object.freeze({ role: "reviewer" }) }),
+      Object.freeze({ persona: "auditor", target: Object.freeze({ role: "analyst" }) })
+    ]),
+    judge: Object.freeze({ role: "architect" }),
+    quorumFraction: 0.75,
+    approvalFraction: 0.5,
+    distinctness: "provider",
+    judgeMaxTokens: 700,
+    overallTimeoutMs: 12e4
+  })
+]);
+var CouncilProfileRegistry = class _CouncilProfileRegistry {
+  byId;
+  personas;
+  constructor(profiles = [], personas = DEFAULT_COUNCIL_PERSONA_REGISTRY) {
+    this.personas = personas;
+    const entries = /* @__PURE__ */ new Map();
+    for (const profile of profiles) {
+      const normalized = normalizeCouncilProfile(profile, personas);
+      if (entries.has(normalized.id)) {
+        throw new Error(`CouncilProfileRegistry: duplicate profile id "${normalized.id}".`);
+      }
+      entries.set(normalized.id, normalized);
+    }
+    this.byId = entries;
+  }
+  has(id) {
+    return this.byId.has(id);
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  require(id) {
+    const profile = this.get(id);
+    if (!profile) throw new Error(`CouncilProfileRegistry: unknown profile "${id}".`);
+    return profile;
+  }
+  list() {
+    return Object.freeze([...this.byId.values()]);
+  }
+  /** Return a new registry; the current registry is never mutated. */
+  with(profile, opts = {}) {
+    const personas = opts.personas ?? this.personas;
+    const normalized = normalizeCouncilProfile(profile, personas);
+    if (this.has(normalized.id) && opts.replace !== true) {
+      throw new Error(`CouncilProfileRegistry: profile "${normalized.id}" already exists.`);
+    }
+    return new _CouncilProfileRegistry(
+      [
+        ...this.list().filter((entry) => entry.id !== normalized.id),
+        profile
+      ],
+      personas
+    );
+  }
+};
+var DEFAULT_COUNCIL_PROFILE_REGISTRY = new CouncilProfileRegistry(
+  BUILTIN_COUNCIL_PROFILES
+);
+function createCouncilProfileRegistry(additional = [], personas = DEFAULT_COUNCIL_PERSONA_REGISTRY) {
+  return new CouncilProfileRegistry([...BUILTIN_COUNCIL_PROFILES, ...additional], personas);
+}
+function resolveCouncilProfile(profile, opts = {}) {
+  const personas = opts.personas ?? DEFAULT_COUNCIL_PERSONA_REGISTRY;
+  if (profile && typeof profile !== "string") return normalizeCouncilProfile(profile, personas);
+  const id = profile ?? opts.defaultProfile ?? "balanced";
+  return (opts.registry ?? DEFAULT_COUNCIL_PROFILE_REGISTRY).require(id);
+}
+function normalizeCouncilProfile(profile, personas = DEFAULT_COUNCIL_PERSONA_REGISTRY) {
+  const id = profile.id.trim();
+  if (!PROFILE_ID_RE.test(id)) {
+    throw new Error(`CouncilProfileRegistry: invalid profile id "${profile.id}".`);
+  }
+  if (profile.seats.length === 0) {
+    throw new Error(`CouncilProfileRegistry: profile "${id}" requires at least one seat.`);
+  }
+  const usedIds = /* @__PURE__ */ new Set();
+  const seats = profile.seats.map((seat) => {
+    const persona = personas.require(seat.persona.trim());
+    const explicitSeatId = seat.id?.trim();
+    if (explicitSeatId && usedIds.has(explicitSeatId)) {
+      throw new Error(`CouncilProfileRegistry: duplicate seat id "${explicitSeatId}".`);
+    }
+    const seatId = uniqueSeatId(explicitSeatId || persona.id, usedIds);
+    const label = seat.label?.trim() || persona.name;
+    const weight = seat.weight ?? persona.defaultWeight ?? 1;
+    if (!Number.isFinite(weight) || weight <= 0) {
+      throw new Error(`CouncilProfileRegistry: seat "${seatId}" has an invalid weight.`);
+    }
+    return Object.freeze({
+      id: seatId,
+      label,
+      persona: persona.id,
+      ...seat.target ? { target: freezeTarget(seat.target, `seat "${seatId}"`) } : {},
+      weight,
+      veto: seat.veto ?? persona.defaultVeto ?? false
+    });
+  });
+  const quorumFraction = fraction(
+    profile.quorumFraction ?? DEFAULT_COUNCIL_QUORUM_FRACTION,
+    "quorumFraction",
+    id
+  );
+  const approvalFraction = fraction(
+    profile.approvalFraction ?? DEFAULT_COUNCIL_APPROVAL_FRACTION,
+    "approvalFraction",
+    id
+  );
+  const distinctness = profile.distinctness ?? "model";
+  if (!DISTINCTNESS_VALUES.has(distinctness)) {
+    throw new Error(`CouncilProfileRegistry: profile "${id}" has invalid distinctness.`);
+  }
+  const voterMaxTokens = positiveInteger(
+    profile.voterMaxTokens ?? DEFAULT_COUNCIL_VOTER_MAX_TOKENS,
+    "voterMaxTokens",
+    id
+  );
+  const judgeMaxTokens = positiveInteger(
+    profile.judgeMaxTokens ?? DEFAULT_COUNCIL_JUDGE_MAX_TOKENS,
+    "judgeMaxTokens",
+    id
+  );
+  const perCallTimeoutMs = positiveInteger(
+    profile.perCallTimeoutMs ?? DEFAULT_COUNCIL_PER_CALL_TIMEOUT_MS,
+    "perCallTimeoutMs",
+    id
+  );
+  const overallTimeoutMs = positiveInteger(
+    profile.overallTimeoutMs ?? DEFAULT_COUNCIL_OVERALL_TIMEOUT_MS,
+    "overallTimeoutMs",
+    id
+  );
+  if (overallTimeoutMs < perCallTimeoutMs) {
+    throw new Error(
+      `CouncilProfileRegistry: profile "${id}" overallTimeoutMs must be at least perCallTimeoutMs.`
+    );
+  }
+  return Object.freeze({
+    id,
+    name: profile.name?.trim() || id,
+    description: profile.description?.trim() || "",
+    seats: Object.freeze(seats),
+    judge: profile.judge ? freezeTarget(profile.judge, "judge") : false,
+    quorumFraction,
+    approvalFraction,
+    distinctness,
+    voterMaxTokens,
+    judgeMaxTokens,
+    perCallTimeoutMs,
+    overallTimeoutMs
+  });
+}
+function uniqueSeatId(base, used) {
+  if (!PROFILE_ID_RE.test(base)) {
+    throw new Error(`CouncilProfileRegistry: invalid seat id "${base}".`);
+  }
+  let id = base;
+  let suffix = 2;
+  while (used.has(id)) id = `${base}-${suffix++}`;
+  used.add(id);
+  return id;
+}
+function freezeTarget(target, label) {
+  const providerId = optionalText(target.providerId);
+  const model = optionalText(target.model);
+  const role = optionalText(target.role);
+  const fallbackProfile = optionalText(target.fallbackProfile);
+  const fallbackModels = Object.freeze(
+    [...new Set((target.fallbackModels ?? []).map((ref) => ref.trim()).filter(Boolean))]
+  );
+  if (!providerId && !model && !role && !fallbackProfile && fallbackModels.length === 0) {
+    throw new Error(`CouncilProfileRegistry: ${label} target is empty.`);
+  }
+  return Object.freeze({
+    ...providerId ? { providerId } : {},
+    ...model ? { model } : {},
+    ...role ? { role } : {},
+    ...fallbackProfile ? { fallbackProfile } : {},
+    ...fallbackModels.length > 0 ? { fallbackModels } : {}
+  });
+}
+function optionalText(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function fraction(value, field, profileId) {
+  if (!Number.isFinite(value) || value <= 0 || value > 1) {
+    throw new Error(`CouncilProfileRegistry: profile "${profileId}" ${field} must be in (0, 1].`);
+  }
+  return value;
+}
+function positiveInteger(value, field, profileId) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(
+      `CouncilProfileRegistry: profile "${profileId}" ${field} must be a positive integer.`
+    );
+  }
+  return value;
+}
+
+// src/execution/council-prompts.ts
+var COUNCIL_VOTER_PROMPT_PATH = "llm/council-voter.md";
+var COUNCIL_JUDGE_PROMPT_PATH = "llm/council-judge.md";
+function buildCouncilVoterSystemPrompt(persona) {
+  const template = requiredInstruction(COUNCIL_VOTER_PROMPT_PATH);
+  return renderInstructionTemplate(template, {
+    personaInstruction: persona.instruction
+  });
+}
+function buildCouncilJudgeSystemPrompt() {
+  return requiredInstruction(COUNCIL_JUDGE_PROMPT_PATH);
+}
+function buildCouncilQuestionPrompt(question, opts = {}) {
+  const text = question.question.trim();
+  if (!text) throw new Error("buildCouncilQuestionPrompt: question must not be empty.");
+  const options = normalizeOptions(question.options);
+  return [
+    "<council-question>",
+    `Question: ${text}`,
+    question.context?.trim() ? `Context:
+${question.context.trim()}` : "",
+    options.length > 0 ? `Options (JSON):
+${JSON.stringify(options)}` : "Options: none",
+    opts.refusalOptionId ? `Refusal option id: ${opts.refusalOptionId}` : "Refusal option id: not supplied",
+    "</council-question>"
+  ].filter(Boolean).join("\n\n");
+}
+function buildCouncilVoterUserPrompt(question, seat, opts = {}) {
+  return [
+    buildCouncilQuestionPrompt(question, opts),
+    "<seat-metadata>",
+    `Seat id: ${seat.id}`,
+    `Seat label: ${seat.label}`,
+    `Persona id: ${seat.persona}`,
+    `Vote weight: ${seat.weight}`,
+    seat.veto ? "Veto power: yes \u2014 your refusal unilaterally denies the proposal." : "",
+    "</seat-metadata>"
+  ].filter(Boolean).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 validateCouncilOptions(options) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const option of 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 (seen.has(id)) errors.push(`Duplicate option id "${id}".`);
+    seen.add(id);
+  }
+  return errors;
+}
+function normalizeOptions(options) {
+  if (!options) return [];
+  const errors = validateCouncilOptions(options);
+  if (errors.length > 0) {
+    throw new Error(`buildCouncilQuestionPrompt: ${errors.join("; ")}`);
+  }
+  return options.map((option) => ({
+    id: option.id.trim(),
+    label: option.label.trim(),
+    ...option.consequence?.trim() ? { consequence: option.consequence.trim() } : {}
+  }));
+}
+function requiredInstruction(path) {
+  const text = readBundledInstructionText(path);
+  if (!text) throw new Error(`Council instruction file is unavailable: ${path}`);
+  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-response-parser.ts
+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 optionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function parseCouncilResponse(text, question, refusalOptionId, opts) {
+  const roleLabel = opts.role === "judge" ? "Judge" : "Voter";
+  const parsed = parseObject(text);
+  if (!parsed.ok && (!question.options || question.options.length === 0)) {
+    const fallback = text.trim();
+    if (fallback) return { ok: true, value: { [opts.freeTextField]: fallback } };
+    return { ok: false, error: `${roleLabel} returned an empty response.` };
+  }
+  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: `${roleLabel} returned an unknown or missing optionId.` };
+    }
+    return { ok: true, value: { optionId, ...rationale ? { rationale } : {} } };
+  }
+  const freeText = optionalString(parsed.value[opts.freeTextField]);
+  if (!freeText) {
+    return {
+      ok: false,
+      error: `${roleLabel} returned an empty or missing ${opts.freeTextField}.`
+    };
+  }
+  return {
+    ok: true,
+    value: { [opts.freeTextField]: freeText, ...rationale ? { rationale } : {} }
+  };
+}
+function divergentStances(valid) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const vote of valid) {
+    const normalized = vote.stance.trim().replace(/^["'`]+|["'`]+$/g, "").toLowerCase().replace(/[.!?;:,]+$/g, "").replace(/\s+/g, " ").trim();
+    if (!normalized) return true;
+    seen.add(normalized);
+    if (seen.size > 1) return true;
+  }
+  return false;
+}
+function parseVote(text, question, refusalOptionId) {
+  const parsed = parseCouncilResponse(text, question, refusalOptionId, {
+    role: "voter",
+    freeTextField: "stance"
+  });
+  if (!parsed.ok) return parsed;
+  const { optionId, stance, rationale } = parsed.value;
+  return {
+    ok: true,
+    vote: {
+      ...optionId ? { optionId } : {},
+      ...stance ? { stance } : {},
+      ...rationale ? { rationale } : {}
+    }
+  };
+}
+function parseJudge(text, question, refusalOptionId) {
+  const parsed = parseCouncilResponse(text, question, refusalOptionId, {
+    role: "judge",
+    freeTextField: "answer"
+  });
+  if (!parsed.ok) return parsed;
+  const { optionId, answer, rationale } = parsed.value;
+  return {
+    ok: true,
+    value: {
+      ...optionId ? { optionId } : {},
+      ...answer ? { answer } : {},
+      ...rationale ? { rationale } : {}
+    }
+  };
+}
+function withTruncationNote(error, result, maxTokens) {
+  if (result.stopReason !== "max_tokens") return error;
+  return `${error} (response truncated at maxTokens=${maxTokens} \u2014 reasoning models may need a larger budget)`;
+}
+
+// src/execution/council-orchestrator.ts
+var CouncilOrchestrator = class {
+  caller;
+  personas;
+  profiles;
+  defaultProfile;
+  maxConcurrency;
+  refusalOptionId;
+  fallbackProfileManager;
+  seatCaller;
+  judgeCaller;
+  constructor(opts) {
+    if (!opts.caller && !opts.seatCaller && !opts.judgeCaller) {
+      throw new Error("CouncilOrchestrator: provide `caller`, `seatCaller`, or `judgeCaller`.");
+    }
+    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;
+    this.fallbackProfileManager = opts.fallbackProfileManager;
+    this.seatCaller = opts.seatCaller;
+    this.judgeCaller = opts.judgeCaller;
+  }
+  resolveProfile(profile) {
+    return resolveCouncilProfile(profile, {
+      registry: this.profiles,
+      personas: this.personas,
+      defaultProfile: this.defaultProfile
+    });
+  }
+  async ask(question) {
+    const startedAt = Date.now();
+    const profile = this.resolveProfile(question.profile);
+    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, i) => {
+        try {
+          return await this.callSeat(question, profile, seat, i, signal, usage);
+        } catch (error) {
+          const timedOut = signal.aborted && !question.signal?.aborted;
+          return {
+            seatId: seat.id,
+            persona: seat.persona,
+            status: question.signal?.aborted ? "cancelled" : "failed",
+            error: question.signal?.aborted ? CALL_CANCELLED_REASON : timedOut ? OVERALL_TIMEOUT_REASON : 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: CALL_CANCELLED_REASON,
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors
+      });
+    }
+    if (timeoutSignal.aborted) {
+      return resultEnvelope({
+        status: "failed",
+        reason: OVERALL_TIMEOUT_REASON,
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors: errors.some((entry) => entry.includes(OVERALL_TIMEOUT_REASON)) ? errors : [...errors, OVERALL_TIMEOUT_REASON]
+      });
+    }
+    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, seatIndex, signal, usage) {
+    if (signal.aborted) {
+      return question.signal?.aborted ? cancelledVote(seat) : {
+        seatId: seat.id,
+        persona: seat.persona,
+        status: "failed",
+        ...seat.target?.providerId ? { provider: seat.target.providerId } : {},
+        ...seat.target?.model ? { model: seat.target.model } : {},
+        durationMs: 0,
+        error: OVERALL_TIMEOUT_REASON
+      };
+    }
+    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,
+      seatIndex
+    });
+    const metadata = callMetadata(result);
+    if (result.error) {
+      const timedOut = signal.aborted && !question.signal?.aborted;
+      return {
+        seatId: seat.id,
+        persona: seat.persona,
+        status: question.signal?.aborted ? "cancelled" : "failed",
+        ...metadata,
+        error: question.signal?.aborted ? CALL_CANCELLED_REASON : timedOut ? OVERALL_TIMEOUT_REASON : result.error
+      };
+    }
+    const parsed = parseVote(result.text, question, this.refusalOptionId);
+    if (!parsed.ok) {
+      return {
+        seatId: seat.id,
+        persona: seat.persona,
+        status: "invalid",
+        ...metadata,
+        error: withTruncationNote(parsed.error, result, profile.voterMaxTokens)
+      };
+    }
+    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 (signal.aborted) {
+      const cancelled = question.signal?.aborted === true;
+      const reason = cancelled ? CALL_CANCELLED_REASON : OVERALL_TIMEOUT_REASON;
+      return resultEnvelope({
+        status: cancelled ? "cancelled" : "failed",
+        reason,
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors: errors.some((entry) => entry.includes(reason)) ? errors : [...errors, reason],
+        judgeUsed: true
+      });
+    }
+    if (!judged.ok) {
+      return resultEnvelope({
+        status: question.signal?.aborted ? "cancelled" : signal.aborted ? "failed" : "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) {
+      if (divergentStances(valid)) {
+        return resultEnvelope({
+          status: "abstained",
+          reason: "Council produced multiple distinct stances and has no judge to reconcile them.",
+          resolution: "none",
+          votes,
+          profile,
+          usage,
+          startedAt,
+          warnings,
+          errors
+        });
+      }
+      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 (signal.aborted) {
+      const cancelled = question.signal?.aborted === true;
+      const reason = cancelled ? CALL_CANCELLED_REASON : OVERALL_TIMEOUT_REASON;
+      return resultEnvelope({
+        status: cancelled ? "cancelled" : "failed",
+        reason,
+        resolution: "none",
+        votes,
+        profile,
+        usage,
+        startedAt,
+        warnings,
+        errors: errors.some((entry) => entry.includes(reason)) ? errors : [...errors, reason],
+        judgeUsed: true
+      });
+    }
+    if (!judged.ok) {
+      return resultEnvelope({
+        status: question.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) {
+      if (signal.aborted && !question.signal?.aborted) {
+        return { ok: false, error: OVERALL_TIMEOUT_REASON };
+      }
+      if (question.signal?.aborted) {
+        return { ok: false, error: CALL_CANCELLED_REASON };
+      }
+      return { ok: false, error: result.error };
+    }
+    const judged = parseJudge(result.text, question, this.refusalOptionId);
+    if (!judged.ok) {
+      return {
+        ok: false,
+        error: withTruncationNote(judged.error, result, profile.judgeMaxTokens)
+      };
+    }
+    return judged;
+  }
+  resolveCaller(seatIndex) {
+    if (seatIndex !== void 0) {
+      if (this.seatCaller) return this.seatCaller(seatIndex);
+      return this.caller ?? this.judgeCaller;
+    }
+    if (this.judgeCaller) return this.judgeCaller;
+    if (this.seatCaller) return this.seatCaller(0);
+    return this.caller;
+  }
+  async safeCall(input) {
+    const effectiveCaller = this.resolveCaller(input.seatIndex);
+    const resolvedTarget = this.resolveCouncilTarget(input.target);
+    const startedAt = Date.now();
+    try {
+      const result = await effectiveCaller.call({
+        system: input.system,
+        userPrompt: input.userPrompt,
+        responseFormat: { type: "json_object" },
+        maxTokens: input.maxTokens,
+        timeoutMs: input.timeoutMs,
+        signal: input.signal,
+        ...resolvedTarget?.providerId ? { providerId: resolvedTarget.providerId } : {},
+        ...resolvedTarget?.model ? { model: resolvedTarget.model } : {},
+        ...resolvedTarget?.role ? { role: resolvedTarget.role } : {},
+        ...resolvedTarget?.fallbackModels && resolvedTarget.fallbackModels.length > 0 ? { fallbackModels: [...resolvedTarget.fallbackModels] } : {}
+      });
+      addUsage(input.usage, result);
+      return result;
+    } catch (error) {
+      const failed = {
+        text: "",
+        model: resolvedTarget?.model ?? "",
+        provider: resolvedTarget?.providerId ?? "",
+        tokens: { input: 0, output: 0, total: 0 },
+        durationMs: Math.max(0, Date.now() - startedAt),
+        fromFallback: false,
+        error: errorMessage(error)
+      };
+      addUsage(input.usage, failed);
+      return failed;
+    }
+  }
+  resolveCouncilTarget(target) {
+    if (!target) return void 0;
+    if (!target.fallbackProfile) return target;
+    const mgr = this.fallbackProfileManager;
+    if (!mgr) return target;
+    const chain = mgr.resolve(target.fallbackProfile);
+    if (chain.length === 0) return target;
+    const combined = [
+      ...chain.map((e) => `${e.providerId}/${e.model}`),
+      ...target.fallbackModels ?? []
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = combined.filter((ref) => {
+      if (seen.has(ref)) return false;
+      seen.add(ref);
+      return true;
+    });
+    return {
+      ...target.providerId ? { providerId: target.providerId } : {},
+      ...target.model ? { model: target.model } : {},
+      ...target.role ? { role: target.role } : {},
+      fallbackModels: deduped
+    };
+  }
+};
+
+// 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,
+        attempts: 0,
+        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,
+        attempts: 0,
+        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);
+    const tracker = this.opts.statusTracker;
+    let servingProviderId = provider.id;
+    let servingModel = target.model;
+    let fromFallback = false;
+    let lastError;
+    let fallbackEligible = false;
+    let attempts = 0;
+    if (tracker && !tracker.isAvailable(target.providerId, target.model) || !evaluateModelCalendar(config.modelAvailabilitySchedule, target.providerId, target.model).allowed) {
+      this.opts.logger?.debug(
+        `one-shot: primary "${target.providerId}/${target.model}" is blocked \u2014 trying fallback`
+      );
+    } else {
+      attempts += 1;
+      const primaryAttempt = await this.tryCall(
+        provider,
+        request,
+        signal,
+        target.providerId,
+        target.model
+      );
+      const result = primaryAttempt.response;
+      lastError = primaryAttempt.error;
+      fallbackEligible = primaryAttempt.fallbackEligible;
+      if (result) {
+        tracker?.recordSuccess(target.providerId, target.model);
+        servingProviderId = provider.id;
+        servingModel = target.model;
+        return this.buildResult(result, servingProviderId, servingModel, false, startedAt, attempts);
+      }
+      if (!fallbackEligible || chain.length === 0) {
+        return this.buildErrorResult(
+          lastError,
+          target.providerId,
+          target.model,
+          false,
+          startedAt,
+          attempts
+        );
+      }
+    }
+    const estimatedTokens = estimateRequestTokens(request.messages, request.system, []).total;
+    const usableChain = tracker ? chain.filter((e) => tracker.isAvailable(e.providerId, e.model)) : chain;
+    for (const entry of usableChain) {
+      if (!evaluateModelCalendar(config.modelAvailabilitySchedule, entry.providerId, entry.model).allowed)
+        continue;
+      if (tracker && !tracker.isAvailable(entry.providerId, entry.model)) {
+        continue;
+      }
+      if (entry.providerId === provider.id && entry.model === target.model) continue;
+      let fbProvider;
+      try {
+        fbProvider = await this.opts.buildProvider(entry.providerId, entry.model);
+      } catch (err) {
+        lastError = err;
+        continue;
+      }
+      const fbMaxContext = fbProvider.capabilities.maxContext;
+      if (typeof fbMaxContext === "number" && Number.isFinite(fbMaxContext) && fbMaxContext > 0 && estimatedTokens > fbMaxContext) {
+        this.opts.logger?.debug(
+          `one-shot: skipping "${entry.providerId}/${entry.model}" \u2014 context window (${fbMaxContext}) is smaller than request tokens (${estimatedTokens})`
+        );
+        continue;
+      }
+      servingProviderId = fbProvider.id;
+      servingModel = entry.model;
+      attempts += 1;
+      const attempt = await this.tryCall(
+        fbProvider,
+        this.buildRequest(input, entry.model),
+        signal,
+        entry.providerId,
+        entry.model
+      );
+      if (attempt.response) {
+        tracker?.recordSuccess(entry.providerId, entry.model);
+        fromFallback = true;
+        return this.buildResult(
+          attempt.response,
+          servingProviderId,
+          servingModel,
+          true,
+          startedAt,
+          attempts
+        );
+      }
+      lastError = attempt.error;
+    }
+    return this.buildErrorResult(
+      lastError,
+      servingProviderId,
+      servingModel,
+      fromFallback,
+      startedAt,
+      attempts
+    );
+  }
+  // ── 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, "");
+      const hasExplicitTarget = Boolean(input.providerId || input.model);
+      if (pick && (pick.fromMatrix === true || !hasExplicitTarget)) {
+        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.
+   * Delegates to {@link FallbackProfileManager.resolveCandidates} — the
+   * shared constructor used by both the agent loop and the one-shot path,
+   * so both produce identical ordering, depth, and fromExplicitSource
+   * semantics.
+   *
+   * The injected {@link OneShotOrchestratorOptions.fallbackProfileManager}
+   * is the only allowed manager — OneShot never owns a private snapshot
+   * so a live `ConfigStore` change reaches every call without rebuilding
+   * the manager.
+   */
+  resolveFallbackChain(input, config, target) {
+    return this.opts.fallbackProfileManager.resolveCandidates(target, {
+      fallbackModels: input.fallbackModels && input.fallbackModels.length > 0 ? input.fallbackModels : config.fallbackModels,
+      // The one-shot already tried `target` as the primary before entering
+      // the chain. Passing it as `primary` suppresses the primary-insertion
+      // step in resolveCandidates (primary === current → not pushed).
+      primary: target
+    });
+  }
+  /** Attempt a provider call while preserving the actual failure for callers. */
+  async tryCall(provider, request, signal, providerId, model) {
+    try {
+      const direct = (req) => provider.complete(req, { signal });
+      const response = this.opts.wrapProviderCall ? await this.opts.wrapProviderCall(request, direct) : await direct(request);
+      return { response, fallbackEligible: false };
+    } catch (err) {
+      if (err instanceof ProviderError && providerId && model) {
+        this.opts.statusTracker?.recordFailure(
+          providerId,
+          model,
+          err.kind,
+          err.status,
+          err.describe(),
+          { retryAfterMs: err.body?.retryAfterMs }
+        );
+      }
+      return {
+        error: err,
+        // Provider failures retain their normal fallback policy. A plain error
+        // thrown by the host wrapper is a local refusal (for example,
+        // prompt-firewall block mode), not evidence that another provider may
+        // succeed; retrying would only replay the same blocked request and
+        // misattribute the final error to the last fallback.
+        fallbackEligible: !signal.aborted && (err instanceof ProviderError ? isFallbackWorthy(err.kind) : this.opts.wrapProviderCall === void 0)
+      };
+    }
+  }
+  /** Build a success result from a provider Response. */
+  buildResult(response, servingProviderId, servingModel, fromFallback, startedAt, attempts) {
+    const textBlocks = response.content.filter(isTextBlock);
+    const text = textBlocks.map((b) => b.text).join("\n").trim();
+    return {
+      text: text || "(empty response)",
+      model: response.model ?? servingModel,
+      provider: servingProviderId,
+      tokens: {
+        input: response.usage?.input ?? 0,
+        output: response.usage?.output ?? 0,
+        total: (response.usage?.input ?? 0) + (response.usage?.output ?? 0)
+      },
+      durationMs: Math.round(performance.now() - startedAt),
+      fromFallback,
+      attempts,
+      stopReason: response.stopReason
+    };
+  }
+  /** Build a total-failure error result. */
+  buildErrorResult(error, servingProviderId, servingModel, fromFallback, startedAt, attempts) {
+    return {
+      text: "",
+      model: servingModel,
+      provider: servingProviderId,
+      tokens: { input: 0, output: 0, total: 0 },
+      durationMs: Math.round(performance.now() - startedAt),
+      fromFallback,
+      attempts,
+      error: error instanceof Error ? error.message : String(error ?? "Unknown error")
+    };
+  }
+};
+function asTextBlocks(system) {
+  if (!system) return [];
+  if (Array.isArray(system)) return system;
+  return [{ type: "text", text: system }];
+}
+
+export {
+  COUNCIL_REFUSAL_OPTION_ID,
+  DEFAULT_COUNCIL_MAX_CONCURRENCY,
+  MAX_COUNCIL_CONCURRENCY,
+  BUILTIN_COUNCIL_PERSONAS,
+  BUILTIN_COUNCIL_PERSONA_IDS,
+  CouncilPersonaRegistry,
+  DEFAULT_COUNCIL_PERSONA_REGISTRY,
+  createCouncilPersonaRegistry,
+  DEFAULT_COUNCIL_QUORUM_FRACTION,
+  DEFAULT_COUNCIL_APPROVAL_FRACTION,
+  DEFAULT_COUNCIL_VOTER_MAX_TOKENS,
+  DEFAULT_COUNCIL_JUDGE_MAX_TOKENS,
+  DEFAULT_COUNCIL_PER_CALL_TIMEOUT_MS,
+  DEFAULT_COUNCIL_OVERALL_TIMEOUT_MS,
+  BUILTIN_COUNCIL_PROFILES,
+  CouncilProfileRegistry,
+  DEFAULT_COUNCIL_PROFILE_REGISTRY,
+  createCouncilProfileRegistry,
+  resolveCouncilProfile,
+  normalizeCouncilProfile,
+  COUNCIL_VOTER_PROMPT_PATH,
+  COUNCIL_JUDGE_PROMPT_PATH,
+  buildCouncilVoterSystemPrompt,
+  buildCouncilJudgeSystemPrompt,
+  buildCouncilQuestionPrompt,
+  buildCouncilVoterUserPrompt,
+  buildCouncilJudgeUserPrompt,
+  validateCouncilOptions,
+  resolveCouncilVotes,
+  CouncilOrchestrator,
+  OneShotOrchestrator
+};
+//# sourceMappingURL=chunk-PFCMSSUF.js.map