framework-agents 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,3951 @@
+import {
+  Agent,
+  AgentError,
+  AgentState,
+  AudioBlockSchema,
+  ChatMessageSchema,
+  ClearToolUsesEdit,
+  ContentBlockSchema,
+  FileBlockSchema,
+  FileMemory,
+  HitlInterrupt,
+  ImageBlockSchema,
+  InMemoryMemory,
+  InMemoryStorage,
+  LocalFileStorage,
+  NonStandardBlockSchema,
+  NullConversationManager,
+  ReasoningBlockSchema,
+  SessionManager,
+  SlidingWindowConversationManager,
+  SummarizingConversationManager,
+  TextBlockSchema,
+  ToolCallBlockSchema,
+  ToolRegistry,
+  ToolRejection,
+  assistant,
+  backoffDelayMs,
+  contextEditingMiddleware,
+  createMiddleware,
+  createSubAgentMiddleware,
+  defaultToResult,
+  defineTool,
+  deserializeMessages,
+  estimateCostUsd,
+  estimateTokens,
+  filesystemMiddleware,
+  filesystemTools,
+  getRetryable,
+  hasImages,
+  historyTokens,
+  hitlKey,
+  humanInTheLoopMiddleware,
+  imagesOf,
+  llmToolSelectorMiddleware,
+  messageTokens,
+  modelCallLimit,
+  modelFallbackMiddleware,
+  modelRetryMiddleware,
+  parseStructured,
+  piiMiddleware,
+  priceFor,
+  providerStrategy,
+  responseFormatJsonSchema,
+  responseFormatName,
+  runWithBudget,
+  selectSnapshotFields,
+  serializeMessages,
+  sleep,
+  stampRetryable,
+  summarizationMiddleware,
+  system,
+  textOf,
+  todoListMiddleware,
+  toolCallLimitMiddleware,
+  toolEmulatorMiddleware,
+  toolResult,
+  toolRetry,
+  toolRetryMiddleware,
+  toolStrategy,
+  trimDangling,
+  usageCost,
+  user,
+  wireTextOf
+} from "./chunk-77OZE2QD.js";
+
+// src/config/index.ts
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { config } from "dotenv";
+import { z } from "zod";
+function loadEnv() {
+  if (process.env.FRAMEWORK_ENV_PATH) {
+    config({ path: process.env.FRAMEWORK_ENV_PATH });
+    return;
+  }
+  config();
+  let dir = resolve(process.cwd());
+  for (let i = 0; i < 3; i++) {
+    dir = dirname(dir);
+    const candidate = join(dir, ".env");
+    if (existsSync(candidate)) {
+      config({ path: candidate });
+      return;
+    }
+  }
+}
+loadEnv();
+var ConfigSchema = z.object({
+  TOGETHER_API_KEY: z.string().default(""),
+  TOGETHER_BASE_URL: z.string().default("https://api.together.xyz/v1"),
+  /** Small chat default — one model, no tiers. */
+  TOGETHER_MODEL: z.string().default("Qwen/Qwen3.5-9B"),
+  OPENAI_BASE_URL: z.string().default("https://api.openai.com/v1"),
+  OPENAI_API_KEY: z.string().default(""),
+  OPENAI_MODEL: z.string().default("gpt-4o-mini"),
+  ANTHROPIC_API_KEY: z.string().default(""),
+  ANTHROPIC_BASE_URL: z.string().default("https://api.anthropic.com"),
+  ANTHROPIC_MODEL: z.string().default("claude-sonnet-4-6"),
+  OLLAMA_BASE_URL: z.string().default("http://localhost:11434/v1"),
+  OLLAMA_MODEL: z.string().default("qwen2.5"),
+  E2E_MODEL: z.string().default("")
+});
+var cached;
+function loadConfig(env = process.env) {
+  if (cached) return cached;
+  const parsed = ConfigSchema.parse({
+    TOGETHER_API_KEY: env.TOGETHER_API_KEY ?? "",
+    TOGETHER_BASE_URL: env.TOGETHER_BASE_URL,
+    TOGETHER_MODEL: env.TOGETHER_MODEL,
+    OPENAI_BASE_URL: env.OPENAI_BASE_URL,
+    OPENAI_API_KEY: env.OPENAI_API_KEY ?? "",
+    OPENAI_MODEL: env.OPENAI_MODEL,
+    ANTHROPIC_API_KEY: env.ANTHROPIC_API_KEY ?? "",
+    ANTHROPIC_BASE_URL: env.ANTHROPIC_BASE_URL,
+    ANTHROPIC_MODEL: env.ANTHROPIC_MODEL,
+    OLLAMA_BASE_URL: env.OLLAMA_BASE_URL,
+    OLLAMA_MODEL: env.OLLAMA_MODEL,
+    E2E_MODEL: env.E2E_MODEL ?? ""
+  });
+  const useTogether = parsed.TOGETHER_API_KEY.length > 0;
+  const model = useTogether ? parsed.TOGETHER_MODEL : parsed.OPENAI_MODEL;
+  cached = {
+    ...parsed,
+    active: useTogether ? { baseUrl: parsed.TOGETHER_BASE_URL, apiKey: parsed.TOGETHER_API_KEY, model, source: "together" } : { baseUrl: parsed.OPENAI_BASE_URL, apiKey: parsed.OPENAI_API_KEY, model, source: "openai" }
+  };
+  return cached;
+}
+function __resetConfig() {
+  cached = void 0;
+}
+
+// src/checkpoint/index.ts
+import { mkdir, open, readFile, stat, unlink, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+async function withFileLock(lockPath, fn, opts = {}) {
+  const staleMs = opts.staleMs ?? 3e4;
+  await mkdir(join2(lockPath, ".."), { recursive: true });
+  for (; ; ) {
+    try {
+      const handle = await open(lockPath, "wx");
+      await handle.close();
+      break;
+    } catch (err) {
+      const code = err.code;
+      if (code !== "EEXIST") throw err;
+      try {
+        const info = await stat(lockPath);
+        if (Date.now() - info.mtimeMs < staleMs) {
+          throw new Error(`Lock held: ${lockPath}`);
+        }
+      } catch (statErr) {
+        if (statErr.code !== "ENOENT") throw statErr;
+      }
+      try {
+        await unlink(lockPath);
+      } catch {
+      }
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    try {
+      await unlink(lockPath);
+    } catch {
+    }
+  }
+}
+var FileCheckpointer = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  /** threadId lands in a filesystem path — keep it a single safe directory name. */
+  threadDir(threadId) {
+    if (threadId === "" || threadId === "." || threadId === ".." || threadId.includes("/")) {
+      throw new AgentError("THREAD_ID_INVALID", `Invalid threadId: ${JSON.stringify(threadId)}`, false);
+    }
+    return join2(this.root, "threads", threadId);
+  }
+  file(threadId) {
+    return join2(this.threadDir(threadId), "checkpoint.json");
+  }
+  lock(threadId) {
+    return join2(this.threadDir(threadId), ".lock");
+  }
+  async save(threadId, checkpoint) {
+    const record = { threadId, savedAt: (/* @__PURE__ */ new Date()).toISOString(), ...checkpoint };
+    await withFileLock(this.lock(threadId), async () => {
+      await mkdir(join2(this.file(threadId), ".."), { recursive: true });
+      await writeFile(this.file(threadId), JSON.stringify(record), "utf8");
+    });
+  }
+  async load(threadId) {
+    return withFileLock(this.lock(threadId), async () => {
+      try {
+        return JSON.parse(await readFile(this.file(threadId), "utf8"));
+      } catch {
+        return void 0;
+      }
+    });
+  }
+  async delete(threadId) {
+    await withFileLock(this.lock(threadId), async () => {
+      try {
+        await unlink(this.file(threadId));
+      } catch {
+      }
+    });
+  }
+};
+
+// src/swarm/index.ts
+import { z as z2 } from "zod";
+var HANDOFF_TOOL = "handoff_to_agent";
+function handoffSignal(to, message, context) {
+  const err = new AgentError("SWARM_HANDOFF", `Handoff to ${to}`, false);
+  err.handoff = { to, message, context };
+  return err;
+}
+function readHandoffSignal(err) {
+  if (err instanceof AgentError && err.code === "SWARM_HANDOFF") {
+    return err.handoff;
+  }
+  return void 0;
+}
+function combineAbort(parent, timeoutMs) {
+  if (!parent && !timeoutMs) return void 0;
+  const controller = new AbortController();
+  if (parent) {
+    if (parent.aborted) controller.abort();
+    else parent.addEventListener("abort", () => controller.abort(), { once: true });
+  }
+  if (timeoutMs) {
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    controller.signal.addEventListener("abort", () => clearTimeout(timer), { once: true });
+  }
+  return controller.signal;
+}
+var Swarm = class {
+  agents;
+  entryPoint;
+  maxHandoffs;
+  maxIterations;
+  executionTimeoutMs;
+  nodeTimeoutMs;
+  loopWindow;
+  minUniqueAgents;
+  constructor(opts) {
+    if (!opts.agents.length) throw new AgentError("SWARM_EMPTY", "Swarm needs at least one agent", false);
+    this.agents = opts.agents;
+    this.entryPoint = typeof opts.entryPoint === "string" ? opts.agents.find((a) => a.name === opts.entryPoint) ?? (() => {
+      throw new AgentError("SWARM_UNKNOWN_ENTRY", `Unknown entry point: ${opts.entryPoint}`, false);
+    })() : opts.entryPoint ?? opts.agents[0];
+    this.maxHandoffs = opts.maxHandoffs ?? 20;
+    this.maxIterations = opts.maxIterations ?? 20;
+    this.executionTimeoutMs = opts.executionTimeoutMs;
+    this.nodeTimeoutMs = opts.nodeTimeoutMs;
+    this.loopWindow = opts.loopDetectionWindow ?? 0;
+    this.minUniqueAgents = opts.minUniqueAgents ?? (this.loopWindow > 0 ? 2 : 0);
+  }
+  roster(except) {
+    return this.agents.filter((a) => a.name !== except).map((a) => `- ${a.name}${a.description ? `: ${a.description}` : ""}`).join("\n");
+  }
+  buildInput(task, history, shared, message, current) {
+    const knowledge = Object.entries(shared).map(([agent, facts]) => `\u2022 ${agent}: ${JSON.stringify(facts)}`).join("\n");
+    return [
+      `Original task: ${task}`,
+      message ? `Handoff message: ${message}` : "",
+      history.length ? `Agents so far: ${history.join(" \u2192 ")}` : "",
+      knowledge ? `Shared knowledge:
+${knowledge}` : "",
+      `Available collaborators:
+${this.roster(current)}`,
+      `If you need a collaborator, call ${HANDOFF_TOOL} with their name. Otherwise finish with your final answer as text.`
+    ].filter(Boolean).join("\n\n");
+  }
+  memberWithHandoff(agent, shared) {
+    const handoff = defineTool({
+      name: HANDOFF_TOOL,
+      description: `Hand control to a specialist. Args: to (agent name), message (what you need), context (facts to share as an object).`,
+      schema: z2.object({ to: z2.string(), message: z2.string(), context: z2.record(z2.unknown()).optional() }),
+      execute: async ({ to, message, context }) => {
+        if (!this.agents.some((a) => a.name === to)) {
+          return `Error: unknown agent "${to}". Available: ${this.agents.map((a) => a.name).join(", ")}. Pick one or finish yourself.`;
+        }
+        if (context && Object.keys(context).length) shared[agent.name] = { ...shared[agent.name] ?? {}, ...context };
+        throw handoffSignal(to, message, context);
+      }
+    });
+    return agent.withTools(handoff);
+  }
+  async run(task, opts) {
+    const stream = this.stream(task, opts);
+    for (; ; ) {
+      const next = await stream.next();
+      if (next.done) return next.value;
+    }
+  }
+  async *stream(task, opts) {
+    const taskText = typeof task === "string" ? task : task.map((b) => b.type === "text" ? b.text : `[${b.type}]`).join("\n");
+    const invocationState = opts?.sharedState ?? {};
+    const execSignal = combineAbort(opts?.signal, this.executionTimeoutMs);
+    const shared = {};
+    const history = [];
+    const results = {};
+    const usage = { inputTokens: 0, outputTokens: 0 };
+    const handoffTrail = [];
+    let current = this.entryPoint;
+    let message = "";
+    let iterations = 0;
+    let handoffs = 0;
+    let finalText = "";
+    const fail = (error) => this.finish("FAILED", error, history, results, usage, shared, iterations, handoffs);
+    for (; ; ) {
+      iterations += 1;
+      if (iterations > this.maxIterations) {
+        return fail(`Exceeded maxIterations (${this.maxIterations})`);
+      }
+      yield { type: "node_start", agent: current.name };
+      const runner = this.memberWithHandoff(current, shared);
+      const nodeSignal = combineAbort(execSignal, this.nodeTimeoutMs);
+      let result;
+      try {
+        const gen = runner.stream(this.buildInput(taskText, history, shared, message, current.name), {
+          signal: nodeSignal,
+          invocationState
+        });
+        for (; ; ) {
+          const next = await runWithBudget(() => gen.next(), { signal: execSignal });
+          if (next.done) {
+            result = next.value;
+            break;
+          }
+          yield { type: "agent_event", agent: current.name, event: next.value };
+        }
+      } catch (err) {
+        const handoff = readHandoffSignal(err);
+        if (!handoff) {
+          const messageText = err instanceof Error ? err.message : String(err);
+          return fail(`Agent ${current.name} failed: ${messageText}`);
+        }
+        handoffs += 1;
+        if (handoffs > this.maxHandoffs) {
+          return fail(`Exceeded maxHandoffs (${this.maxHandoffs})`);
+        }
+        handoffTrail.push(current.name, handoff.to);
+        yield { type: "handoff", from: current.name, to: handoff.to };
+        const loop = this.detectLoop(handoffTrail);
+        if (loop) {
+          return fail(loop);
+        }
+        const next = this.agents.find((a) => a.name === handoff.to);
+        if (!next) {
+          return fail(`Handoff to unknown agent: ${handoff.to}`);
+        }
+        history.push(current.name);
+        message = handoff.message;
+        current = next;
+        continue;
+      }
+      if (!result) return fail(`Agent ${current.name} returned no result`);
+      history.push(current.name);
+      results[current.name] = result;
+      usage.inputTokens += result.usage.inputTokens;
+      usage.outputTokens += result.usage.outputTokens;
+      usage.reasoningTokens = (usage.reasoningTokens ?? 0) + (result.usage.reasoningTokens ?? 0);
+      finalText = result.text;
+      yield { type: "node_done", agent: current.name };
+      const done = this.finish("COMPLETED", "", history, results, usage, shared, iterations, handoffs, finalText);
+      yield { type: "result", result: done };
+      return done;
+    }
+  }
+  detectLoop(trail) {
+    if (this.loopWindow <= 0 || this.minUniqueAgents <= 0) return void 0;
+    const window = trail.slice(-this.loopWindow);
+    if (window.length < this.loopWindow) return void 0;
+    if (new Set(window).size < this.minUniqueAgents) {
+      return `Repetitive handoff detected (${window.join(" \u2192 ")}): fewer than ${this.minUniqueAgents} unique agents in the last ${this.loopWindow} trail entries`;
+    }
+    return void 0;
+  }
+  finish(status, error, history, results, usage, shared, iterations, handoffs, text = "") {
+    return {
+      status,
+      text,
+      nodeHistory: [...history],
+      results,
+      iterations,
+      handoffs,
+      usage,
+      sharedContext: shared,
+      ...error ? { error } : {}
+    };
+  }
+};
+
+// src/a2a/index.ts
+import { createServer } from "http";
+import { z as z3 } from "zod";
+function textOfParts(parts) {
+  if (!Array.isArray(parts)) return "";
+  return parts.map((p) => {
+    if (typeof p === "string") return p;
+    if (p && typeof p === "object") {
+      const o = p;
+      if (typeof o.text === "string") return o.text;
+    }
+    return "";
+  }).join("");
+}
+function parseSendResult(result) {
+  if (typeof result === "string") return result;
+  if (result && typeof result === "object") {
+    const o = result;
+    const msg = o.message;
+    if (msg?.parts) return textOfParts(msg.parts);
+    if (typeof o.text === "string") return o.text;
+    return JSON.stringify(result);
+  }
+  return String(result ?? "");
+}
+var A2AClient = class {
+  constructor(endpoint, opts = {}) {
+    this.endpoint = endpoint;
+    this.endpoint = endpoint.replace(/\/$/, "");
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.timeoutMs = opts.timeoutMs ?? 3e5;
+  }
+  endpoint;
+  fetchFn;
+  timeoutMs;
+  async getCard() {
+    let res;
+    try {
+      res = await this.fetchFn(`${this.endpoint}/.well-known/agent-card.json`, {
+        headers: { accept: "application/json" },
+        signal: AbortSignal.timeout(this.timeoutMs)
+      });
+    } catch (err) {
+      throw new AgentError("A2A_TRANSPORT", `Agent card fetch failed: ${err instanceof Error ? err.message : String(err)}`, true);
+    }
+    if (!res.ok) throw new AgentError("A2A_CARD", `Agent card fetch failed: HTTP ${res.status}`, res.status >= 500);
+    const card = await res.json();
+    if (!card?.name) throw new AgentError("A2A_CARD", "Invalid agent card (missing name)", false);
+    return card;
+  }
+  async send(text, contextId) {
+    let res;
+    try {
+      res = await this.fetchFn(this.endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json", accept: "application/json" },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: `a2a-${Date.now().toString(36)}`,
+          method: "message/send",
+          params: {
+            message: { role: "user", parts: [{ kind: "text", text }] },
+            ...contextId ? { contextId } : {}
+          }
+        }),
+        signal: AbortSignal.timeout(this.timeoutMs)
+      });
+    } catch (err) {
+      throw new AgentError("A2A_TRANSPORT", `A2A send failed: ${err instanceof Error ? err.message : String(err)}`, true);
+    }
+    if (!res.ok) throw new AgentError("A2A_TRANSPORT", `A2A HTTP ${res.status}`, res.status >= 500);
+    const rpc = await res.json();
+    if (rpc.error) throw new AgentError("A2A_ERROR", `Remote agent error: ${rpc.error.message}`, false);
+    const resultContextId = rpc.result && typeof rpc.result === "object" ? rpc.result.contextId : void 0;
+    return { text: parseSendResult(rpc.result), contextId: resultContextId ?? contextId };
+  }
+};
+function a2aAsTool(client, opts = {}) {
+  return defineTool({
+    name: opts.name ?? "remote_agent",
+    description: opts.description ?? `Remote A2A agent at ${client.endpoint}`,
+    schema: z3.object({ input: z3.string(), contextId: z3.string().optional() }),
+    execute: async ({ input, contextId }) => (await client.send(input, contextId)).text
+  });
+}
+var A2AServer = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.maxContexts = Math.max(1, opts.maxContexts ?? 1e3);
+  }
+  opts;
+  server;
+  contexts = /* @__PURE__ */ new Map();
+  maxContexts;
+  corsHeaders(origin) {
+    const allowed = this.opts.corsOrigins ?? [];
+    if (!allowed.length || !origin) return {};
+    if (!allowed.includes("*") && !allowed.includes(origin)) return {};
+    return {
+      "access-control-allow-origin": allowed.includes("*") ? "*" : origin,
+      "access-control-allow-methods": "GET, POST, OPTIONS",
+      "access-control-allow-headers": "content-type, authorization"
+    };
+  }
+  runOpts(contextId) {
+    return this.opts.checkpointer ? { checkpointer: this.opts.checkpointer, threadId: contextId } : {};
+  }
+  async agentFor(contextId) {
+    const existing = this.contexts.get(contextId);
+    if (existing) {
+      this.contexts.delete(contextId);
+      this.contexts.set(contextId, existing);
+      return existing;
+    }
+    const agent = await this.opts.agentFactory(contextId);
+    this.contexts.set(contextId, agent);
+    while (this.contexts.size > this.maxContexts) {
+      const oldest = this.contexts.keys().next().value;
+      if (oldest === void 0) break;
+      this.contexts.delete(oldest);
+    }
+    return agent;
+  }
+  /** Read a request body with a hard cap; JSON.parse errors to the caller. */
+  readBody(req) {
+    const max = this.opts.maxBodyBytes ?? 10 * 1024 * 1024;
+    return new Promise((resolve4, reject) => {
+      let data = "";
+      req.on("data", (c) => {
+        data += c;
+        if (data.length > max) {
+          req.destroy();
+          reject(new AgentError("A2A_BODY_TOO_LARGE", `Request body exceeds ${max} bytes`, false));
+        }
+      });
+      req.on("end", () => resolve4(data));
+      req.on("error", reject);
+    });
+  }
+  async handle(req, res) {
+    const cors = this.corsHeaders(req.headers.origin);
+    const send = (code, body) => {
+      res.writeHead(code, { "content-type": "application/json", ...cors });
+      res.end(JSON.stringify(body));
+    };
+    try {
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, { ...cors });
+        res.end();
+        return;
+      }
+      if (req.method === "GET" && (req.url === "/ok" || req.url === "/health")) {
+        send(200, { ok: true });
+        return;
+      }
+      if (req.method === "GET" && req.url === "/.well-known/agent-card.json") {
+        send(200, this.opts.card);
+        return;
+      }
+      if (req.method === "POST" && (req.url === "/" || req.url === "")) {
+        const rpc = JSON.parse(await this.readBody(req));
+        if (rpc.method !== "message/send") {
+          send(200, { jsonrpc: "2.0", id: rpc.id, error: { code: -32601, message: `Unknown method: ${rpc.method}` } });
+          return;
+        }
+        const contextId = rpc.params?.contextId ?? `ctx-${Date.now().toString(36)}`;
+        const text = textOfParts(rpc.params?.message?.parts);
+        const result = await (await this.agentFor(contextId)).run(text, this.runOpts(contextId));
+        send(200, {
+          jsonrpc: "2.0",
+          id: rpc.id,
+          result: { message: { role: "agent", parts: [{ kind: "text", text: result.text }] }, contextId }
+        });
+        return;
+      }
+      if (req.method === "POST" && req.url === "/stream") {
+        const rpc = JSON.parse(await this.readBody(req));
+        const contextId = rpc.params?.contextId ?? `ctx-${Date.now().toString(36)}`;
+        const text = textOfParts(rpc.params?.message?.parts);
+        res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
+        const write = (payload) => {
+          res.write(`data: ${JSON.stringify(payload)}
+
+`);
+        };
+        const disconnect = new AbortController();
+        res.on("close", () => {
+          if (!res.writableEnded) disconnect.abort();
+        });
+        try {
+          const gen = (await this.agentFor(contextId)).stream(text, {
+            signal: disconnect.signal,
+            ...this.runOpts(contextId)
+          });
+          for (; ; ) {
+            const next = await gen.next();
+            if (next.done) {
+              write({ contextId, done: true, text: next.value.text });
+              break;
+            }
+            write({ contextId, event: next.value });
+          }
+        } catch (err) {
+          write({ contextId, error: err instanceof Error ? err.message : String(err) });
+        }
+        write("[DONE]");
+        res.end();
+        return;
+      }
+      send(404, { error: "not found" });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (res.headersSent) {
+        try {
+          res.write(`data: ${JSON.stringify({ error: message })}
+
+`);
+          res.write("data: [DONE]\n\n");
+          res.end();
+        } catch {
+        }
+        return;
+      }
+      send(
+        err instanceof AgentError && err.code === "A2A_BODY_TOO_LARGE" ? 413 : 200,
+        { jsonrpc: "2.0", id: null, error: { code: -32603, message } }
+      );
+    }
+  }
+  async start(port, host) {
+    const listenPort = port ?? this.opts.port ?? 0;
+    const listenHost = host ?? this.opts.host ?? "127.0.0.1";
+    this.server = createServer((req, res) => void this.handle(req, res));
+    await new Promise((resolve4) => this.server?.listen(listenPort, listenHost, () => resolve4()));
+    return this.server.address().port;
+  }
+  async stop() {
+    await new Promise(
+      (resolve4, reject) => this.server ? this.server.close((e) => e ? reject(e) : resolve4()) : resolve4()
+    );
+    this.server = void 0;
+    this.contexts.clear();
+  }
+};
+
+// src/client/index.ts
+var AgentClient = class {
+  a2a;
+  fetchFn;
+  endpoint;
+  constructor(endpoint, opts = {}) {
+    this.endpoint = endpoint.replace(/\/$/, "");
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.a2a = new A2AClient(this.endpoint, opts);
+  }
+  async card() {
+    return this.a2a.getCard();
+  }
+  async send(text, contextId) {
+    return this.a2a.send(text, contextId);
+  }
+  /** Live StreamEvents over SSE (`POST /stream`). Throws AgentError on server errors. */
+  async *stream(text, contextId, signal, opts = {}) {
+    let res;
+    try {
+      res = await this.fetchFn(`${this.endpoint}/stream`, {
+        method: "POST",
+        headers: { "content-type": "application/json", accept: "text/event-stream" },
+        // JSON-RPC envelope — the server reads params.message.parts.
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: `a2a-${Date.now().toString(36)}`,
+          method: "message/stream",
+          params: {
+            message: { role: "user", parts: [{ kind: "text", text }] },
+            ...contextId ? { contextId } : {}
+          }
+        }),
+        ...signal ? { signal } : {}
+      });
+    } catch (err) {
+      throw new AgentError("A2A_TRANSPORT", `Stream failed: ${err instanceof Error ? err.message : String(err)}`, true);
+    }
+    if (!res.ok || !res.body) throw new AgentError("A2A_TRANSPORT", `Stream HTTP ${res.status}`, res.status >= 500);
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const flush = function* (chunk) {
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const t = line.trim();
+        if (!t.startsWith("data:")) continue;
+        const payload = t.slice(5).trim();
+        if (payload === "[DONE]") continue;
+        let msg;
+        try {
+          msg = JSON.parse(payload);
+        } catch {
+          continue;
+        }
+        if (msg.contextId) opts.onContext?.(msg.contextId);
+        if (msg.error) throw new AgentError("A2A_ERROR", msg.error, false);
+        if (msg.event && typeof msg.event.type === "string") yield msg.event;
+      }
+    };
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        yield* flush(decoder.decode(value, { stream: true }));
+      }
+      yield* flush(decoder.decode());
+    } finally {
+      await reader.cancel().catch(() => {
+      });
+    }
+  }
+};
+async function handleAgentRoute(req, client) {
+  const { text, contextId } = await req.json();
+  let latestContextId = contextId;
+  const stream = new ReadableStream({
+    async start(controller) {
+      const send = (payload) => {
+        controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(payload)}
+
+`));
+      };
+      try {
+        for await (const event of client.stream(text, contextId, req.signal, {
+          onContext: (id) => latestContextId = id
+        })) {
+          send({ contextId: latestContextId, event });
+        }
+        send({ contextId: latestContextId });
+        send("[DONE]");
+      } catch (err) {
+        send({ error: err instanceof Error ? err.message : String(err) });
+      } finally {
+        try {
+          controller.close();
+        } catch {
+        }
+      }
+    }
+  });
+  return new Response(stream, { headers: { "content-type": "text/event-stream", "cache-control": "no-cache" } });
+}
+
+// src/serve/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { config as dotenvConfig } from "dotenv";
+import { z as z5 } from "zod";
+
+// src/models/capabilities.ts
+var VISION_CAPABLE_PATTERNS = [
+  /qwen2.*vl/i,
+  /qwen.*vl/i,
+  /llama-3\.2-11b-vision/i,
+  /llama-3\.2-90b-vision/i,
+  /llava/i,
+  /minicpm-v/i,
+  /gpt-4o/i,
+  /gpt-4\.1/i,
+  /claude.*sonnet/i,
+  /claude.*opus/i,
+  /gemini/i
+];
+function supportsVision(modelId) {
+  return VISION_CAPABLE_PATTERNS.some((re) => re.test(modelId));
+}
+function assertCanHandle(modelId, needsVision) {
+  if (needsVision && !supportsVision(modelId)) {
+    throw new AgentError(
+      "MODEL_CAPABILITY",
+      `Model "${modelId}" cannot take image input. Switch TOGETHER_MODEL to a vision-capable model (e.g. Qwen/Qwen2.5-VL-72B-Instruct) or drop the images.`,
+      false
+    );
+  }
+}
+
+// src/models/openai-compatible.ts
+function reasoningOf(usage) {
+  return usage.reasoning_tokens ?? usage.completion_tokens_details?.reasoning_tokens;
+}
+function thinkingOf(m) {
+  const trace = m.reasoning ?? m.reasoning_content;
+  return trace ? trace : void 0;
+}
+function toWireRole(role) {
+  if (role === "tool") return "tool";
+  return role;
+}
+function toWireContent(m) {
+  if (typeof m.content === "string" && !hasImages(m.content)) return m.content;
+  const text = wireTextOf(m.content);
+  const imgs = imagesOf(m.content);
+  if (!imgs.length) return text;
+  return [
+    ...text ? [{ type: "text", text }] : [],
+    ...imgs.map((img) => ({
+      type: "image_url",
+      image_url: { url: img.data ? `data:${img.mimeType ?? "image/jpeg"};base64,${img.data}` : img.url }
+    }))
+  ];
+}
+function toWireMessage(m) {
+  const base = { role: toWireRole(m.role), content: toWireContent(m) };
+  if (m.toolCallId) base.tool_call_id = m.toolCallId;
+  if (typeof m.content !== "string") {
+    const calls = m.content.filter(
+      (b) => b.type === "tool_call"
+    );
+    if (calls.length) {
+      base.tool_calls = calls.map((c) => ({
+        id: c.id,
+        type: "function",
+        function: { name: c.name, arguments: JSON.stringify(c.args ?? {}) }
+      }));
+    }
+  }
+  return base;
+}
+var OpenAICompatibleProvider = class {
+  id;
+  capabilities = { structuredOutput: true, streaming: true };
+  opts;
+  constructor(opts) {
+    if (!opts.apiKey) throw new Error("OpenAICompatibleProvider: apiKey is required (.env TOGETHER_API_KEY / OPENAI_API_KEY)");
+    this.opts = { temperature: 0.2, ...opts };
+    this.id = `openai-compatible:${opts.model}`;
+  }
+  async complete(options) {
+    const { fetchFn = fetch, baseUrl, apiKey, model, temperature, maxTokens, stream } = this.opts;
+    const needsVision = options.messages.some((m) => hasImages(m.content));
+    assertCanHandle(model, needsVision);
+    const url = `${baseUrl.replace(/\/$/, "")}/chat/completions`;
+    const body = {
+      model,
+      temperature,
+      ...maxTokens ? { max_tokens: maxTokens } : {},
+      // stream_options makes OpenAI-compatible servers attach usage to the final
+      // chunk; without it streaming runs report {0,0} — budgets/cost would be fiction.
+      ...stream ? { stream: true, stream_options: { include_usage: true } } : {},
+      ...options.responseFormat ? {
+        response_format: {
+          type: "json_schema",
+          json_schema: {
+            name: options.responseFormat.name,
+            strict: options.responseFormat.strict ?? true,
+            schema: options.responseFormat.schema
+          }
+        }
+      } : {},
+      messages: options.messages.map(toWireMessage),
+      ...options.tools.length ? {
+        tools: options.tools.map((t) => ({
+          type: "function",
+          function: {
+            name: t.name,
+            description: t.description,
+            // Without parameters the API advertises a zero-arg tool.
+            ...t.parametersSchema ? { parameters: t.parametersSchema } : {}
+          }
+        }))
+      } : {}
+    };
+    let res;
+    try {
+      res = await fetchFn(url, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+        body: JSON.stringify(body),
+        ...options.signal ? { signal: options.signal } : {}
+      });
+    } catch (err) {
+      throw new AgentError("MODEL_ERROR", `Model request failed: ${err instanceof Error ? err.message : String(err)}`, true);
+    }
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      const retryable = res.status === 429 || res.status >= 500;
+      throw new AgentError("MODEL_ERROR", `Model HTTP ${res.status}: ${text.slice(0, 300)}`, retryable);
+    }
+    return stream ? this.readStream(res, options) : this.readJson(res, options);
+  }
+  async readJson(res, options) {
+    const json = await res.json();
+    const choice = json.choices[0];
+    const msg = choice?.message ?? {};
+    const thinking = thinkingOf(msg);
+    if (thinking) options.onThinking?.(thinking);
+    if (msg.content) options.onToken?.(msg.content);
+    const finishReason = choice?.finish_reason ?? void 0;
+    if (!msg.content && !(msg.tool_calls ?? []).length && thinking && finishReason === "stop") {
+      throw new AgentError(
+        "MODEL_ERROR",
+        "Model stopped with finish_reason=stop having put the entire answer in the reasoning channel (empty content, no tool calls, thinking present). The reasoning/content split lost the reply \u2014 retry or raise maxTokens.",
+        true
+      );
+    }
+    if (!msg.content && !(msg.tool_calls ?? []).length && finishReason === "length") {
+      throw new AgentError(
+        "MODEL_ERROR",
+        `Model spent its entire max_tokens budget (${json.usage?.completion_tokens ?? "?"} tokens, finish_reason=length) thinking without producing content. Raise maxTokens.`,
+        false
+      );
+    }
+    const reasoningTokens = json.usage ? reasoningOf(json.usage) : void 0;
+    return {
+      text: msg.content ?? "",
+      ...thinking ? { thinking } : {},
+      toolCalls: parseToolCalls(msg.tool_calls ?? []),
+      ...finishReason ? { finishReason } : {},
+      usage: {
+        inputTokens: json.usage?.prompt_tokens ?? 0,
+        outputTokens: json.usage?.completion_tokens ?? 0,
+        ...reasoningTokens != null ? { reasoningTokens } : {}
+      }
+    };
+  }
+  /** SSE: `data: {...}` lines; delta.content -> onToken, delta.reasoning_content -> onThinking. */
+  async readStream(res, options) {
+    if (!res.body) throw new Error("Streaming response has no body");
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let text = "";
+    let thinking = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let reasoningTokens;
+    let finishReason;
+    const toolArgBuffers = /* @__PURE__ */ new Map();
+    let buffer = "";
+    const flush = (chunk) => {
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const t = line.trim();
+        if (!t.startsWith("data:")) continue;
+        const payload = t.slice(5).trim();
+        if (payload === "[DONE]") continue;
+        let evt;
+        try {
+          evt = JSON.parse(payload);
+        } catch {
+          continue;
+        }
+        if (evt.choices?.[0]?.finish_reason) finishReason = evt.choices[0].finish_reason ?? void 0;
+        if (evt.usage) {
+          if (evt.usage.prompt_tokens != null) inputTokens = evt.usage.prompt_tokens;
+          if (evt.usage.completion_tokens != null) outputTokens = evt.usage.completion_tokens;
+          const rt = reasoningOf(evt.usage);
+          if (rt != null) reasoningTokens = rt;
+          continue;
+        }
+        const delta = evt.choices?.[0]?.delta;
+        if (!delta) continue;
+        const think = thinkingOf(delta);
+        if (think) {
+          thinking += think;
+          options.onThinking?.(think);
+        }
+        if (delta.content) {
+          text += delta.content;
+          options.onToken?.(delta.content);
+        }
+        for (const [i, tc] of (delta.tool_calls ?? []).entries()) {
+          const key = tc.index ?? i;
+          const slot = toolArgBuffers.get(key) ?? { id: "", name: "", args: "" };
+          if (tc.id) slot.id = tc.id;
+          if (tc.function?.name) slot.name = tc.function.name;
+          if (tc.function?.arguments) slot.args += tc.function.arguments;
+          toolArgBuffers.set(key, slot);
+        }
+      }
+    };
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      flush(decoder.decode(value, { stream: true }));
+    }
+    flush(decoder.decode());
+    if (!text && !toolArgBuffers.size && thinking && finishReason === "stop") {
+      throw new AgentError(
+        "MODEL_ERROR",
+        "Stream ended at finish_reason=stop having put the entire answer in the reasoning channel (no content, no tool calls, thinking present). The reasoning/content split lost the reply \u2014 retry or raise maxTokens.",
+        true
+      );
+    }
+    if (!text && !toolArgBuffers.size && finishReason === "length") {
+      throw new AgentError(
+        "MODEL_ERROR",
+        `Stream ended at finish_reason=length with no content (${outputTokens} tokens burned). Raise maxTokens.`,
+        false
+      );
+    }
+    return {
+      text,
+      ...thinking ? { thinking } : {},
+      ...finishReason ? { finishReason } : {},
+      toolCalls: [...toolArgBuffers.values()].filter((t) => t.name).map((t) => ({ id: t.id || `call_${++callSeq}`, name: t.name, args: safeJson(t.args) })),
+      usage: {
+        inputTokens,
+        outputTokens,
+        ...reasoningTokens != null ? { reasoningTokens } : {}
+      }
+    };
+  }
+};
+var callSeq = 0;
+function parseToolCalls(calls) {
+  return calls.map((c) => ({ id: c.id ?? `call_${++callSeq}`, name: c.function.name, args: safeJson(c.function.arguments || "{}") }));
+}
+function safeJson(raw) {
+  try {
+    return JSON.parse(raw || "{}");
+  } catch {
+    return {};
+  }
+}
+function providerFromEnv(active, extra) {
+  return new OpenAICompatibleProvider({ baseUrl: active.baseUrl, apiKey: active.apiKey, model: active.model, ...extra });
+}
+
+// src/models/anthropic.ts
+function normalizeStopReason(stopReason) {
+  if (!stopReason) return void 0;
+  return stopReason === "max_tokens" ? "length" : stopReason;
+}
+function assertNotEmptyTruncation(text, toolCalls, finishReason, tokenCount) {
+  if (!text && !toolCalls.length && finishReason === "length") {
+    throw new AgentError(
+      "MODEL_ERROR",
+      `Model stopped at max_tokens (${tokenCount} tokens) without producing content. Raise maxTokens.`,
+      false
+    );
+  }
+}
+function assertNotEmptyReasoningSplit(text, toolCalls, thinking, stopReason) {
+  if (!text && !toolCalls.length && thinking && stopReason === "stop") {
+    throw new AgentError(
+      "MODEL_ERROR",
+      "Model stopped with stop_reason=stop having put the entire answer in the reasoning channel (empty content, no tool calls, thinking present). The reasoning/content split lost the reply \u2014 retry or raise maxTokens.",
+      true
+    );
+  }
+}
+function toAnthropicContent(m) {
+  if (typeof m.content === "string") return m.content;
+  const parts = [];
+  const text = wireTextOf(m.content);
+  if (text) parts.push({ type: "text", text });
+  for (const img of imagesOf(m.content)) {
+    parts.push({
+      type: "image",
+      source: img.data ? { type: "base64", media_type: img.mimeType ?? "image/jpeg", data: img.data } : { type: "url", url: img.url }
+    });
+  }
+  for (const b of m.content) {
+    if (b.type === "tool_call") parts.push({ type: "tool_use", id: b.id, name: b.name, input: b.args ?? {} });
+  }
+  return parts;
+}
+var AnthropicProvider = class {
+  id;
+  capabilities = { structuredOutput: false, streaming: true };
+  opts;
+  constructor(opts) {
+    if (!opts.apiKey) throw new Error("AnthropicProvider: apiKey is required (.env ANTHROPIC_API_KEY)");
+    this.opts = { baseUrl: "https://api.anthropic.com", maxTokens: 1024, ...opts };
+    if (this.opts.thinkingBudget && this.opts.maxTokens != null && this.opts.maxTokens <= this.opts.thinkingBudget) {
+      throw new Error(
+        `AnthropicProvider: maxTokens (${this.opts.maxTokens}) must exceed thinkingBudget (${this.opts.thinkingBudget}); raise maxTokens`
+      );
+    }
+    this.id = `anthropic:${opts.model}`;
+  }
+  async complete(options) {
+    const { fetchFn = fetch, apiKey, model, baseUrl, maxTokens, temperature, thinkingBudget, stream } = this.opts;
+    const needsVision = options.messages.some((m) => hasImages(m.content));
+    assertCanHandle(model, needsVision);
+    const system2 = options.messages.filter((m) => m.role === "system").map((m) => wireTextOf(m.content)).join("\n\n");
+    const messages = [];
+    for (const m of options.messages.filter((x) => x.role !== "system")) {
+      if (m.role === "tool") {
+        const result = { type: "tool_result", tool_use_id: m.toolCallId, content: toAnthropicContent(m) };
+        const last = messages[messages.length - 1];
+        if (last && last.role === "user" && Array.isArray(last.content) && last.content.some((b) => b.type === "tool_result")) {
+          last.content.push(result);
+          continue;
+        }
+        messages.push({ role: "user", content: [result] });
+        continue;
+      }
+      messages.push({ role: m.role === "assistant" ? "assistant" : "user", content: toAnthropicContent(m) });
+    }
+    const body = {
+      model,
+      max_tokens: maxTokens,
+      ...system2 ? { system: system2 } : {},
+      ...temperature != null ? { temperature } : {},
+      ...thinkingBudget ? { thinking: { type: "enabled", budget_tokens: thinkingBudget } } : {},
+      ...stream ? { stream: true } : {},
+      messages,
+      ...options.tools.length ? {
+        tools: options.tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          input_schema: t.parametersSchema ?? { type: "object" }
+        }))
+      } : {}
+    };
+    let res;
+    try {
+      res = await fetchFn(`${baseUrl.replace(/\/$/, "")}/v1/messages`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+          ...stream ? { accept: "text/event-stream" } : {}
+        },
+        body: JSON.stringify(body),
+        ...options.signal ? { signal: options.signal } : {}
+      });
+    } catch (err) {
+      throw new AgentError("MODEL_ERROR", `Model request failed: ${err instanceof Error ? err.message : String(err)}`, true);
+    }
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      const retryable = res.status === 429 || res.status >= 500;
+      throw new AgentError("MODEL_ERROR", `Model HTTP ${res.status}: ${text.slice(0, 300)}`, retryable);
+    }
+    return stream ? this.readStream(res, options) : this.readJson(res, options);
+  }
+  toCompletion(blocks, usage, options) {
+    let text = "";
+    let thinking = "";
+    const toolCalls = [];
+    for (const b of blocks) {
+      if (b.type === "text" && b.text) {
+        text += b.text;
+        options.onToken?.(b.text);
+      } else if (b.type === "thinking" && b.thinking) {
+        thinking += b.thinking;
+        options.onThinking?.(b.thinking);
+      } else if (b.type === "tool_use" && b.name) {
+        toolCalls.push({ id: b.id ?? `call_${toolCalls.length}`, name: b.name, args: b.input ?? {} });
+      }
+    }
+    return { text, ...thinking ? { thinking } : {}, toolCalls, usage };
+  }
+  async readJson(res, options) {
+    const json = await res.json();
+    const out = this.toCompletion(json.content ?? [], {
+      inputTokens: json.usage?.input_tokens ?? 0,
+      outputTokens: json.usage?.output_tokens ?? 0
+    }, options);
+    const finishReason = normalizeStopReason(json.stop_reason);
+    assertNotEmptyTruncation(out.text, out.toolCalls, finishReason, json.usage?.output_tokens ?? 0);
+    assertNotEmptyReasoningSplit(out.text, out.toolCalls, out.thinking ?? "", finishReason);
+    return finishReason ? { ...out, finishReason } : out;
+  }
+  async readStream(res, options) {
+    if (!res.body) throw new Error("Streaming response has no body");
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let event = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let stopReason;
+    const blocks = [];
+    let current;
+    let jsonInput = "";
+    const flush = (chunk) => {
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const t = line.trim();
+        if (!t) continue;
+        if (t.startsWith("event:")) {
+          event = t.slice(6).trim();
+          continue;
+        }
+        if (!t.startsWith("data:")) continue;
+        const payload = t.slice(5).trim();
+        if (!payload) continue;
+        let data;
+        try {
+          data = JSON.parse(payload);
+        } catch {
+          continue;
+        }
+        if (event === "message_start") {
+          const mu = (data.message ?? {}).usage;
+          if (mu?.input_tokens != null) inputTokens = mu.input_tokens;
+        } else if (event === "message_delta") {
+          const du = data.usage ?? {};
+          if (du.output_tokens != null) outputTokens = du.output_tokens;
+          const sr = data.delta ?? {};
+          if (sr.stop_reason) stopReason = normalizeStopReason(sr.stop_reason);
+        } else if (event === "content_block_start") {
+          const block = data.content_block ?? {};
+          current = { type: block.type, id: block.id, name: block.name };
+          jsonInput = "";
+        } else if (event === "content_block_delta") {
+          const delta = data.delta ?? {};
+          if (delta.text) {
+            current = current ?? { type: "text" };
+            current.text = (current.text ?? "") + delta.text;
+          } else if (delta.thinking) {
+            current = current ?? { type: "thinking" };
+            current.thinking = (current.thinking ?? "") + delta.thinking;
+          } else if (delta.partial_json) {
+            jsonInput += delta.partial_json;
+          }
+        } else if (event === "content_block_stop") {
+          if (current) {
+            if (current.type === "tool_use") {
+              try {
+                current.input = JSON.parse(jsonInput || "{}");
+              } catch {
+                current.input = {};
+              }
+            }
+            blocks.push(current);
+            current = void 0;
+          }
+        }
+      }
+    };
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      flush(decoder.decode(value, { stream: true }));
+    }
+    flush(decoder.decode());
+    if (current) blocks.push(current);
+    const out = this.toCompletion(blocks, { inputTokens, outputTokens }, options);
+    assertNotEmptyTruncation(out.text, out.toolCalls, stopReason, outputTokens);
+    assertNotEmptyReasoningSplit(out.text, out.toolCalls, out.thinking ?? "", stopReason);
+    return stopReason ? { ...out, finishReason: stopReason } : out;
+  }
+};
+
+// src/models/ollama.ts
+var OllamaProvider = class extends OpenAICompatibleProvider {
+  id;
+  capabilities = { structuredOutput: false, streaming: true };
+  constructor(opts) {
+    super({
+      baseUrl: opts.baseUrl ?? "http://localhost:11434/v1",
+      apiKey: "ollama",
+      model: opts.model,
+      ...opts.temperature != null ? { temperature: opts.temperature } : {},
+      ...opts.maxTokens != null ? { maxTokens: opts.maxTokens } : {},
+      ...opts.stream != null ? { stream: opts.stream } : {},
+      ...opts.fetchFn ? { fetchFn: opts.fetchFn } : {}
+    });
+    this.id = `ollama:${opts.model}`;
+  }
+};
+function ollama(opts) {
+  return new OllamaProvider(opts);
+}
+
+// src/models/factory.ts
+function initChatModel(spec, opts = {}) {
+  const cfg = loadConfig();
+  const extra = {
+    ...opts.temperature != null ? { temperature: opts.temperature } : {},
+    ...opts.maxTokens != null ? { maxTokens: opts.maxTokens } : {},
+    ...opts.stream != null ? { stream: opts.stream } : {}
+  };
+  const colon = spec.indexOf(":");
+  const provider = colon > 0 ? spec.slice(0, colon) : "together";
+  const model = colon > 0 ? spec.slice(colon + 1) : spec;
+  switch (provider) {
+    case "together": {
+      const apiKey = opts.apiKey ?? cfg.TOGETHER_API_KEY;
+      if (!apiKey) throw new Error("initChatModel: set TOGETHER_API_KEY in .env (or pass apiKey)");
+      return new OpenAICompatibleProvider({ baseUrl: opts.baseUrl ?? cfg.TOGETHER_BASE_URL, apiKey, model, ...extra });
+    }
+    case "openai": {
+      const apiKey = opts.apiKey ?? cfg.OPENAI_API_KEY;
+      if (!apiKey) throw new Error("initChatModel: set OPENAI_API_KEY in .env (or pass apiKey)");
+      return new OpenAICompatibleProvider({ baseUrl: opts.baseUrl ?? cfg.OPENAI_BASE_URL, apiKey, model, ...extra });
+    }
+    case "anthropic": {
+      const apiKey = opts.apiKey ?? cfg.ANTHROPIC_API_KEY;
+      if (!apiKey) throw new Error("initChatModel: set ANTHROPIC_API_KEY in .env (or pass apiKey)");
+      return new AnthropicProvider({
+        apiKey,
+        model,
+        ...opts.baseUrl ? { baseUrl: opts.baseUrl } : { baseUrl: cfg.ANTHROPIC_BASE_URL },
+        ...opts.thinkingBudget != null ? { thinkingBudget: opts.thinkingBudget } : {},
+        ...extra
+      });
+    }
+    case "ollama": {
+      return new OllamaProvider({ model, ...opts.baseUrl ? { baseUrl: opts.baseUrl } : { baseUrl: cfg.OLLAMA_BASE_URL }, ...extra });
+    }
+    case "custom": {
+      if (!opts.baseUrl || !opts.apiKey) throw new Error("initChatModel: custom: needs baseUrl + apiKey");
+      return new OpenAICompatibleProvider({ baseUrl: opts.baseUrl, apiKey: opts.apiKey, model, ...extra });
+    }
+    default:
+      throw new Error(`initChatModel: unknown provider "${provider}" (use together:|openai:|anthropic:|ollama:|custom:)`);
+  }
+}
+
+// src/skills/index.ts
+import { readdirSync, readFileSync, statSync } from "fs";
+import { join as join3 } from "path";
+import { z as z4 } from "zod";
+var FrontmatterSchema = z4.object({
+  name: z4.string().min(1),
+  description: z4.string().min(1),
+  version: z4.string().default("0.1.0")
+});
+function parseSkillFile(content, path = "<inline>") {
+  const raw = content.startsWith("\uFEFF") ? content.slice(1) : content;
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) throw new Error(`Invalid SKILL.md (missing frontmatter): ${path}`);
+  const [, fm, body] = match;
+  const meta = {};
+  for (const line of fm.split("\n")) {
+    const i = line.indexOf(":");
+    if (i > 0) meta[line.slice(0, i).trim()] = line.slice(i + 1).trim().replace(/^["']|["']$/g, "");
+  }
+  const parsed = FrontmatterSchema.parse(meta);
+  if (!body.trim()) throw new Error(`Invalid SKILL.md (empty body): ${path}`);
+  return { ...parsed, path, body: body.trim() };
+}
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  register(skill) {
+    if (this.skills.has(skill.name)) throw new Error(`Skill already registered: ${skill.name}`);
+    this.skills.set(skill.name, skill);
+    return this;
+  }
+  get(name) {
+    return this.skills.get(name);
+  }
+  list() {
+    return [...this.skills.values()];
+  }
+  /** Expose each skill's tools (if any) for Agent consumption. */
+  asTools() {
+    return this.list().flatMap((s) => s.tools ?? []);
+  }
+};
+async function discoverSkills(dirs, opts = {}) {
+  const found = [];
+  for (const dir of dirs) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = join3(dir, entry);
+      let stat3;
+      try {
+        stat3 = statSync(full);
+      } catch {
+        continue;
+      }
+      const file = stat3.isDirectory() ? join3(full, "SKILL.md") : full;
+      if (!file.endsWith("SKILL.md")) continue;
+      try {
+        found.push({ ...parseSkillFile(readFileSync(file, "utf8"), file), tools: [] });
+      } catch (err) {
+        if (opts.strict) throw err;
+      }
+    }
+  }
+  return found;
+}
+async function loadSkillsInto(registry, dirs, opts = {}) {
+  const skills = await discoverSkills(dirs, opts);
+  for (const s of skills) registry.register(s);
+  return skills;
+}
+function tokenize(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 1);
+}
+function scoreSkills(registry, input) {
+  const skills = registry.list();
+  const docs = skills.map((s) => tokenize(`${s.name} ${s.description}`));
+  const query = tokenize(input);
+  const df = /* @__PURE__ */ new Map();
+  for (const doc of docs) {
+    for (const term of new Set(doc)) df.set(term, (df.get(term) ?? 0) + 1);
+  }
+  const idf = (term) => Math.log((docs.length + 1) / ((df.get(term) ?? 0) + 1)) + 1;
+  const qtf = /* @__PURE__ */ new Map();
+  for (const t of query) qtf.set(t, (qtf.get(t) ?? 0) + 1);
+  const qnorm = Math.sqrt([...qtf.values()].reduce((n, c) => n + c * c, 0)) || 1;
+  return skills.map((skill, i) => {
+    if (new RegExp(`\\$${skill.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w-])`).test(input)) {
+      return { skill, score: Number.POSITIVE_INFINITY };
+    }
+    const dtf = /* @__PURE__ */ new Map();
+    for (const t of docs[i]) dtf.set(t, (dtf.get(t) ?? 0) + 1);
+    let dot = 0;
+    let dnorm = 0;
+    for (const [term, count] of dtf) {
+      const w = count * idf(term);
+      dnorm += w * w;
+      if (qtf.has(term)) dot += w * (qtf.get(term) ?? 0) * idf(term);
+    }
+    const denom = Math.sqrt(dnorm) * qnorm || 1;
+    return { skill, score: dot / denom };
+  });
+}
+function matchSkills(registry, input, threshold = 0.05) {
+  return scoreSkills(registry, input).filter(({ score }) => score >= threshold).sort((a, b) => b.score - a.score).map(({ skill }) => skill);
+}
+
+// src/serve/index.ts
+var AgentDefSchema = z5.object({
+  name: z5.string().min(1),
+  description: z5.string().default(""),
+  systemPrompt: z5.string().default("You are a helpful agent. Use tools when needed. Be concise."),
+  model: z5.string(),
+  port: z5.number().int().positive().optional(),
+  skills: z5.array(z5.string()).default([]),
+  filesystem: z5.string().optional(),
+  todos: z5.boolean().default(false),
+  maxSteps: z5.number().int().positive().default(8),
+  sessionDir: z5.string().optional(),
+  /** Extra env file for this agent (keys override framework-level). */
+  envFile: z5.string().optional()
+});
+var AgentEntrySchema = z5.union([
+  AgentDefSchema,
+  z5.object({ file: z5.string() }).catchall(z5.unknown())
+]);
+var FrameworkFileSchema = z5.object({
+  server: z5.object({ host: z5.string().default("127.0.0.1"), basePort: z5.number().int().min(0).default(8484) }).default({}),
+  /** Framework-level env file(s), loaded before agents resolve models. */
+  envFile: z5.union([z5.string(), z5.array(z5.string())]).optional(),
+  /** Inline env mapping (applied after env files, overrides them). */
+  env: z5.record(z5.string()).optional(),
+  /** Local checkpoint dir for served agents (durable HITL threads). */
+  checkpointer: z5.object({ dir: z5.string() }).optional(),
+  http: z5.object({ corsOrigins: z5.array(z5.string()).default([]) }).default({}),
+  agents: z5.array(AgentEntrySchema).min(1)
+});
+function loadEnvFile(path, override = true) {
+  dotenvConfig({ path, override });
+}
+function resolveAgentPaths(def, dir) {
+  return {
+    ...def,
+    skills: def.skills.map((s) => resolve2(dir, s)),
+    ...def.filesystem ? { filesystem: resolve2(dir, def.filesystem) } : {},
+    ...def.sessionDir ? { sessionDir: resolve2(dir, def.sessionDir) } : {},
+    ...def.envFile ? { envFile: resolve2(dir, def.envFile) } : {}
+  };
+}
+function resolveAgentEntry(fileRaw, overrides, agentDir, frameworkDir) {
+  const fileKeys = new Set(Object.keys(fileRaw));
+  const merged = AgentDefSchema.parse({ ...fileRaw, ...overrides });
+  const against = (key) => fileKeys.has(key) && !(key in overrides) ? agentDir : frameworkDir;
+  return {
+    ...merged,
+    skills: merged.skills.map((s) => resolve2(against("skills"), s)),
+    ...merged.filesystem ? { filesystem: resolve2(against("filesystem"), merged.filesystem) } : {},
+    ...merged.sessionDir ? { sessionDir: resolve2(against("sessionDir"), merged.sessionDir) } : {},
+    ...merged.envFile ? { envFile: resolve2(against("envFile"), merged.envFile) } : {}
+  };
+}
+function loadFrameworkConfig(path) {
+  const raw = JSON.parse(readFileSync2(path, "utf8"));
+  const parsed = FrameworkFileSchema.parse(raw);
+  const dir = dirname2(resolve2(path));
+  for (const envFile of parsed.envFile ? [parsed.envFile].flat() : []) {
+    loadEnvFile(resolve2(dir, envFile), false);
+  }
+  for (const [key, value] of Object.entries(parsed.env ?? {})) {
+    process.env[key] = value;
+  }
+  return {
+    server: parsed.server,
+    ...parsed.envFile ? { envFile: parsed.envFile } : {},
+    ...parsed.env ? { env: parsed.env } : {},
+    ...parsed.checkpointer ? { checkpointer: { dir: resolve2(dir, parsed.checkpointer.dir) } } : {},
+    http: parsed.http,
+    agents: parsed.agents.map((entry) => {
+      if ("file" in entry && typeof entry.file === "string") {
+        const agentPath = resolve2(dir, entry.file);
+        const agentDir = dirname2(agentPath);
+        const fileRaw = JSON.parse(readFileSync2(agentPath, "utf8"));
+        const { file: _file, ...overrides } = entry;
+        void _file;
+        const resolved2 = resolveAgentEntry(fileRaw, overrides, agentDir, dir);
+        if (resolved2.envFile) loadEnvFile(resolved2.envFile);
+        return resolved2;
+      }
+      const resolved = resolveAgentPaths(AgentDefSchema.parse(entry), dir);
+      if (resolved.envFile) loadEnvFile(resolved.envFile);
+      return resolved;
+    })
+  };
+}
+async function buildServedAgent(def, opts = {}) {
+  const middlewares = [];
+  if (def.filesystem) middlewares.push(filesystemMiddleware({ root: def.filesystem }));
+  if (def.todos) middlewares.push(todoListMiddleware());
+  let systemPrompt = def.systemPrompt;
+  if (def.skills.length) {
+    const registry = new SkillRegistry();
+    for (const dir of def.skills) {
+      for (const s of await discoverSkills([dir])) {
+        try {
+          registry.register(s);
+        } catch {
+        }
+      }
+    }
+    const catalog = registry.list().map((s) => `- ${s.name}: ${s.description}`).join("\n");
+    if (catalog) systemPrompt += `
+
+Available skill packs (mention $name to invoke):
+${catalog}`;
+  }
+  const agent = new Agent({
+    name: def.name,
+    description: def.description,
+    systemPrompt,
+    model: initChatModel(def.model),
+    maxSteps: def.maxSteps,
+    middleware: middlewares,
+    ...def.sessionDir ? {
+      // Context-scoped id keeps one def's sessions from mingling when
+      // the server runs a fresh agent per A2A contextId.
+      sessionManager: new SessionManager({
+        sessionId: opts.sessionId ?? def.name,
+        storage: new LocalFileStorage(def.sessionDir)
+      })
+    } : {}
+  });
+  return { agent, card: { name: def.name, ...def.description ? { description: def.description } : {} } };
+}
+async function serveFramework(file) {
+  const served = [];
+  const checkpointer = file.checkpointer ? new FileCheckpointer(file.checkpointer.dir) : void 0;
+  let port = file.server.basePort;
+  for (const def of file.agents) {
+    const { card } = await buildServedAgent(def);
+    const server = new A2AServer({
+      card,
+      // Fresh agent per A2A contextId — sharing one instance would leak one
+      // conversation into another context's history.
+      agentFactory: (contextId) => buildServedAgent(def, def.sessionDir ? { sessionId: `${def.name}:${contextId}` } : {}).then((r) => r.agent),
+      ...checkpointer ? { checkpointer } : {},
+      corsOrigins: file.http.corsOrigins,
+      host: file.server.host
+    });
+    const actual = await server.start(def.port ?? port, file.server.host);
+    port = actual + 1;
+    const url = `http://${file.server.host}:${actual}`;
+    served.push({ name: def.name, url, cardUrl: `${url}/.well-known/agent-card.json`, server });
+  }
+  return {
+    agents: served,
+    stop: async () => {
+      for (const s of served) await s.server.stop();
+    }
+  };
+}
+
+// src/rag/index.ts
+import { z as z6 } from "zod";
+var InMemoryRetriever = class {
+  id = "tfidf";
+  docs;
+  df = /* @__PURE__ */ new Map();
+  constructor(docs) {
+    this.docs = docs.map((d) => {
+      const terms = /* @__PURE__ */ new Map();
+      for (const t of tokenize(d.text)) terms.set(t, (terms.get(t) ?? 0) + 1);
+      return { ...d, terms };
+    });
+    for (const d of this.docs) {
+      for (const t of new Set(d.terms.keys())) this.df.set(t, (this.df.get(t) ?? 0) + 1);
+    }
+  }
+  idf(term) {
+    return Math.log((this.docs.length + 1) / ((this.df.get(term) ?? 0) + 1)) + 1;
+  }
+  async search(query, k = 4) {
+    const qtf = /* @__PURE__ */ new Map();
+    for (const t of tokenize(query)) qtf.set(t, (qtf.get(t) ?? 0) + 1);
+    return this.docs.map((d) => {
+      let dot = 0;
+      let norm = 0;
+      for (const [term, count] of d.terms) {
+        const w = count * this.idf(term);
+        norm += w * w;
+        if (qtf.has(term)) dot += w * (qtf.get(term) ?? 0) * this.idf(term);
+      }
+      const qnorm = Math.sqrt([...qtf.values()].reduce((n, c) => n + c * c, 0)) || 1;
+      return { id: d.id, text: d.text, meta: d.meta, score: dot / ((Math.sqrt(norm) || 1) * qnorm) };
+    }).filter((d) => d.score > 0).sort((a, b) => b.score - a.score).slice(0, k);
+  }
+};
+function retrievalTool(retriever, opts = {}) {
+  return defineTool({
+    name: opts.name ?? "retrieve",
+    description: `Search the knowledge base (${retriever.id}). Returns top passages with scores.`,
+    schema: z6.object({ query: z6.string().min(1).max(500), k: z6.number().int().min(1).max(10).default(opts.k ?? 4) }),
+    execute: async ({ query, k }) => retriever.search(query, k)
+  });
+}
+function sparqlRetriever(store, opts = {}) {
+  return {
+    id: opts.id ?? "sparql",
+    search: async (query, k = 4) => {
+      const terms = new Set(tokenize(query));
+      if (!terms.size) return [];
+      const quads = await store.match(null, null, null);
+      return quads.map((q, i) => {
+        const hay = `${q.subject} ${q.predicate} ${q.object}`.toLowerCase();
+        let score = 0;
+        for (const t of terms) if (hay.includes(t)) score += 1;
+        return { id: `q${i}`, text: `${q.subject} ${q.predicate} ${q.object}`, score };
+      }).filter((d) => d.score > 0).sort((a, b) => b.score - a.score).slice(0, k);
+    }
+  };
+}
+
+// src/sandbox/index.ts
+import { runInNewContext } from "vm";
+import { z as z7 } from "zod";
+import { execFile } from "child_process";
+import { readdir, readFile as readFile2, stat as stat2, writeFile as writeFile2 } from "fs/promises";
+import { join as join4, relative, resolve as resolve3 } from "path";
+function runJavascriptTool(opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 2e3;
+  const maxOutputChars = opts.maxOutputChars ?? 4e3;
+  return defineTool({
+    name: "run_javascript",
+    description: "Execute JavaScript in a sandbox (no network, no fs, timeout). Completion value becomes the result.",
+    schema: z7.object({ code: z7.string().min(1).max(8e3) }),
+    execute: async ({ code }) => {
+      let result;
+      try {
+        result = runInNewContext(code, Object.freeze({ Math, JSON }), { timeout: timeoutMs });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (/timed out/i.test(message)) {
+          throw new AgentError("SANDBOX_TIMEOUT", `Sandbox exceeded ${timeoutMs}ms`, true);
+        }
+        throw new AgentError("SANDBOX_ERROR", `Sandbox failed: ${message}`, false);
+      }
+      const text = typeof result === "string" ? result : JSON.stringify(result ?? null);
+      return text.length > maxOutputChars ? `${text.slice(0, maxOutputChars)}\u2026[truncated]` : result ?? null;
+    }
+  });
+}
+var SCRUBBED_ENV = ["PATH", "HOME", "LANG", "LC_ALL", "TZ", "TERM", "NO_COLOR"];
+function baseEnv(extra = {}) {
+  const env = {};
+  for (const k of SCRUBBED_ENV) {
+    const v = process.env[k];
+    if (v !== void 0) env[k] = v;
+  }
+  return { ...env, ...extra };
+}
+function escapeRegExp(s) {
+  return s.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+}
+function matchGlob(pattern, path) {
+  const parts = pattern.split("**/");
+  let rx = "^";
+  parts.forEach((part, index) => {
+    if (index > 0) rx += "(.*/)?";
+    for (let i = 0; i < part.length; i++) {
+      const c = part[i];
+      if (c === "*" && part[i + 1] === "*") {
+        rx += ".*";
+        i += 1;
+      } else if (c === "*") rx += "[^/]*";
+      else if (c === "?") rx += "[^/]";
+      else rx += escapeRegExp(c);
+    }
+  });
+  return new RegExp(`${rx}$`).test(path);
+}
+async function walkFiles(root) {
+  const out = [];
+  const walk = async (dir) => {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = join4(dir, e.name);
+      if (e.isDirectory()) await walk(full);
+      else if (e.isFile()) out.push(relative(root, full));
+    }
+  };
+  await walk(root);
+  return out.sort();
+}
+function createSandboxBackend(opts = {}) {
+  const root = resolve3(opts.root ?? process.cwd());
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  const maxOutputChars = opts.maxOutputChars ?? 12e3;
+  const env = baseEnv(opts.env);
+  let spills = 0;
+  const spill = async (text) => {
+    spills += 1;
+    const name = `.spill-${spills}.txt`;
+    await writeFile2(join4(root, name), text, "utf8");
+    return `${text.slice(0, maxOutputChars)}
+\u2026[truncated ${text.length - maxOutputChars} chars \u2192 read ${name} with read_file]`;
+  };
+  const executeTool = defineTool({
+    name: "execute",
+    description: "Run a shell command in the sandbox workspace (cwd=root, scrubbed env, timeout). Large output spills to a file.",
+    schema: z7.object({ command: z7.string().min(1).max(4e3) }),
+    execute: ({ command }) => new Promise((resolveExec, reject) => {
+      execFile("sh", ["-c", command], { cwd: root, env, timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+        if (err && err.killed) {
+          if (err.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+            reject(new AgentError("SANDBOX_OUTPUT_TOO_LARGE", "Command output exceeded the 4MB buffer; write output to a file and read it in chunks", false));
+            return;
+          }
+          reject(new AgentError("SANDBOX_TIMEOUT", `Command exceeded ${timeoutMs}ms`, true));
+          return;
+        }
+        const code = err && "code" in err ? err.code : 0;
+        const combined = `${stdout}${stderr ? `
+[stderr]
+${stderr}` : ""}`;
+        if (combined.length <= maxOutputChars) {
+          resolveExec(err ? `${combined}
+[Command failed with exit code ${code}]` : combined || "[Command succeeded with exit code 0]");
+          return;
+        }
+        void spill(combined).then(
+          (pointer) => resolveExec(`${pointer}
+[exit ${code}]`),
+          reject
+        );
+      });
+    })
+  });
+  const globTool = defineTool({
+    name: "glob",
+    description: "List workspace files matching a glob (*, ?, **).",
+    schema: z7.object({ pattern: z7.string().min(1).max(300) }),
+    execute: async ({ pattern }) => (await walkFiles(root)).filter((f) => matchGlob(pattern, f)).join("\n")
+  });
+  const grepTool = defineTool({
+    name: "grep",
+    description: "Search file contents (literal substring) under a glob. Returns path:line matches.",
+    schema: z7.object({ query: z7.string().min(1).max(300), pattern: z7.string().default("**") }),
+    execute: async ({ query, pattern }) => {
+      const files = (await walkFiles(root)).filter((f) => matchGlob(pattern ?? "**", f));
+      const hits = [];
+      for (const f of files.slice(0, 200)) {
+        let info;
+        try {
+          info = await stat2(join4(root, f));
+        } catch {
+          continue;
+        }
+        if (info.size > 512 * 1024) continue;
+        let content;
+        try {
+          content = await readFile2(join4(root, f), "utf8");
+        } catch {
+          continue;
+        }
+        content.split("\n").forEach((line, i) => {
+          if (line.includes(query)) hits.push(`${f}:${i + 1}:${line.slice(0, 200)}`);
+        });
+        if (hits.length >= 50) break;
+      }
+      return hits.join("\n") || "(no matches)";
+    }
+  });
+  return {
+    root,
+    tools: () => [...filesystemTools(root), globTool, grepTool, executeTool]
+  };
+}
+
+// src/evals/index.ts
+import { readFileSync as readFileSync3 } from "fs";
+function loadJsonl(path) {
+  return readFileSync3(path, "utf8").split("\n").map((l) => l.trim()).filter(Boolean).map((l) => JSON.parse(l));
+}
+async function runEval(cases, makeAgent) {
+  const scores = [];
+  for (const c of cases) {
+    try {
+      const res = await makeAgent(c).run(c.input);
+      const missing = (c.expect?.contains ?? []).filter((s) => !res.text.includes(s));
+      const missingTools = (c.expect?.toolUsed ?? []).filter((t) => !res.toolCalls.some((tc) => tc.name === t));
+      const pass = !missing.length && !missingTools.length;
+      scores.push({
+        id: c.id,
+        pass,
+        detail: pass ? "ok" : `missing text ${JSON.stringify(missing)} tools ${JSON.stringify(missingTools)} :: ${res.text.slice(0, 120)}`,
+        usage: res.usage
+      });
+    } catch (err) {
+      scores.push({
+        id: c.id,
+        pass: false,
+        detail: `threw: ${err instanceof Error ? err.message : String(err)}`,
+        usage: { inputTokens: 0, outputTokens: 0 }
+      });
+    }
+  }
+  const passRate = scores.length ? scores.filter((s) => s.pass).length / scores.length : 1;
+  return { scores, passRate };
+}
+function printReport(scores, passRate) {
+  for (const s of scores) {
+    console.log(`${s.pass ? "PASS" : "FAIL"}  ${s.id}  ${s.detail}`);
+  }
+  console.log(`
+pass rate: ${(passRate * 100).toFixed(1)}% (${scores.filter((s) => s.pass).length}/${scores.length})`);
+}
+
+// src/tracing/index.ts
+import { appendFileSync, mkdirSync } from "fs";
+import { dirname as dirname3 } from "path";
+function hex(n) {
+  return [...Array(n)].map(() => Math.floor(Math.random() * 16).toString(16)).join("");
+}
+var ConsoleSpanSink = class {
+  emit(span) {
+    console.log(`[trace] ${span.name}`, JSON.stringify(span.attributes));
+  }
+};
+var JsonlSpanSink = class {
+  constructor(path) {
+    this.path = path;
+    mkdirSync(dirname3(path), { recursive: true });
+  }
+  path;
+  emit(span) {
+    appendFileSync(this.path, `${JSON.stringify(span)}
+`, "utf8");
+  }
+};
+var MemorySpanSink = class {
+  spans = [];
+  emit(span) {
+    this.spans.push(span);
+  }
+};
+function tracingEvents(sink, opts = {}) {
+  const traceId = opts.traceId ?? hex(32);
+  const open2 = /* @__PURE__ */ new Map();
+  const emit = (name, attributes, parentId) => {
+    const span = {
+      traceId,
+      spanId: hex(16),
+      ...parentId ? { parentId } : {},
+      name,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attributes
+    };
+    sink.emit(span);
+    return span;
+  };
+  return {
+    onStep: (e) => {
+      emit("agent.step", { step: e.step, messages: e.messages.length });
+    },
+    onToolCall: (e) => {
+      const span = emit("tool.call", { tool: e.tool, args: e.args });
+      open2.set(e.tool, span);
+    },
+    onToolResult: (e) => {
+      const parent = open2.get(e.tool);
+      open2.delete(e.tool);
+      emit("tool.result", { tool: e.tool, output: e.output }, parent?.spanId);
+    },
+    onToken: (delta) => {
+      emit("model.token", { delta: delta.slice(0, 200) });
+    },
+    onThinking: (delta) => {
+      emit("model.thinking", { delta: delta.slice(0, 200) });
+    },
+    onDone: (e) => {
+      emit("agent.done", { text: e.text.slice(0, 500), toolCalls: e.toolCalls.length });
+    }
+  };
+}
+function policyFilterMiddleware(opts) {
+  const match = (list, name) => (
+    // `g`-flagged regexes are stateful across .test() calls — clone without
+    // the flag so one tool name can't alternate denied/allowed.
+    (list ?? []).some(
+      (p) => typeof p === "string" ? p === name : new RegExp(p.source, p.flags.replace("g", "")).test(name)
+    )
+  );
+  return {
+    name: "policy-filter",
+    beforeTool: (call) => {
+      if (opts.deny && match(opts.deny, call.name)) {
+        if (opts.exitBehavior === "error") {
+          throw new AgentError("POLICY_DENY", `Policy denies tool "${call.name}"`, false);
+        }
+        throw new ToolRejection(`Policy denies tool "${call.name}". Do not retry it; finish another way.`);
+      }
+      if (opts.allow && !match(opts.allow, call.name)) {
+        throw new ToolRejection(`Policy allows only [${opts.allow.join(", ")}]; "${call.name}" is not allowed.`);
+      }
+      return void 0;
+    }
+  };
+}
+
+// src/streaming/index.ts
+async function collectStream(stream) {
+  const events = [];
+  for (; ; ) {
+    const next = await stream.next();
+    if (next.done) return { events, result: next.value };
+    events.push(next.value);
+  }
+}
+
+// src/memory/compaction.ts
+function defaultSummarize(messages) {
+  const head = messages.filter((m) => m.role !== "system").slice(0, 5).map((m) => `[${m.role}] ${textOf(m.content).slice(0, 200)}`).join("\n");
+  return Promise.resolve(`Prior context summary (${messages.length} msgs):
+${head}`);
+}
+var CompactedMemory = class {
+  constructor(inner, opts = {}) {
+    this.inner = inner;
+    this.opts = opts;
+  }
+  inner;
+  opts;
+  async load() {
+    return this.inner.load();
+  }
+  async save(messages) {
+    await this.inner.save(messages);
+    const max = this.opts.maxMessages ?? 40;
+    const current = await this.inner.load();
+    if (current.length <= max) return;
+    const summarize = this.opts.summarize ?? defaultSummarize;
+    const overflow = current.slice(0, current.length - max + 1);
+    const rest = current.slice(current.length - max + 1);
+    const summary = await summarize(overflow);
+    await this.inner.clear();
+    await this.inner.save([{ role: "assistant", content: summary }, ...rest]);
+  }
+  async clear() {
+    return this.inner.clear();
+  }
+};
+
+// src/models/index.ts
+var MockModelProvider = class {
+  id = "mock";
+  capabilities = { structuredOutput: false, streaming: false };
+  calls = 0;
+  async complete(_options) {
+    this.calls += 1;
+    return {
+      text: `mock-response-${this.calls}`,
+      toolCalls: [],
+      usage: { inputTokens: 10, outputTokens: 5 }
+    };
+  }
+};
+
+// src/observability/index.ts
+function supportsColor() {
+  return !process.env.NO_COLOR && !!process.stdout?.isTTY;
+}
+var C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  green: "\x1B[32m",
+  magenta: "\x1B[35m",
+  red: "\x1B[31m"
+};
+function paint(color, text, on) {
+  if (!on || color === "reset") return text;
+  return `${C[color]}${text}${C.reset}`;
+}
+function consoleEvents(prefixOrOpts = "[agent]", maybeOpts = {}) {
+  const { prefix, colors } = typeof prefixOrOpts === "string" ? { prefix: prefixOrOpts, colors: maybeOpts.colors ?? supportsColor() } : { prefix: prefixOrOpts.prefix ?? "[agent]", colors: prefixOrOpts.colors ?? supportsColor() };
+  const tag = (color, label) => `${paint(color, `${prefix} ${label}`, colors)}`;
+  return {
+    onStep: (e) => console.log(tag("cyan", `step ${e.step} (${e.messages.length} msgs)`)),
+    onToolCall: (e) => console.log(tag("yellow", `tool:call ${e.tool}`), e.args),
+    onToolResult: (e) => console.log(tag("green", `tool:result ${e.tool}`), e.output),
+    onDone: (e) => console.log(tag("green", paint("bold", "done:", colors)), e.text),
+    onToken: (d) => process.stdout.write(d),
+    onThinking: (d) => process.stdout.write(paint("dim", d, colors))
+  };
+}
+function logError(prefix, err, colors) {
+  const on = colors ?? supportsColor();
+  const message = err instanceof Error ? err.stack ?? err.message : String(err);
+  console.error(paint("red", `${prefix} error:`, on), message);
+}
+
+// src/orchestration/index.ts
+function requireAgents(plan) {
+  if (!plan.agents.length) throw new AgentError("ORCHESTRATION_EMPTY", "Orchestration needs at least one agent", false);
+}
+async function runSequential(plan, input, opts = {}) {
+  requireAgents(plan);
+  const results = [];
+  let current = input;
+  for (let i = 0; i < plan.agents.length; i++) {
+    opts.signal?.throwIfAborted();
+    plan.events?.onStep?.({ step: i, messages: [] });
+    const res = await plan.agents[i].run(current, { signal: opts.signal, invocationState: opts.invocationState });
+    results.push(res);
+    current = `${input}
+
+Previous result (${plan.agents[i].name}):
+${res.text}`;
+  }
+  return { strategy: "sequential", results, text: results.at(-1)?.text ?? "" };
+}
+async function runParallel(plan, input, opts = {}) {
+  requireAgents(plan);
+  const limit = Math.max(1, plan.concurrency ?? plan.agents.length);
+  const results = new Array(plan.agents.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(limit, plan.agents.length) }, async () => {
+    for (; ; ) {
+      opts.signal?.throwIfAborted();
+      const i = next++;
+      if (i >= plan.agents.length) return;
+      results[i] = await plan.agents[i].run(input, { signal: opts.signal, invocationState: opts.invocationState });
+    }
+  });
+  await Promise.all(workers);
+  return { strategy: "parallel", results, text: results.map((r) => r.text).join("\n\n") };
+}
+async function runRouter(plan, input, opts = {}) {
+  requireAgents(plan);
+  const routerModel = plan.routerModel ?? plan.agents[0].model;
+  const menu = plan.agents.map((a, i) => `${i}: ${a.name}${a.description ? ` \u2014 ${a.description}` : ""}`).join("\n");
+  const pick = await routerModel.complete({
+    messages: [
+      { role: "system", content: "You route user requests to specialist agents. Reply with ONLY the agent number." },
+      { role: "user", content: `Agents:
+${menu}
+
+Request: ${input}` }
+    ],
+    tools: []
+  });
+  const match = pick.text.match(/\d+/);
+  const idx = match ? Number.parseInt(match[0], 10) : Number.NaN;
+  if (!Number.isInteger(idx) || idx < 0 || idx >= plan.agents.length) {
+    throw new AgentError("ROUTER_NO_MATCH", `Router picked invalid agent: ${JSON.stringify(pick.text)}`, false);
+  }
+  const res = await plan.agents[idx].run(input, { signal: opts.signal, invocationState: opts.invocationState });
+  return { strategy: "router", results: [res], text: res.text, routedTo: idx };
+}
+async function runOrchestrated(plan, input, signalOrOpts) {
+  const opts = signalOrOpts instanceof AbortSignal ? { signal: signalOrOpts } : signalOrOpts ?? {};
+  switch (plan.strategy) {
+    case "sequential":
+      return runSequential(plan, input, opts);
+    case "parallel":
+      return runParallel(plan, input, opts);
+    case "router":
+      return runRouter(plan, input, opts);
+  }
+}
+
+// src/workflows/index.ts
+function sortTopo(nodes) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  if (byId.size !== nodes.length) throw new AgentError("WORKFLOW_DUPLICATE_ID", "Workflow node ids must be unique", false);
+  for (const n of nodes) {
+    for (const dep of n.dependsOn ?? []) {
+      if (!byId.has(dep)) throw new AgentError("WORKFLOW_UNKNOWN_DEP", `Node "${n.id}" depends on unknown node "${dep}"`, false);
+      if (dep === n.id) throw new AgentError("WORKFLOW_CYCLE", `Node "${n.id}" depends on itself`, false);
+    }
+  }
+  const indegree = new Map(nodes.map((n) => [n.id, n.dependsOn ? new Set(n.dependsOn).size : 0]));
+  const levels = [];
+  let ready = nodes.filter((n) => (indegree.get(n.id) ?? 0) === 0);
+  while (ready.length) {
+    levels.push(ready);
+    const next = [];
+    for (const n of nodes) {
+      if (!ready.includes(n)) continue;
+      for (const m of nodes) {
+        if (!(m.dependsOn ?? []).includes(n.id)) continue;
+        indegree.set(m.id, (indegree.get(m.id) ?? 1) - 1);
+        if (indegree.get(m.id) === 0) next.push(m);
+      }
+    }
+    ready = next;
+  }
+  if (levels.flat().length !== nodes.length) {
+    throw new AgentError("WORKFLOW_CYCLE", "Workflow has a dependency cycle", false);
+  }
+  return levels;
+}
+async function runWithRetry(node, ctx, signal, invocationState) {
+  const attempts = Math.max(1, node.retry?.attempts ?? 1);
+  const backoffMs = node.retry?.backoffMs ?? 0;
+  let last;
+  for (let i = 0; i < attempts; i++) {
+    signal?.throwIfAborted();
+    try {
+      return await node.run(ctx, invocationState);
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") throw err;
+      last = err;
+      if (i < attempts - 1 && backoffMs > 0) await sleep(backoffMs, signal);
+    }
+  }
+  throw last;
+}
+async function runWorkflow(nodes, opts = {}) {
+  const ctx = {};
+  for (const level of sortTopo(nodes)) {
+    opts.signal?.throwIfAborted();
+    const entries = await Promise.all(
+      level.map(async (n) => [n.id, await runWithRetry(n, ctx, opts.signal, opts.invocationState)])
+    );
+    for (const [id, value] of entries) ctx[id] = value;
+  }
+  return ctx;
+}
+
+// src/mcp/index.ts
+import { spawn } from "child_process";
+import { z as z8 } from "zod";
+var rpcSeq = 0;
+function jsonSchemaToZod(schema) {
+  const type = schema.type;
+  if (Array.isArray(schema.enum)) {
+    const values = schema.enum;
+    if (values.length && values.every((v) => typeof v === "string")) return z8.enum(values);
+    if (values.length) {
+      const literals = values.map((v) => z8.literal(v));
+      return literals.length > 1 ? z8.union(literals) : literals[0];
+    }
+    return z8.never();
+  }
+  switch (type) {
+    case "string":
+      return z8.string();
+    case "number":
+      return z8.number();
+    case "integer":
+      return z8.number().int();
+    case "boolean":
+      return z8.boolean();
+    case "null":
+      return z8.null();
+    case "array": {
+      const items = schema.items;
+      return z8.array(items ? jsonSchemaToZod(items) : z8.unknown());
+    }
+    case "object": {
+      const props = schema.properties ?? {};
+      const required = new Set(schema.required ?? []);
+      const shape = {};
+      for (const [key, sub] of Object.entries(props)) {
+        const inner = jsonSchemaToZod(sub);
+        shape[key] = required.has(key) ? inner : inner.optional();
+      }
+      return z8.object(shape).passthrough();
+    }
+    default:
+      return z8.unknown();
+  }
+}
+async function parseStreamableResponse(res) {
+  const contentType = res.headers.get("content-type") ?? "";
+  if (contentType.includes("text/event-stream")) {
+    const text = await res.text();
+    let last;
+    for (const line of text.split("\n")) {
+      const t = line.trim();
+      if (!t.startsWith("data:")) continue;
+      const payload = t.slice(5).trim();
+      if (payload === "[DONE]") continue;
+      try {
+        const msg = JSON.parse(payload);
+        if (msg.id !== void 0 || msg.result !== void 0 || msg.error) last = msg;
+      } catch {
+        continue;
+      }
+    }
+    if (!last) throw new AgentError("MCP_PROTOCOL", "Empty SSE response from MCP server", true);
+    return last;
+  }
+  return await res.json();
+}
+function checkRpc(res, what) {
+  if (res.error) throw new AgentError("MCP_ERROR", `MCP ${what}: ${res.error.message} (${res.error.code})`, false);
+  return res.result;
+}
+var McpHttpClient = class {
+  serverId;
+  url;
+  headers;
+  fetchFn;
+  clientName;
+  sessionId;
+  connected = false;
+  constructor(url, opts = {}) {
+    this.url = url.replace(/\/$/, "");
+    this.serverId = opts.serverId ?? url;
+    this.headers = opts.headers ?? {};
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.clientName = opts.clientName ?? "fabisch-agents";
+  }
+  async rpc(method, params) {
+    return this.rpcInner(method, params, true);
+  }
+  /** JSON-RPC notification — no id, no response expected. */
+  async notify(method, params) {
+    await this.rpcInner(method, params, false);
+  }
+  async rpcInner(method, params, withId) {
+    let res;
+    try {
+      res = await this.fetchFn(this.url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          accept: "application/json, text/event-stream",
+          ...this.sessionId ? { "mcp-session-id": this.sessionId } : {},
+          ...this.headers
+        },
+        body: JSON.stringify(
+          withId ? { jsonrpc: "2.0", id: ++rpcSeq, method, params: params ?? {} } : { jsonrpc: "2.0", method, params: params ?? {} }
+        )
+      });
+    } catch (err) {
+      throw new AgentError("MCP_TRANSPORT", `MCP request failed: ${err instanceof Error ? err.message : String(err)}`, true);
+    }
+    const session = res.headers.get("mcp-session-id");
+    if (session) this.sessionId = session;
+    if (!res.ok) throw new AgentError("MCP_TRANSPORT", `MCP HTTP ${res.status}`, res.status >= 500);
+    if (!withId) {
+      await res.text().catch(() => "");
+      return void 0;
+    }
+    return checkRpc(await parseStreamableResponse(res), method);
+  }
+  async connect() {
+    const result = await this.rpc("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: this.clientName, version: "0.1.0" }
+    });
+    await this.notify("notifications/initialized", {}).catch(() => void 0);
+    this.connected = true;
+    return { name: result.serverInfo?.name ?? this.serverId, version: result.serverInfo?.version };
+  }
+  requireConnected() {
+    if (!this.connected) throw new AgentError("MCP_NOT_CONNECTED", "Call connect() first", false);
+  }
+  async listTools() {
+    this.requireConnected();
+    const result = await this.rpc("tools/list");
+    return result.tools ?? [];
+  }
+  async callTool(name, args) {
+    this.requireConnected();
+    const result = await this.rpc("tools/call", { name, arguments: args ?? {} });
+    const text = (result.content ?? []).filter((c) => c.type === "text").map((c) => c.text ?? "").join("\n");
+    if (result.isError) throw new AgentError("MCP_TOOL_ERROR", `MCP tool "${name}" failed: ${text}`, false);
+    return text;
+  }
+  async close() {
+    this.connected = false;
+    this.sessionId = void 0;
+  }
+};
+var McpStdioClient = class {
+  constructor(command, args = [], opts = {}) {
+    this.command = command;
+    this.args = args;
+    this.serverId = opts.serverId ?? `${command} ${args.join(" ")}`.trim();
+    this.clientName = opts.clientName ?? "fabisch-agents";
+  }
+  command;
+  args;
+  serverId;
+  child;
+  buffer = "";
+  pending = /* @__PURE__ */ new Map();
+  clientName;
+  async connect() {
+    try {
+      this.child = spawn(this.command, this.args, { stdio: ["pipe", "pipe", "ignore"] });
+    } catch (err) {
+      throw new AgentError("MCP_TRANSPORT", `Cannot spawn MCP server: ${err instanceof Error ? err.message : String(err)}`, false);
+    }
+    if (!this.child.stdout || !this.child.stdin) {
+      throw new AgentError("MCP_TRANSPORT", "MCP stdio pipes unavailable", false);
+    }
+    this.child.on("error", (err) => {
+      for (const [, respond] of this.pending) {
+        respond({ jsonrpc: "2.0", error: { code: -32e3, message: `MCP server failed: ${err.message}` } });
+      }
+      this.pending.clear();
+    });
+    this.child.on("exit", (code, signal) => {
+      for (const [, respond] of this.pending) {
+        respond({ jsonrpc: "2.0", error: { code: -32e3, message: `MCP server exited (code ${code ?? "null"}, signal ${signal ?? "none"})` } });
+      }
+      this.pending.clear();
+    });
+    this.child.stdout.on("data", (chunk) => {
+      this.buffer += chunk.toString("utf8");
+      const lines = this.buffer.split("\n");
+      this.buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const t = line.trim();
+        if (!t) continue;
+        try {
+          const msg = JSON.parse(t);
+          if (msg.id !== void 0) this.pending.get(msg.id)?.(msg);
+        } catch {
+          continue;
+        }
+      }
+    });
+    const result = await this.request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: this.clientName, version: "0.1.0" }
+    });
+    void result;
+  }
+  request(method, params) {
+    return new Promise((resolve4, reject) => {
+      if (!this.child?.stdin) {
+        reject(new AgentError("MCP_NOT_CONNECTED", "Call connect() first", false));
+        return;
+      }
+      const id = ++rpcSeq;
+      this.pending.set(id, (res) => {
+        this.pending.delete(id);
+        try {
+          resolve4(checkRpc(res, method));
+        } catch (err) {
+          reject(err);
+        }
+      });
+      this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
+`, (err) => {
+        if (err) {
+          this.pending.delete(id);
+          reject(new AgentError("MCP_TRANSPORT", `MCP stdio write failed: ${err.message}`, true));
+        }
+      });
+    });
+  }
+  async listTools() {
+    const result = await this.request("tools/list", {});
+    return result.tools ?? [];
+  }
+  async callTool(name, args) {
+    const result = await this.request("tools/call", { name, arguments: args ?? {} });
+    const text = (result.content ?? []).filter((c) => c.type === "text").map((c) => c.text ?? "").join("\n");
+    if (result.isError) throw new AgentError("MCP_TOOL_ERROR", `MCP tool "${name}" failed: ${text}`, false);
+    return text;
+  }
+  async close() {
+    this.child?.kill();
+    this.child = void 0;
+    for (const [, respond] of this.pending) {
+      respond({ jsonrpc: "2.0", error: { code: -32e3, message: "MCP client closed" } });
+    }
+    this.pending.clear();
+  }
+};
+async function mcpToolsToFramework(client, defs) {
+  const list = defs ?? await client.listTools();
+  const seen = /* @__PURE__ */ new Set();
+  return list.map((d) => {
+    const name = seen.has(d.name) ? `${client.serverId}.${d.name}` : d.name;
+    seen.add(d.name);
+    return defineTool({
+      name,
+      description: d.description ?? `MCP tool ${d.name} (via ${client.serverId})`,
+      schema: jsonSchemaToZod(d.inputSchema ?? { type: "object" }),
+      execute: async (args) => client.callTool(d.name, args)
+    });
+  });
+}
+async function connectMcpHttp(url, opts) {
+  const client = new McpHttpClient(url, opts);
+  await client.connect();
+  return client;
+}
+async function connectMcpStdio(command, args = []) {
+  const client = new McpStdioClient(command, args);
+  await client.connect();
+  return client;
+}
+
+// src/prompts/index.ts
+import { readFileSync as readFileSync4 } from "fs";
+function definePrompt(name, template, version = "0.1.0") {
+  return {
+    name,
+    version,
+    template,
+    render(vars) {
+      return template.replace(/\{\{\s*(\w+)\s*\}\}/g, (_, key) => {
+        if (!(key in vars)) throw new Error(`Missing prompt var: ${key} (prompt: ${name})`);
+        return String(vars[key]);
+      });
+    }
+  };
+}
+function loadPromptFile(path) {
+  const file = readFileSync4(path, "utf8");
+  const raw = file.startsWith("\uFEFF") ? file.slice(1) : file;
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) throw new Error(`Invalid prompt file (missing frontmatter): ${path}`);
+  const meta = {};
+  for (const line of match[1].split("\n")) {
+    const i = line.indexOf(":");
+    if (i > 0) meta[line.slice(0, i).trim()] = line.slice(i + 1).trim().replace(/^["']|["']$/g, "");
+  }
+  if (!meta.name) throw new Error(`Invalid prompt file (missing name): ${path}`);
+  return definePrompt(meta.name, match[2].trim(), meta.version ?? "0.1.0");
+}
+function abPrompts(variants, pick) {
+  if (pick) {
+    const found = variants.find((v) => (v.version ? `${v.name}@${v.version}` : v.name) === pick || v.name === pick);
+    if (!found) throw new Error(`Unknown prompt variant: ${pick}`);
+    return definePrompt(found.name, found.template, found.version);
+  }
+  const total = variants.reduce((n, v) => n + (v.weight ?? 1), 0);
+  let roll = Math.random() * total;
+  for (const v of variants) {
+    roll -= v.weight ?? 1;
+    if (roll <= 0) return definePrompt(v.name, v.template, v.version);
+  }
+  const last = variants[variants.length - 1];
+  return definePrompt(last.name, last.template, last.version);
+}
+
+// src/semantic/index.ts
+import { z as z12 } from "zod";
+
+// src/semantic/remote-sparql.ts
+import { z as z9 } from "zod";
+var DEFAULT_PREFIXES = {
+  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#",
+  owl: "http://www.w3.org/2002/07/owl#",
+  xsd: "http://www.w3.org/2001/XMLSchema#",
+  skos: "http://www.w3.org/2004/02/skos/core#",
+  dct: "http://purl.org/dc/terms/",
+  prov: "http://www.w3.org/ns/prov#",
+  schema: "https://schema.org/"
+};
+var RemoteSparqlAdapter = class {
+  endpoint;
+  updateEndpoint;
+  prefixes;
+  extraHeaders;
+  fetchFn;
+  timeoutMs;
+  maxRetries;
+  auth;
+  constructor(opts) {
+    this.endpoint = opts.endpoint.replace(/\/$/, "");
+    this.updateEndpoint = (opts.updateEndpoint ?? opts.endpoint).replace(/\/$/, "");
+    this.prefixes = { ...DEFAULT_PREFIXES, ...opts.prefixes };
+    this.extraHeaders = opts.headers ?? {};
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.timeoutMs = opts.timeoutMs ?? 3e4;
+    this.maxRetries = Math.max(0, opts.maxRetries ?? 2);
+    this.auth = opts.auth;
+  }
+  /** Prepend pinned PREFIX declarations so caller queries stay short. */
+  withPrefixes(query) {
+    const declarations = Object.entries(this.prefixes).map(([prefix, iri]) => `PREFIX ${prefix}: <${iri}>`).join("\n");
+    return `${declarations}
+${query}`;
+  }
+  headers(extra = {}) {
+    const out = { ...extra, ...this.extraHeaders };
+    out["user-agent"] ??= "agent-framework/0.1 (+RemoteSparqlAdapter)";
+    if (!this.auth) return out;
+    if (this.auth.type === "basic") {
+      out.authorization = `Basic ${Buffer.from(`${this.auth.user}:${this.auth.password}`).toString("base64")}`;
+    } else if (this.auth.type === "bearer") {
+      out.authorization = `Bearer ${this.auth.token}`;
+    } else {
+      out[this.auth.name] = this.auth.value;
+    }
+    return out;
+  }
+  async post(url, contentType, body, accept) {
+    let lastError;
+    let retryDelayMs;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        await new Promise((r) => setTimeout(r, retryDelayMs ?? Math.min(2e3 * 2 ** (attempt - 1), 1e4)));
+      }
+      let res;
+      try {
+        res = await this.fetchFn(url, {
+          method: "POST",
+          headers: this.headers({ "content-type": contentType, accept }),
+          body,
+          signal: AbortSignal.timeout(this.timeoutMs)
+        });
+      } catch (err) {
+        lastError = new AgentError(
+          "REMOTE_SPARQL",
+          `SPARQL request failed: ${err instanceof Error ? err.message : String(err)}`,
+          true
+        );
+        retryDelayMs = void 0;
+        continue;
+      }
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        const retryable = res.status === 429 || res.status >= 500;
+        const err = new AgentError(
+          "REMOTE_SPARQL",
+          `${url} HTTP ${res.status}: ${text.slice(0, 300)}`,
+          retryable
+        );
+        const retryAfterHeader = Number.parseInt(res.headers.get("retry-after") ?? "", 10);
+        retryDelayMs = Number.isFinite(retryAfterHeader) ? Math.min(retryAfterHeader * 1e3, 6e4) : void 0;
+        if (!retryable || attempt === this.maxRetries) throw err;
+        lastError = err;
+        continue;
+      }
+      return res;
+    }
+    throw lastError ?? new AgentError("REMOTE_SPARQL", "request failed", true);
+  }
+  /**
+   * SELECT over the remote endpoint. Returns rows of plain-string terms
+   * (same shape as the local `executeSelect`) so both path kinds compose.
+   */
+  async select(query) {
+    const res = await this.post(
+      this.endpoint,
+      "application/sparql-query",
+      this.withPrefixes(query),
+      "application/sparql-results+json"
+    );
+    let json;
+    try {
+      json = await res.json();
+    } catch (err) {
+      throw new AgentError(
+        "REMOTE_SPARQL",
+        `Endpoint returned non-JSON results (expected sparql-results+json): ${err instanceof Error ? err.message : String(err)}`,
+        false
+      );
+    }
+    const vars = json.head?.vars ?? [];
+    const bindings = json.results?.bindings ?? [];
+    return bindings.map((b) => {
+      const row = {};
+      for (const v of vars) row[v] = b[v]?.value ?? "";
+      return row;
+    });
+  }
+  /**
+   * SPARQL 1.1 UPDATE (INSERT/DELETE DATA, DELETE WHERE...) against the
+   * update endpoint. Opt-in — never wire this into a read-only agent.
+   */
+  async update(query) {
+    await this.post(
+      this.updateEndpoint,
+      "application/sparql-update",
+      this.withPrefixes(query),
+      "*/*"
+    );
+  }
+};
+function remoteSparqlTool(adapter, opts = {}) {
+  if (!opts.allowUpdate) {
+    return defineTool({
+      name: "remote_sparql_select",
+      description: "Query a remote SPARQL endpoint (read-only SELECT).",
+      schema: z9.object({ query: z9.string().min(1).max(2e4) }),
+      execute: async ({ query }) => adapter.select(query)
+    });
+  }
+  return defineTool({
+    name: "remote_sparql",
+    description: "Query or mutate a remote SPARQL endpoint (SELECT, or UPDATE with { update: true }).",
+    schema: z9.object({ query: z9.string().min(1).max(2e4), update: z9.boolean().default(false) }),
+    execute: async ({ query, update }) => {
+      if (update) {
+        await adapter.update(query);
+        return { updated: true };
+      }
+      return adapter.select(query);
+    }
+  });
+}
+
+// src/semantic/entity-linking.ts
+import { z as z10 } from "zod";
+var LABEL_PREDICATES = /* @__PURE__ */ new Set([
+  "rdfs:label",
+  "http://www.w3.org/2000/01/rdf-schema#label",
+  "skos:prefLabel",
+  "http://www.w3.org/2004/02/skos/core#prefLabel",
+  "skos:altLabel",
+  "http://www.w3.org/2004/02/skos/core#altLabel"
+]);
+var SAME_AS = /* @__PURE__ */ new Set(["owl:sameAs", "http://www.w3.org/2002/07/owl#sameAs"]);
+var JSONLD_PREFIXES = {
+  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#",
+  owl: "http://www.w3.org/2002/07/owl#",
+  xsd: "http://www.w3.org/2001/XMLSchema#",
+  skos: "http://www.w3.org/2004/02/skos/core#",
+  dct: "http://purl.org/dc/terms/",
+  prov: "http://www.w3.org/ns/prov#",
+  schema: "https://schema.org/",
+  ex: "urn:example:"
+};
+var EntityLinker = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  /** Union-find over owl:sameAs pairs: every alias cluster -> one representative. */
+  async sameAsGroups() {
+    const pairs = (await this.store.match(null, null, null)).filter((q) => SAME_AS.has(q.predicate));
+    const parent = /* @__PURE__ */ new Map();
+    const find = (x) => {
+      let root = x;
+      while (parent.get(root) !== root && parent.has(root)) root = parent.get(root);
+      return root;
+    };
+    const union = (a, b) => {
+      const ra = find(a);
+      const rb = find(b);
+      if (ra !== rb) parent.set(ra, rb);
+    };
+    for (const q of pairs) {
+      if (!parent.has(q.subject)) parent.set(q.subject, q.subject);
+      if (!parent.has(q.object)) parent.set(q.object, q.object);
+      union(q.subject, q.object);
+    }
+    const representative = /* @__PURE__ */ new Map();
+    for (const member of parent.keys()) representative.set(member, find(member));
+    return representative;
+  }
+  /** Mention -> candidate entities, best first, canonicalized via sameAs. */
+  async link(mention, k = 5) {
+    const needle = mention.trim().toLowerCase();
+    if (!needle) return [];
+    const quads = await this.store.match(null, null, null);
+    const canonical = await this.sameAsGroups();
+    const labels = /* @__PURE__ */ new Map();
+    const labelScore = /* @__PURE__ */ new Map();
+    const candidates = [];
+    for (const q of quads) {
+      const localPart = localName(q.subject);
+      const fullTail = q.subject.includes("/") || q.subject.includes("#") ? q.subject.split(/[#/]/).pop() ?? "" : localPart;
+      if (localPart === needle) candidates.push({ iri: q.subject, score: 40 });
+      else if (localPart.startsWith(needle)) candidates.push({ iri: q.subject, score: 25 });
+      else if (fullTail.toLowerCase() === needle) candidates.push({ iri: q.subject, score: 40 });
+      if (LABEL_PREDICATES.has(q.predicate)) {
+        const label = stripLiteral(q.object).toLowerCase();
+        const trust = q.predicate.includes("altLabel") ? 2 : q.predicate.includes("prefLabel") ? 0 : 1;
+        if (label === needle) candidates.push({ iri: q.subject, label: stripLiteral(q.object), score: 100 });
+        else if (label.startsWith(needle)) candidates.push({ iri: q.subject, label: stripLiteral(q.object), score: 60 });
+        else if (label.includes(needle)) candidates.push({ iri: q.subject, label: stripLiteral(q.object), score: 30 });
+        const prev = labelScore.get(q.subject);
+        if (prev === void 0 || trust < prev) {
+          labels.set(q.subject, stripLiteral(q.object));
+          labelScore.set(q.subject, trust);
+        }
+      }
+    }
+    const merged = /* @__PURE__ */ new Map();
+    for (const c of candidates) {
+      const rep = canonical.get(c.iri) ?? c.iri;
+      const existing = merged.get(rep);
+      if (existing) {
+        existing.score = Math.max(existing.score, c.score);
+        if (c.label && !existing.label) existing.label = c.label;
+        if (!existing.sameAsGroup.includes(c.iri)) existing.sameAsGroup.push(c.iri);
+      } else {
+        merged.set(rep, {
+          iri: rep,
+          label: c.label ?? labels.get(rep),
+          score: c.score,
+          sameAsGroup: [c.iri, ...rep !== c.iri ? [rep] : []]
+        });
+      }
+    }
+    for (const group of merged.values()) {
+      group.label ??= labels.get(group.iri);
+      if (group.sameAsGroup.length < 2) {
+        const members = [...canonical.keys()].filter((m) => canonical.get(m) === canonical.get(group.iri));
+        if (members.length > 1) group.sameAsGroup = members;
+      }
+    }
+    return [...merged.values()].sort((a, b) => b.score - a.score).slice(0, k);
+  }
+};
+function stripLiteral(term) {
+  const m = term.match(/^"(.*)"(\^\^<?[\w:/#.-]+>?|@[\w-]+)?$/);
+  return m ? m[1] : term;
+}
+function localName(iri) {
+  const tail = iri.split(/[#/:]/).pop() ?? "";
+  return tail.toLowerCase();
+}
+function linkEntityTool(linker) {
+  return defineTool({
+    name: "link_entity",
+    description: "Link a text mention to known graph entities (labels + sameAs canonicalized). Returns canonical IRIs with scores \u2014 never invent IRIs.",
+    schema: z10.object({ mention: z10.string().min(1).max(200), k: z10.number().int().min(1).max(10).default(5) }),
+    execute: async ({ mention, k }) => linker.link(mention, k)
+  });
+}
+var MappingProposals = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  opts;
+  seq = 0;
+  items = /* @__PURE__ */ new Map();
+  /** True when proposals commit themselves (autonomy on AND a store bound). */
+  get autonomy() {
+    return this.opts.autonomy !== false && !!this.opts.store;
+  }
+  async commit(proposal, store) {
+    await store.add([
+      {
+        subject: proposal.to,
+        predicate: "skos:altLabel",
+        object: `"${proposal.from}"`,
+        source: proposal.source,
+        derivedFrom: `mapping:${proposal.id}`
+      }
+    ]);
+  }
+  /**
+   * Record an LLM-proposed mapping. With autonomy (default) + a bound store
+   * it commits right away, provenance required; with `autonomy: false` (or
+   * no store bound) it queues as pending until decide().
+   */
+  async propose(from, to, source) {
+    const existing = [...this.items.values()].find(
+      (p) => p.from === from && p.to === to && (p.status === "pending" || this.autonomy && p.status === "approved")
+    );
+    if (existing) return existing;
+    const proposal = {
+      id: `map-${++this.seq}`,
+      from,
+      to,
+      source,
+      status: "pending",
+      proposedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (this.autonomy && this.opts.store) {
+      await this.commit(proposal, this.opts.store);
+      proposal.status = "approved";
+      proposal.committedByAutonomy = true;
+    }
+    this.items.set(proposal.id, proposal);
+    return proposal;
+  }
+  list(status) {
+    return [...this.items.values()].filter((p) => !status || p.status === status);
+  }
+  /** Human decision. `approved` also commits the alias into the graph. */
+  async decide(store, id, decision) {
+    const proposal = this.items.get(id);
+    if (!proposal || proposal.status !== "pending") return void 0;
+    proposal.status = decision;
+    if (decision === "approved") {
+      await this.commit(proposal, store);
+    }
+    return proposal;
+  }
+};
+function proposeMappingTool(proposals) {
+  return defineTool({
+    name: "propose_mapping",
+    description: "Map a raw term to a canonical ontology IRI. Autonomy mode commits the alias immediately (provenance required); review mode queues it for human approval.",
+    schema: z10.object({
+      from: z10.string().min(1).max(200),
+      to: z10.string().min(1).max(500),
+      source: z10.string().min(1).describe("Provenance URI for the committed alias")
+    }),
+    execute: async ({ from, to, source }) => {
+      let p;
+      try {
+        p = await proposals.propose(from, to, source);
+      } catch (err) {
+        return `Commit rejected \u2014 fix and retry: ${err instanceof Error ? err.message : String(err)}`;
+      }
+      return p.committedByAutonomy ? { id: p.id, status: "approved", committed: true } : { id: p.id, status: "pending", note: "Review mode: awaits a human decide() before writing." };
+    }
+  });
+}
+function resolveIri(term, prefixes) {
+  const m = term.match(/^([a-zA-Z][\w-]*):(.+)$/);
+  const base = m ? prefixes[m[1]] : void 0;
+  if (m && base) return `${base}${m[2]}`;
+  if (/^https?:\/\//.test(term)) return term;
+  return void 0;
+}
+function compactIri(iri, prefixes) {
+  for (const [prefix, base] of Object.entries(prefixes)) {
+    if (iri.startsWith(base)) return `${prefix}:${iri.slice(base.length)}`;
+  }
+  return iri;
+}
+function termToJsonLd(term, prefixes) {
+  const iri = resolveIri(term, prefixes);
+  if (iri) return { "@id": iri };
+  const lang = term.match(/^"(.*)"@([\w-]+)$/);
+  if (lang) return { "@value": lang[1], "@language": lang[2] };
+  const typed = term.match(/^"(.*)"\^\^<?([\w:/#.-]+)>?$/);
+  if (typed) {
+    const type = resolveIri(typed[2], prefixes) ?? typed[2];
+    return { "@value": typed[1], "@type": type };
+  }
+  const plain = term.match(/^"(.*)"$/);
+  if (plain) return { "@value": plain[1] };
+  if (/^-?\d+(\.\d+)?$/.test(term) || /^(true|false)$/.test(term)) return { "@value": term };
+  return { "@value": term };
+}
+function jsonLdToTerm(value, prefixes) {
+  if (value === null || typeof value !== "object") {
+    const native = String(value);
+    return /^-?\d+(\.\d+)?$/.test(native) || native === "true" || native === "false" ? native : `"${native}"`;
+  }
+  if (value["@id"]) return compactIri(value["@id"], prefixes);
+  if (value["@value"] !== void 0) {
+    if (value["@language"]) return `"${value["@value"]}"@${value["@language"]}`;
+    if (value["@type"]) {
+      const type = compactIri(value["@type"], prefixes);
+      return `"${value["@value"]}"^^${type}`;
+    }
+    return `"${value["@value"]}"`;
+  }
+  return void 0;
+}
+function quadsToJsonLd(quads, prefixes = JSONLD_PREFIXES) {
+  const byGraph = /* @__PURE__ */ new Map();
+  for (const q of quads) {
+    const g = q.graph ?? "";
+    byGraph.set(g, [...byGraph.get(g) ?? [], q]);
+  }
+  const buildNodes = (group) => {
+    const nodes = /* @__PURE__ */ new Map();
+    const nodeOf = (id) => {
+      let n = nodes.get(id);
+      if (!n) {
+        n = { "@id": resolveIri(id, prefixes) ?? id };
+        nodes.set(id, n);
+      }
+      return n;
+    };
+    for (const q of group) {
+      const node = nodeOf(q.subject);
+      if (q.predicate === "rdf:type" || q.predicate === "a") {
+        const existing2 = node["@type"];
+        const typeIri = resolveIri(q.object, prefixes) ?? q.object;
+        node["@type"] = Array.isArray(existing2) ? [...existing2, typeIri].filter((t, i, a) => a.indexOf(t) === i) : existing2 ? [existing2, typeIri] : typeIri;
+        continue;
+      }
+      const key = resolveIri(q.predicate, prefixes) ?? q.predicate;
+      const value = termToJsonLd(q.object, prefixes);
+      const existing = node[key];
+      node[key] = Array.isArray(existing) ? [...existing, value] : existing ? [existing, value] : value;
+    }
+    return [...nodes.values()];
+  };
+  const graphEntries = [];
+  for (const [g, group] of byGraph) {
+    const nodes = buildNodes(group);
+    if (g === "") graphEntries.push(...nodes);
+    else graphEntries.push({ "@id": resolveIri(g, prefixes) ?? g, "@graph": nodes });
+  }
+  return { "@context": prefixes, "@graph": graphEntries };
+}
+function jsonldToQuads(doc, prefixes = JSONLD_PREFIXES) {
+  const out = [];
+  let blank = 0;
+  const convertNode = (node, graphName) => {
+    const subjectId = (node["@id"] ? String(node["@id"]) : "") ? compactIri(String(node["@id"]), prefixes) : `_:b${blank++}`;
+    const types = node["@type"];
+    for (const t of Array.isArray(types) ? types : types ? [types] : []) {
+      out.push({ subject: subjectId, predicate: "rdf:type", object: compactIri(String(t), prefixes), ...graphName ? { graph: graphName } : {} });
+    }
+    for (const [key, raw] of Object.entries(node)) {
+      if (key === "@id" || key === "@type") continue;
+      const predicate = compactIri(key.includes(":") ? resolveIri(key, prefixes) ?? key : key, prefixes);
+      for (const v of Array.isArray(raw) ? raw : [raw]) {
+        const object = jsonLdToTerm(v, prefixes);
+        if (object !== void 0) out.push({ subject: subjectId, predicate, object, ...graphName ? { graph: graphName } : {} });
+      }
+    }
+  };
+  for (const entry of doc["@graph"] ?? []) {
+    if (entry && typeof entry === "object" && Array.isArray(entry["@graph"])) {
+      const named = entry;
+      const graphName = named["@id"] ? compactIri(named["@id"], prefixes) : `_:g${out.length}`;
+      for (const node of named["@graph"]) convertNode(node, graphName);
+      continue;
+    }
+    convertNode(entry, void 0);
+  }
+  return out;
+}
+
+// src/semantic/ontology-evolution.ts
+async function runConformance(store, battery) {
+  const results = [];
+  const runner = async (check, closure2) => {
+    if (check.ask) {
+      const rows = await executeSelect(store, check.ask);
+      const min = check.minRows ?? 1;
+      const ok = rows.length >= min && (check.maxRows == null || rows.length <= check.maxRows);
+      results.push({
+        id: check.id,
+        passed: ok,
+        detail: `${rows.length} rows (expected >= ${min}${check.maxRows == null ? "" : `, <= ${check.maxRows}`})`
+      });
+      return;
+    }
+    if (check.shape) {
+      const scratch = new InMemoryGraphStore({ shapes: [check.shape] });
+      const mine = scratch.checkShapes(closure2).violations;
+      results.push({
+        id: check.id,
+        passed: mine.length === 0,
+        detail: mine.length ? mine.map((v) => v.message).join("; ") : "shape holds"
+      });
+      return;
+    }
+    results.push({
+      id: check.id,
+      passed: false,
+      detail: `check has neither ask nor shape${check.reason ? ` (${check.reason})` : ""}`
+    });
+  };
+  const closure = await store.match(null, null, null);
+  for (const check of battery) {
+    try {
+      await runner(check, closure);
+    } catch (err) {
+      results.push({ id: check.id, passed: false, detail: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { passed: results.every((r) => r.passed), results };
+}
+function termKey(q) {
+  return `${q.subject}|${q.predicate}|${q.object}`;
+}
+var TBOX_PREDICATES = /* @__PURE__ */ new Set([
+  "rdfs:subClassOf",
+  "http://www.w3.org/2000/01/rdf-schema#subClassOf",
+  "rdfs:subPropertyOf",
+  "http://www.w3.org/2000/01/rdf-schema#subPropertyOf",
+  "rdfs:domain",
+  "http://www.w3.org/2000/01/rdf-schema#domain",
+  "rdfs:range",
+  "http://www.w3.org/2000/01/rdf-schema#range",
+  "owl:inverseOf",
+  "http://www.w3.org/2002/07/owl#inverseOf"
+]);
+var OWL_VOCAB = /* @__PURE__ */ new Set([
+  "owl:TransitiveProperty",
+  "http://www.w3.org/2002/07/owl#TransitiveProperty",
+  "owl:SymmetricProperty",
+  "http://www.w3.org/2002/07/owl#SymmetricProperty",
+  "owl:FunctionalProperty",
+  "http://www.w3.org/2002/07/owl#FunctionalProperty",
+  "owl:Class",
+  "http://www.w3.org/2002/07/owl#Class",
+  "rdfs:Class",
+  "http://www.w3.org/2000/01/rdf-schema#Class",
+  "rdfs:Datatype",
+  "http://www.w3.org/2000/01/rdf-schema#Datatype"
+]);
+async function migrateTBox(oldStore, spec, opts = {}) {
+  const report = {
+    from: spec.from,
+    to: spec.to,
+    status: "migrated",
+    addedQuads: 0,
+    removedQuads: 0,
+    rewrittenQuads: 0,
+    deprecatedWarnings: [],
+    errors: []
+  };
+  if (opts.battery?.length) {
+    report.preBattery = await runConformance(oldStore, opts.battery);
+    if (!report.preBattery.passed) {
+      report.status = "aborted";
+      report.errors.push("pre-migration conformance battery failed \u2014 ontology not migrated");
+      return { report };
+    }
+  }
+  const removeKeys = new Set((spec.removed ?? []).map(termKey));
+  const renameMap = /* @__PURE__ */ new Map();
+  for (const r of spec.renames ?? []) renameMap.set(r.from, r.to);
+  for (const d of spec.deprecations ?? []) {
+    if (d.replacement) {
+      renameMap.set(d.term, d.replacement);
+      report.deprecatedWarnings.push(`${d.term} deprecated (${d.reason}) \u2014 rewritten to ${d.replacement}`);
+    } else {
+      report.deprecatedWarnings.push(`${d.term} deprecated (${d.reason}) \u2014 uses kept, flagged`);
+    }
+  }
+  const rewriteTerm = (term) => renameMap.get(term) ?? term;
+  const factory = opts.factory ?? ((o) => new InMemoryGraphStore(o));
+  const newStore = factory({
+    shapes: spec.shapes ?? oldStore.ontologyShapes(),
+    rules: spec.rules ?? oldStore.ontologyRules()
+  });
+  const explicit = (await oldStore.match(null, null, null)).filter((q) => q.source !== "entailment");
+  const tboxGraph = opts.tboxGraph === false ? void 0 : opts.tboxGraph ?? `urn:fabisch:ontology:${spec.to}`;
+  report.tboxGraph = tboxGraph;
+  const isAxiom = (q, predicatesInUse2) => {
+    if (TBOX_PREDICATES.has(q.predicate)) return true;
+    if (q.predicate === "rdf:type" || q.predicate === "a" || q.predicate === "http://www.w3.org/1999/02/22-rdf-syntax-ns#type") {
+      return predicatesInUse2.has(q.subject) || OWL_VOCAB.has(q.object);
+    }
+    return false;
+  };
+  const predicatesInUse = new Set(explicit.filter((q) => !removeKeys.has(termKey(q))).map((q) => rewriteTerm(q.predicate)));
+  const rewrittenSpecAdded = (spec.added ?? []).map(
+    (aq) => tboxGraph ? { ...aq, graph: tboxGraph, derivedFrom: `migration:${spec.from}->${spec.to}` } : { ...aq, derivedFrom: `migration:${spec.from}->${spec.to}` }
+  );
+  const rebuilt = [];
+  for (const q of explicit) {
+    if (removeKeys.has(termKey(q))) {
+      report.removedQuads += 1;
+      continue;
+    }
+    const next = {
+      subject: rewriteTerm(q.subject),
+      predicate: rewriteTerm(q.predicate),
+      object: rewriteTerm(q.object),
+      source: q.source,
+      ...q.graph ? { graph: q.graph } : {},
+      ...q.derivedFrom ? { derivedFrom: q.derivedFrom } : {}
+    };
+    if (isAxiom(next, predicatesInUse) && tboxGraph) next.graph = tboxGraph;
+    if (termKey(next) !== termKey(q)) {
+      report.rewrittenQuads += 1;
+      next.derivedFrom = `${next.derivedFrom ? `${next.derivedFrom};` : ""}migration:${spec.from}->${spec.to}`;
+    }
+    rebuilt.push(next);
+  }
+  for (const aq of rewrittenSpecAdded) rebuilt.push(aq);
+  report.addedQuads = (spec.added ?? []).length;
+  try {
+    await newStore.add(rebuilt);
+  } catch (err) {
+    report.status = "failed";
+    report.errors.push(`v4 store rejected migrated facts: ${err instanceof Error ? err.message : String(err)}`);
+    return { report };
+  }
+  if (opts.battery?.length) {
+    report.postBattery = await runConformance(newStore, opts.battery);
+    if (!report.postBattery.passed) {
+      report.status = "failed";
+      const failed = report.postBattery.results.filter((r) => !r.passed).map((r) => `${r.id}: ${r.detail}`);
+      report.errors.push(`post-migration conformance battery failed \u2014 ${failed.join("; ")}`);
+      return { report };
+    }
+  }
+  return { report, store: newStore };
+}
+
+// src/semantic/ontology-review.ts
+import { z as z11 } from "zod";
+var RDF_TYPE = /* @__PURE__ */ new Set(["rdf:type", "a", "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"]);
+var isAxiomQuad = (q, predicatesInUse) => TBOX_PREDICATES.has(q.predicate) || RDF_TYPE.has(q.predicate) && (predicatesInUse.has(q.subject) || OWL_VOCAB.has(q.object));
+function strip(term) {
+  const m = term.match(/^"(.*)"(\^\^<?[\w:/#.-]+>?|@[\w-]+)?$/);
+  return m ? m[1] : term;
+}
+async function reviewOntology(store) {
+  const closure = await store.match(null, null, null);
+  const explicit = closure.filter((q) => q.source !== "entailment");
+  const predicatesInUse = new Set(explicit.map((q) => q.predicate));
+  const labels = /* @__PURE__ */ new Map();
+  for (const q of closure) {
+    if (LABEL_PREDICATES.has(q.predicate)) labels.set(q.subject, strip(q.object));
+  }
+  const classes = /* @__PURE__ */ new Map();
+  const properties = /* @__PURE__ */ new Map();
+  const class_ = (term) => {
+    let s = classes.get(term);
+    if (!s) {
+      s = { term, kind: "class", uses: 0, axiomCount: 0, label: labels.get(term) };
+      classes.set(term, s);
+    }
+    return s;
+  };
+  const property = (term) => {
+    let s = properties.get(term);
+    if (!s) {
+      s = { term, kind: "property", uses: 0, axiomCount: 0, label: labels.get(term) };
+      properties.set(term, s);
+    }
+    return s;
+  };
+  const domains = /* @__PURE__ */ new Map();
+  const ranges = /* @__PURE__ */ new Map();
+  for (const q of explicit) {
+    const axiom = isAxiomQuad(q, predicatesInUse);
+    if (RDF_TYPE.has(q.predicate)) {
+      if (axiom) class_(q.subject).axiomCount += 1;
+      else class_(q.object).uses += 1;
+      continue;
+    }
+    if (TBOX_PREDICATES.has(q.predicate)) {
+      const subject = q.predicate.includes("subClassOf") ? class_(q.subject) : property(q.subject);
+      subject.axiomCount += 1;
+      if (!q.predicate.includes("inverseOf")) class_(q.object).axiomCount += 1;
+      if (q.predicate.includes("domain")) domains.set(q.subject, (domains.get(q.subject) ?? 0) + 1);
+      if (q.predicate.includes("range")) ranges.set(q.subject, (ranges.get(q.subject) ?? 0) + 1);
+      continue;
+    }
+    property(q.predicate).uses += 1;
+  }
+  const all = [...classes.values(), ...properties.values()];
+  const undeclared = all.filter((t) => t.uses > 0 && t.axiomCount === 0);
+  const unused = all.filter((t) => t.axiomCount > 0 && t.uses === 0).map((t) => t.term);
+  const unlabeled = all.filter((t) => !t.label).map((t) => t.term);
+  const missingDomain = [...properties.values()].filter((t) => t.axiomCount > 0 || t.uses > 0).filter((t) => !domains.has(t.term)).map((t) => t.term);
+  const missingRange = [...properties.values()].filter((t) => t.axiomCount > 0 || t.uses > 0).filter((t) => !ranges.has(t.term)).map((t) => t.term);
+  return {
+    classes: [...classes.values()].sort((a, b) => b.uses - a.uses || a.term.localeCompare(b.term)),
+    properties: [...properties.values()].sort((a, b) => b.uses - a.uses || a.term.localeCompare(b.term)),
+    undeclared: undeclared.sort((a, b) => b.uses - a.uses),
+    unused,
+    unlabeled,
+    missingDomain,
+    missingRange,
+    explicitQuads: explicit.length,
+    closureQuads: closure.length
+  };
+}
+async function proposeShapes(store, opts = {}) {
+  const minInstances = opts.minInstances ?? 2;
+  const coverage = opts.coverage ?? 0.5;
+  const explicit = (await store.match(null, null, null)).filter((q) => q.source !== "entailment");
+  const predicatesInUse = new Set(explicit.map((q) => q.predicate));
+  const instancesOf = /* @__PURE__ */ new Map();
+  for (const q of explicit) {
+    if (!RDF_TYPE.has(q.predicate) || isAxiomQuad(q, predicatesInUse)) continue;
+    const set = instancesOf.get(q.object) ?? /* @__PURE__ */ new Set();
+    set.add(q.subject);
+    instancesOf.set(q.object, set);
+  }
+  const shapes = [];
+  for (const [cls, subjects] of instancesOf) {
+    if (subjects.size < minInstances) continue;
+    const observed = /* @__PURE__ */ new Map();
+    const bySubject = /* @__PURE__ */ new Map();
+    for (const q of explicit) {
+      if (!subjects.has(q.subject)) continue;
+      bySubject.set(q.subject, [...bySubject.get(q.subject) ?? [], q]);
+    }
+    for (const [, quads] of bySubject) {
+      const byPath = /* @__PURE__ */ new Map();
+      for (const q of quads) {
+        if (RDF_TYPE.has(q.predicate)) continue;
+        byPath.set(q.predicate, [...byPath.get(q.predicate) ?? [], q]);
+      }
+      for (const [path, pathQuads] of byPath) {
+        const o = observed.get(path) ?? { present: 0, maxSeen: 0, datatypes: /* @__PURE__ */ new Set(), nodeKinds: /* @__PURE__ */ new Set() };
+        o.present += 1;
+        o.maxSeen = Math.max(o.maxSeen, pathQuads.length);
+        for (const q of pathQuads) {
+          o.nodeKinds.add(isLiteralTerm(q.object) ? "literal" : "iri");
+          const dt = datatypeOf(q.object);
+          if (dt) o.datatypes.add(dt);
+        }
+        observed.set(path, o);
+      }
+    }
+    const properties = [];
+    for (const [path, o] of observed) {
+      if (o.present / subjects.size < coverage) continue;
+      const shape = { path };
+      if (o.present === subjects.size) shape.minCount = 1;
+      if (o.maxSeen === 1) shape.maxCount = 1;
+      if (o.datatypes.size === 1) shape.datatype = [...o.datatypes][0];
+      if (o.nodeKinds.size === 1) shape.nodeKind = [...o.nodeKinds][0];
+      properties.push(shape);
+    }
+    if (properties.length) shapes.push({ targetClass: cls, properties });
+  }
+  return shapes;
+}
+function isLiteralTerm(term) {
+  if (term.startsWith('"')) return true;
+  if (/^(-?\d+(\.\d+)?|true|false)$/.test(term)) return true;
+  if (term.startsWith("<") || /^[a-zA-Z][\w-]*:/.test(term)) return false;
+  return true;
+}
+function datatypeOf(term) {
+  const m = term.match(/\^\^<?([\w:/#.-]+)>?$/);
+  if (m) return m[1];
+  if (/^".*"@[\w-]+$/.test(term)) return "rdf:langString";
+  if (/^".*"$/.test(term)) return "xsd:string";
+  if (/^-?\d+$/.test(term)) return "xsd:integer";
+  if (/^-?\d*\.\d+$/.test(term)) return "xsd:decimal";
+  if (/^(true|false)$/.test(term)) return "xsd:boolean";
+  return void 0;
+}
+async function adoptShapes(store, shapes) {
+  const closure = await store.match(null, null, null);
+  const adopted = [];
+  const rejected = [];
+  for (const shape of shapes) {
+    const violations = new InMemoryGraphStore({ shapes: [shape] }).checkShapes(closure).violations;
+    if (violations.length) rejected.push({ shape, violations: violations.map((v) => v.message) });
+    else adopted.push(shape);
+  }
+  if (adopted.length) store.addShapes(...adopted);
+  return { adopted, rejected };
+}
+function reviewOntologyTool(store) {
+  return defineTool({
+    name: "review_ontology",
+    description: "Audit the knowledge graph's ontology: classes/properties with usage counts, used-but-undeclared terms, unlabeled/unused terms, properties missing domain or range. Read-only.",
+    schema: z11.object({}),
+    execute: async () => reviewOntology(store)
+  });
+}
+function proposeShapesTool(store, opts = {}) {
+  return defineTool({
+    name: "propose_shapes",
+    description: "Induce candidate SHACL shapes from existing instance data (>= 2 instances per class, >= 50% property coverage). PROPOSAL: adoption is the builder's call via adoptShapes(), never automatic.",
+    schema: z11.object({}),
+    execute: async () => proposeShapes(store, opts)
+  });
+}
+
+// src/semantic/index.ts
+var RDF_TYPE2 = /* @__PURE__ */ new Set(["rdf:type", "a", "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"]);
+var SUB_CLASS = /* @__PURE__ */ new Set(["rdfs:subClassOf", "http://www.w3.org/2000/01/rdf-schema#subClassOf"]);
+var SUB_PROP = /* @__PURE__ */ new Set(["rdfs:subPropertyOf", "http://www.w3.org/2000/01/rdf-schema#subPropertyOf"]);
+var DOMAIN = /* @__PURE__ */ new Set(["rdfs:domain", "http://www.w3.org/2000/01/rdf-schema#domain"]);
+var RANGE = /* @__PURE__ */ new Set(["rdfs:range", "http://www.w3.org/2000/01/rdf-schema#range"]);
+var OWL_TRANSITIVE = /* @__PURE__ */ new Set(["owl:TransitiveProperty", "http://www.w3.org/2002/07/owl#TransitiveProperty"]);
+var OWL_SYMMETRIC = /* @__PURE__ */ new Set(["owl:SymmetricProperty", "http://www.w3.org/2002/07/owl#SymmetricProperty"]);
+var OWL_FUNCTIONAL = /* @__PURE__ */ new Set(["owl:FunctionalProperty", "http://www.w3.org/2002/07/owl#FunctionalProperty"]);
+var OWL_INVERSE = /* @__PURE__ */ new Set(["owl:inverseOf", "http://www.w3.org/2002/07/owl#inverseOf"]);
+function isLiteral(term) {
+  if (term.startsWith('"')) return true;
+  if (/^(-?\d+(\.\d+)?|true|false)$/.test(term)) return true;
+  if (term.startsWith("<") || /^[a-zA-Z][\w-]*:/.test(term)) return false;
+  return true;
+}
+function termDatatype(term) {
+  const m = term.match(/\^\^<?([\w:/#.-]+)>?$/);
+  if (m) return m[1];
+  if (/^".*"@[\w-]+$/.test(term)) return "rdf:langString";
+  if (/^".*"$/.test(term)) return "xsd:string";
+  if (/^-?\d+$/.test(term)) return "xsd:integer";
+  if (/^-?\d*\.\d+$/.test(term)) return "xsd:decimal";
+  if (/^(true|false)$/.test(term)) return "xsd:boolean";
+  return void 0;
+}
+var InMemoryGraphStore = class {
+  quads = [];
+  derivations = /* @__PURE__ */ new Map();
+  shapes = [];
+  rules = [];
+  constructor(opts = {}) {
+    this.shapes = [...opts.shapes ?? []];
+    this.rules = [...opts.rules ?? []];
+  }
+  addShapes(...shapes) {
+    this.shapes.push(...shapes);
+    return this;
+  }
+  addRules(...rules) {
+    this.rules.push(...rules);
+    return this;
+  }
+  /** Registered SHACL shapes (carried to new stores by TBox migrations). */
+  ontologyShapes() {
+    return [...this.shapes];
+  }
+  /** Registered CONSTRUCT rules (versioned with the ontology they encode). */
+  ontologyRules() {
+    return [...this.rules];
+  }
+  /** Identity includes the named graph: the same s/p/o in two graphs are two quads. */
+  key(q) {
+    return `${q.subject}|${q.predicate}|${q.object}|${q.graph ?? ""}`;
+  }
+  async add(quads) {
+    const report = await this.validate(quads);
+    if (!report.valid) {
+      throw new Error(`SHACL violation: ${report.violations.map((v) => v.message).join("; ")}`);
+    }
+    const known = new Set(this.quads.map((q) => this.key(q)));
+    const addedKeys = [];
+    for (const q of quads) {
+      if (!known.has(this.key(q))) {
+        known.add(this.key(q));
+        addedKeys.push(this.key(q));
+        this.quads.push(q);
+      }
+    }
+    const rollback = () => {
+      const doomed = new Set(addedKeys);
+      this.quads = this.quads.filter((q) => !doomed.has(this.key(q)));
+      for (const k of doomed) this.derivations.delete(k);
+    };
+    const conflicts = this.checkFunctional();
+    if (conflicts.length) {
+      rollback();
+      throw new Error(`Functional property violation: ${conflicts.join("; ")}`);
+    }
+    const shapeReport = this.checkShapes(this.quads);
+    if (!shapeReport.valid) {
+      rollback();
+      throw new Error(`SHACL violation: ${shapeReport.violations.map((v) => v.message).join("; ")}`);
+    }
+    this.entailToFixpoint(known);
+  }
+  async match(s, p, o, g) {
+    return this.quads.filter(
+      (q) => (!s || q.subject === s) && (!p || q.predicate === p) && (!o || q.object === o) && (!g || q.graph === g)
+    );
+  }
+  /** Structural + provenance check. Full SHACL engine lands in P1-sem. */
+  async validate(quads) {
+    const violations = quads.filter((q) => !q.subject || !q.predicate || !q.object).map((q) => ({ message: `Incomplete triple: ${JSON.stringify(q)}` }));
+    const noSource = quads.filter((q) => !q.source).map((q) => ({ message: `Missing provenance (source) on ${q.subject} ${q.predicate} ${q.object}` }));
+    return { valid: violations.length + noSource.length === 0, violations: [...violations, ...noSource] };
+  }
+  async why(quad) {
+    return this.derivations.get(this.key(quad)) ?? null;
+  }
+  /** Functional properties must have at most one value per subject (conflict, not a second fact). */
+  checkFunctional() {
+    const functionalProps = new Set(
+      this.quads.filter((q) => RDF_TYPE2.has(q.predicate) && OWL_FUNCTIONAL.has(q.object)).map((q) => q.subject)
+    );
+    const conflicts = [];
+    for (const prop of functionalProps) {
+      const bySubject = /* @__PURE__ */ new Map();
+      for (const q of this.quads) {
+        if (q.predicate !== prop) continue;
+        const values = bySubject.get(q.subject) ?? /* @__PURE__ */ new Set();
+        values.add(q.object);
+        bySubject.set(q.subject, values);
+      }
+      for (const [subject, values] of bySubject) {
+        if (values.size > 1) conflicts.push(`${subject} has ${values.size} values for functional ${prop}`);
+      }
+    }
+    return conflicts;
+  }
+  /** SHACL-subset validation over a quad set. */
+  checkShapes(quads) {
+    const violations = [];
+    for (const shape of this.shapes) {
+      const targets = quads.filter((q) => RDF_TYPE2.has(q.predicate) && q.object === shape.targetClass).map((q) => q.subject);
+      for (const node of new Set(targets)) {
+        for (const prop of shape.properties) {
+          const values = quads.filter((q) => q.subject === node && q.predicate === prop.path).map((q) => q.object);
+          if (prop.minCount != null && values.length < prop.minCount) {
+            violations.push({ message: `${node} needs >= ${prop.minCount} ${prop.path}`, node, path: prop.path });
+          }
+          if (prop.maxCount != null && values.length > prop.maxCount) {
+            violations.push({ message: `${node} allows <= ${prop.maxCount} ${prop.path}`, node, path: prop.path });
+          }
+          for (const v of values) {
+            if (prop.datatype && termDatatype(v) !== prop.datatype && !(prop.datatype === "xsd:string" && isLiteral(v))) {
+              violations.push({ message: `${node} ${prop.path}=${v} is not ${prop.datatype}`, node, path: prop.path });
+            }
+            if (prop.nodeKind === "iri" && isLiteral(v)) {
+              violations.push({ message: `${node} ${prop.path}=${v} must be an IRI`, node, path: prop.path });
+            }
+            if (prop.nodeKind === "literal" && !isLiteral(v)) {
+              violations.push({ message: `${node} ${prop.path}=${v} must be a literal`, node, path: prop.path });
+            }
+            if (prop.hasValue !== void 0 && v !== prop.hasValue) {
+              violations.push({ message: `${node} ${prop.path} must be ${prop.hasValue}`, node, path: prop.path });
+            }
+          }
+        }
+      }
+    }
+    return { valid: violations.length === 0, violations };
+  }
+  insert(q, premises, rule, known) {
+    const k = this.key(q);
+    if (known.has(k)) return false;
+    known.add(k);
+    this.quads.push(q);
+    this.derivations.set(k, { premises, rule });
+    return true;
+  }
+  /**
+   * RDFS subset + OWL property axioms + versioned rules, to fixpoint:
+   * - RDFS-SUB-TRANS / RDFS-TYPE / RDFS-SUBPROP-TRANS / RDFS-SUBPROP / RDFS-DOMAIN / RDFS-RANGE
+   * - OWL-TRANSITIVE / OWL-SYMMETRIC / OWL-INVERSE (inverseOf both directions)
+   * - <ruleId>@<version> for each applied GraphRule (premises tracked for why())
+   */
+  entailToFixpoint(known) {
+    for (; ; ) {
+      let added = false;
+      const snapshot = [...this.quads];
+      const byPred = (ps) => snapshot.filter((q) => ps.has(q.predicate));
+      const insert = (q, premises, rule) => {
+        const addedOne = this.insert(q, premises, rule, known);
+        added = addedOne || added;
+        return addedOne;
+      };
+      for (const ab of byPred(SUB_CLASS)) {
+        for (const bc of byPred(SUB_CLASS).filter((q) => q.subject === ab.object)) {
+          added = this.insert(
+            { subject: ab.subject, predicate: ab.predicate, object: bc.object, source: "entailment", rule: "RDFS-SUB-TRANS" },
+            [ab, bc],
+            "RDFS-SUB-TRANS",
+            known
+          ) || added;
+        }
+      }
+      for (const t of byPred(RDF_TYPE2)) {
+        for (const sc of byPred(SUB_CLASS).filter((q) => q.subject === t.object)) {
+          added = this.insert(
+            { subject: t.subject, predicate: t.predicate, object: sc.object, source: "entailment", rule: "RDFS-TYPE" },
+            [t, sc],
+            "RDFS-TYPE",
+            known
+          ) || added;
+        }
+      }
+      for (const ab of byPred(SUB_PROP)) {
+        for (const bc of byPred(SUB_PROP).filter((q) => q.subject === ab.object)) {
+          added = this.insert(
+            { subject: ab.subject, predicate: ab.predicate, object: bc.object, source: "entailment", rule: "RDFS-SUBPROP-TRANS" },
+            [ab, bc],
+            "RDFS-SUBPROP-TRANS",
+            known
+          ) || added;
+        }
+        for (const use of snapshot.filter((q) => q.predicate === ab.subject)) {
+          added = this.insert(
+            { subject: use.subject, predicate: ab.object, object: use.object, source: "entailment", rule: "RDFS-SUBPROP" },
+            [ab, use],
+            "RDFS-SUBPROP",
+            known
+          ) || added;
+        }
+      }
+      for (const d of byPred(DOMAIN)) {
+        for (const use of snapshot.filter((q) => q.predicate === d.subject)) {
+          added = this.insert(
+            { subject: use.subject, predicate: "rdf:type", object: d.object, source: "entailment", rule: "RDFS-DOMAIN" },
+            [d, use],
+            "RDFS-DOMAIN",
+            known
+          ) || added;
+        }
+      }
+      for (const r of byPred(RANGE)) {
+        for (const use of snapshot.filter((q) => q.predicate === r.subject)) {
+          if (insert(
+            { subject: use.object, predicate: "rdf:type", object: r.object, source: "entailment", rule: "RDFS-RANGE" },
+            [r, use],
+            "RDFS-RANGE"
+          )) added = true;
+        }
+      }
+      added = this.applyOwl(snapshot, insert) || added;
+      added = this.applyRules(snapshot, insert) || added;
+      if (!added) return;
+    }
+  }
+  applyOwl(snapshot, insert) {
+    let added = false;
+    const transitive = new Set(
+      snapshot.filter((q) => RDF_TYPE2.has(q.predicate) && OWL_TRANSITIVE.has(q.object)).map((q) => q.subject)
+    );
+    const symmetric = new Set(
+      snapshot.filter((q) => RDF_TYPE2.has(q.predicate) && OWL_SYMMETRIC.has(q.object)).map((q) => q.subject)
+    );
+    for (const p of transitive) {
+      const uses = snapshot.filter((q) => q.predicate === p);
+      for (const xy of uses) {
+        for (const yz of uses.filter((q) => q.subject === xy.object)) {
+          if (insert({ subject: xy.subject, predicate: p, object: yz.object, source: "entailment", rule: "OWL-TRANSITIVE" }, [xy, yz], "OWL-TRANSITIVE")) added = true;
+        }
+      }
+    }
+    for (const p of symmetric) {
+      for (const xy of snapshot.filter((q) => q.predicate === p)) {
+        if (insert({ subject: xy.object, predicate: p, object: xy.subject, source: "entailment", rule: "OWL-SYMMETRIC" }, [xy], "OWL-SYMMETRIC")) added = true;
+      }
+    }
+    for (const inv of snapshot.filter((q) => OWL_INVERSE.has(q.predicate))) {
+      for (const use of snapshot.filter((q) => q.predicate === inv.subject || q.predicate === inv.object)) {
+        const flipped = use.predicate === inv.subject ? inv.object : inv.subject;
+        if (insert({ subject: use.object, predicate: flipped, object: use.subject, source: "entailment", rule: "OWL-INVERSE" }, [inv, use], "OWL-INVERSE")) added = true;
+      }
+    }
+    return added;
+  }
+  applyRules(snapshot, insert) {
+    let added = false;
+    for (const rule of this.rules) {
+      const tag = rule.version ? `${rule.id}@${rule.version}` : rule.id;
+      for (const binding of matchPatterns(rule.where, snapshot)) {
+        for (const pattern of rule.construct) {
+          const built = {
+            subject: instantiate(pattern.subject, binding.vars),
+            predicate: instantiate(pattern.predicate, binding.vars),
+            object: instantiate(pattern.object, binding.vars)
+          };
+          if (built.subject == null || built.predicate == null || built.object == null) continue;
+          if (insert(
+            { subject: built.subject, predicate: built.predicate, object: built.object, source: "entailment", rule: tag, derivedFrom: tag },
+            binding.quads,
+            tag
+          )) added = true;
+        }
+      }
+    }
+    return added;
+  }
+};
+function isVar(term) {
+  return term.startsWith("?");
+}
+function matchTerm(pattern, value, vars) {
+  if (isVar(pattern)) {
+    const bound = vars.get(pattern);
+    if (bound === void 0) {
+      const next = new Map(vars);
+      next.set(pattern, value);
+      return next;
+    }
+    return bound === value ? vars : void 0;
+  }
+  return pattern === value ? vars : void 0;
+}
+function matchOne(pattern, quad, vars) {
+  let v = matchTerm(pattern.subject, quad.subject, vars);
+  if (!v) return void 0;
+  v = matchTerm(pattern.predicate, quad.predicate, v);
+  if (!v) return void 0;
+  return matchTerm(pattern.object, quad.object, v);
+}
+function matchPatterns(patterns, quads) {
+  let bindings = [{ vars: /* @__PURE__ */ new Map(), quads: [] }];
+  for (const pattern of patterns) {
+    const next = [];
+    for (const b of bindings) {
+      for (const q of quads) {
+        const vars = matchOne(pattern, q, b.vars);
+        if (vars) next.push({ vars, quads: [...b.quads, q] });
+      }
+    }
+    bindings = next;
+    if (!bindings.length) break;
+  }
+  return bindings;
+}
+function instantiate(term, vars) {
+  return isVar(term) ? vars.get(term) ?? term : term;
+}
+function tokenizeSparql(input) {
+  const tokens = [];
+  const re = /"[^"]*"(?:\^\^<?[\w:/#.-]+>?|@[\w-]+)?|<[^>]*>|[{}().;]|\S+/g;
+  let m;
+  while ((m = re.exec(input)) !== null) tokens.push(m[0]);
+  return tokens;
+}
+function parseSelect(query) {
+  const tokens = tokenizeSparql(query);
+  let i = 0;
+  const expect = (want) => {
+    if (tokens[i]?.toUpperCase() !== want) throw new Error(`SPARQL: expected ${want}, got ${tokens[i] ?? "end"}`);
+    i += 1;
+  };
+  expect("SELECT");
+  const variables = [];
+  while (i < tokens.length && tokens[i].startsWith("?")) {
+    variables.push(tokens[i]);
+    i += 1;
+  }
+  if (!variables.length) throw new Error("SPARQL: SELECT needs at least one variable");
+  expect("WHERE");
+  expect("{");
+  const patterns = [];
+  while (i < tokens.length && tokens[i] !== "}") {
+    const s = tokens[i++];
+    const p = tokens[i++];
+    const o = tokens[i++];
+    if (s == null || p == null || o == null || s === "." || p === "." || o === ".") {
+      throw new Error("SPARQL: malformed triple pattern");
+    }
+    patterns.push({ subject: s, predicate: p, object: o });
+    if (tokens[i] === ".") i += 1;
+  }
+  expect("}");
+  return { variables, patterns };
+}
+async function executeSelect(store, query) {
+  const { variables, patterns } = parseSelect(query);
+  const quads = await store.match(null, null, null);
+  return matchPatterns(patterns, quads).map((b) => {
+    const row = {};
+    for (const v of variables) row[v] = b.vars.get(v) ?? "";
+    return row;
+  });
+}
+function sparqlSelectTool(store) {
+  return defineTool({
+    name: "sparql_select",
+    description: "Query the knowledge graph. Subset: SELECT ?vars WHERE { s p o . ... } over the inferred closure.",
+    schema: z12.object({ query: z12.string().min(1).max(4e3) }),
+    execute: async ({ query }) => executeSelect(store, query)
+  });
+}
+function ontologyLookupTool(store) {
+  return defineTool({
+    name: "ontology_lookup",
+    description: "Look up ontology terms (classes, properties, labels) instead of inventing predicates.",
+    schema: z12.object({ term: z12.string().min(1).max(200), limit: z12.number().int().min(1).max(20).default(8) }),
+    execute: async ({ term, limit }) => {
+      const needle = term.toLowerCase();
+      const quads = await store.match(null, null, null);
+      return quads.filter((q) => `${q.subject} ${q.predicate} ${q.object}`.toLowerCase().includes(needle)).slice(0, limit ?? 8).map((q) => ({ subject: q.subject, predicate: q.predicate, object: q.object }));
+    }
+  });
+}
+var TurtleQuadSchema = z12.object({
+  subject: z12.string().min(1),
+  predicate: z12.string().min(1),
+  object: z12.string().min(1),
+  source: z12.string().min(1).describe("Provenance URI (required \u2014 writes without it are rejected)")
+});
+function graphAddTool(store) {
+  return defineTool({
+    name: "graph_add",
+    description: "Write facts to the knowledge graph. Validated (SHACL/provenance/functional); violations return repair feedback.",
+    schema: z12.object({ quads: z12.array(TurtleQuadSchema).min(1).max(50) }),
+    execute: async ({ quads }) => {
+      try {
+        await store.add(quads);
+        const inferred = (await store.match(null, null, null)).filter((q) => q.source === "entailment");
+        return { committed: quads.length, inferred: inferred.length };
+      } catch (err) {
+        return `Validation failed \u2014 fix and retry: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    },
+    toResult: (output) => ({
+      content: typeof output === "string" ? output : JSON.stringify(output),
+      artifact: typeof output === "string" ? void 0 : { committed: output.committed }
+    })
+  });
+}
+function claimCheckTool(store) {
+  return defineTool({
+    name: "claim_check",
+    description: "Verify a fact against the graph before asserting it. Returns grounded | unknown | contradicted with proof.",
+    schema: z12.object({ subject: z12.string().min(1), predicate: z12.string().min(1), object: z12.string().min(1) }),
+    execute: async ({ subject, predicate, object }) => {
+      const direct = await store.match(subject, predicate, object);
+      if (direct.length) {
+        return { verdict: "grounded", proof: await store.why(direct[0]) };
+      }
+      const siblings = await store.match(subject, predicate, null);
+      const declarations = await store.match(predicate, null, null);
+      const functional = declarations.some((q) => RDF_TYPE2.has(q.predicate) && OWL_FUNCTIONAL.has(q.object));
+      const clash = siblings.filter((q) => q.object !== object);
+      if (functional && clash.length) {
+        return {
+          verdict: "contradicted",
+          proof: { existing: clash.map((q) => q.object) }
+        };
+      }
+      return {
+        verdict: "unknown",
+        proof: siblings.length ? { related: siblings.map((q) => q.object) } : null
+      };
+    }
+  });
+}
+var GraphMemory = class {
+  constructor(store, inner, opts = {}) {
+    this.store = store;
+    this.inner = inner;
+    this.opts = opts;
+  }
+  store;
+  inner;
+  opts;
+  async load() {
+    const messages = await this.inner.load();
+    const lastUser = [...messages].reverse().find((m) => m.role === "user");
+    if (!lastUser) return messages;
+    const terms = new Set(tokenize(typeof lastUser.content === "string" ? lastUser.content : ""));
+    if (!terms.size) return messages;
+    const quads = await this.store.match(null, null, null);
+    const scored = quads.map((q) => {
+      const hay = `${q.subject} ${q.predicate} ${q.object}`.toLowerCase();
+      let score = 0;
+      for (const t of terms) if (hay.includes(t)) score += 1;
+      return { q, score };
+    }).filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, this.opts.facts ?? 8);
+    if (!scored.length) return messages;
+    const lines = scored.map((s) => `- ${s.q.subject} ${s.q.predicate} ${s.q.object}`);
+    return [...messages, { role: "assistant", content: `Relevant known facts (ground answers in these):
+${lines.join("\n")}` }];
+  }
+  async save(messages) {
+    await this.inner.save(messages);
+  }
+  async clear() {
+    await this.inner.clear();
+  }
+  /** Serialize the closure for snapshots / long-term persistence. */
+  async exportState() {
+    return { quads: await this.store.match(null, null, null) };
+  }
+  /** Restore a previously exported closure (facts become explicit again). */
+  async importState(state) {
+    const fresh = state.quads.filter((q) => q.source !== "entailment");
+    if (fresh.length) await this.store.add(fresh);
+  }
+};
+export {
+  A2AClient,
+  A2AServer,
+  Agent,
+  AgentClient,
+  AgentError,
+  AgentState,
+  AnthropicProvider,
+  AudioBlockSchema,
+  ChatMessageSchema,
+  ClearToolUsesEdit,
+  CompactedMemory,
+  ConsoleSpanSink,
+  ContentBlockSchema,
+  EntityLinker,
+  FileBlockSchema,
+  FileCheckpointer,
+  FileMemory,
+  FrameworkFileSchema,
+  GraphMemory,
+  HitlInterrupt,
+  ImageBlockSchema,
+  InMemoryGraphStore,
+  InMemoryMemory,
+  InMemoryRetriever,
+  InMemoryStorage,
+  JSONLD_PREFIXES,
+  JsonlSpanSink,
+  LABEL_PREDICATES,
+  LocalFileStorage,
+  MappingProposals,
+  McpHttpClient,
+  McpStdioClient,
+  MemorySpanSink,
+  MockModelProvider,
+  NonStandardBlockSchema,
+  NullConversationManager,
+  OWL_VOCAB,
+  OllamaProvider,
+  OpenAICompatibleProvider,
+  ReasoningBlockSchema,
+  RemoteSparqlAdapter,
+  SessionManager,
+  SkillRegistry,
+  SlidingWindowConversationManager,
+  SummarizingConversationManager,
+  Swarm,
+  TBOX_PREDICATES,
+  TextBlockSchema,
+  ToolCallBlockSchema,
+  ToolRegistry,
+  ToolRejection,
+  TurtleQuadSchema,
+  __resetConfig,
+  a2aAsTool,
+  abPrompts,
+  adoptShapes,
+  assertCanHandle,
+  assistant,
+  backoffDelayMs,
+  buildServedAgent,
+  claimCheckTool,
+  collectStream,
+  connectMcpHttp,
+  connectMcpStdio,
+  consoleEvents,
+  contextEditingMiddleware,
+  createMiddleware,
+  createSandboxBackend,
+  createSubAgentMiddleware,
+  defaultSummarize,
+  defaultToResult,
+  definePrompt,
+  defineTool,
+  deserializeMessages,
+  discoverSkills,
+  estimateCostUsd,
+  estimateTokens,
+  executeSelect,
+  filesystemMiddleware,
+  filesystemTools,
+  getRetryable,
+  graphAddTool,
+  handleAgentRoute,
+  hasImages,
+  historyTokens,
+  hitlKey,
+  humanInTheLoopMiddleware,
+  imagesOf,
+  initChatModel,
+  instantiate,
+  jsonSchemaToZod,
+  jsonldToQuads,
+  linkEntityTool,
+  llmToolSelectorMiddleware,
+  loadConfig,
+  loadEnvFile,
+  loadFrameworkConfig,
+  loadJsonl,
+  loadPromptFile,
+  loadSkillsInto,
+  logError,
+  matchGlob,
+  matchPatterns,
+  matchSkills,
+  mcpToolsToFramework,
+  messageTokens,
+  migrateTBox,
+  modelCallLimit,
+  modelFallbackMiddleware,
+  modelRetryMiddleware,
+  ollama,
+  ontologyLookupTool,
+  parseSelect,
+  parseSkillFile,
+  parseStructured,
+  piiMiddleware,
+  policyFilterMiddleware,
+  priceFor,
+  printReport,
+  proposeMappingTool,
+  proposeShapes,
+  proposeShapesTool,
+  providerFromEnv,
+  providerStrategy,
+  quadsToJsonLd,
+  readHandoffSignal,
+  remoteSparqlTool,
+  responseFormatJsonSchema,
+  responseFormatName,
+  retrievalTool,
+  reviewOntology,
+  reviewOntologyTool,
+  runConformance,
+  runEval,
+  runJavascriptTool,
+  runOrchestrated,
+  runWithBudget,
+  runWorkflow,
+  scoreSkills,
+  selectSnapshotFields,
+  serializeMessages,
+  serveFramework,
+  sleep,
+  sparqlRetriever,
+  sparqlSelectTool,
+  stampRetryable,
+  summarizationMiddleware,
+  supportsColor,
+  supportsVision,
+  system,
+  textOf,
+  todoListMiddleware,
+  tokenize,
+  toolCallLimitMiddleware,
+  toolEmulatorMiddleware,
+  toolResult,
+  toolRetry,
+  toolRetryMiddleware,
+  toolStrategy,
+  tracingEvents,
+  trimDangling,
+  usageCost,
+  user,
+  wireTextOf,
+  withFileLock
+};
+//# sourceMappingURL=index.js.map