@vextlabs/theron-agent-sdk 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -5,6 +5,22 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.3.1] - 2026-06-26
+
+### Added
+- **Sub-agent delegation actually executes.** A supervisor `Agent` with `sub_agents` now exposes one `delegate_to_<name>` tool per sub-agent (via `toolSchemas()`), and the `Runner` routes those calls back into `runner.run(subAgent, task)`, threading the abort signal — hierarchical multi-agent graphs work end-to-end instead of `sub_agents` being a silent no-op. New export `subAgentToolName`.
+- **On-disk SKILL.md loader** — `parseMarkdownSkill` / `loadMarkdownSkills` / `loadAllMarkdownSkills` (+ `MarkdownSkill` type) load user/project skills from `~/.theron/skills/*.md` and `<project>/.theron/skills/*.md` (also `<name>/SKILL.md` dirs), with project-local overriding global. Mirrors the markdown-agent loader; consumed by both the CLI and VS Code surfaces.
+- **`AbortSignal` cancellation** — `Runner.run`/`runCouncil` accept `{ signal }` (new `RunOptions`); the loop checks it each turn and emits an `aborted` event; `ModelAdapter.chat` gains an optional `signal` to forward to `fetch`.
+- **Cost accounting** — `ModelAdapter.chat` may return `cost_usd`; the Runner sums it into `AgentResult.cost_usd`, so `costUsdAtLeast` and budget-stop now work.
+- **`max_turns_exhausted` event** — emitted when the loop runs out of turns without a final answer (instead of silently returning `""`).
+- **Council `claimExtractor`** — opt-in extractor (e.g. exported `sentenceClaimExtractor`) so the deterministic reconciler can ratify cross-specialist claims; default behavior unchanged.
+- **`compactHistory({ summaryRole })`** — attach the summary under `user` instead of `system` for providers that reject a second system message.
+
+### Changed
+- **Parallel tool dispatch.** Multiple tool calls in a single turn now execute concurrently (`Promise.all`) with results appended in call order — turn latency drops from sum-of-tools to slowest-tool.
+- **Robust Zod → JSON Schema.** The converter now handles unions, literals, records, nullables, defaults, enums, and `.describe()` annotations (and excludes default-valued fields from `required`) instead of silently emitting `{type:"string"}`.
+- **MCP single-flight init.** Concurrent `listTools`/`callTool` callers share one in-flight `initialize` handshake (no duplicate sessions); a failed init is retryable.
+
 ## [0.3.0] - 2026-06-13
 
 ### Added

package/dist/adapters/theron.cjs

@@ -35,6 +35,7 @@ function theronAdapter(opts = {}) {
         let inputTokens = 0;
         let outputTokens = 0;
         let buf = "";
+        const toolAcc = {};
         for (; ; ) {
           const { value, done } = await reader.read();
           if (done) break;
@@ -47,11 +48,20 @@ function theronAdapter(opts = {}) {
             if (!data || data === "[DONE]") continue;
             try {
               const json2 = JSON.parse(data);
-              const delta = json2.choices?.[0]?.delta?.content;
+              const d = json2.choices?.[0]?.delta;
+              const delta = d?.content;
               if (delta) {
                 onDelta(delta);
                 content += delta;
               }
+              if (Array.isArray(d?.tool_calls)) {
+                for (const tc of d.tool_calls) {
+                  const i = typeof tc.index === "number" ? tc.index : 0;
+                  toolAcc[i] ??= { name: "", args: "" };
+                  if (tc.function?.name) toolAcc[i].name = tc.function.name;
+                  if (tc.function?.arguments) toolAcc[i].args += tc.function.arguments;
+                }
+              }
               if (json2.usage) {
                 inputTokens = json2.usage.prompt_tokens ?? inputTokens;
                 outputTokens = json2.usage.completion_tokens ?? outputTokens;
@@ -60,7 +70,8 @@ function theronAdapter(opts = {}) {
             }
           }
         }
-        return { content, tokens: { input: inputTokens, output: outputTokens } };
+        const tool_calls2 = Object.keys(toolAcc).length ? Object.values(toolAcc).map((t) => ({ name: t.name, input: safeJson(t.args) })) : void 0;
+        return { content, tool_calls: tool_calls2, tokens: { input: inputTokens, output: outputTokens } };
       }
       const json = await res.json();
       const msg = json.choices?.[0]?.message ?? { content: "" };

package/dist/adapters/theron.js

@@ -33,6 +33,7 @@ function theronAdapter(opts = {}) {
         let inputTokens = 0;
         let outputTokens = 0;
         let buf = "";
+        const toolAcc = {};
         for (; ; ) {
           const { value, done } = await reader.read();
           if (done) break;
@@ -45,11 +46,20 @@ function theronAdapter(opts = {}) {
             if (!data || data === "[DONE]") continue;
             try {
               const json2 = JSON.parse(data);
-              const delta = json2.choices?.[0]?.delta?.content;
+              const d = json2.choices?.[0]?.delta;
+              const delta = d?.content;
               if (delta) {
                 onDelta(delta);
                 content += delta;
               }
+              if (Array.isArray(d?.tool_calls)) {
+                for (const tc of d.tool_calls) {
+                  const i = typeof tc.index === "number" ? tc.index : 0;
+                  toolAcc[i] ??= { name: "", args: "" };
+                  if (tc.function?.name) toolAcc[i].name = tc.function.name;
+                  if (tc.function?.arguments) toolAcc[i].args += tc.function.arguments;
+                }
+              }
               if (json2.usage) {
                 inputTokens = json2.usage.prompt_tokens ?? inputTokens;
                 outputTokens = json2.usage.completion_tokens ?? outputTokens;
@@ -58,7 +68,8 @@ function theronAdapter(opts = {}) {
             }
           }
         }
-        return { content, tokens: { input: inputTokens, output: outputTokens } };
+        const tool_calls2 = Object.keys(toolAcc).length ? Object.values(toolAcc).map((t) => ({ name: t.name, input: safeJson(t.args) })) : void 0;
+        return { content, tool_calls: tool_calls2, tokens: { input: inputTokens, output: outputTokens } };
       }
       const json = await res.json();
       const msg = json.choices?.[0]?.message ?? { content: "" };

package/dist/agent/index.cjs

@@ -20,14 +20,123 @@ var Agent = class {
     this.verifiers = config.verifiers ?? [];
     this.max_turns = config.max_turns ?? 10;
   }
-  /** Render the tools as JSON schemas for the model. */
+  /**
+   * Render the tools as JSON schemas for the model — the agent's own tools
+   * PLUS one `delegate_to_<sub-agent>` tool per declared sub-agent, so a
+   * supervisor can actually hand work to its specialists. The Runner routes
+   * those delegate calls back into `runner.run(subAgent, task)`.
+   */
   toolSchemas() {
-    return this.tools.map((t) => t.schema);
+    const own = this.tools.map((t) => t.schema);
+    const delegates = this.sub_agents.map((sa) => ({
+      name: subAgentToolName(sa.name),
+      description: `Delegate a self-contained subtask to the "${sa.name}" sub-agent and get back its result. ${sa.instruction.system.slice(0, 200)}`,
+      input_schema: {
+        type: "object",
+        properties: {
+          task: {
+            type: "string",
+            description: `The subtask for the "${sa.name}" sub-agent to perform, stated as a complete, standalone instruction.`
+          }
+        },
+        required: ["task"]
+      }
+    }));
+    return [...own, ...delegates];
+  }
+  /** Resolve a delegate tool-call name back to the sub-agent it targets. */
+  findSubAgent(toolName) {
+    return this.sub_agents.find((sa) => subAgentToolName(sa.name) === toolName);
   }
   /** True if the agent has any sub-agents (i.e., this is a supervisor). */
   isSupervisor() {
     return this.sub_agents.length > 0;
   }
 };
+function subAgentToolName(name) {
+  return `delegate_to_${name}`.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+function parseMarkdownAgent(filename, content) {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!fmMatch) return null;
+  const frontmatter = fmMatch[1];
+  const body = fmMatch[2].trim();
+  if (!body) return null;
+  const fields = {};
+  let currentKey = "";
+  for (const line of frontmatter.split("\n")) {
+    const listMatch = line.match(/^\s+-\s+(.+)$/);
+    if (listMatch && currentKey) {
+      const existing = fields[currentKey];
+      if (Array.isArray(existing)) {
+        existing.push(listMatch[1].trim());
+      } else {
+        fields[currentKey] = [listMatch[1].trim()];
+      }
+      continue;
+    }
+    const kvMatch = line.match(/^(\w[\w-]*)\s*:\s*(.*)$/);
+    if (kvMatch) {
+      const key = kvMatch[1].trim();
+      const value = kvMatch[2].trim();
+      currentKey = key;
+      fields[key] = value.replace(/^["']|["']$/g, "");
+    }
+  }
+  const name = String(fields.name || "").trim();
+  if (!name) return null;
+  const baseFilename = filename.replace(/\.md$/i, "").replace(/[^a-z0-9_-]/gi, "-").toLowerCase();
+  const id = name.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/-+/g, "-") || baseFilename;
+  return {
+    id,
+    name,
+    description: String(fields.description || ""),
+    model: fields.model ? String(fields.model) : void 0,
+    tools: Array.isArray(fields.tools) ? fields.tools.map(String) : void 0,
+    max_turns: fields.max_turns ? parseInt(String(fields.max_turns), 10) || void 0 : void 0,
+    system_prompt: body,
+    source: filename
+  };
+}
+async function loadMarkdownAgents(dir) {
+  const fs = await import('fs/promises');
+  const path = await import('path');
+  try {
+    const entries = await fs.readdir(dir);
+    const mdFiles = entries.filter((f) => f.endsWith(".md"));
+    const results = [];
+    for (const file of mdFiles) {
+      try {
+        const fullPath = path.join(dir, file);
+        const content = await fs.readFile(fullPath, "utf8");
+        const parsed = parseMarkdownAgent(file, content);
+        if (parsed) results.push(parsed);
+      } catch {
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+async function loadAllMarkdownAgents(projectDir) {
+  const os = await import('os');
+  const path = await import('path');
+  const home = os.homedir();
+  const globalDir = path.join(home, ".theron", "agents");
+  const localDir = projectDir ? path.join(projectDir, ".theron", "agents") : path.join(process.cwd(), ".theron", "agents");
+  const [globalAgents, localAgents] = await Promise.all([
+    loadMarkdownAgents(globalDir),
+    loadMarkdownAgents(localDir)
+  ]);
+  const byId = /* @__PURE__ */ new Map();
+  for (const a of globalAgents) byId.set(a.id, a);
+  for (const a of localAgents) byId.set(a.id, a);
+  return [...byId.values()];
+}
 
 exports.Agent = Agent;
+exports.loadAllMarkdownAgents = loadAllMarkdownAgents;
+exports.loadMarkdownAgents = loadMarkdownAgents;
+exports.parseMarkdownAgent = parseMarkdownAgent;
+exports.subAgentToolName = subAgentToolName;

package/dist/agent/index.d.cts

@@ -75,10 +75,51 @@ declare class Agent {
     readonly verifiers: Verifier[];
     readonly max_turns: number;
     constructor(config: AgentConfig);
-    /** Render the tools as JSON schemas for the model. */
+    /**
+     * Render the tools as JSON schemas for the model — the agent's own tools
+     * PLUS one `delegate_to_<sub-agent>` tool per declared sub-agent, so a
+     * supervisor can actually hand work to its specialists. The Runner routes
+     * those delegate calls back into `runner.run(subAgent, task)`.
+     */
     toolSchemas(): ToolSchema[];
+    /** Resolve a delegate tool-call name back to the sub-agent it targets. */
+    findSubAgent(toolName: string): Agent | undefined;
     /** True if the agent has any sub-agents (i.e., this is a supervisor). */
     isSupervisor(): boolean;
 }
+/** Canonical tool name a supervisor uses to delegate to a sub-agent. */
+declare function subAgentToolName(name: string): string;
+interface MarkdownAgentType {
+    /** Unique slug derived from the filename or frontmatter `name`. */
+    id: string;
+    /** Display name from frontmatter. */
+    name: string;
+    /** Human-readable description from frontmatter. */
+    description: string;
+    /** Model identifier from frontmatter (optional). */
+    model?: string;
+    /** Tool name allowlist from frontmatter (optional). */
+    tools?: string[];
+    /** Max turns from frontmatter (optional, defaults to 10). */
+    max_turns?: number;
+    /** System prompt — the Markdown body after frontmatter. */
+    system_prompt: string;
+    /** Source file path. */
+    source: string;
+}
+/** Parse a single Markdown agent file into a MarkdownAgentType. */
+declare function parseMarkdownAgent(filename: string, content: string): MarkdownAgentType | null;
+/**
+ * Load all Markdown agent types from a directory.
+ * Returns an array of parsed agent types, or an empty array if the
+ * directory doesn't exist or can't be read. Never throws.
+ */
+declare function loadMarkdownAgents(dir: string): Promise<MarkdownAgentType[]>;
+/**
+ * Load Markdown agents from both global (~/.theron/agents) and project-local
+ * (.theron/agents) directories. Project-local takes precedence on id
+ * collisions. Never throws.
+ */
+declare function loadAllMarkdownAgents(projectDir?: string): Promise<MarkdownAgentType[]>;
 
-export { Agent, type AgentConfig, type AgentInstruction, type AgentResult };
+export { Agent, type AgentConfig, type AgentInstruction, type AgentResult, type MarkdownAgentType, loadAllMarkdownAgents, loadMarkdownAgents, parseMarkdownAgent, subAgentToolName };

package/dist/agent/index.d.ts

@@ -75,10 +75,51 @@ declare class Agent {
     readonly verifiers: Verifier[];
     readonly max_turns: number;
     constructor(config: AgentConfig);
-    /** Render the tools as JSON schemas for the model. */
+    /**
+     * Render the tools as JSON schemas for the model — the agent's own tools
+     * PLUS one `delegate_to_<sub-agent>` tool per declared sub-agent, so a
+     * supervisor can actually hand work to its specialists. The Runner routes
+     * those delegate calls back into `runner.run(subAgent, task)`.
+     */
     toolSchemas(): ToolSchema[];
+    /** Resolve a delegate tool-call name back to the sub-agent it targets. */
+    findSubAgent(toolName: string): Agent | undefined;
     /** True if the agent has any sub-agents (i.e., this is a supervisor). */
     isSupervisor(): boolean;
 }
+/** Canonical tool name a supervisor uses to delegate to a sub-agent. */
+declare function subAgentToolName(name: string): string;
+interface MarkdownAgentType {
+    /** Unique slug derived from the filename or frontmatter `name`. */
+    id: string;
+    /** Display name from frontmatter. */
+    name: string;
+    /** Human-readable description from frontmatter. */
+    description: string;
+    /** Model identifier from frontmatter (optional). */
+    model?: string;
+    /** Tool name allowlist from frontmatter (optional). */
+    tools?: string[];
+    /** Max turns from frontmatter (optional, defaults to 10). */
+    max_turns?: number;
+    /** System prompt — the Markdown body after frontmatter. */
+    system_prompt: string;
+    /** Source file path. */
+    source: string;
+}
+/** Parse a single Markdown agent file into a MarkdownAgentType. */
+declare function parseMarkdownAgent(filename: string, content: string): MarkdownAgentType | null;
+/**
+ * Load all Markdown agent types from a directory.
+ * Returns an array of parsed agent types, or an empty array if the
+ * directory doesn't exist or can't be read. Never throws.
+ */
+declare function loadMarkdownAgents(dir: string): Promise<MarkdownAgentType[]>;
+/**
+ * Load Markdown agents from both global (~/.theron/agents) and project-local
+ * (.theron/agents) directories. Project-local takes precedence on id
+ * collisions. Never throws.
+ */
+declare function loadAllMarkdownAgents(projectDir?: string): Promise<MarkdownAgentType[]>;
 
-export { Agent, type AgentConfig, type AgentInstruction, type AgentResult };
+export { Agent, type AgentConfig, type AgentInstruction, type AgentResult, type MarkdownAgentType, loadAllMarkdownAgents, loadMarkdownAgents, parseMarkdownAgent, subAgentToolName };

package/dist/agent/index.js

@@ -18,14 +18,119 @@ var Agent = class {
     this.verifiers = config.verifiers ?? [];
     this.max_turns = config.max_turns ?? 10;
   }
-  /** Render the tools as JSON schemas for the model. */
+  /**
+   * Render the tools as JSON schemas for the model — the agent's own tools
+   * PLUS one `delegate_to_<sub-agent>` tool per declared sub-agent, so a
+   * supervisor can actually hand work to its specialists. The Runner routes
+   * those delegate calls back into `runner.run(subAgent, task)`.
+   */
   toolSchemas() {
-    return this.tools.map((t) => t.schema);
+    const own = this.tools.map((t) => t.schema);
+    const delegates = this.sub_agents.map((sa) => ({
+      name: subAgentToolName(sa.name),
+      description: `Delegate a self-contained subtask to the "${sa.name}" sub-agent and get back its result. ${sa.instruction.system.slice(0, 200)}`,
+      input_schema: {
+        type: "object",
+        properties: {
+          task: {
+            type: "string",
+            description: `The subtask for the "${sa.name}" sub-agent to perform, stated as a complete, standalone instruction.`
+          }
+        },
+        required: ["task"]
+      }
+    }));
+    return [...own, ...delegates];
+  }
+  /** Resolve a delegate tool-call name back to the sub-agent it targets. */
+  findSubAgent(toolName) {
+    return this.sub_agents.find((sa) => subAgentToolName(sa.name) === toolName);
   }
   /** True if the agent has any sub-agents (i.e., this is a supervisor). */
   isSupervisor() {
     return this.sub_agents.length > 0;
   }
 };
+function subAgentToolName(name) {
+  return `delegate_to_${name}`.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+function parseMarkdownAgent(filename, content) {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!fmMatch) return null;
+  const frontmatter = fmMatch[1];
+  const body = fmMatch[2].trim();
+  if (!body) return null;
+  const fields = {};
+  let currentKey = "";
+  for (const line of frontmatter.split("\n")) {
+    const listMatch = line.match(/^\s+-\s+(.+)$/);
+    if (listMatch && currentKey) {
+      const existing = fields[currentKey];
+      if (Array.isArray(existing)) {
+        existing.push(listMatch[1].trim());
+      } else {
+        fields[currentKey] = [listMatch[1].trim()];
+      }
+      continue;
+    }
+    const kvMatch = line.match(/^(\w[\w-]*)\s*:\s*(.*)$/);
+    if (kvMatch) {
+      const key = kvMatch[1].trim();
+      const value = kvMatch[2].trim();
+      currentKey = key;
+      fields[key] = value.replace(/^["']|["']$/g, "");
+    }
+  }
+  const name = String(fields.name || "").trim();
+  if (!name) return null;
+  const baseFilename = filename.replace(/\.md$/i, "").replace(/[^a-z0-9_-]/gi, "-").toLowerCase();
+  const id = name.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/-+/g, "-") || baseFilename;
+  return {
+    id,
+    name,
+    description: String(fields.description || ""),
+    model: fields.model ? String(fields.model) : void 0,
+    tools: Array.isArray(fields.tools) ? fields.tools.map(String) : void 0,
+    max_turns: fields.max_turns ? parseInt(String(fields.max_turns), 10) || void 0 : void 0,
+    system_prompt: body,
+    source: filename
+  };
+}
+async function loadMarkdownAgents(dir) {
+  const fs = await import('fs/promises');
+  const path = await import('path');
+  try {
+    const entries = await fs.readdir(dir);
+    const mdFiles = entries.filter((f) => f.endsWith(".md"));
+    const results = [];
+    for (const file of mdFiles) {
+      try {
+        const fullPath = path.join(dir, file);
+        const content = await fs.readFile(fullPath, "utf8");
+        const parsed = parseMarkdownAgent(file, content);
+        if (parsed) results.push(parsed);
+      } catch {
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+async function loadAllMarkdownAgents(projectDir) {
+  const os = await import('os');
+  const path = await import('path');
+  const home = os.homedir();
+  const globalDir = path.join(home, ".theron", "agents");
+  const localDir = projectDir ? path.join(projectDir, ".theron", "agents") : path.join(process.cwd(), ".theron", "agents");
+  const [globalAgents, localAgents] = await Promise.all([
+    loadMarkdownAgents(globalDir),
+    loadMarkdownAgents(localDir)
+  ]);
+  const byId = /* @__PURE__ */ new Map();
+  for (const a of globalAgents) byId.set(a.id, a);
+  for (const a of localAgents) byId.set(a.id, a);
+  return [...byId.values()];
+}
 
-export { Agent };
+export { Agent, loadAllMarkdownAgents, loadMarkdownAgents, parseMarkdownAgent, subAgentToolName };

package/dist/council/index.cjs

@@ -1,12 +1,14 @@
 'use strict';
 
 // src/council/index.ts
+var sentenceClaimExtractor = (output) => output.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter((s) => s.length > 0).map((text) => ({ text, confidence: 1, type: "assertion" }));
 var Council = class {
   name;
   specialists;
   verifiers;
   reconciler;
   specialist_timeout_ms;
+  claimExtractor;
   constructor(config) {
     if (!config.name) throw new Error("Council requires a `name`.");
     if (!config.specialists || config.specialists.length === 0) {
@@ -17,6 +19,7 @@ var Council = class {
     this.verifiers = config.verifiers ?? [];
     this.reconciler = config.reconciler ?? deterministicClaimMerge;
     this.specialist_timeout_ms = config.specialist_timeout_ms ?? 3e4;
+    this.claimExtractor = config.claimExtractor;
   }
   /**
    * Convenience entry point — pointed at the Runner you've already constructed.
@@ -66,3 +69,4 @@ var deterministicClaimMerge = async (specialists) => {
 };
 
 exports.Council = Council;
+exports.sentenceClaimExtractor = sentenceClaimExtractor;

package/dist/council/index.d.cts

@@ -60,7 +60,30 @@ interface CouncilConfig {
     reconciler?: Reconciler;
     /** Optional timeout per specialist (ms). Slow specialists are dropped. */
     specialist_timeout_ms?: number;
+    /**
+     * Optional claim extractor. The default deterministic reconciler votes over
+     * the per-specialist `claims` arrays — with no extractor those arrays are
+     * empty and the reconciler can only fall back to the first specialist's
+     * output ("refuted"). Supply an extractor (e.g. a sentence splitter, or a
+     * structured parser keyed on your specialists' output format) to enable
+     * real cross-specialist ratification. See `sentenceClaimExtractor`.
+     */
+    claimExtractor?: ClaimExtractor;
 }
+/** Turn a specialist's raw output into a list of claims for voting. */
+type ClaimExtractor = (output: string) => Array<{
+    text: string;
+    confidence: number;
+    type: string;
+}>;
+/**
+ * A simple, dependency-free claim extractor: split the output into sentences
+ * and treat each as an assertion at full confidence. Paraphrase-insensitive
+ * (the default reconciler matches claim text exactly, lowercased), so it
+ * ratifies only verbatim-agreeing claims — good enough for short, factual
+ * specialist answers; swap in a semantic extractor for prose.
+ */
+declare const sentenceClaimExtractor: ClaimExtractor;
 /**
  * The Council primitive.
  *
@@ -84,6 +107,7 @@ declare class Council {
     readonly verifiers: Verifier[];
     readonly reconciler: Reconciler;
     readonly specialist_timeout_ms: number;
+    readonly claimExtractor: ClaimExtractor | undefined;
     constructor(config: CouncilConfig);
     /**
      * Convenience entry point — pointed at the Runner you've already constructed.
@@ -93,4 +117,4 @@ declare class Council {
     deliberate(_query: string): Promise<CouncilOutput>;
 }
 
-export { Council, type CouncilConfig, type CouncilOutput, type CouncilSpecialistOutput, type Reconciler };
+export { type ClaimExtractor, Council, type CouncilConfig, type CouncilOutput, type CouncilSpecialistOutput, type Reconciler, sentenceClaimExtractor };

package/dist/council/index.d.ts

@@ -60,7 +60,30 @@ interface CouncilConfig {
     reconciler?: Reconciler;
     /** Optional timeout per specialist (ms). Slow specialists are dropped. */
     specialist_timeout_ms?: number;
+    /**
+     * Optional claim extractor. The default deterministic reconciler votes over
+     * the per-specialist `claims` arrays — with no extractor those arrays are
+     * empty and the reconciler can only fall back to the first specialist's
+     * output ("refuted"). Supply an extractor (e.g. a sentence splitter, or a
+     * structured parser keyed on your specialists' output format) to enable
+     * real cross-specialist ratification. See `sentenceClaimExtractor`.
+     */
+    claimExtractor?: ClaimExtractor;
 }
+/** Turn a specialist's raw output into a list of claims for voting. */
+type ClaimExtractor = (output: string) => Array<{
+    text: string;
+    confidence: number;
+    type: string;
+}>;
+/**
+ * A simple, dependency-free claim extractor: split the output into sentences
+ * and treat each as an assertion at full confidence. Paraphrase-insensitive
+ * (the default reconciler matches claim text exactly, lowercased), so it
+ * ratifies only verbatim-agreeing claims — good enough for short, factual
+ * specialist answers; swap in a semantic extractor for prose.
+ */
+declare const sentenceClaimExtractor: ClaimExtractor;
 /**
  * The Council primitive.
  *
@@ -84,6 +107,7 @@ declare class Council {
     readonly verifiers: Verifier[];
     readonly reconciler: Reconciler;
     readonly specialist_timeout_ms: number;
+    readonly claimExtractor: ClaimExtractor | undefined;
     constructor(config: CouncilConfig);
     /**
      * Convenience entry point — pointed at the Runner you've already constructed.
@@ -93,4 +117,4 @@ declare class Council {
     deliberate(_query: string): Promise<CouncilOutput>;
 }
 
-export { Council, type CouncilConfig, type CouncilOutput, type CouncilSpecialistOutput, type Reconciler };
+export { type ClaimExtractor, Council, type CouncilConfig, type CouncilOutput, type CouncilSpecialistOutput, type Reconciler, sentenceClaimExtractor };

package/dist/council/index.js

@@ -1,10 +1,12 @@
 // src/council/index.ts
+var sentenceClaimExtractor = (output) => output.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter((s) => s.length > 0).map((text) => ({ text, confidence: 1, type: "assertion" }));
 var Council = class {
   name;
   specialists;
   verifiers;
   reconciler;
   specialist_timeout_ms;
+  claimExtractor;
   constructor(config) {
     if (!config.name) throw new Error("Council requires a `name`.");
     if (!config.specialists || config.specialists.length === 0) {
@@ -15,6 +17,7 @@ var Council = class {
     this.verifiers = config.verifiers ?? [];
     this.reconciler = config.reconciler ?? deterministicClaimMerge;
     this.specialist_timeout_ms = config.specialist_timeout_ms ?? 3e4;
+    this.claimExtractor = config.claimExtractor;
   }
   /**
    * Convenience entry point — pointed at the Runner you've already constructed.
@@ -63,4 +66,4 @@ var deterministicClaimMerge = async (specialists) => {
   return { answer, consensus, disagreements: disagreements.length > 0 ? disagreements : void 0 };
 };
 
-export { Council };
+export { Council, sentenceClaimExtractor };