@ci-kit/roundtable 0.0.1 → 0.3.1

package/dist/index.mjs

@@ -1,15 +1,1835 @@
-const ROUNDTABLE_SCHEMA = 1;
-function notImplemented() {
-  throw new Error("@ci-kit/roundtable is not implemented yet; see ai-docs/design-docs/roundtable/");
+import { stat, readFile, readdir, mkdir, writeFile } from 'node:fs/promises';
+import { resolve, join, basename, dirname } from 'node:path';
+import { createHash } from 'node:crypto';
+import process from 'node:process';
+import { text, isAiError } from '@ci-kit/ai';
+
+class YamlError extends Error {
+  constructor(message, line) {
+    super(line === void 0 ? message : `line ${line}: ${message}`);
+    this.line = line;
+    this.name = "YamlError";
+  }
+}
+function parseScalar(raw, line) {
+  const value = raw.trim();
+  if (!value) {
+    return null;
+  }
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  if (value === "null" || value === "~") {
+    return null;
+  }
+  if (value.startsWith('"') && value.endsWith('"') && value.length >= 2 || value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
+    const inner = value.slice(1, -1);
+    return value.startsWith('"') ? unescapeDouble(inner, line) : inner.replace(/''/g, "'");
+  }
+  if (value.startsWith("[")) {
+    if (!value.endsWith("]")) {
+      throw new YamlError(`Unterminated inline list: ${value}`, line);
+    }
+    return splitInlineList(value.slice(1, -1), line);
+  }
+  if (value.startsWith("{")) {
+    throw new YamlError("Inline mappings are not supported in frontmatter; use a block mapping", line);
+  }
+  if (/^-?\d+$/.test(value)) {
+    return Number(value);
+  }
+  if (/^-?\d+\.\d+$/.test(value)) {
+    return Number(value);
+  }
+  return value;
+}
+function unescapeDouble(value, line) {
+  let result = "";
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    if (char === "\\" && i + 1 < value.length) {
+      const next = value[++i];
+      result += next === "n" ? "\n" : next === "t" ? "	" : next === '"' ? '"' : next === "\\" ? "\\" : next;
+      continue;
+    }
+    if (char === '"') {
+      throw new YamlError("Unescaped double quote inside a double-quoted string", line);
+    }
+    result += char;
+  }
+  return result;
+}
+function splitInlineList(body, line) {
+  const items = [];
+  let current = "";
+  let quote = null;
+  for (const char of body) {
+    if (quote) {
+      current += char;
+      if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (char === ",") {
+      items.push(parseScalar(current, line));
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim() || body.trim() === "") {
+    items.push(parseScalar(current, line));
+  }
+  return items;
+}
+function splitKey(text) {
+  const match = /^([A-Z_][\w-]*)\s*:(.*)$/i.exec(text);
+  if (!match) {
+    return null;
+  }
+  return {
+    key: match[1],
+    rest: (match[2] ?? "").trim()
+  };
+}
+function toLines(source) {
+  return source.replace(/\r\n?/g, "\n").split("\n").map((raw, index) => ({
+    indent: raw.length - raw.trimStart().length,
+    text: raw.trim(),
+    number: index + 1
+  })).filter((line) => line.text !== "" && !line.text.startsWith("#"));
+}
+function parseYaml(source) {
+  if (/\t/.test(source.split("\n").map((line) => line.match(/^[ \t]+/)?.[0] ?? "").join(""))) {
+    throw new YamlError("Tabs are not allowed for indentation; use spaces");
+  }
+  const lines = toLines(source);
+  if (!lines.length) {
+    return {};
+  }
+  const [value, next] = parseBlock(lines, 0, lines[0].indent);
+  if (next !== lines.length) {
+    throw new YamlError(`Unexpected content`, lines[next].number);
+  }
+  if (Array.isArray(value)) {
+    throw new YamlError("The frontmatter root must be a mapping, not a list", lines[0].number);
+  }
+  if (value === null || typeof value !== "object") {
+    throw new YamlError("The frontmatter root must be a mapping", lines[0].number);
+  }
+  return value;
+}
+function parseBlock(lines, start, indent) {
+  const first = lines[start];
+  if (first.indent !== indent) {
+    throw new YamlError(`Inconsistent indentation (expected ${indent}, found ${first.indent})`, first.number);
+  }
+  return first.text === "-" || first.text.startsWith("- ") ? parseList(lines, start, indent) : parseMapping(lines, start, indent);
+}
+function parseMapping(lines, start, indent) {
+  const result = {};
+  let index = start;
+  while (index < lines.length) {
+    const line = lines[index];
+    if (line.indent < indent) {
+      break;
+    }
+    if (line.indent > indent) {
+      throw new YamlError(`Unexpected extra indentation`, line.number);
+    }
+    if (line.text === "-" || line.text.startsWith("- ")) {
+      break;
+    }
+    const entry = splitKey(line.text);
+    if (!entry) {
+      throw new YamlError(`Expected "key: value", found "${line.text}"`, line.number);
+    }
+    if (Object.hasOwn(result, entry.key)) {
+      throw new YamlError(`Duplicate key "${entry.key}"`, line.number);
+    }
+    if (entry.rest !== "") {
+      result[entry.key] = parseScalar(entry.rest, line.number);
+      index++;
+      continue;
+    }
+    const next = lines[index + 1];
+    if (!next || next.indent <= indent) {
+      result[entry.key] = null;
+      index++;
+      continue;
+    }
+    const [child, after] = parseBlock(lines, index + 1, next.indent);
+    result[entry.key] = child;
+    index = after;
+  }
+  return [result, index];
+}
+function parseList(lines, start, indent) {
+  const result = [];
+  let index = start;
+  while (index < lines.length) {
+    const line = lines[index];
+    if (line.indent < indent) {
+      break;
+    }
+    if (line.indent > indent) {
+      throw new YamlError("Unexpected extra indentation in list", line.number);
+    }
+    if (line.text !== "-" && !line.text.startsWith("- ")) {
+      break;
+    }
+    const body = line.text === "-" ? "" : line.text.slice(2).trim();
+    if (body === "") {
+      const next = lines[index + 1];
+      if (!next || next.indent <= indent) {
+        result.push(null);
+        index++;
+        continue;
+      }
+      const [child, after] = parseBlock(lines, index + 1, next.indent);
+      result.push(child);
+      index = after;
+      continue;
+    }
+    if (splitKey(body)) {
+      const itemIndent = line.indent + 2;
+      const view = [
+        { indent: itemIndent, text: body, number: line.number },
+        ...lines.slice(index + 1)
+      ];
+      const [mapping, consumed] = parseMapping(view, 0, itemIndent);
+      result.push(mapping);
+      index += consumed;
+      continue;
+    }
+    result.push(parseScalar(body, line.number));
+    index++;
+  }
+  return [result, index];
+}
+
+class FrontmatterError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FrontmatterError";
+  }
+}
+const DELIMITER = /^---[ \t]*$/;
+function readFrontmatter(source, label) {
+  const normalized = source.replace(/\r\n?/g, "\n");
+  const lines = normalized.split("\n");
+  if (!DELIMITER.test(lines[0] ?? "")) {
+    const firstLine = lines[0] ?? "";
+    if (!/^[A-Z_][\w-]*\s*:(?:\s|$)/i.test(firstLine)) {
+      return {
+        data: {},
+        body: normalized.trim(),
+        hasFrontmatter: false
+      };
+    }
+    let end = lines.length;
+    for (let index = 0; index < lines.length; index++) {
+      if (lines[index].trim() === "") {
+        end = index;
+        break;
+      }
+    }
+    const yamlText2 = lines.slice(0, end).join("\n");
+    let data2;
+    try {
+      data2 = parseYaml(yamlText2);
+    } catch (error) {
+      const detail = error instanceof YamlError ? error.message : String(error);
+      throw new FrontmatterError(`${label}: ${detail}`);
+    }
+    return {
+      data: data2,
+      body: lines.slice(end + 1).join("\n").trim(),
+      hasFrontmatter: false
+    };
+  }
+  let close = -1;
+  for (let index = 1; index < lines.length; index++) {
+    if (DELIMITER.test(lines[index])) {
+      close = index;
+      break;
+    }
+  }
+  if (close === -1) {
+    throw new FrontmatterError(`${label}: frontmatter opened with --- but never closed`);
+  }
+  const yamlText = lines.slice(1, close).join("\n");
+  let data;
+  try {
+    data = parseYaml(yamlText);
+  } catch (error) {
+    const detail = error instanceof YamlError ? error.message : String(error);
+    throw new FrontmatterError(`${label}: ${detail}`);
+  }
+  return {
+    data,
+    body: lines.slice(close + 1).join("\n").trim(),
+    hasFrontmatter: true
+  };
+}
+
+class SeatError extends Error {
+  constructor(label, message) {
+    super(`${label}: ${message}`);
+    this.label = label;
+    this.name = "SeatError";
+  }
+}
+const TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "role",
+  "enabled",
+  "identity",
+  "persona",
+  "seat"
+]);
+const IDENTITY_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "avatar",
+  "title",
+  "background"
+]);
+const PERSONA_KEYS = /* @__PURE__ */ new Set([
+  "stance",
+  "personality",
+  "style",
+  "speech",
+  "values",
+  "quirks",
+  "avoid"
+]);
+const SEAT_KEYS = /* @__PURE__ */ new Set([
+  "phase",
+  "sees",
+  "canPropose",
+  "canVeto",
+  "lead",
+  "weight",
+  "priority",
+  "budget",
+  "fallback",
+  "output",
+  "model",
+  "temperature",
+  "maxTokens"
+]);
+const FLAT_ALIASES = new Map([
+  ...[
+    "name",
+    "avatar",
+    "title",
+    "background"
+  ].map((key) => [key, "identity"]),
+  ...[
+    "stance",
+    "personality",
+    "style",
+    "speech",
+    "values",
+    "quirks",
+    "avoid"
+  ].map((key) => [key, "persona"]),
+  ...[
+    "phase",
+    "sees",
+    "canPropose",
+    "canVeto",
+    "lead",
+    "weight",
+    "priority",
+    "budget",
+    "fallback",
+    "output",
+    "model",
+    "temperature",
+    "maxTokens"
+  ].map((key) => [key, "seat"])
+]);
+function asString$1(value, label, field) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new SeatError(label, `${field} must be a string`);
+  }
+  const trimmed = value.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function requireString(value, label, field) {
+  const result = asString$1(value, label, field);
+  if (!result) {
+    throw new SeatError(label, `${field} is required`);
+  }
+  return result;
+}
+function asBoolean(value, label, field, fallback) {
+  if (value === void 0 || value === null) {
+    return fallback;
+  }
+  if (typeof value !== "boolean") {
+    throw new SeatError(label, `${field} must be true or false`);
+  }
+  return value;
+}
+function asNumber$1(value, label, field) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new SeatError(label, `${field} must be a number`);
+  }
+  return value;
+}
+function asStringList$1(value, label, field) {
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  const items = Array.isArray(value) ? value : [value];
+  return items.map((item) => {
+    if (typeof item !== "string" || !item.trim()) {
+      throw new SeatError(label, `${field} must contain non-empty strings`);
+    }
+    return item.trim();
+  });
+}
+function asMapping$1(value, label, field) {
+  if (value === void 0 || value === null) {
+    return {};
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new SeatError(label, `${field} must be a mapping`);
+  }
+  return value;
+}
+function rejectUnknownKeys(mapping, allowed, label, where) {
+  const unknown = Object.keys(mapping).filter((key) => !allowed.has(key));
+  if (unknown.length) {
+    throw new SeatError(label, `unknown field${unknown.length > 1 ? "s" : ""} in ${where}: ${unknown.join(", ")}`);
+  }
+}
+function groupData(data, label) {
+  const groups = {
+    identity: {
+      ...asMapping$1(data.identity, label, "identity")
+    },
+    persona: {
+      ...asMapping$1(data.persona, label, "persona")
+    },
+    seat: {
+      ...asMapping$1(data.seat, label, "seat")
+    }
+  };
+  for (const [key, value] of Object.entries(data)) {
+    if (TOP_LEVEL_KEYS.has(key)) {
+      continue;
+    }
+    const target = FLAT_ALIASES.get(key);
+    if (!target) {
+      throw new SeatError(label, `unknown field "${key}"; expected one of ${[...TOP_LEVEL_KEYS].join(", ")}`);
+    }
+    if (Object.hasOwn(groups[target], key)) {
+      throw new SeatError(label, `"${key}" is declared both at the top level and inside ${target}`);
+    }
+    groups[target][key] = value;
+  }
+  return groups;
+}
+function parseSees(value, label) {
+  if (value === void 0 || value === null) {
+    return "all";
+  }
+  if (Array.isArray(value)) {
+    const ids = asStringList$1(value, label, "seat.sees");
+    if (!ids.length) {
+      throw new SeatError(label, 'seat.sees list must not be empty; use "all" or "none"');
+    }
+    return ids;
+  }
+  if (value === "all" || value === "none" || value === "lead-only") {
+    return value;
+  }
+  throw new SeatError(label, `seat.sees must be all, none, lead-only or a list of seat ids; got "${String(value)}"`);
+}
+function renderSeatSystemPrompt(seat) {
+  const lines = [];
+  const { identity, persona } = seat;
+  const headline = [identity.title, `\u662F\u4E00\u540D${seat.role}`].filter(Boolean).join("\uFF0C");
+  lines.push(`\u4F60\u662F${identity.name}\uFF0C${headline}\u3002`);
+  if (identity.background) {
+    lines.push("", "## \u80CC\u666F", identity.background);
+  }
+  if (persona.personality.length) {
+    lines.push("", "## \u4F60\u7684\u6027\u683C", persona.personality.join("\u3001"));
+  }
+  if (persona.stance) {
+    lines.push("", "## \u4F60\u7684\u7ACB\u573A", persona.stance);
+  }
+  const speech = [];
+  if (persona.style) {
+    speech.push(persona.style);
+  }
+  if (persona.speech) {
+    speech.push(persona.speech);
+  }
+  if (persona.quirks) {
+    speech.push(persona.quirks);
+  }
+  if (speech.length) {
+    lines.push("", "## \u4F60\u7684\u8BF4\u8BDD\u65B9\u5F0F", ...speech.map((line) => `- ${line}`));
+  }
+  if (persona.values) {
+    lines.push("", "## \u4F60\u7684\u539F\u5219", persona.values);
+  }
+  if (persona.avoid) {
+    lines.push("", "## \u4F60\u7684\u8FB9\u754C", persona.avoid);
+  }
+  if (seat.body) {
+    lines.push("", seat.body);
+  }
+  return lines.join("\n");
+}
+function parseSeat(document, source) {
+  const label = `seat ${source}`;
+  const { identity, persona, seat } = groupData(document.data, label);
+  rejectUnknownKeys(identity, IDENTITY_KEYS, label, "identity");
+  rejectUnknownKeys(persona, PERSONA_KEYS, label, "persona");
+  rejectUnknownKeys(seat, SEAT_KEYS, label, "seat");
+  const id = requireString(document.data.id, label, "id");
+  if (!/^[\w-]+$/.test(id)) {
+    throw new SeatError(label, `id "${id}" must use letters, digits, underscore or hyphen`);
+  }
+  const role = requireString(document.data.role, label, "role");
+  const weight = asNumber$1(seat.weight, label, "seat.weight") ?? 1;
+  if (weight <= 0) {
+    throw new SeatError(label, "seat.weight must be greater than 0");
+  }
+  const budget = asNumber$1(seat.budget, label, "seat.budget");
+  if (budget !== void 0 && budget < 0) {
+    throw new SeatError(label, "seat.budget must not be negative");
+  }
+  const fallback = asString$1(seat.fallback, label, "seat.fallback") ?? "skip";
+  if (!["skip", "retry", "abort"].includes(fallback)) {
+    throw new SeatError(label, "seat.fallback must be skip, retry or abort");
+  }
+  const output = asString$1(seat.output, label, "seat.output") ?? "text";
+  if (!["text", "json", "markdown"].includes(output)) {
+    throw new SeatError(label, "seat.output must be text, json or markdown");
+  }
+  const name = asString$1(identity.name, label, "identity.name") ?? role;
+  return {
+    id,
+    role,
+    enabled: asBoolean(document.data.enabled, label, "enabled", true),
+    identity: {
+      name,
+      avatar: asString$1(identity.avatar, label, "identity.avatar"),
+      title: asString$1(identity.title, label, "identity.title"),
+      background: asString$1(identity.background, label, "identity.background")
+    },
+    persona: {
+      stance: asString$1(persona.stance, label, "persona.stance"),
+      personality: asStringList$1(persona.personality, label, "persona.personality"),
+      style: asString$1(persona.style, label, "persona.style"),
+      speech: asString$1(persona.speech, label, "persona.speech"),
+      values: asString$1(persona.values, label, "persona.values"),
+      quirks: asString$1(persona.quirks, label, "persona.quirks"),
+      avoid: asString$1(persona.avoid, label, "persona.avoid")
+    },
+    seat: {
+      phase: asStringList$1(seat.phase, label, "seat.phase"),
+      sees: parseSees(seat.sees, label),
+      canPropose: asBoolean(seat.canPropose, label, "seat.canPropose", false),
+      canVeto: asBoolean(seat.canVeto, label, "seat.canVeto", false),
+      lead: asBoolean(seat.lead, label, "seat.lead", false),
+      weight,
+      priority: asNumber$1(seat.priority, label, "seat.priority") ?? 99,
+      budget,
+      fallback,
+      output,
+      model: asString$1(seat.model, label, "seat.model"),
+      temperature: asNumber$1(seat.temperature, label, "seat.temperature"),
+      maxTokens: asNumber$1(seat.maxTokens, label, "seat.maxTokens")
+    },
+    body: document.body,
+    source
+  };
+}
+
+class TableError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TableError";
+  }
+}
+const TABLE_KEYS = /* @__PURE__ */ new Set([
+  "title",
+  "schedule",
+  "budget",
+  "onVeto",
+  "maxAttempts",
+  "threshold",
+  "timeoutMs",
+  "phases",
+  "special"
+]);
+const PHASE_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "seats",
+  "vetoable",
+  "requires",
+  "mode"
+]);
+function asString(value, field) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new TableError(`table: ${field} must be a string`);
+  }
+  const trimmed = value.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function asNumber(value, field) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TableError(`table: ${field} must be a number`);
+  }
+  return value;
+}
+function asStringList(value, field) {
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  const items = Array.isArray(value) ? value : [value];
+  return items.map((item) => {
+    if (typeof item !== "string" || !item.trim()) {
+      throw new TableError(`table: ${field} must contain non-empty strings`);
+    }
+    return item.trim();
+  });
+}
+function asMapping(value, field) {
+  if (value === void 0 || value === null) {
+    return {};
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new TableError(`table: ${field} must be a mapping`);
+  }
+  return value;
+}
+function parsePhases(value) {
+  if (value === void 0 || value === null) {
+    throw new TableError("table: phases is required");
+  }
+  if (!Array.isArray(value)) {
+    throw new TableError("table: phases must be a list");
+  }
+  return value.map((item, index) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      throw new TableError(`table: phases[${index}] must be a mapping`);
+    }
+    const raw = item;
+    const unknown = Object.keys(raw).filter((key) => !PHASE_KEYS.has(key));
+    if (unknown.length) {
+      throw new TableError(`table: phases[${index}] has unknown field(s): ${unknown.join(", ")}`);
+    }
+    const id = asString(raw.id, `phases[${index}].id`);
+    if (!id) {
+      throw new TableError(`table: phases[${index}].id is required`);
+    }
+    const mode = asString(raw.mode, `phases[${index}].mode`) ?? "serial";
+    if (mode !== "serial" && mode !== "parallel") {
+      throw new TableError(`table: phases[${index}].mode must be serial or parallel`);
+    }
+    if (raw.vetoable !== void 0 && raw.vetoable !== null && typeof raw.vetoable !== "boolean") {
+      throw new TableError(`table: phases[${index}].vetoable must be true or false`);
+    }
+    return {
+      id,
+      seats: asStringList(raw.seats, `phases[${index}].seats`),
+      vetoable: raw.vetoable === true,
+      requires: asStringList(raw.requires, `phases[${index}].requires`),
+      mode
+    };
+  });
+}
+function resolveSpecial(phases, special) {
+  const ids = phases.map((phase) => phase.id);
+  const declaredPropose = asString(special.propose, "special.propose");
+  const declaredConverge = asString(special.converge, "special.converge");
+  const propose = declaredPropose ?? (ids.includes("propose") ? "propose" : phases[0].id);
+  const converge = declaredConverge ?? (ids.includes("converge") ? "converge" : phases[phases.length - 1].id);
+  for (const [field, id] of [
+    ["propose", propose],
+    ["converge", converge]
+  ]) {
+    if (!ids.includes(id)) {
+      throw new TableError(`table: special.${field} points at unknown phase "${id}"`);
+    }
+  }
+  return { propose, converge };
+}
+function parseTable(document, fallbackTitle) {
+  const data = document.data;
+  const unknown = Object.keys(data).filter((key) => !TABLE_KEYS.has(key));
+  if (unknown.length) {
+    throw new TableError(`table: unknown field(s): ${unknown.join(", ")}`);
+  }
+  const budgetRaw = asMapping(data.budget, "budget");
+  const budgetUnknown = Object.keys(budgetRaw).filter((key) => key !== "total" && key !== "perSeat");
+  if (budgetUnknown.length) {
+    throw new TableError(`table: budget has unknown field(s): ${budgetUnknown.join(", ")}`);
+  }
+  const total = asNumber(budgetRaw.total, "budget.total");
+  const perSeat = asNumber(budgetRaw.perSeat, "budget.perSeat");
+  if (total !== void 0 && total < 0) {
+    throw new TableError("table: budget.total must not be negative");
+  }
+  if (perSeat !== void 0 && perSeat < 0) {
+    throw new TableError("table: budget.perSeat must not be negative");
+  }
+  const onVeto = asString(data.onVeto, "onVeto") ?? "re-propose";
+  if (!["re-propose", "revise", "abort"].includes(onVeto)) {
+    throw new TableError("table: onVeto must be re-propose, revise or abort");
+  }
+  const maxAttempts = asNumber(data.maxAttempts, "maxAttempts") ?? 3;
+  if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
+    throw new TableError("table: maxAttempts must be a positive integer");
+  }
+  const threshold = asNumber(data.threshold, "threshold") ?? 0.5;
+  if (threshold <= 0 || threshold > 1) {
+    throw new TableError("table: threshold must be greater than 0 and at most 1");
+  }
+  const timeoutMs = asNumber(data.timeoutMs, "timeoutMs");
+  if (timeoutMs !== void 0 && (!Number.isInteger(timeoutMs) || timeoutMs < 1e3 || timeoutMs > 36e5)) {
+    throw new TableError("table: timeoutMs must be an integer between 1000 and 3600000");
+  }
+  const phases = parsePhases(data.phases);
+  if (!phases.length) {
+    throw new TableError("table: at least one phase is required");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const phase of phases) {
+    if (seen.has(phase.id)) {
+      throw new TableError(`table: duplicate phase id "${phase.id}"`);
+    }
+    seen.add(phase.id);
+  }
+  return {
+    title: asString(data.title, "title") ?? fallbackTitle,
+    schedule: asString(data.schedule, "schedule"),
+    budget: { total, perSeat },
+    onVeto,
+    maxAttempts,
+    threshold,
+    timeoutMs,
+    phases,
+    special: resolveSpecial(phases, asMapping(data.special, "special"))
+  };
+}
+function resolvePhases(table, seats, allPhaseIds) {
+  const byId = new Map(seats.map((seat) => [seat.id, seat]));
+  for (const phase of table.phases) {
+    for (const seatId of phase.seats) {
+      if (!byId.has(seatId)) {
+        throw new TableError(`table: phase "${phase.id}" names unknown seat "${seatId}"`);
+      }
+    }
+    for (const required of phase.requires) {
+      if (!allPhaseIds.includes(required)) {
+        throw new TableError(`table: phase "${phase.id}" requires unknown phase "${required}"`);
+      }
+      if (required === phase.id) {
+        throw new TableError(`table: phase "${phase.id}" cannot require itself`);
+      }
+    }
+  }
+  const order = new Map(table.phases.map((phase, index) => [phase.id, index]));
+  for (const phase of table.phases) {
+    const deps = phase.requires.length ? phase.requires : order.get(phase.id) > 0 ? [table.phases[order.get(phase.id) - 1].id] : [];
+    for (const dep of deps) {
+      if (order.get(dep) > order.get(phase.id)) {
+        throw new TableError(`table: phase "${phase.id}" requires "${dep}" which comes later; phases run in order`);
+      }
+    }
+  }
+  return table.phases.map((phase) => {
+    const participating = seats.filter((seat) => seat.enabled).filter((seat) => phase.seats.length ? phase.seats.includes(seat.id) : true).filter((seat) => {
+      const declared = seat.seat.phase;
+      if (!declared.length) {
+        return true;
+      }
+      if (!declared.includes(phase.id)) {
+        if (phase.seats.includes(seat.id)) {
+          throw new TableError(
+            `seat "${seat.id}" is listed in phase "${phase.id}" but its seat.phase does not include it`
+          );
+        }
+        return false;
+      }
+      return true;
+    }).sort((a, b) => a.seat.priority - b.seat.priority || a.id.localeCompare(b.id)).map((seat) => seat.id);
+    return { ...phase, seats: participating };
+  });
+}
+
+class RoundtableConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RoundtableConfigError";
+  }
+}
+const SEAT_DIR = "seats";
+async function readIfPresent(path) {
+  try {
+    const info = await stat(path);
+    if (!info.isFile()) {
+      throw new RoundtableConfigError(`${path} exists but is not a file`);
+    }
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function seatFiles(dir) {
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new RoundtableConfigError(`No ${SEAT_DIR}/ directory in ${dir}; a roundtable needs at least one seat`);
+    }
+    throw error;
+  }
+  return entries.filter((name) => name.endsWith(".md")).sort((a, b) => a.localeCompare(b)).map((name) => join(dir, name));
+}
+function digest(parts) {
+  const hash = createHash("sha256");
+  for (const part of parts) {
+    hash.update(`${part.length}:`);
+    hash.update(part);
+  }
+  return `sha256:${hash.digest("hex")}`;
+}
+async function loadRoundtable(options) {
+  const configDir = resolve(options.configDir);
+  const info = await stat(configDir).catch(() => null);
+  if (!info || !info.isDirectory()) {
+    throw new RoundtableConfigError(`Roundtable directory not found: ${configDir}`);
+  }
+  const tablePath = join(configDir, "table.md");
+  const tableSource = await readIfPresent(tablePath);
+  if (tableSource === null) {
+    throw new RoundtableConfigError(`Missing table.md in ${configDir}`);
+  }
+  let table;
+  try {
+    table = parseTable(readFrontmatter(tableSource, "table.md"), basename(configDir));
+  } catch (error) {
+    if (error instanceof TableError) {
+      throw new RoundtableConfigError(error.message);
+    }
+    throw error;
+  }
+  const files = await seatFiles(join(configDir, SEAT_DIR));
+  if (!files.length) {
+    throw new RoundtableConfigError(`No seat files in ${join(configDir, SEAT_DIR)}`);
+  }
+  const seats = [];
+  const rawSeatSources = [];
+  for (const file of files) {
+    const source = await readIfPresent(file);
+    rawSeatSources.push(source);
+    try {
+      seats.push(parseSeat(readFrontmatter(source, basename(file)), basename(file)));
+    } catch (error) {
+      if (error instanceof SeatError) {
+        throw new RoundtableConfigError(error.message);
+      }
+      throw error;
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const seat of seats) {
+    const existing = seen.get(seat.id);
+    if (existing) {
+      throw new RoundtableConfigError(`Duplicate seat id "${seat.id}" in ${existing} and ${seat.source}`);
+    }
+    seen.set(seat.id, seat.source);
+  }
+  const enabled = seats.filter((seat) => seat.enabled);
+  if (!enabled.length) {
+    throw new RoundtableConfigError("Every seat is disabled; a roundtable needs at least one enabled seat");
+  }
+  let phases;
+  try {
+    phases = resolvePhases(table, seats, table.phases.map((phase) => phase.id));
+  } catch (error) {
+    if (error instanceof TableError) {
+      throw new RoundtableConfigError(error.message);
+    }
+    throw error;
+  }
+  const emptyPhase = phases.find((phase) => !phase.seats.length);
+  if (emptyPhase) {
+    throw new RoundtableConfigError(`Phase "${emptyPhase.id}" has no participating seats`);
+  }
+  return {
+    table,
+    seats,
+    byId: new Map(enabled.map((seat) => [seat.id, seat])),
+    phases,
+    configDir,
+    fingerprint: digest([
+      String(options.schema ?? 1),
+      tableSource,
+      ...rawSeatSources
+    ])
+  };
+}
+async function checkRoundtable(options) {
+  return loadRoundtable({ configDir: options.configDir, schema: 1 });
+}
+function defaultOutDir(cwd = process.cwd()) {
+  return join(cwd, "roundtable-out");
+}
+
+function visibleStatements(viewer, statements, leadIds) {
+  const { sees } = viewer.seat;
+  if (sees === "none") {
+    return [];
+  }
+  if (sees === "all") {
+    return statements.filter((statement) => statement.seat !== viewer.id);
+  }
+  if (sees === "lead-only") {
+    return statements.filter((statement) => statement.seat !== viewer.id && leadIds.has(statement.seat));
+  }
+  const allowed = new Set(sees);
+  return statements.filter((statement) => statement.seat !== viewer.id && allowed.has(statement.seat));
+}
+function renderStatement(statement) {
+  const label = [statement.name, statement.role].filter(Boolean).join(" \xB7 ");
+  const body = statement.structured !== void 0 && statement.structured !== null ? JSON.stringify(statement.structured, null, 2) : statement.content;
+  return `### ${label}
+
+${body}`;
+}
+function buildUserPrompt(input) {
+  const blocks = [];
+  if (input.topic) {
+    blocks.push(`## \u672C\u6B21\u8BAE\u9898
+
+${input.topic}`);
+  }
+  if (input.context.length) {
+    const items = input.context.map((item, index) => `${index + 1}. ${item}`).join("\n");
+    blocks.push(`## \u5DF2\u77E5\u6750\u6599
+
+${items}`);
+  }
+  if (input.phaseInstruction) {
+    blocks.push(`## \u5F53\u524D\u9636\u6BB5
+
+${input.phaseInstruction}`);
+  }
+  if (input.visible.length) {
+    blocks.push(`## \u524D\u5E8F\u53D1\u8A00
+
+${input.visible.map(renderStatement).join("\n\n")}`);
+  }
+  if (input.revisionNotes?.length) {
+    const notes = input.revisionNotes.map((note) => `- ${note}`).join("\n");
+    blocks.push(`## \u4E0A\u4E00\u8F6E\u7684\u5426\u51B3\u7406\u7531
+
+${notes}`);
+  }
+  blocks.push(
+    "## \u8F93\u51FA\u8981\u6C42\n\n\u53EA\u8F93\u51FA\u4F60\u7684\u53D1\u8A00\u672C\u8EAB\uFF0C\u4E0D\u8981\u590D\u8FF0\u4E0A\u8FF0\u6750\u6599\u3002\n\u82E5\u4F60\u62E5\u6709\u5426\u51B3\u6743\uFF0C\u8BF7\u5728\u9700\u8981\u5426\u51B3\u65F6\u5199\u660E\u7406\u7531\uFF1B\u6CA1\u6709\u7406\u7531\u7684\u5426\u51B3\u4F1A\u88AB\u5FFD\u7565\u3002"
+  );
+  return blocks.join("\n\n");
+}
+function defaultPhaseInstruction(phaseId) {
+  switch (phaseId) {
+    case "propose":
+      return "\u63D0\u51FA\u4E00\u4E2A\u4F60\u8BA4\u4E3A\u503C\u5F97\u8BA8\u8BBA\u7684\u5177\u4F53\u8BAE\u9898\uFF0C\u5E76\u8BF4\u660E\u4E3A\u4EC0\u4E48\u662F\u73B0\u5728\u3001\u4E3A\u4EC0\u4E48\u503C\u5F97\u505A\u3002";
+    case "discuss":
+      return "\u5BF9\u4F60\u770B\u5230\u7684\u524D\u5E8F\u89C2\u70B9\u4F5C\u51FA\u56DE\u5E94\uFF1A\u53EF\u4EE5\u9644\u8BAE\u3001\u53CD\u9A73\u6216\u8865\u5145\uFF0C\u4F46\u5FC5\u987B\u7ED9\u51FA\u7406\u7531\u3002";
+    case "produce":
+      return "\u6309\u5DF2\u8FBE\u6210\u7684\u65B9\u5411\u4EA7\u51FA\u5B9E\u9645\u7ED3\u679C\u3002";
+    case "review":
+      return "\u6838\u5BF9\u4EA7\u51FA\u662F\u5426\u6EE1\u8DB3\u8981\u6C42\u3002\u53D1\u73B0\u95EE\u9898\u8BF7\u9010\u6761\u5217\u51FA\uFF1B\u9700\u8981\u5426\u51B3\u65F6\u5199\u660E\u7406\u7531\u3002";
+    case "converge":
+      return "\u6536\u53E3\uFF1A\u7ED9\u51FA\u7ED3\u8BBA\u3001\u9057\u7559\u5206\u6B67\u548C\u4E0B\u4E00\u6B65\u3002";
+    default:
+      return void 0;
+  }
+}
+
+function judgePhase(phase, seats, votes, table) {
+  const byId = new Map(seats.map((seat) => [seat.id, seat]));
+  const vetoed = [];
+  const rejected = [];
+  const invalidVetoes = [];
+  let passWeight = 0;
+  let voteWeight = 0;
+  const vetoEnabled = phase.vetoable;
+  for (const vote of votes) {
+    const seat = byId.get(vote.seatId);
+    if (!seat || vote.vote === void 0) {
+      continue;
+    }
+    voteWeight += vote.weight;
+    if (vote.vote === "pass") {
+      passWeight += vote.weight;
+      continue;
+    }
+    rejected.push(seat.id);
+    if (!vote.veto) {
+      continue;
+    }
+    if (!vetoEnabled || !seat.seat.canVeto) {
+      continue;
+    }
+    if (!vote.hasReason) {
+      invalidVetoes.push(seat.id);
+      continue;
+    }
+    vetoed.push(seat.id);
+  }
+  const score = voteWeight === 0 ? 0 : passWeight / voteWeight;
+  const passed = vetoed.length === 0 && voteWeight > 0 && score >= table.threshold;
+  return {
+    passed,
+    vetoed,
+    rejected,
+    score,
+    invalidVetoes
+  };
+}
+
+const ARTIFACT_THRESHOLD = 8e3;
+function remainingTotal(budget) {
+  if (budget.total === void 0) {
+    return Number.POSITIVE_INFINITY;
+  }
+  return budget.total - budget.used;
+}
+function seatLimit(seat, budget) {
+  return seat.seat.budget ?? budget.perSeatLimit[seat.id];
+}
+function canSpend(seat, budget) {
+  if (remainingTotal(budget) <= 0) {
+    return false;
+  }
+  const limit = seatLimit(seat, budget);
+  if (limit === void 0) {
+    return true;
+  }
+  return (budget.perSeat[seat.id] ?? 0) < limit;
+}
+function spend(seatId, budget) {
+  budget.used += 1;
+  budget.perSeat[seatId] = (budget.perSeat[seatId] ?? 0) + 1;
+}
+async function callSeat(seat, prompt, options) {
+  const started = Date.now();
+  const wantJson = seat.seat.output === "json";
+  const call = options.callText ?? text;
+  try {
+    const result = await call({
+      prompt,
+      system: renderSeatSystemPrompt(seat),
+      json: wantJson,
+      temperature: seat.seat.temperature,
+      maxTokens: seat.seat.maxTokens,
+      // How long one seat may spend reading and answering. The table sets it
+      // because a seat's work is longer than a short request; leaving it
+      // undefined keeps the transport default.
+      timeoutMs: options.loaded.table.timeoutMs,
+      // Paid, non-idempotent: never resend after an unknown outcome.
+      retries: seat.seat.fallback === "retry" ? void 0 : 0,
+      env: options.env
+    });
+    let structured;
+    if (wantJson) {
+      try {
+        structured = JSON.parse(result.value);
+      } catch {
+        return {
+          ok: false,
+          content: result.value,
+          model: result.model,
+          usage: result.usage,
+          durationMs: Date.now() - started,
+          error: "output: seat returned invalid JSON"
+        };
+      }
+    }
+    return {
+      ok: true,
+      content: result.value,
+      structured,
+      model: result.model,
+      usage: result.usage,
+      durationMs: Date.now() - started
+    };
+  } catch (error) {
+    const describe = isAiError(error) ? error.describe() : error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      content: "",
+      durationMs: Date.now() - started,
+      error: describe
+    };
+  }
+}
+function emptyStatement(seat, phaseId, status, extra) {
+  return {
+    seat: seat.id,
+    name: seat.identity.name,
+    role: seat.role,
+    phase: phaseId,
+    status,
+    content: "",
+    ...extra
+  };
+}
+async function runPhase(phase, attempt, options, priorStatements, revisionNotes, dependenciesProduced) {
+  const { loaded, budget, events } = options;
+  const seats = phase.seats.map((id) => loaded.byId.get(id)).filter((seat) => Boolean(seat));
+  const leadIds = new Set(loaded.seats.filter((seat) => seat.seat.lead).map((seat) => seat.id));
+  if (!dependenciesProduced) {
+    return {
+      record: {
+        id: phase.id,
+        status: "skipped",
+        statements: [],
+        pruned: true
+      }
+    };
+  }
+  events?.onPhaseStart?.(phase, attempt);
+  const instruction = options.phaseInstructions?.[phase.id] ?? defaultPhaseInstruction(phase.id);
+  const statements = [];
+  const votes = [];
+  let stop;
+  const runSeat = async (seat) => {
+    if (!canSpend(seat, budget)) {
+      statements.push(emptyStatement(seat, phase.id, "budget-exhausted"));
+      return;
+    }
+    const visible = visibleStatements(seat, priorStatements.concat(statements), leadIds);
+    const prompt = buildUserPrompt({
+      phaseId: phase.id,
+      topic: options.topic,
+      context: options.context,
+      visible,
+      revisionNotes,
+      phaseInstruction: instruction
+    });
+    spend(seat.id, budget);
+    await options.persist?.();
+    const call = await callSeat(seat, prompt, options);
+    if (!call.ok) {
+      const status2 = "failed";
+      statements.push(emptyStatement(seat, phase.id, status2, {
+        content: call.content,
+        error: call.error,
+        durationMs: call.durationMs,
+        model: call.model,
+        usage: call.usage
+      }));
+      if (seat.seat.fallback === "abort") {
+        stop = "aborted";
+      }
+      return;
+    }
+    const statement = {
+      seat: seat.id,
+      name: seat.identity.name,
+      role: seat.role,
+      phase: phase.id,
+      status: "completed",
+      content: call.content,
+      structured: call.structured,
+      durationMs: call.durationMs,
+      model: call.model,
+      usage: call.usage
+    };
+    if (options.writeArtifact && call.content.length > ARTIFACT_THRESHOLD) {
+      const attempt2 = options.attempt ?? 1;
+      const relative = `artifacts/attempt-${attempt2}-${seat.id}-${phase.id}.md`;
+      const bytes = await options.writeArtifact(relative, call.content);
+      statement.artifacts = [
+        { path: relative, bytes }
+      ];
+    }
+    statements.push(statement);
+    events?.onStatement?.(statement);
+    if (phase.vetoable) {
+      const verdict = readJudgement(call.structured, call.content);
+      const vote = {
+        seatId: seat.id,
+        weight: seat.seat.weight,
+        vote: verdict.verdict,
+        veto: verdict.veto,
+        hasReason: verdict.hasReason
+      };
+      if (verdict.invalidVeto) {
+        statement.status = "invalid-veto";
+      }
+      votes.push(vote);
+    }
+  };
+  if (phase.mode === "parallel") {
+    await Promise.all(seats.map(async (seat) => runSeat(seat)));
+  } else {
+    for (const seat of seats) {
+      await runSeat(seat);
+      if (stop) {
+        break;
+      }
+    }
+  }
+  if (stop) {
+    return {
+      record: { id: phase.id, status: "failed", statements },
+      stop
+    };
+  }
+  const judgement = phase.vetoable ? judgePhase(phase, seats, votes, loaded.table) : void 0;
+  const exhausted = statements.some((statement) => statement.status === "budget-exhausted");
+  const completed = statements.some((statement) => statement.status === "completed");
+  const status = exhausted && !completed ? "budget-exhausted" : completed ? "completed" : "failed";
+  const record = {
+    id: phase.id,
+    status,
+    statements,
+    judgement
+  };
+  events?.onPhaseEnd?.(phase, record, attempt);
+  return {
+    record,
+    stop: exhausted && !completed ? "budget-exhausted" : void 0
+  };
+}
+function readJudgement(structured, content) {
+  if (structured && typeof structured === "object" && !Array.isArray(structured)) {
+    const source = structured;
+    const verdict = source.verdict === "pass" || source.verdict === "reject" ? source.verdict : void 0;
+    const reason = typeof source.reason === "string" ? source.reason.trim() : "";
+    const veto = verdict === "reject";
+    return {
+      verdict,
+      veto,
+      hasReason: reason.length > 0,
+      invalidVeto: veto && reason.length === 0
+    };
+  }
+  const head = content.trim().slice(0, 40);
+  if (/^(?:否决|不通过|reject)/i.test(head)) {
+    const reason = content.trim().slice(head.length).replace(/^[：:\s]+/, "").trim();
+    return {
+      verdict: "reject",
+      veto: true,
+      hasReason: reason.length > 0,
+      invalidVeto: reason.length === 0
+    };
+  }
+  if (/^(?:通过|approve|pass)\b/i.test(head)) {
+    return { verdict: "pass", veto: false };
+  }
+  return {};
+}
+async function runAttempt(attempt, options) {
+  const { loaded, events } = options;
+  const phases = [];
+  let stop;
+  let judgement;
+  const startIndex = options.startPhaseId ? Math.max(0, loaded.phases.findIndex((item) => item.id === options.startPhaseId)) : 0;
+  const finished = [
+    ...options.completedPhases ?? []
+  ];
+  let allStatements = finished.flatMap((phase) => phase.statements);
+  for (let index = startIndex; index < loaded.phases.length; index++) {
+    const phase = loaded.phases[index];
+    const previous = loaded.phases[index - 1];
+    const deps = phase.requires.length ? phase.requires : previous ? [previous.id] : [];
+    const dependenciesProduced = deps.every((dep) => {
+      const record2 = phases.find((item) => item.id === dep) ?? finished.find((item) => item.id === dep);
+      return Boolean(record2 && record2.status === "completed");
+    });
+    const notes = attempt > 1 && phase.id === loaded.table.special.propose ? options.revisionNotes ?? [] : [];
+    const { record, stop: phaseStop } = await runPhase(
+      phase,
+      attempt,
+      options,
+      allStatements,
+      notes,
+      deps.length === 0 || dependenciesProduced
+    );
+    phases.push(record);
+    allStatements = allStatements.concat(record.statements);
+    await options.persist?.();
+    if (record.judgement) {
+      judgement = record.judgement;
+    }
+    if (phaseStop) {
+      stop = phaseStop;
+      break;
+    }
+  }
+  events?.onAttempt?.(attempt, judgement);
+  return {
+    round: { attempt, phases },
+    judgement,
+    stop
+  };
+}
+function collectRejectionNotes(round, loaded) {
+  const notes = [];
+  for (const phase of round.phases) {
+    const judgement = phase.judgement;
+    if (!judgement) {
+      continue;
+    }
+    for (const seatId of [
+      ...judgement.vetoed,
+      ...judgement.rejected
+    ]) {
+      const statement = phase.statements.find((item) => item.seat === seatId && item.status === "completed");
+      if (!statement) {
+        continue;
+      }
+      const seat = loaded.byId.get(seatId);
+      const label = seat ? `${seat.identity.name}\uFF08${seat.role}\uFF09` : seatId;
+      const reason = extractReason(statement);
+      notes.push(`${label}\uFF1A${reason || "\u672A\u8BF4\u660E\u5177\u4F53\u7406\u7531"}`);
+    }
+  }
+  return notes;
+}
+function extractReason(statement) {
+  if (statement.structured && typeof statement.structured === "object" && !Array.isArray(statement.structured)) {
+    const source = statement.structured;
+    if (typeof source.reason === "string" && source.reason.trim()) {
+      return source.reason.trim();
+    }
+    if (Array.isArray(source.issues)) {
+      const issues = source.issues.filter((item) => typeof item === "string" && item.trim() !== "");
+      if (issues.length) {
+        return issues.slice(0, 5).join("\uFF1B");
+      }
+    }
+  }
+  return statement.content.trim().slice(0, 300);
+}
+
+const RECORD_SCHEMA = 1;
+function statusWord(status) {
+  switch (status) {
+    case "passed":
+      return "\u901A\u8FC7";
+    case "rejected":
+      return "\u672A\u901A\u8FC7";
+    case "aborted":
+      return "\u4E2D\u6B62";
+    case "failed":
+      return "\u5931\u8D25";
+    default:
+      return "\u8FDB\u884C\u4E2D";
+  }
+}
+function formatDuration(ms) {
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) {
+    return `${seconds} \u79D2`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const rest = seconds % 60;
+  return rest ? `${minutes} \u5206 ${rest} \u79D2` : `${minutes} \u5206`;
+}
+function statementLabel(statement, loaded) {
+  const seat = loaded.byId.get(statement.seat);
+  const name = statement.name || seat?.identity.name || statement.seat;
+  const role = statement.role || seat?.role || "";
+  const avatar = seat?.identity.avatar;
+  const parts = [avatar, name].filter(Boolean).join(" ");
+  return role ? `${parts} \xB7 ${role}` : parts;
+}
+function renderRecordMarkdown(record, loaded) {
+  const lines = [];
+  const date = record.startedAt.slice(0, 10);
+  lines.push(`# ${record.title} \xB7 ${date}`, "");
+  const vetoText = record.verdict.vetoed.length ? `\uFF0C\u5426\u51B3\uFF1A${record.verdict.vetoed.join("\u3001")}` : "\uFF0C\u65E0\u5426\u51B3";
+  lines.push(`**\u7ED3\u8BBA**\uFF1A${statusWord(record.status)}\uFF08\u901A\u8FC7\u7387 ${Math.round(record.verdict.score * 100)}%${vetoText}\uFF09`);
+  const elapsed = record.finishedAt ? formatDuration(new Date(record.finishedAt).getTime() - new Date(record.startedAt).getTime()) : "\u8FDB\u884C\u4E2D";
+  const total = record.budget.total === void 0 ? "\u4E0D\u9650" : String(record.budget.total);
+  lines.push(`**\u8F6E\u6B21**\uFF1A\u7B2C ${record.attempts} \u8F6E \xB7 \u9884\u7B97 ${record.budget.used}/${total} \xB7 \u7528\u65F6 ${elapsed}`);
+  const absent = [];
+  const latest = record.rounds[record.rounds.length - 1];
+  if (latest) {
+    for (const phase of latest.phases) {
+      const heading = phaseHeading(phase.id, loaded);
+      const completed = phase.statements.filter((statement) => statement.status === "completed");
+      for (const statement of phase.statements) {
+        if (statement.status !== "completed") {
+          absent.push(`${statementLabel(statement, loaded)}\uFF08${describeStatus(statement.status)}\uFF09`);
+        }
+      }
+      if (!completed.length) {
+        if (phase.pruned) {
+          lines.push("", `## ${heading}`, "", "\uFF08\u524D\u7F6E\u9636\u6BB5\u6CA1\u6709\u4EA7\u51FA\uFF0C\u672C\u9636\u6BB5\u8DF3\u8FC7\uFF09");
+        }
+        continue;
+      }
+      lines.push("", `## ${heading}`, "");
+      for (const statement of completed) {
+        lines.push(`**${statementLabel(statement, loaded)}**`, "");
+        lines.push(renderStatementBody(statement), "");
+      }
+      if (phase.judgement) {
+        lines.push(renderJudgement(phase.judgement, loaded), "");
+      }
+    }
+  }
+  if (record.verdict.invalidVetoes.length) {
+    lines.push("## \u88AB\u5FFD\u7565\u7684\u5426\u51B3", "", `\u4EE5\u4E0B\u5426\u51B3\u672A\u5199\u660E\u7406\u7531\uFF0C\u6309\u89C4\u5219\u89C6\u4E3A\u65E0\u6548\uFF1A${record.verdict.invalidVetoes.join("\u3001")}`, "");
+  }
+  if (absent.length) {
+    lines.push("## \u7F3A\u5E2D\u540D\u5355", "", ...absent.map((item) => `- ${item}`), "");
+  }
+  if (record.artifacts?.length) {
+    lines.push("## \u4EA7\u7269", "", ...record.artifacts.map((path) => `- ${path}`), "");
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function phaseHeading(phaseId, loaded) {
+  const special = loaded.table.special;
+  if (phaseId === special.propose) {
+    return "\u8BAE\u9898";
+  }
+  if (phaseId === special.converge) {
+    return "\u6536\u53E3";
+  }
+  const season = {
+    propose: "\u8BAE\u9898",
+    discuss: "\u8BA8\u8BBA",
+    produce: "\u4EA7\u51FA",
+    review: "\u5BA1\u6838",
+    converge: "\u6536\u53E3"
+  };
+  return season[phaseId] ?? phaseId;
+}
+function describeStatus(status) {
+  switch (status) {
+    case "skipped":
+      return "\u8DF3\u8FC7";
+    case "failed":
+      return "\u5931\u8D25";
+    case "budget-exhausted":
+      return "\u9884\u7B97\u8017\u5C3D";
+    case "invalid-veto":
+      return "\u5426\u51B3\u65E0\u6548";
+    default:
+      return status;
+  }
+}
+function renderStatementBody(statement) {
+  const { structured } = statement;
+  if (structured && typeof structured === "object" && !Array.isArray(structured)) {
+    const entries = Object.entries(structured);
+    if (entries.length) {
+      const rows = entries.map(([key, value]) => {
+        const text = typeof value === "string" ? value : JSON.stringify(value);
+        return `| ${key} | ${String(text).replace(/\|/g, "\\|")} |`;
+      });
+      return ["| \u952E | \u503C |", "| --- | --- |", ...rows].join("\n");
+    }
+  }
+  return statement.content.trim();
+}
+function renderJudgement(judgement, loaded) {
+  const parts = [];
+  parts.push(judgement.passed ? "\u88C1\u51B3\uFF1A\u901A\u8FC7" : "\u88C1\u51B3\uFF1A\u672A\u901A\u8FC7");
+  parts.push(`\u901A\u8FC7\u7387 ${Math.round(judgement.score * 100)}%`);
+  if (judgement.vetoed.length) {
+    const names = judgement.vetoed.map((id) => loaded.byId.get(id)?.identity.name ?? id);
+    parts.push(`\u5426\u51B3\uFF1A${names.join("\u3001")}`);
+  }
+  if (judgement.rejected.length && !judgement.vetoed.length) {
+    const names = judgement.rejected.map((id) => loaded.byId.get(id)?.identity.name ?? id);
+    parts.push(`\u53CD\u5BF9\uFF1A${names.join("\u3001")}`);
+  }
+  return `> ${parts.join(" \xB7 ")}`;
+}
+async function writeJson(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+async function writeText(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, value, "utf8");
+}
+function buildRecord(state, loaded) {
+  const finalJudgement = state.rounds.flatMap((round) => round.phases).filter((phase) => Boolean(phase.judgement)).pop()?.judgement;
+  const artifacts = state.rounds.flatMap((round) => round.phases).flatMap((phase) => phase.statements).flatMap((statement) => statement.artifacts ?? []).map((item) => item.path);
+  return {
+    schema: RECORD_SCHEMA,
+    title: loaded.table.title,
+    startedAt: state.startedAt,
+    finishedAt: state.finishedAt,
+    status: state.status,
+    attempts: state.rounds.length,
+    verdict: {
+      passed: state.status === "passed",
+      vetoed: finalJudgement?.vetoed ?? [],
+      rejected: finalJudgement?.rejected ?? [],
+      score: finalJudgement?.score ?? 0,
+      invalidVetoes: state.rounds.flatMap((round) => round.phases).flatMap((phase) => phase.judgement?.invalidVetoes ?? [])
+    },
+    rounds: state.rounds,
+    budget: {
+      total: state.budget.total,
+      used: state.budget.used,
+      perSeat: state.budget.perSeat
+    },
+    artifacts: artifacts.length ? artifacts : void 0,
+    error: state.error
+  };
+}
+function makeRunId(date = /* @__PURE__ */ new Date()) {
+  const pad = (value) => String(value).padStart(2, "0");
+  return [
+    date.getFullYear(),
+    "-",
+    pad(date.getMonth() + 1),
+    "-",
+    pad(date.getDate()),
+    "T",
+    pad(date.getHours()),
+    "-",
+    pad(date.getMinutes()),
+    "-",
+    pad(date.getSeconds())
+  ].join("");
+}
+
+function toContextList(context) {
+  if (context === void 0 || context === null) {
+    return [];
+  }
+  if (typeof context === "string") {
+    return context.trim() ? [context] : [];
+  }
+  if (!Array.isArray(context)) {
+    throw new RoundtableConfigError("context must be a string or an array of strings");
+  }
+  return context.map((item, index) => {
+    if (typeof item !== "string") {
+      throw new RoundtableConfigError(`context[${index}] must be a string`);
+    }
+    return item.trim();
+  }).filter(Boolean);
+}
+function initialBudget(loaded) {
+  const perSeatLimit = {};
+  for (const seat of loaded.seats) {
+    perSeatLimit[seat.id] = seat.seat.budget ?? loaded.table.budget.perSeat;
+  }
+  return {
+    total: loaded.table.budget.total,
+    used: 0,
+    perSeat: {},
+    perSeatLimit
+  };
+}
+function phaseInstructions(loaded, tableBody) {
+  const result = {};
+  if (!tableBody.trim()) {
+    return result;
+  }
+  const sections = tableBody.split(/^##\s+/m).slice(1);
+  for (const section of sections) {
+    const [head, ...rest] = section.split("\n");
+    const id = head?.trim();
+    if (id && loaded.phases.some((phase) => phase.id === id)) {
+      const text = rest.join("\n").trim();
+      if (text) {
+        result[id] = text;
+      }
+    }
+  }
+  return result;
+}
+async function readTableBody(configDir) {
+  const { readFile } = await import('node:fs/promises');
+  const source = await readFile(join(resolve(configDir), "table.md"), "utf8");
+  return readFrontmatter(source, "table.md").body;
 }
-async function loadRoundtable(_options) {
-  return notImplemented();
+async function runRoundtable(options) {
+  const loaded = await loadRoundtable({ configDir: options.configDir, schema: RECORD_SCHEMA });
+  const context = toContextList(options.context);
+  const outDir = resolve(options.outDir ?? defaultOutDir());
+  const runId = makeRunId();
+  const runDir = join(outDir, runId);
+  await mkdir(runDir, { recursive: true });
+  const state = {
+    schema: RECORD_SCHEMA,
+    runId,
+    status: "running",
+    attempt: 1,
+    phaseIndex: 0,
+    budget: initialBudget(loaded),
+    fingerprint: loaded.fingerprint,
+    resumable: true,
+    rounds: [],
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    topic: options.topic,
+    context
+  };
+  const statePath = join(runDir, "state.json");
+  const recordPath = join(runDir, "record.json");
+  const minutesPath = join(runDir, "record.md");
+  const persist = () => writeJson(statePath, state);
+  const writeArtifact = async (relativePath, content) => {
+    const target = join(runDir, relativePath);
+    await writeText(target, content);
+    return new TextEncoder().encode(content).byteLength;
+  };
+  let revisionNotes = [];
+  const instructions = phaseInstructions(loaded, await readTableBody(options.configDir));
+  for (let attempt = 1; attempt <= loaded.table.maxAttempts; attempt++) {
+    state.attempt = attempt;
+    options.onProgress?.(`roundtable: \u7B2C ${attempt} \u8F6E\u5F00\u59CB`);
+    const result = await runAttempt(attempt, {
+      loaded,
+      context,
+      topic: options.topic,
+      env: options.env,
+      budget: state.budget,
+      phaseInstructions: instructions,
+      revisionNotes,
+      persist,
+      callText: options.callText,
+      writeArtifact,
+      attempt,
+      events: {
+        onStatement: (statement) => {
+          const seat = loaded.byId.get(statement.seat);
+          const name = seat?.identity.name ?? statement.seat;
+          options.onProgress?.(`  ${name} \xB7 ${statement.phase} \xB7 ${statement.status}`);
+        },
+        // Progress is positional only; the authoritative round data comes from
+        // runAttempt's return value so a partially filled state can never leak
+        // into the record.
+        onPhaseStart: (phase) => {
+          state.phaseId = phase.id;
+          state.phaseIndex = loaded.phases.findIndex((item) => item.id === phase.id);
+        },
+        onPhaseEnd: () => {
+          void persist();
+        }
+      }
+    });
+    state.rounds = state.rounds.filter((round) => round.attempt !== attempt).concat(result.round);
+    if (result.stop) {
+      state.status = "aborted";
+      state.error = result.stop === "budget-exhausted" ? `\u9884\u7B97\u5728\u9636\u6BB5 "${state.phaseId ?? ""}" \u8017\u5C3D` : "\u6709\u5E2D\u4F4D\u8981\u6C42\u4E2D\u6B62";
+      break;
+    }
+    const passed = result.round.phases.filter((phase) => phase.judgement).every((phase) => phase.judgement.passed);
+    const anyJudged = result.round.phases.some((phase) => phase.judgement);
+    const completedAll = result.round.phases.every((phase) => phase.status === "completed");
+    if (anyJudged ? passed : completedAll) {
+      state.status = "passed";
+      break;
+    }
+    revisionNotes = collectRejectionNotes(result.round, loaded);
+    if (attempt === loaded.table.maxAttempts) {
+      state.status = "rejected";
+      break;
+    }
+    if (loaded.table.onVeto === "abort") {
+      state.status = "aborted";
+      state.error = "\u89C4\u5219\u8981\u6C42\u88AB\u5426\u51B3\u5373\u4E2D\u6B62";
+      break;
+    }
+    options.onProgress?.(`roundtable: \u7B2C ${attempt} \u8F6E\u672A\u901A\u8FC7\uFF0C\u8FDB\u5165\u7B2C ${attempt + 1} \u8F6E`);
+  }
+  if (state.status === "running") {
+    state.status = "rejected";
+  }
+  state.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  state.resumable = false;
+  const record = buildRecord(state, loaded);
+  await writeJson(statePath, state);
+  await writeJson(recordPath, record);
+  await writeText(minutesPath, renderRecordMarkdown(record, loaded));
+  return {
+    status: record.status,
+    recordPath,
+    runDir,
+    record,
+    used: state.budget.used,
+    budgetTotal: state.budget.total
+  };
 }
-async function checkRoundtable(_options) {
-  return notImplemented();
+async function resumeRoundtable(options) {
+  const runDir = resolve(options.runDir);
+  const loaded = await loadRoundtable({ configDir: options.configDir, schema: RECORD_SCHEMA });
+  const state = await readState(runDir);
+  if (!state) {
+    throw new RoundtableConfigError(`No state.json in ${runDir}; nothing to resume`);
+  }
+  if (state.fingerprint !== loaded.fingerprint) {
+    throw new RoundtableConfigError(
+      "Rules changed since this run started; open a new meeting instead of resuming"
+    );
+  }
+  const recordPath = join(runDir, "record.json");
+  const minutesPath = join(runDir, "record.md");
+  if (state.status !== "running") {
+    const existing = buildRecord(state, loaded);
+    await writeJson(recordPath, existing);
+    await writeText(minutesPath, renderRecordMarkdown(existing, loaded));
+    return {
+      status: existing.status,
+      recordPath,
+      runDir,
+      record: existing,
+      used: state.budget.used,
+      budgetTotal: state.budget.total
+    };
+  }
+  const context = state.context.length ? state.context : toContextList(options.context);
+  const instructions = phaseInstructions(loaded, await readTableBody(options.configDir));
+  const persist = () => writeJson(join(runDir, "state.json"), state);
+  const writeArtifact = async (relativePath, content) => {
+    await writeText(join(runDir, relativePath), content);
+    return new TextEncoder().encode(content).byteLength;
+  };
+  for (let attempt = state.rounds.length || 1; attempt <= loaded.table.maxAttempts; attempt++) {
+    state.attempt = attempt;
+    options.onProgress?.(`roundtable: \u7EED\u8DD1\u7B2C ${attempt} \u8F6E`);
+    const donePhases = state.rounds.find((round) => round.attempt === attempt)?.phases ?? [];
+    const startPhase = loaded.phases.findIndex((phase) => {
+      const record2 = donePhases.find((item) => item.id === phase.id);
+      return !record2 || record2.status !== "completed";
+    });
+    if (startPhase === -1) {
+      state.status = donePhases.some((phase) => phase.judgement && !phase.judgement.passed) ? "rejected" : "passed";
+      break;
+    }
+    const startPhaseId = loaded.phases[startPhase]?.id;
+    const revisionNotes = collectRejectionNotes(
+      { phases: state.rounds.at(-1)?.phases ?? [] },
+      loaded
+    );
+    const result = await runAttempt(attempt, {
+      loaded,
+      context,
+      topic: state.topic ?? options.topic,
+      env: options.env,
+      budget: state.budget,
+      phaseInstructions: instructions,
+      revisionNotes,
+      persist,
+      callText: options.callText,
+      writeArtifact,
+      attempt,
+      // Finished phases stay available as input for the resumed ones.
+      completedPhases: donePhases.filter((phase) => phase.status === "completed"),
+      events: {
+        onStatement: (statement) => {
+          const seat = loaded.byId.get(statement.seat);
+          options.onProgress?.(`  ${seat?.identity.name ?? statement.seat} \xB7 ${statement.phase} \xB7 ${statement.status}`);
+        },
+        onPhaseStart: (phase) => {
+          state.phaseId = phase.id;
+          state.phaseIndex = loaded.phases.findIndex((item) => item.id === phase.id);
+        }
+      },
+      startPhaseId
+    });
+    const merged = loaded.phases.map((phase) => {
+      const fresh = result.round.phases.find((item) => item.id === phase.id);
+      if (fresh) {
+        return fresh;
+      }
+      const previous = donePhases.find((item) => item.id === phase.id);
+      return previous ?? { id: phase.id, status: "skipped", statements: [] };
+    });
+    state.rounds = state.rounds.filter((round) => round.attempt !== attempt).concat({ attempt, phases: merged });
+    if (result.stop) {
+      state.status = "aborted";
+      state.error = result.stop === "budget-exhausted" ? `\u9884\u7B97\u5728\u9636\u6BB5 "${state.phaseId ?? ""}" \u8017\u5C3D` : "\u6709\u5E2D\u4F4D\u8981\u6C42\u4E2D\u6B62";
+      break;
+    }
+    const anyJudged = merged.some((phase) => phase.judgement);
+    const passed = anyJudged && merged.every((phase) => !phase.judgement || phase.judgement.passed);
+    if (anyJudged ? passed : merged.every((phase) => phase.status === "completed")) {
+      state.status = "passed";
+      break;
+    }
+    if (attempt === loaded.table.maxAttempts) {
+      state.status = "rejected";
+      break;
+    }
+    if (loaded.table.onVeto === "abort") {
+      state.status = "aborted";
+      state.error = "\u89C4\u5219\u8981\u6C42\u88AB\u5426\u51B3\u5373\u4E2D\u6B62";
+      break;
+    }
+  }
+  if (state.status === "running") {
+    state.status = "rejected";
+  }
+  state.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  state.resumable = false;
+  const record = buildRecord(state, loaded);
+  await writeJson(join(runDir, "state.json"), state);
+  await writeJson(recordPath, record);
+  await writeText(minutesPath, renderRecordMarkdown(record, loaded));
+  return {
+    status: record.status,
+    recordPath,
+    runDir,
+    record,
+    used: state.budget.used,
+    budgetTotal: state.budget.total
+  };
 }
-async function runRoundtable(_options) {
-  return notImplemented();
+async function readState(runDir) {
+  const { readFile } = await import('node:fs/promises');
+  try {
+    const raw = await readFile(join(runDir, "state.json"), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
 }
 
-export { ROUNDTABLE_SCHEMA, checkRoundtable, loadRoundtable, runRoundtable };
+export { RECORD_SCHEMA as ROUNDTABLE_SCHEMA, RoundtableConfigError, checkRoundtable, defaultOutDir, loadRoundtable, resumeRoundtable, runRoundtable };