@agentskit/cli 0.6.0 → 0.7.0

package/dist/{chunk-V7E4HWTG.js → chunk-72XFU2X2.js}

@@ -1,35 +1,37 @@
 #!/usr/bin/env node
-import { mkdir, writeFile, readFile } from 'fs/promises';
+import { readdir, stat, mkdir, writeFile, glob, readFile } from 'fs/promises';
 import { homedir } from 'os';
-import path3, { join, resolve, basename } from 'path';
+import path, { join, resolve, isAbsolute, basename } from 'path';
 import { kimi, grok, deepseek, ollama, gemini, anthropic, openai } from '@agentskit/adapters';
-import React3, { useState, useMemo, useRef, useEffect } from 'react';
+import { randomBytes, createHash } from 'crypto';
+import { writeFileSync, existsSync, readdirSync, statSync, readFileSync, mkdirSync } from 'fs';
+import { spawn } from 'child_process';
+import React2, { useMemo, useState, useEffect, useRef } from 'react';
 import { Box, Text, render } from 'ink';
 import { useChat, StatusHeader, ChatContainer, Message, ToolCallView, ToolConfirmation, ThinkingIndicator, InputBar } from '@agentskit/ink';
 import { shell, filesystem, fetchUrl, webSearch } from '@agentskit/tools';
 import { summarizer, critic, planner, coder, researcher, composeSkills } from '@agentskit/skills';
-import { fileChatMemory, sqliteChatMemory } from '@agentskit/memory';
-import { randomBytes, createHash } from 'crypto';
-import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, readFileSync } from 'fs';
+import { fileVectorMemory, fileChatMemory, sqliteChatMemory } from '@agentskit/memory';
 import { jsxs, jsx } from 'react/jsx-runtime';
+import { pathToFileURL } from 'url';
 import { createRuntime } from '@agentskit/runtime';
-import { spawn } from 'child_process';
 import chokidar from 'chokidar';
 import kleur3 from 'kleur';
+import { createRAG } from '@agentskit/rag';
 import { Command } from 'commander';
 import { input, select, checkbox, confirm } from '@inquirer/prompts';
 
-async function loadJsonConfig(path4) {
+async function loadJsonConfig(path5) {
   try {
-    const raw = await readFile(path4, "utf8");
+    const raw = await readFile(path5, "utf8");
     return JSON.parse(raw);
   } catch {
     return void 0;
   }
 }
-async function loadTsConfig(path4) {
+async function loadTsConfig(path5) {
   try {
-    const mod = await import(path4);
+    const mod = await import(path5);
     return mod.default ?? mod;
   } catch {
     return void 0;
@@ -139,7 +141,7 @@ function createDemoAdapter(provider, model) {
           ].join(" ");
           for (const chunk of reply.match(/.{1,18}/g) ?? []) {
             if (cancelled) return;
-            await new Promise((resolve2) => setTimeout(resolve2, 35));
+            await new Promise((resolve4) => setTimeout(resolve4, 35));
             yield { type: "text", content: chunk };
           }
           yield { type: "done" };
@@ -190,80 +192,6 @@ function resolveChatProvider(options) {
     summary: `${entry.label} live adapter`
   };
 }
-var skillRegistry = {
-  researcher,
-  coder,
-  planner,
-  critic,
-  summarizer
-};
-function instantiate(kind) {
-  switch (kind) {
-    case "web_search":
-      return [webSearch()];
-    case "fetch_url":
-      return [fetchUrl()];
-    case "filesystem":
-      return filesystem({ basePath: process.cwd() });
-    case "shell":
-      return [shell({ timeout: 3e4 })];
-  }
-}
-function gateTool(tool) {
-  if (tool.requiresConfirmation === false) return tool;
-  return { ...tool, requiresConfirmation: true };
-}
-function resolveTools(toolNames) {
-  if (!toolNames) {
-    return [...instantiate("web_search"), ...instantiate("fetch_url")].map(gateTool);
-  }
-  const tools = [];
-  for (const name of toolNames.split(",").map((s) => s.trim()).filter(Boolean)) {
-    switch (name) {
-      case "web_search":
-      case "fetch_url":
-      case "filesystem":
-      case "shell":
-        tools.push(...instantiate(name));
-        break;
-      default:
-        process.stderr.write(`Unknown tool: ${name}
-`);
-    }
-  }
-  return tools;
-}
-function resolveSkill(skillName) {
-  if (!skillName) return void 0;
-  const skill = skillRegistry[skillName.trim()];
-  if (!skill) {
-    process.stderr.write(`Unknown skill: ${skillName}
-`);
-    return void 0;
-  }
-  return skill;
-}
-function resolveSkills(skillNames) {
-  if (!skillNames) return void 0;
-  const names = skillNames.split(",").map((s) => s.trim());
-  const resolved = names.map((n) => skillRegistry[n]).filter(Boolean);
-  if (resolved.length === 0) {
-    process.stderr.write(`No valid skills found in: ${skillNames}
-`);
-    return void 0;
-  }
-  if (resolved.length === 1) return resolved[0];
-  return composeSkills(...resolved);
-}
-function resolveMemory(backend, memoryPath) {
-  switch (backend) {
-    case "sqlite":
-      return sqliteChatMemory({ path: memoryPath.replace(/\.json$/, ".db") });
-    case "file":
-    default:
-      return fileChatMemory(memoryPath);
-  }
-}
 var ROOT = join(homedir(), ".agentskit", "sessions");
 var META_SUFFIX = ".meta.json";
 function cwdHash(cwd = process.cwd()) {
@@ -288,10 +216,10 @@ function metaPath(id, cwd = process.cwd()) {
   return join(dirFor(cwd), `${id}${META_SUFFIX}`);
 }
 function readMeta(id, cwd = process.cwd()) {
-  const path4 = metaPath(id, cwd);
-  if (!existsSync(path4)) return null;
+  const path5 = metaPath(id, cwd);
+  if (!existsSync(path5)) return null;
   try {
-    return JSON.parse(readFileSync(path4, "utf8"));
+    return JSON.parse(readFileSync(path5, "utf8"));
   } catch {
     return null;
   }
@@ -341,11 +269,41 @@ function findLatestSession(cwd = process.cwd()) {
   return all[0] ?? null;
 }
 function findSession(id, cwd = process.cwd()) {
-  const exact = listSessions(cwd).find((s) => s.metadata.id === id);
+  const all = listSessions(cwd);
+  const exact = all.find((s) => s.metadata.id === id || s.metadata.label === id);
   if (exact) return exact;
-  const prefix = listSessions(cwd).find((s) => s.metadata.id.startsWith(id));
+  const prefix = all.find((s) => s.metadata.id.startsWith(id));
   return prefix ?? null;
 }
+function renameSession(id, label, cwd = process.cwd()) {
+  const record = findSession(id, cwd);
+  if (!record) throw new Error(`No session matching "${id}".`);
+  const next = { ...record.metadata, label, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  writeSessionMeta(next, cwd);
+  return next;
+}
+function forkSession(id, cwd = process.cwd()) {
+  const record = findSession(id, cwd);
+  if (!record) throw new Error(`No session matching "${id}".`);
+  const newId = generateSessionId();
+  const newFile = sessionFilePath(newId, cwd);
+  if (existsSync(record.file)) {
+    writeFileSync(newFile, readFileSync(record.file, "utf8"));
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  writeSessionMeta(
+    {
+      ...record.metadata,
+      id: newId,
+      createdAt: now,
+      updatedAt: now,
+      forkedFrom: record.metadata.id,
+      label: void 0
+    },
+    cwd
+  );
+  return { id: newId, file: newFile, isNew: true };
+}
 function resolveSession(input2) {
   const cwd = input2.cwd ?? process.cwd();
   if (input2.explicitPath) {
@@ -371,6 +329,182 @@ function resolveSession(input2) {
   return { id, file: sessionFilePath(id, cwd), isNew: true };
 }
 
+// src/extensibility/telemetry/pricing.ts
+var builtinPricing = {
+  "gpt-4o": { inputPerM: 2.5, outputPerM: 10 },
+  "gpt-4o-mini": { inputPerM: 0.15, outputPerM: 0.6 },
+  "gpt-4.1": { inputPerM: 2, outputPerM: 8 },
+  "gpt-4.1-mini": { inputPerM: 0.4, outputPerM: 1.6 },
+  "claude-opus-4": { inputPerM: 15, outputPerM: 75 },
+  "claude-sonnet-4": { inputPerM: 3, outputPerM: 15 },
+  "claude-haiku-4": { inputPerM: 0.8, outputPerM: 4 },
+  "gemini-2.5-pro": { inputPerM: 1.25, outputPerM: 10 },
+  "gemini-2.5-flash": { inputPerM: 0.3, outputPerM: 2.5 }
+};
+var customPricing = {};
+function registerPricing(model, pricing) {
+  customPricing[model] = pricing;
+}
+function getPricing(model) {
+  if (!model) return void 0;
+  if (customPricing[model]) return customPricing[model];
+  if (builtinPricing[model]) return builtinPricing[model];
+  const short = model.includes("/") ? model.split("/").pop() : model;
+  return customPricing[short] ?? builtinPricing[short];
+}
+function computeCost(model, usage) {
+  if (!model) return void 0;
+  const pricing = getPricing(model);
+  if (!pricing) return void 0;
+  const inputUsd = usage.promptTokens / 1e6 * pricing.inputPerM;
+  const outputUsd = usage.completionTokens / 1e6 * pricing.outputPerM;
+  return {
+    model,
+    inputUsd,
+    outputUsd,
+    totalUsd: inputUsd + outputUsd
+  };
+}
+
+// src/extensibility/permissions/policy.ts
+var defaultPolicy = {
+  mode: "default",
+  rules: []
+};
+function evaluatePolicy(policy, toolName) {
+  if (policy.mode === "bypassPermissions") return "allow";
+  if (policy.mode === "plan") return "ask";
+  for (const rule of policy.rules) {
+    if (matchesRule(rule, toolName)) return rule.action;
+  }
+  if (policy.mode === "acceptEdits" && /^(fs_write|edit|write_file)/.test(toolName)) {
+    return "allow";
+  }
+  return "ask";
+}
+function matchesRule(rule, toolName) {
+  if (rule.tool instanceof RegExp) return rule.tool.test(toolName);
+  const str = rule.tool;
+  if (str.startsWith("re:")) return new RegExp(str.slice(3)).test(toolName);
+  return str === toolName;
+}
+function applyPolicyToTool(policy, tool) {
+  const action = evaluatePolicy(policy, tool.name);
+  if (action === "deny") return null;
+  if (action === "allow") return { ...tool, requiresConfirmation: false };
+  return { ...tool, requiresConfirmation: true };
+}
+function applyPolicyToTools(policy, tools) {
+  const out = [];
+  for (const tool of tools) {
+    const gated = applyPolicyToTool(policy, tool);
+    if (gated) out.push(gated);
+  }
+  return out;
+}
+
+// src/extensibility/hooks/runner.ts
+var HookDispatcher = class {
+  constructor(handlers = [], onError = (_h, err) => process.stderr.write(
+    `[agentskit] hook error: ${err instanceof Error ? err.message : String(err)}
+`
+  )) {
+    this.onError = onError;
+    this.handlers = /* @__PURE__ */ new Map();
+    for (const handler of handlers) this.register(handler);
+  }
+  register(handler) {
+    const list = this.handlers.get(handler.event) ?? [];
+    list.push(handler);
+    this.handlers.set(handler.event, list);
+  }
+  async dispatch(event, payload) {
+    const list = this.handlers.get(event) ?? [];
+    let current = { ...payload, event };
+    for (const handler of list) {
+      if (!this.matches(handler, current)) continue;
+      let result;
+      try {
+        result = await handler.run(current);
+      } catch (err) {
+        this.onError(handler, err);
+        continue;
+      }
+      if (result.decision === "block") {
+        return { payload: current, blocked: true, reason: result.reason };
+      }
+      if (result.decision === "modify") {
+        current = { ...result.payload, event };
+      }
+    }
+    return { payload: current, blocked: false };
+  }
+  matches(handler, payload) {
+    if (!handler.matcher) return true;
+    if (typeof handler.matcher === "function") return handler.matcher(payload);
+    return handler.matcher.test(String(payload.tool ?? payload.prompt ?? ""));
+  }
+};
+function configHooksToHandlers(config) {
+  if (!config) return [];
+  const handlers = [];
+  for (const [event, entries] of Object.entries(config)) {
+    for (const entry of entries) {
+      handlers.push({
+        event,
+        matcher: entry.matcher ? new RegExp(entry.matcher) : void 0,
+        run: (payload) => runShellHook(entry, payload)
+      });
+    }
+  }
+  return handlers;
+}
+function runShellHook(entry, payload) {
+  return new Promise((resolvePromise) => {
+    const timeoutMs = entry.timeout ?? 5e3;
+    const child = spawn("sh", ["-c", entry.run], {
+      stdio: ["pipe", "pipe", "inherit"]
+    });
+    let stdout = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+    }, timeoutMs);
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        resolvePromise({
+          decision: "block",
+          reason: `shell hook exited with code ${code}`
+        });
+        return;
+      }
+      const trimmed = stdout.trim();
+      if (!trimmed) {
+        resolvePromise({ decision: "continue" });
+        return;
+      }
+      try {
+        const parsed = JSON.parse(trimmed);
+        resolvePromise(parsed);
+      } catch {
+        resolvePromise({ decision: "continue" });
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolvePromise({ decision: "block", reason: err.message });
+    });
+    try {
+      child.stdin.write(JSON.stringify(payload));
+      child.stdin.end();
+    } catch {
+    }
+  });
+}
+
 // src/slash-commands.ts
 function parseSlashCommand(input2) {
   if (!input2.startsWith("/")) return null;
@@ -493,6 +627,89 @@ ${lines.join("\n")}`, "info");
       ctx.feedback("History cleared.", "success");
     }
   },
+  {
+    name: "usage",
+    description: "Show the cumulative token usage for this session.",
+    run(ctx) {
+      const usage = ctx.chat.usage;
+      if (!usage || usage.totalTokens === 0) {
+        ctx.feedback("No usage reported yet for this session.", "info");
+        return;
+      }
+      ctx.feedback(
+        `Tokens \u2014 prompt=${usage.promptTokens}  completion=${usage.completionTokens}  total=${usage.totalTokens}`,
+        "info"
+      );
+    }
+  },
+  {
+    name: "cost",
+    description: "Estimate the cost so far for the current model.",
+    run(ctx) {
+      const usage = ctx.chat.usage;
+      const model = ctx.runtime.model;
+      if (!usage || usage.totalTokens === 0) {
+        ctx.feedback("No usage reported yet for this session.", "info");
+        return;
+      }
+      const cost = computeCost(model, usage);
+      if (!cost) {
+        ctx.feedback(
+          `No pricing registered for model "${model ?? "unset"}". Register with registerPricing() or provide a known model name.`,
+          "warn"
+        );
+        return;
+      }
+      ctx.feedback(
+        `$${cost.totalUsd.toFixed(4)} total (in=$${cost.inputUsd.toFixed(4)}  out=$${cost.outputUsd.toFixed(4)}  model=${cost.model})`,
+        "info"
+      );
+    }
+  },
+  {
+    name: "rename",
+    description: "Attach a human-readable label to the current session.",
+    usage: "/rename <label>",
+    run(ctx, args) {
+      const label = args.trim();
+      const sessionId = ctx.runtime.sessionId;
+      if (!sessionId || sessionId === "custom") {
+        ctx.feedback("Rename is only available for managed sessions.", "warn");
+        return;
+      }
+      if (!label) {
+        ctx.feedback("Usage: /rename <label>", "warn");
+        return;
+      }
+      try {
+        renameSession(sessionId, label);
+        ctx.feedback(`Session labeled "${label}".`, "success");
+      } catch (err) {
+        ctx.feedback(`/rename failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+      }
+    }
+  },
+  {
+    name: "fork",
+    description: "Branch a copy of the current session. Does not switch to it.",
+    run(ctx) {
+      const sessionId = ctx.runtime.sessionId;
+      if (!sessionId || sessionId === "custom") {
+        ctx.feedback("Fork is only available for managed sessions.", "warn");
+        return;
+      }
+      try {
+        const result = forkSession(sessionId);
+        ctx.feedback(
+          `Forked into ${result.id}. Resume with:
+  agentskit chat --resume ${result.id}`,
+          "success"
+        );
+      } catch (err) {
+        ctx.feedback(`/fork failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+      }
+    }
+  },
   {
     name: "exit",
     aliases: ["quit", "q"],
@@ -502,57 +719,127 @@ ${lines.join("\n")}`, "info");
     }
   }
 ];
-function groupIntoTurns(messages) {
-  const turns = [];
-  let current = [];
-  for (const message of messages) {
-    if (message.role === "user") {
-      if (current.length > 0) turns.push(current);
-      current = [message];
-    } else if (message.role === "system") {
-      if (current.length > 0) turns.push(current);
-      turns.push([message]);
-      current = [];
-    } else {
-      current.push(message);
+var skillRegistry = {
+  researcher,
+  coder,
+  planner,
+  critic,
+  summarizer
+};
+function instantiate(kind) {
+  switch (kind) {
+    case "web_search":
+      return [webSearch()];
+    case "fetch_url":
+      return [fetchUrl()];
+    case "filesystem":
+      return filesystem({ basePath: process.cwd() });
+    case "shell":
+      return [shell({ timeout: 3e4 })];
+  }
+}
+function gateTool(tool) {
+  if (tool.requiresConfirmation === false) return tool;
+  return { ...tool, requiresConfirmation: true };
+}
+function resolveTools(toolNames) {
+  if (!toolNames) {
+    return [...instantiate("web_search"), ...instantiate("fetch_url")].map(gateTool);
+  }
+  const tools = [];
+  for (const name of toolNames.split(",").map((s) => s.trim()).filter(Boolean)) {
+    switch (name) {
+      case "web_search":
+      case "fetch_url":
+      case "filesystem":
+      case "shell":
+        tools.push(...instantiate(name));
+        break;
+      default:
+        process.stderr.write(`Unknown tool: ${name}
+`);
     }
   }
-  if (current.length > 0) turns.push(current);
-  return turns;
+  return tools;
 }
-function ChatApp(options) {
-  const [provider, setProvider] = useState(options.provider);
-  const [model, setModel] = useState(options.model);
-  const [apiKey, setApiKey] = useState(options.apiKey);
-  const [baseUrl, setBaseUrl] = useState(options.baseUrl);
-  const [toolsFlag, setToolsFlag] = useState(options.tools);
-  const [skillFlag, setSkillFlag] = useState(options.skill);
-  const runtime = useMemo(
-    () => resolveChatProvider({ provider, model, apiKey, baseUrl }),
-    [provider, model, apiKey, baseUrl]
-  );
-  const memory = useMemo(
-    () => resolveMemory(options.memoryBackend, options.memoryPath ?? ".agentskit-history.json"),
-    [options.memoryPath, options.memoryBackend]
-  );
-  const tools = useMemo(() => resolveTools(toolsFlag), [toolsFlag]);
-  const skills = useMemo(() => {
-    if (!skillFlag) return void 0;
-    const names = skillFlag.split(",").map((s) => s.trim());
-    const resolved = names.map((n) => skillRegistry[n]).filter(Boolean);
-    if (resolved.length === 0) return void 0;
-    return resolved;
-  }, [skillFlag]);
-  const chat = useChat({
-    adapter: runtime.adapter,
-    memory,
-    systemPrompt: options.system,
-    tools: tools.length > 0 ? tools : void 0,
-    skills
-  });
-  const [sessionAllowed, setSessionAllowed] = useState(/* @__PURE__ */ new Set());
-  const autoApprovedRef = useRef(/* @__PURE__ */ new Set());
-  useEffect(() => {
+function resolveSkill(skillName) {
+  if (!skillName) return void 0;
+  const skill = skillRegistry[skillName.trim()];
+  if (!skill) {
+    process.stderr.write(`Unknown skill: ${skillName}
+`);
+    return void 0;
+  }
+  return skill;
+}
+function resolveSkills(skillNames) {
+  if (!skillNames) return void 0;
+  const names = skillNames.split(",").map((s) => s.trim());
+  const resolved = names.map((n) => skillRegistry[n]).filter(Boolean);
+  if (resolved.length === 0) {
+    process.stderr.write(`No valid skills found in: ${skillNames}
+`);
+    return void 0;
+  }
+  if (resolved.length === 1) return resolved[0];
+  return composeSkills(...resolved);
+}
+function resolveMemory(backend, memoryPath) {
+  switch (backend) {
+    case "sqlite":
+      return sqliteChatMemory({ path: memoryPath.replace(/\.json$/, ".db") });
+    case "file":
+    default:
+      return fileChatMemory(memoryPath);
+  }
+}
+
+// src/runtime/use-runtime.ts
+function useRuntime(options) {
+  const [provider, setProvider] = useState(options.provider);
+  const [model, setModel] = useState(options.model);
+  const [apiKey, setApiKey] = useState(options.apiKey);
+  const [baseUrl, setBaseUrl] = useState(options.baseUrl);
+  const [toolsFlag, setToolsFlag] = useState(options.tools);
+  const [skillFlag, setSkillFlag] = useState(options.skill);
+  const runtime = useMemo(
+    () => resolveChatProvider({ provider, model, apiKey, baseUrl }),
+    [provider, model, apiKey, baseUrl]
+  );
+  const memory = useMemo(
+    () => resolveMemory(options.memoryBackend, options.memoryPath ?? ".agentskit-history.json"),
+    [options.memoryPath, options.memoryBackend]
+  );
+  const tools = useMemo(() => {
+    const resolved = resolveTools(toolsFlag);
+    if (!options.permissionPolicy) return resolved;
+    return applyPolicyToTools(options.permissionPolicy, resolved);
+  }, [toolsFlag, options.permissionPolicy]);
+  const skills = useMemo(() => {
+    if (!skillFlag) return void 0;
+    const names = skillFlag.split(",").map((s) => s.trim());
+    const resolved = names.map((n) => skillRegistry[n]).filter(Boolean);
+    if (resolved.length === 0) return void 0;
+    return resolved;
+  }, [skillFlag]);
+  return {
+    runtime,
+    memory,
+    tools,
+    skills,
+    state: { provider, model, apiKey, baseUrl, toolsFlag, skillFlag },
+    setProvider,
+    setModel,
+    setApiKey,
+    setBaseUrl,
+    setToolsFlag,
+    setSkillFlag
+  };
+}
+function useToolPermissions(chat) {
+  const [sessionAllowed, setSessionAllowed] = useState(/* @__PURE__ */ new Set());
+  const autoApprovedRef = useRef(/* @__PURE__ */ new Set());
+  useEffect(() => {
     if (sessionAllowed.size === 0) return;
     for (const message of chat.messages) {
       for (const call of message.toolCalls ?? []) {
@@ -573,9 +860,20 @@ function ChatApp(options) {
     autoApprovedRef.current.add(toolCallId);
     void chat.approve(toolCallId);
   };
+  const awaitingConfirmation = useMemo(
+    () => chat.messages.some(
+      (message) => message.toolCalls?.some(
+        (call) => call.status === "requires_confirmation" && !sessionAllowed.has(call.name)
+      )
+    ),
+    [chat.messages, sessionAllowed]
+  );
+  return { sessionAllowed, handleApproveAlways, awaitingConfirmation };
+}
+function useSessionMeta(options) {
   const sessionCreatedAtRef = useRef(void 0);
-  const messageCount = chat.messages.length;
-  const firstUserContent = chat.messages.find((m) => m.role === "user")?.content ?? "";
+  const messageCount = options.messages.length;
+  const firstUserContent = options.messages.find((m) => m.role === "user")?.content ?? "";
   useEffect(() => {
     const sessionId = options.sessionId;
     if (!sessionId || sessionId === "custom") return;
@@ -589,16 +887,90 @@ function ChatApp(options) {
         createdAt: sessionCreatedAtRef.current,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         messageCount,
-        preview: derivePreview(chat.messages),
-        provider: runtime.provider,
-        model: runtime.model
+        preview: derivePreview(options.messages),
+        provider: options.provider,
+        model: options.model
       });
     } catch {
     }
-  }, [options.sessionId, messageCount, firstUserContent, runtime.provider, runtime.model]);
+  }, [options.sessionId, messageCount, firstUserContent, options.provider, options.model]);
+}
+function groupIntoTurns(messages) {
+  const turns = [];
+  let current = [];
+  for (const message of messages) {
+    if (message.role === "user") {
+      if (current.length > 0) turns.push(current);
+      current = [message];
+    } else if (message.role === "system") {
+      if (current.length > 0) turns.push(current);
+      turns.push([message]);
+      current = [];
+    } else {
+      current.push(message);
+    }
+  }
+  if (current.length > 0) turns.push(current);
+  return turns;
+}
+function ChatApp(options) {
+  const {
+    runtime,
+    memory,
+    tools,
+    skills,
+    state: { baseUrl, toolsFlag, skillFlag },
+    setProvider,
+    setModel,
+    setApiKey,
+    setBaseUrl,
+    setToolsFlag,
+    setSkillFlag
+  } = useRuntime(options);
+  const mergedTools = useMemo(() => {
+    const extra = options.extraTools ?? [];
+    return [...tools, ...extra];
+  }, [tools, options.extraTools]);
+  const mergedSkills = useMemo(() => {
+    const extra = options.extraSkills ?? [];
+    if (!skills && extra.length === 0) return void 0;
+    return [...skills ?? [], ...extra];
+  }, [skills, options.extraSkills]);
+  const chat = useChat({
+    adapter: runtime.adapter,
+    memory,
+    systemPrompt: options.system,
+    tools: mergedTools.length > 0 ? mergedTools : void 0,
+    skills: mergedSkills
+  });
+  const { sessionAllowed, handleApproveAlways, awaitingConfirmation } = useToolPermissions(chat);
+  useSessionMeta({
+    sessionId: options.sessionId,
+    messages: chat.messages,
+    provider: runtime.provider,
+    model: runtime.model
+  });
   const turns = useMemo(() => groupIntoTurns(chat.messages), [chat.messages]);
   const toolNames = toolsFlag ? toolsFlag.split(",").map((s) => s.trim()).filter(Boolean) : [];
   const [feedback, setFeedback] = useState(null);
+  const hookDispatcher = useMemo(
+    () => new HookDispatcher(options.hookHandlers ?? []),
+    [options.hookHandlers]
+  );
+  useEffect(() => {
+    void hookDispatcher.dispatch("SessionStart", {
+      event: "SessionStart",
+      sessionId: options.sessionId,
+      provider: runtime.provider,
+      model: runtime.model
+    });
+    return () => {
+      void hookDispatcher.dispatch("SessionEnd", {
+        event: "SessionEnd",
+        sessionId: options.sessionId
+      });
+    };
+  }, [hookDispatcher]);
   const slashCommands = useMemo(
     () => [...builtinSlashCommands, ...options.slashCommands ?? []],
     [options.slashCommands]
@@ -607,6 +979,17 @@ function ChatApp(options) {
   const handleSubmitInput = async (raw) => {
     const parsed = parseSlashCommand(raw);
     if (!parsed) {
+      const hookResult = await hookDispatcher.dispatch("UserPromptSubmit", {
+        event: "UserPromptSubmit",
+        prompt: raw
+      });
+      if (hookResult.blocked) {
+        setFeedback({
+          message: `Prompt blocked: ${hookResult.reason ?? "hook refused"}`,
+          kind: "warn"
+        });
+        return true;
+      }
       setFeedback(null);
       return false;
     }
@@ -626,7 +1009,8 @@ function ChatApp(options) {
         mode: runtime.mode,
         baseUrl,
         tools: toolsFlag,
-        skill: skillFlag
+        skill: skillFlag,
+        sessionId: options.sessionId
       },
       setProvider,
       setModel,
@@ -645,14 +1029,6 @@ function ChatApp(options) {
     }
     return true;
   };
-  const awaitingConfirmation = useMemo(
-    () => chat.messages.some(
-      (message) => message.toolCalls?.some(
-        (call) => call.status === "requires_confirmation" && !sessionAllowed.has(call.name)
-      )
-    ),
-    [chat.messages, sessionAllowed]
-  );
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", gap: 1, children: [
     /* @__PURE__ */ jsx(
       StatusHeader,
@@ -743,6 +1119,291 @@ function renderChatHeader(options) {
   if (options.memoryBackend) parts.push(`memory=${options.memoryBackend}`);
   return parts.join(" ");
 }
+async function loadPlugins(options = {}) {
+  const {
+    specs = [],
+    pluginDirs = [],
+    cwd = process.cwd(),
+    autoDiscoverUserDir = true,
+    onError = (spec, err) => process.stderr.write(
+      `[agentskit] plugin "${spec}" failed to load: ${err instanceof Error ? err.message : String(err)}
+`
+    ),
+    log = () => {
+    }
+  } = options;
+  const resolvedSpecs = [...specs];
+  const discoveryDirs = [...pluginDirs];
+  if (autoDiscoverUserDir) discoveryDirs.push(join(homedir(), ".agentskit", "plugins"));
+  for (const dir of discoveryDirs) {
+    const discovered = await discoverPluginsInDir(dir);
+    resolvedSpecs.push(...discovered);
+  }
+  const plugins = [];
+  for (const spec of resolvedSpecs) {
+    try {
+      const plugin = await loadPluginFromSpec(spec, cwd, log);
+      if (plugin) plugins.push(plugin);
+    } catch (err) {
+      onError(spec, err);
+    }
+  }
+  return mergePluginsIntoBundle(plugins);
+}
+async function discoverPluginsInDir(dir) {
+  try {
+    const entries = await readdir(dir);
+    const absolutes = entries.filter((name) => /\.(m?js|ts)$/i.test(name)).map((name) => join(dir, name));
+    const validated = [];
+    for (const p of absolutes) {
+      try {
+        const s = await stat(p);
+        if (s.isFile()) validated.push(p);
+      } catch {
+      }
+    }
+    return validated;
+  } catch {
+    return [];
+  }
+}
+async function loadPluginFromSpec(spec, cwd, log) {
+  const isPath = spec.startsWith("./") || spec.startsWith("../") || isAbsolute(spec);
+  const importTarget = isPath ? pathToFileURL(resolve(cwd, spec)).href : spec;
+  const mod = await import(importTarget);
+  const exported = mod.default ?? mod.plugin ?? mod;
+  const sourcePath = isPath ? resolve(cwd, spec) : void 0;
+  const ctx = {
+    cwd,
+    sourcePath,
+    log: (msg) => log(`[${spec}] ${msg}`)
+  };
+  if (typeof exported === "function") {
+    const factory = exported;
+    return await factory(ctx);
+  }
+  if (exported && typeof exported === "object" && "name" in exported) {
+    const plugin = exported;
+    if (plugin.init) await plugin.init(ctx);
+    return plugin;
+  }
+  throw new Error(
+    "Module did not export a Plugin \u2014 expected default export to be a Plugin object or a PluginFactory function."
+  );
+}
+function mergePluginsIntoBundle(plugins) {
+  const bundle = {
+    plugins,
+    slashCommands: [],
+    tools: [],
+    skills: [],
+    providers: {},
+    hooks: [],
+    mcpServers: []
+  };
+  for (const plugin of plugins) {
+    if (plugin.slashCommands) bundle.slashCommands.push(...plugin.slashCommands);
+    if (plugin.tools) bundle.tools.push(...plugin.tools);
+    if (plugin.skills) bundle.skills.push(...plugin.skills);
+    if (plugin.hooks) bundle.hooks.push(...plugin.hooks);
+    if (plugin.mcpServers) bundle.mcpServers.push(...plugin.mcpServers);
+    if (plugin.providers) {
+      for (const [name, factory] of Object.entries(plugin.providers)) {
+        bundle.providers[name] = factory;
+      }
+    }
+  }
+  return bundle;
+}
+var McpClient = class {
+  constructor(spec, onError = (err) => process.stderr.write(
+    `[agentskit] mcp[${spec.name}] error: ${err instanceof Error ? err.message : String(err)}
+`
+  )) {
+    this.spec = spec;
+    this.onError = onError;
+    this.buffer = "";
+    this.nextId = 1;
+    this.pending = /* @__PURE__ */ new Map();
+    this.disposed = false;
+  }
+  async start() {
+    if (this.child) return;
+    const child = spawn(this.spec.command, this.spec.args ?? [], {
+      env: { ...process.env, ...this.spec.env ?? {} },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    child.stdout.on("data", (chunk) => this.onStdout(chunk.toString()));
+    child.stderr.on("data", (chunk) => {
+      process.stderr.write(`[mcp ${this.spec.name}] ${chunk}`);
+    });
+    child.on("error", (err) => this.onError(err));
+    child.on("close", () => {
+      this.disposed = true;
+      for (const pending of this.pending.values()) {
+        pending({ jsonrpc: "2.0", id: 0, error: { code: -1, message: "server closed" } });
+      }
+      this.pending.clear();
+    });
+    await this.request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "agentskit", version: "0" }
+    });
+  }
+  async listTools() {
+    const res = await this.request("tools/list", {});
+    const tools = res.tools ?? [];
+    return tools;
+  }
+  async callTool(name, args) {
+    return await this.request("tools/call", { name, arguments: args });
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.child?.kill("SIGTERM");
+  }
+  request(method, params) {
+    return new Promise((resolvePromise, rejectPromise) => {
+      if (!this.child || this.disposed) {
+        rejectPromise(new Error(`mcp server ${this.spec.name} not running`));
+        return;
+      }
+      const id = this.nextId++;
+      const timeoutMs = this.spec.timeout ?? 1e4;
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        rejectPromise(new Error(`mcp ${this.spec.name}.${method} timed out`));
+      }, timeoutMs);
+      this.pending.set(id, (res) => {
+        clearTimeout(timer);
+        if (res.error) {
+          rejectPromise(new Error(`mcp ${method} failed: ${res.error.message}`));
+          return;
+        }
+        resolvePromise(res.result);
+      });
+      const message = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+      this.child.stdin.write(message);
+    });
+  }
+  onStdout(chunk) {
+    this.buffer += chunk;
+    let newlineIndex = this.buffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      const line = this.buffer.slice(0, newlineIndex).trim();
+      this.buffer = this.buffer.slice(newlineIndex + 1);
+      if (line) {
+        try {
+          const parsed = JSON.parse(line);
+          const pending = this.pending.get(Number(parsed.id));
+          if (pending) {
+            this.pending.delete(Number(parsed.id));
+            pending(parsed);
+          }
+        } catch (err) {
+          this.onError(err);
+        }
+      }
+      newlineIndex = this.buffer.indexOf("\n");
+    }
+  }
+};
+
+// src/extensibility/mcp/bridge.ts
+async function bridgeMcpServers(specs) {
+  const clients = [];
+  const tools = [];
+  for (const spec of specs) {
+    const client = new McpClient(spec);
+    try {
+      await client.start();
+      const mcpTools = await client.listTools();
+      for (const mcpTool of mcpTools) {
+        tools.push(mcpToolToDefinition(spec.name, client, mcpTool));
+      }
+      clients.push(client);
+    } catch (err) {
+      process.stderr.write(
+        `[agentskit] mcp server "${spec.name}" failed: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      client.dispose();
+    }
+  }
+  return { clients, tools };
+}
+function mcpToolToDefinition(serverName, client, tool) {
+  return {
+    name: `${serverName}__${tool.name}`,
+    description: tool.description ?? `MCP tool ${tool.name} from ${serverName}`,
+    schema: tool.inputSchema ?? { type: "object", properties: {} },
+    execute: async (args) => {
+      return await client.callTool(tool.name, args);
+    }
+  };
+}
+function disposeMcpClients(clients) {
+  for (const client of clients) client.dispose();
+}
+function formatEvent(event) {
+  switch (event.type) {
+    case "agent:step":
+      return `[step ${event.step}] ${event.action}`;
+    case "llm:start":
+      return `[llm] start (${event.messageCount} messages)`;
+    case "llm:end": {
+      const preview = event.content.length > 100 ? event.content.slice(0, 100) + "..." : event.content;
+      return `[llm] done (${event.durationMs}ms) "${preview}"`;
+    }
+    case "tool:start":
+      return `[tool] ${event.name} ${JSON.stringify(event.args)}`;
+    case "tool:end":
+      return `[tool] ${event.name} done (${event.durationMs}ms)`;
+    case "error":
+      return `[error] ${event.error.message}`;
+    default:
+      return `[${event.type}]`;
+  }
+}
+async function runAgent(task, options) {
+  if (options.skill && options.skills) {
+    process.stderr.write("Error: --skill and --skills are mutually exclusive. Use one or the other.\n");
+    process.exit(1);
+  }
+  const { adapter } = resolveChatProvider({
+    provider: options.provider,
+    model: options.model,
+    apiKey: options.apiKey,
+    baseUrl: options.baseUrl
+  });
+  const tools = resolveTools(options.tools);
+  const skill = options.skills ? resolveSkills(options.skills) : resolveSkill(options.skill);
+  const memory = options.memory ? resolveMemory(options.memoryBackend, options.memory) : void 0;
+  const observers = [];
+  if (options.verbose) {
+    observers.push({
+      name: "cli-verbose",
+      on(event) {
+        process.stderr.write(formatEvent(event) + "\n");
+      }
+    });
+  }
+  const runtime = createRuntime({
+    adapter,
+    tools,
+    memory,
+    systemPrompt: options.systemPrompt,
+    maxSteps: options.maxSteps ? parseInt(options.maxSteps, 10) : void 0,
+    observers
+  });
+  const result = await runtime.run(task, {
+    skill: skill ?? void 0
+  });
+  process.stdout.write(result.content + "\n");
+}
 var PROVIDER_IMPORT = {
   openai: "openai",
   anthropic: "anthropic",
@@ -841,7 +1502,7 @@ function reactStarter(ctx) {
   return {
     "package.json": JSON.stringify(
       {
-        name: path3.basename(ctx.template === "react" ? "agentskit-react-app" : "agentskit-app"),
+        name: path.basename(ctx.template === "react" ? "agentskit-react-app" : "agentskit-app"),
         private: true,
         type: "module",
         scripts: {
@@ -1210,68 +1871,12 @@ async function writeStarterProject(options) {
   await mkdir(options.targetDir, { recursive: true });
   await Promise.all(
     Object.entries(files).map(async ([relativePath, content]) => {
-      const absolutePath = path3.join(options.targetDir, relativePath);
-      await mkdir(path3.dirname(absolutePath), { recursive: true });
+      const absolutePath = path.join(options.targetDir, relativePath);
+      await mkdir(path.dirname(absolutePath), { recursive: true });
       await writeFile(absolutePath, content, "utf8");
     })
   );
 }
-function formatEvent(event) {
-  switch (event.type) {
-    case "agent:step":
-      return `[step ${event.step}] ${event.action}`;
-    case "llm:start":
-      return `[llm] start (${event.messageCount} messages)`;
-    case "llm:end": {
-      const preview = event.content.length > 100 ? event.content.slice(0, 100) + "..." : event.content;
-      return `[llm] done (${event.durationMs}ms) "${preview}"`;
-    }
-    case "tool:start":
-      return `[tool] ${event.name} ${JSON.stringify(event.args)}`;
-    case "tool:end":
-      return `[tool] ${event.name} done (${event.durationMs}ms)`;
-    case "error":
-      return `[error] ${event.error.message}`;
-    default:
-      return `[${event.type}]`;
-  }
-}
-async function runAgent(task, options) {
-  if (options.skill && options.skills) {
-    process.stderr.write("Error: --skill and --skills are mutually exclusive. Use one or the other.\n");
-    process.exit(1);
-  }
-  const { adapter } = resolveChatProvider({
-    provider: options.provider,
-    model: options.model,
-    apiKey: options.apiKey,
-    baseUrl: options.baseUrl
-  });
-  const tools = resolveTools(options.tools);
-  const skill = options.skills ? resolveSkills(options.skills) : resolveSkill(options.skill);
-  const memory = options.memory ? resolveMemory(options.memoryBackend, options.memory) : void 0;
-  const observers = [];
-  if (options.verbose) {
-    observers.push({
-      name: "cli-verbose",
-      on(event) {
-        process.stderr.write(formatEvent(event) + "\n");
-      }
-    });
-  }
-  const runtime = createRuntime({
-    adapter,
-    tools,
-    memory,
-    systemPrompt: options.systemPrompt,
-    maxSteps: options.maxSteps ? parseInt(options.maxSteps, 10) : void 0,
-    observers
-  });
-  const result = await runtime.run(task, {
-    skill: skill ?? void 0
-  });
-  process.stdout.write(result.content + "\n");
-}
 var PROVIDER_ENV_KEYS = {
   openai: "OPENAI_API_KEY",
   anthropic: "ANTHROPIC_API_KEY",
@@ -1331,8 +1936,8 @@ async function checkPnpm() {
   };
 }
 async function checkPackageJson() {
-  const path4 = join(process.cwd(), "package.json");
-  if (!existsSync(path4)) {
+  const path5 = join(process.cwd(), "package.json");
+  if (!existsSync(path5)) {
     return {
       status: "warn",
       name: "package.json",
@@ -1341,7 +1946,7 @@ async function checkPackageJson() {
     };
   }
   try {
-    const pkg = JSON.parse(await readFile(path4, "utf8"));
+    const pkg = JSON.parse(await readFile(path5, "utf8"));
     const deps = {
       ...pkg.dependencies ?? {},
       ...pkg.devDependencies ?? {}
@@ -1603,11 +2208,11 @@ function startDev(options) {
       }
     });
   };
-  const restart = (path4) => {
+  const restart = (path5) => {
     if (restartTimer) clearTimeout(restartTimer);
     restartTimer = setTimeout(() => {
       restartTimer = void 0;
-      banner(`\u21BB change detected \u2014 ${path4}`, "yellow");
+      banner(`\u21BB change detected \u2014 ${path5}`, "yellow");
       if (child && !child.killed && child.exitCode === null) {
         child.kill("SIGTERM");
       }
@@ -1708,132 +2313,205 @@ async function startTunnel(options) {
     requests: () => requests
   };
 }
-async function runInteractiveInit(defaults = {}) {
-  process.stdout.write(`
-${kleur3.bold().green("\u25B2")} ${kleur3.bold("agentskit init")}
-`);
-  process.stdout.write(kleur3.dim("   Generate a starter project \u2014 answer five questions.\n\n"));
-  try {
-    const targetDir = await input({
-      message: "Project directory:",
-      default: defaults.dir ?? "agentskit-app",
-      validate: (value) => {
-        if (!value.trim()) return "A directory name is required.";
-        const abs = path3.resolve(process.cwd(), value);
-        if (existsSync(abs)) return `${value} already exists. Pick a different name.`;
-        return true;
-      }
-    });
-    const template = await select({
-      message: "Template:",
-      default: defaults.template ?? "react",
-      choices: [
-        { name: "React chat (Vite + browser)", value: "react", description: "Streaming UI with @agentskit/react" },
-        { name: "Ink chat (terminal UI)", value: "ink", description: "Same chat but in your terminal" },
-        { name: "Runtime (headless agent, no UI)", value: "runtime", description: "Autonomous task \u2192 result" },
-        { name: "Multi-agent (planner + delegates)", value: "multi-agent", description: "Supervisor pattern, ready to extend" }
-      ]
-    });
-    const provider = await select({
-      message: "LLM provider:",
-      default: "demo",
-      choices: [
-        { name: "Demo (no API key \u2014 deterministic stub)", value: "demo" },
-        { name: "OpenAI", value: "openai" },
-        { name: "Anthropic", value: "anthropic" },
-        { name: "Gemini", value: "gemini" },
-        { name: "Ollama (local, no key)", value: "ollama" }
-      ]
-    });
-    let tools = [];
-    if (template !== "react") {
-      tools = await checkbox({
-        message: "Tools (space to toggle, enter to confirm):",
-        choices: [
-          { name: "web_search", value: "web_search" },
-          { name: "filesystem", value: "filesystem" },
-          { name: "shell", value: "shell" }
-        ]
-      });
-    }
-    const memory = await select({
-      message: "Memory backend:",
-      default: "none",
-      choices: [
-        { name: "None (stateless)", value: "none" },
-        { name: "File (JSON on disk)", value: "file" },
-        { name: "SQLite (better-sqlite3)", value: "sqlite" }
-      ]
-    });
-    const packageManager = await select({
-      message: "Package manager:",
-      default: "pnpm",
-      choices: [
-        { name: "pnpm", value: "pnpm" },
-        { name: "npm", value: "npm" },
-        { name: "yarn", value: "yarn" },
-        { name: "bun", value: "bun" }
-      ]
-    });
-    process.stdout.write("\n" + kleur3.dim("  Summary:\n"));
-    process.stdout.write(kleur3.dim(`    dir       ${targetDir}
-`));
-    process.stdout.write(kleur3.dim(`    template  ${template}
-`));
-    process.stdout.write(kleur3.dim(`    provider  ${provider}
-`));
-    if (tools.length) process.stdout.write(kleur3.dim(`    tools     ${tools.join(", ")}
-`));
-    process.stdout.write(kleur3.dim(`    memory    ${memory}
-`));
-    process.stdout.write(kleur3.dim(`    pm        ${packageManager}
 
-`));
-    const proceed = await confirm({ message: "Generate?", default: true });
-    if (!proceed) {
-      process.stdout.write(kleur3.yellow("Cancelled.\n"));
-      return { cancelled: true, options: { targetDir, template, provider, tools, memory, packageManager } };
-    }
-    return {
-      cancelled: false,
-      options: {
-        targetDir: path3.resolve(process.cwd(), targetDir),
-        template,
-        provider,
-        tools,
-        memory,
-        packageManager
-      }
-    };
-  } catch (err) {
-    if (err.name === "ExitPromptError") {
-      process.stdout.write(kleur3.yellow("\nCancelled.\n"));
-      return { cancelled: true, options: { targetDir: "", template: "react" } };
+// src/extensibility/rag/embedders.ts
+function createOpenAiEmbedder(config) {
+  const model = config.model ?? "text-embedding-3-small";
+  const baseUrl = (config.baseUrl ?? "https://api.openai.com").replace(/\/$/, "");
+  return async (text) => {
+    const res = await fetch(`${baseUrl}/v1/embeddings`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${config.apiKey}`
+      },
+      body: JSON.stringify({ model, input: text })
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`embedder ${model} HTTP ${res.status}: ${body}`);
     }
-    throw err;
+    const json = await res.json();
+    const first = json.data?.[0]?.embedding;
+    if (!first) throw new Error(`embedder ${model}: response missing data[0].embedding`);
+    return first;
+  };
+}
+function resolveEmbedder(config) {
+  const embedder = config.embedder;
+  const provider = embedder?.provider ?? "openai";
+  if (provider !== "openai") {
+    throw new Error(`Unsupported RAG embedder provider: ${provider}. Only "openai" is built-in.`);
   }
+  const apiKey = embedder?.apiKey ?? process.env.OPENAI_API_KEY ?? process.env.OPENROUTER_API_KEY;
+  if (!apiKey) {
+    throw new Error("RAG embedder needs an API key (config.rag.embedder.apiKey or OPENAI_API_KEY env).");
+  }
+  return createOpenAiEmbedder({
+    apiKey,
+    model: embedder?.model,
+    baseUrl: embedder?.baseUrl
+  });
 }
-function printNextSteps(options) {
-  const dir = path3.relative(process.cwd(), options.targetDir) || ".";
-  const pm = options.packageManager ?? "pnpm";
-  const installCmd = pm === "npm" ? "npm install" : `${pm} install`;
-  const runCmd = pm === "npm" ? "npm run dev" : `${pm} dev`;
-  process.stdout.write("\n" + kleur3.green("\u2713 Created starter at ") + kleur3.bold(dir) + "\n\n");
-  process.stdout.write(kleur3.bold("Next steps:\n\n"));
-  process.stdout.write(`  ${kleur3.cyan("cd")} ${dir}
-`);
-  process.stdout.write(`  ${kleur3.cyan(installCmd)}
-`);
-  if (options.provider && options.provider !== "demo" && options.provider !== "ollama") {
-    process.stdout.write(
-      `  ${kleur3.cyan("cp")} .env.example .env  ${kleur3.dim("# add your API key")}
-`
-    );
+function buildRagFromConfig(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const dir = resolve(cwd, options.config.dir ?? "./.agentskit-rag");
+  const store = fileVectorMemory({ path: `${dir}/store.json` });
+  const embed = options.embedder ?? resolveEmbedder(options.config);
+  return createRAG({
+    embed,
+    store,
+    chunkSize: options.config.chunkSize,
+    topK: options.config.topK
+  });
+}
+async function indexSources(rag, config, cwd) {
+  const root = cwd ?? process.cwd();
+  const sources = config.sources ?? [];
+  const absolutePaths = [];
+  for (const pattern of sources) {
+    for await (const match of glob(pattern, { cwd: root })) {
+      absolutePaths.push(resolve(root, match));
+    }
   }
-  process.stdout.write(`  ${kleur3.cyan(runCmd)}
+  const documents = await Promise.all(
+    absolutePaths.map(async (path5) => ({
+      id: path5,
+      content: await readFile(path5, "utf8"),
+      source: path5
+    }))
+  );
+  if (documents.length > 0) await rag.ingest(documents);
+  return { documentCount: documents.length, sources: absolutePaths };
+}
+
+// src/commands/shared.ts
+function mergeWithConfig(options, config) {
+  if (!config) return options;
+  const d = config.defaults ?? {};
+  const resolvedApiKey = options.apiKey ?? (d.apiKeyEnv ? process.env[d.apiKeyEnv] : void 0) ?? d.apiKey;
+  return {
+    ...options,
+    provider: options.provider !== "demo" ? options.provider : d.provider ?? options.provider,
+    model: options.model ?? d.model,
+    apiKey: resolvedApiKey,
+    baseUrl: options.baseUrl ?? d.baseUrl,
+    tools: options.tools ?? d.tools,
+    skill: options.skill ?? d.skill,
+    system: options.system ?? d.system,
+    memoryBackend: options.memoryBackend ?? d.memoryBackend
+  };
+}
 
+// src/commands/chat.ts
+function registerChatCommand(program) {
+  program.command("chat").description("Start a terminal chat session.").option("--provider <provider>", "Provider to use", "demo").option("--model <model>", "Model name").option("--api-key <key>", "API key for the selected provider").option("--base-url <url>", "Override provider base URL").option("--system <prompt>", "System prompt").option("--memory <path>", "Explicit memory file path (overrides session management)").option("--tools <tools>", "Comma-separated tools: web_search,fetch_url,filesystem,shell").option("--skill <skills>", "Comma-separated skills: researcher,coder,planner,critic,summarizer").option("--memory-backend <backend>", "Memory backend: file (default), sqlite").option("--new", "Start a fresh chat session (ignore previous conversations in this directory)").option("--resume [id]", "Resume a prior session by id; omit id to resume the latest").option("--list-sessions", "List saved sessions for this directory and exit").option("--no-config", "Skip loading .agentskit.config.json").option(
+    "--plugin-dir <dir>",
+    "Extra directory to auto-discover plugin modules from (repeatable)",
+    (value, prev = []) => [...prev, value],
+    []
+  ).option(
+    "--mode <mode>",
+    "Permission mode: default | plan | acceptEdits | bypassPermissions"
+  ).action(async (options) => {
+    if (options.listSessions) {
+      const sessions = listSessions();
+      if (sessions.length === 0) {
+        process.stdout.write("No saved sessions for this directory.\n");
+        return;
+      }
+      for (const s of sessions) {
+        const { id, updatedAt, messageCount, preview, model, label, forkedFrom } = s.metadata;
+        const display = label ? `${label} (${id})` : id;
+        const forkNote = forkedFrom ? `  \u2190 fork ${forkedFrom}` : "";
+        process.stdout.write(
+          `${display}  ${updatedAt}  msgs=${messageCount}${model ? `  model=${model}` : ""}${forkNote}
+    ${preview}
+`
+        );
+      }
+      return;
+    }
+    const config = options.config !== false ? await loadConfig() : void 0;
+    const merged = mergeWithConfig(options, config);
+    const session = resolveSession({
+      explicitPath: options.memory,
+      forceNew: Boolean(options.new),
+      resumeId: options.resume
+    });
+    if (!session.isNew && !options.memory) {
+      process.stdout.write(
+        `Resuming session ${session.id}. Start fresh with --new or list with --list-sessions.
+`
+      );
+    }
+    const pluginBundle = await loadPlugins({
+      specs: config?.plugins ?? [],
+      pluginDirs: options.pluginDir ?? []
+    });
+    const configHooks = configHooksToHandlers(config?.hooks);
+    const hookHandlers = [...configHooks, ...pluginBundle.hooks];
+    const configMcpSpecs = Object.entries(config?.mcp?.servers ?? {}).map(([name, spec]) => ({
+      name,
+      command: spec.command,
+      args: spec.args,
+      env: spec.env,
+      timeout: spec.timeout
+    }));
+    const allMcpSpecs = [...configMcpSpecs, ...pluginBundle.mcpServers];
+    const { clients: mcpClients, tools: mcpTools } = await bridgeMcpServers(allMcpSpecs);
+    const policyMode = options.mode ?? config?.permissions?.mode ?? "default";
+    const permissionPolicy = {
+      mode: policyMode,
+      rules: (config?.permissions?.rules ?? []).map((r) => ({
+        tool: r.tool,
+        action: r.action,
+        scope: r.scope
+      }))
+    };
+    const chatOptions = {
+      apiKey: merged.apiKey ?? options.apiKey,
+      baseUrl: merged.baseUrl ?? options.baseUrl,
+      provider: merged.provider,
+      model: merged.model,
+      system: merged.system ?? options.system,
+      memoryPath: session.file,
+      sessionId: session.id,
+      tools: merged.tools ?? options.tools,
+      skill: merged.skill ?? options.skill,
+      memoryBackend: merged.memoryBackend ?? options.memoryBackend,
+      agentsKitConfig: config,
+      slashCommands: pluginBundle.slashCommands,
+      extraTools: [...pluginBundle.tools, ...mcpTools],
+      extraSkills: pluginBundle.skills,
+      hookHandlers,
+      permissionPolicy
+    };
+    process.stdout.write(`${renderChatHeader(chatOptions)}
 `);
-  process.stdout.write(kleur3.dim("  Docs: https://www.agentskit.io/docs\n\n"));
+    const instance = render(React2.createElement(ChatApp, chatOptions));
+    try {
+      await instance.waitUntilExit();
+    } finally {
+      disposeMcpClients(mcpClients);
+    }
+    if (options.memory) {
+      process.stdout.write(
+        `
+Session saved to ${session.file}. Resume with --memory ${session.file}
+`
+      );
+    } else {
+      process.stdout.write(
+        `
+Session saved. Resume with:
+  agentskit chat --resume ${session.id}
+Or start fresh with:
+  agentskit chat --new
+`
+      );
+    }
+  });
 }
 function RunApp({ task, options }) {
   const [status, setStatus] = useState("running");
@@ -1934,91 +2612,8 @@ function RunApp({ task, options }) {
   ] });
 }
 
-// src/commands.ts
-function mergeWithConfig(options, config) {
-  if (!config) return options;
-  const d = config.defaults ?? {};
-  const resolvedApiKey = options.apiKey ?? (d.apiKeyEnv ? process.env[d.apiKeyEnv] : void 0) ?? d.apiKey;
-  return {
-    ...options,
-    // Config defaults — only apply if CLI flag wasn't set
-    provider: options.provider !== "demo" ? options.provider : d.provider ?? options.provider,
-    model: options.model ?? d.model,
-    apiKey: resolvedApiKey,
-    baseUrl: options.baseUrl ?? d.baseUrl,
-    tools: options.tools ?? d.tools,
-    skill: options.skill ?? d.skill,
-    system: options.system ?? d.system,
-    memoryBackend: options.memoryBackend ?? d.memoryBackend
-  };
-}
-function createCli() {
-  const program = new Command();
-  program.name("agentskit").description("AgentsKit CLI for chat demos and project bootstrapping.");
-  program.command("chat").description("Start a terminal chat session.").option("--provider <provider>", "Provider to use", "demo").option("--model <model>", "Model name").option("--api-key <key>", "API key for the selected provider").option("--base-url <url>", "Override provider base URL").option("--system <prompt>", "System prompt").option("--memory <path>", "Explicit memory file path (overrides session management)").option("--tools <tools>", "Comma-separated tools: web_search,fetch_url,filesystem,shell").option("--skill <skills>", "Comma-separated skills: researcher,coder,planner,critic,summarizer").option("--memory-backend <backend>", "Memory backend: file (default), sqlite").option("--new", "Start a fresh chat session (ignore previous conversations in this directory)").option("--resume [id]", "Resume a prior session by id; omit id to resume the latest").option("--list-sessions", "List saved sessions for this directory and exit").option("--no-config", "Skip loading .agentskit.config.json").action(async (options) => {
-    if (options.listSessions) {
-      const sessions = listSessions();
-      if (sessions.length === 0) {
-        process.stdout.write("No saved sessions for this directory.\n");
-        return;
-      }
-      for (const s of sessions) {
-        const { id, updatedAt, messageCount, preview, model } = s.metadata;
-        process.stdout.write(
-          `${id}  ${updatedAt}  msgs=${messageCount}${model ? `  model=${model}` : ""}
-    ${preview}
-`
-        );
-      }
-      return;
-    }
-    const config = options.config !== false ? await loadConfig() : void 0;
-    const merged = mergeWithConfig(options, config);
-    const session = resolveSession({
-      explicitPath: options.memory,
-      forceNew: Boolean(options.new),
-      resumeId: options.resume
-    });
-    if (!session.isNew && !options.memory) {
-      process.stdout.write(
-        `Resuming session ${session.id}. Start fresh with --new or list with --list-sessions.
-`
-      );
-    }
-    const chatOptions = {
-      apiKey: merged.apiKey ?? options.apiKey,
-      baseUrl: merged.baseUrl ?? options.baseUrl,
-      provider: merged.provider,
-      model: merged.model,
-      system: merged.system ?? options.system,
-      memoryPath: session.file,
-      sessionId: session.id,
-      tools: merged.tools ?? options.tools,
-      skill: merged.skill ?? options.skill,
-      memoryBackend: merged.memoryBackend ?? options.memoryBackend,
-      agentsKitConfig: config
-    };
-    process.stdout.write(`${renderChatHeader(chatOptions)}
-`);
-    const instance = render(React3.createElement(ChatApp, chatOptions));
-    await instance.waitUntilExit();
-    if (options.memory) {
-      process.stdout.write(
-        `
-Session saved to ${session.file}. Resume with --memory ${session.file}
-`
-      );
-    } else {
-      process.stdout.write(
-        `
-Session saved. Resume with:
-  agentskit chat --resume ${session.id}
-Or start fresh with:
-  agentskit chat --new
-`
-      );
-    }
-  });
+// src/commands/run.ts
+function registerRunCommand(program) {
   program.command("run [task]").description("Execute an agent task and output the result.").option("--task <task>", "Task string (alternative to positional argument)").option("--provider <provider>", "Provider to use", "demo").option("--model <model>", "Model name").option("--api-key <key>", "API key for the selected provider").option("--base-url <url>", "Override provider base URL").option("--skill <skill>", "Single skill to use").option("--skills <skills>", "Comma-separated skills (composed together)").option("--tools <tools>", "Comma-separated tools: web_search,filesystem,shell").option("--memory <path>", "Path for memory persistence").option("--memory-backend <backend>", "Memory backend: file (default), sqlite").option("--system-prompt <prompt>", "System prompt").option("--max-steps <steps>", "Maximum agent steps", "10").option("--verbose", "Stream agent steps to stderr").option("--pretty", "Use rich Ink-based output").option("--no-config", "Skip loading .agentskit.config.json").action(async (positionalTask, options) => {
     const task = options.task ?? positionalTask;
     if (!task) {
@@ -2028,7 +2623,7 @@ Or start fresh with:
     const config = options.config !== false ? await loadConfig() : void 0;
     const merged = mergeWithConfig(options, config);
     if (options.pretty) {
-      render(React3.createElement(RunApp, { task, options }));
+      render(React2.createElement(RunApp, { task, options }));
     } else {
       try {
         await runAgent(task, { ...options, provider: merged.provider, model: merged.model });
@@ -2039,13 +2634,144 @@ Or start fresh with:
       }
     }
   });
+}
+async function runInteractiveInit(defaults = {}) {
+  process.stdout.write(`
+${kleur3.bold().green("\u25B2")} ${kleur3.bold("agentskit init")}
+`);
+  process.stdout.write(kleur3.dim("   Generate a starter project \u2014 answer five questions.\n\n"));
+  try {
+    const targetDir = await input({
+      message: "Project directory:",
+      default: defaults.dir ?? "agentskit-app",
+      validate: (value) => {
+        if (!value.trim()) return "A directory name is required.";
+        const abs = path.resolve(process.cwd(), value);
+        if (existsSync(abs)) return `${value} already exists. Pick a different name.`;
+        return true;
+      }
+    });
+    const template = await select({
+      message: "Template:",
+      default: defaults.template ?? "react",
+      choices: [
+        { name: "React chat (Vite + browser)", value: "react", description: "Streaming UI with @agentskit/react" },
+        { name: "Ink chat (terminal UI)", value: "ink", description: "Same chat but in your terminal" },
+        { name: "Runtime (headless agent, no UI)", value: "runtime", description: "Autonomous task \u2192 result" },
+        { name: "Multi-agent (planner + delegates)", value: "multi-agent", description: "Supervisor pattern, ready to extend" }
+      ]
+    });
+    const provider = await select({
+      message: "LLM provider:",
+      default: "demo",
+      choices: [
+        { name: "Demo (no API key \u2014 deterministic stub)", value: "demo" },
+        { name: "OpenAI", value: "openai" },
+        { name: "Anthropic", value: "anthropic" },
+        { name: "Gemini", value: "gemini" },
+        { name: "Ollama (local, no key)", value: "ollama" }
+      ]
+    });
+    let tools = [];
+    if (template !== "react") {
+      tools = await checkbox({
+        message: "Tools (space to toggle, enter to confirm):",
+        choices: [
+          { name: "web_search", value: "web_search" },
+          { name: "filesystem", value: "filesystem" },
+          { name: "shell", value: "shell" }
+        ]
+      });
+    }
+    const memory = await select({
+      message: "Memory backend:",
+      default: "none",
+      choices: [
+        { name: "None (stateless)", value: "none" },
+        { name: "File (JSON on disk)", value: "file" },
+        { name: "SQLite (better-sqlite3)", value: "sqlite" }
+      ]
+    });
+    const packageManager = await select({
+      message: "Package manager:",
+      default: "pnpm",
+      choices: [
+        { name: "pnpm", value: "pnpm" },
+        { name: "npm", value: "npm" },
+        { name: "yarn", value: "yarn" },
+        { name: "bun", value: "bun" }
+      ]
+    });
+    process.stdout.write("\n" + kleur3.dim("  Summary:\n"));
+    process.stdout.write(kleur3.dim(`    dir       ${targetDir}
+`));
+    process.stdout.write(kleur3.dim(`    template  ${template}
+`));
+    process.stdout.write(kleur3.dim(`    provider  ${provider}
+`));
+    if (tools.length) process.stdout.write(kleur3.dim(`    tools     ${tools.join(", ")}
+`));
+    process.stdout.write(kleur3.dim(`    memory    ${memory}
+`));
+    process.stdout.write(kleur3.dim(`    pm        ${packageManager}
+
+`));
+    const proceed = await confirm({ message: "Generate?", default: true });
+    if (!proceed) {
+      process.stdout.write(kleur3.yellow("Cancelled.\n"));
+      return { cancelled: true, options: { targetDir, template, provider, tools, memory, packageManager } };
+    }
+    return {
+      cancelled: false,
+      options: {
+        targetDir: path.resolve(process.cwd(), targetDir),
+        template,
+        provider,
+        tools,
+        memory,
+        packageManager
+      }
+    };
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      process.stdout.write(kleur3.yellow("\nCancelled.\n"));
+      return { cancelled: true, options: { targetDir: "", template: "react" } };
+    }
+    throw err;
+  }
+}
+function printNextSteps(options) {
+  const dir = path.relative(process.cwd(), options.targetDir) || ".";
+  const pm = options.packageManager ?? "pnpm";
+  const installCmd = pm === "npm" ? "npm install" : `${pm} install`;
+  const runCmd = pm === "npm" ? "npm run dev" : `${pm} dev`;
+  process.stdout.write("\n" + kleur3.green("\u2713 Created starter at ") + kleur3.bold(dir) + "\n\n");
+  process.stdout.write(kleur3.bold("Next steps:\n\n"));
+  process.stdout.write(`  ${kleur3.cyan("cd")} ${dir}
+`);
+  process.stdout.write(`  ${kleur3.cyan(installCmd)}
+`);
+  if (options.provider && options.provider !== "demo" && options.provider !== "ollama") {
+    process.stdout.write(
+      `  ${kleur3.cyan("cp")} .env.example .env  ${kleur3.dim("# add your API key")}
+`
+    );
+  }
+  process.stdout.write(`  ${kleur3.cyan(runCmd)}
+
+`);
+  process.stdout.write(kleur3.dim("  Docs: https://www.agentskit.io/docs\n\n"));
+}
+
+// src/commands/init.ts
+function registerInitCommand(program) {
   program.command("init").description("Generate a starter project. Run with no flags for interactive mode.").option("--template <template>", "Starter template (react|ink|runtime|multi-agent)").option("--dir <directory>", "Target directory", "agentskit-app").option("--provider <provider>", "LLM provider (openai|anthropic|gemini|ollama|demo)").option("--tools <tools>", "Comma-separated tools (web_search,filesystem,shell)").option("--memory <backend>", "Memory backend (none|file|sqlite)").option("--pm <packageManager>", "Package manager (pnpm|npm|yarn|bun)").option("-y, --yes", "Skip interactive prompts; use flag values + defaults").action(async (rawOptions) => {
     const isCi = !process.stdout.isTTY || rawOptions.yes || rawOptions.template;
     let resolved;
     if (isCi) {
       const template = rawOptions.template ?? "react";
       resolved = {
-        targetDir: path3.resolve(process.cwd(), rawOptions.dir),
+        targetDir: path.resolve(process.cwd(), rawOptions.dir),
         template,
         provider: rawOptions.provider ?? "demo",
         tools: rawOptions.tools ? rawOptions.tools.split(",").map((t) => t.trim()) : [],
@@ -2065,13 +2791,17 @@ Or start fresh with:
     await writeStarterProject(resolved);
     if (isCi) {
       process.stdout.write(
-        `Created ${resolved.template} starter in ${path3.relative(process.cwd(), resolved.targetDir) || "."}
+        `Created ${resolved.template} starter in ${path.relative(process.cwd(), resolved.targetDir) || "."}
 `
       );
     } else {
       printNextSteps(resolved);
     }
   });
+}
+
+// src/commands/doctor.ts
+function registerDoctorCommand(program) {
   program.command("doctor").description("Diagnose your AgentsKit environment.").option("--no-network", "Skip provider reachability checks").option(
     "--providers <providers>",
     "Comma-separated providers to check (default: openai,anthropic,gemini,ollama)"
@@ -2088,6 +2818,10 @@ Or start fresh with:
     }
     if (report.fail > 0) process.exit(1);
   });
+}
+
+// src/commands/dev.ts
+function registerDevCommand(program) {
   program.command("dev [entry]").description("Run an entry file with hot-reload on file changes.").option("--watch <globs>", "Comma-separated glob patterns to watch").option("--ignore <globs>", "Comma-separated glob patterns to ignore").option("--debounce <ms>", "Debounce window before restart", "200").action(async (positional, options) => {
     const entry = positional ?? "src/index.ts";
     const watch = options.watch ? options.watch.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
@@ -2106,9 +2840,15 @@ Or start fresh with:
       process.exit(1);
     }
   });
-  program.command("config").description("Show or scaffold the AgentsKit config.").argument("[action]", 'Action: "init" to create a template, "show" to print the merged config.', "show").option("--global", "Write/read the global config at ~/.agentskit/config.json (default)").option("--local", "Write/read a project-level .agentskit.config.json in the current directory").option("--force", "Overwrite an existing config file").action(async (action, options) => {
+}
+function registerConfigCommand(program) {
+  program.command("config").description("Show or scaffold the AgentsKit config.").argument(
+    "[action]",
+    'Action: "init" to create a template, "show" to print the merged config.',
+    "show"
+  ).option("--global", "Write/read the global config at ~/.agentskit/config.json (default)").option("--local", "Write/read a project-level .agentskit.config.json in the current directory").option("--force", "Overwrite an existing config file").action(async (action, options) => {
     const isLocal = Boolean(options.local);
-    const targetPath = isLocal ? path3.join(process.cwd(), ".agentskit.config.json") : path3.join(homedir(), ".agentskit", "config.json");
+    const targetPath = isLocal ? path.join(process.cwd(), ".agentskit.config.json") : path.join(homedir(), ".agentskit", "config.json");
     if (action === "show") {
       const config = await loadConfig();
       process.stdout.write(JSON.stringify(config ?? {}, null, 2) + "\n");
@@ -2120,8 +2860,10 @@ Or start fresh with:
       process.exit(2);
     }
     if (existsSync(targetPath) && !options.force) {
-      process.stderr.write(`Config already exists at ${targetPath}. Re-run with --force to overwrite.
-`);
+      process.stderr.write(
+        `Config already exists at ${targetPath}. Re-run with --force to overwrite.
+`
+      );
       process.exit(1);
     }
     const template = {
@@ -2133,7 +2875,7 @@ Or start fresh with:
         tools: "web_search,fetch_url"
       }
     };
-    mkdirSync(path3.dirname(targetPath), { recursive: true });
+    mkdirSync(path.dirname(targetPath), { recursive: true });
     writeFileSync(targetPath, JSON.stringify(template, null, 2) + "\n");
     process.stdout.write(
       `Wrote ${targetPath}
@@ -2143,6 +2885,10 @@ Edit it to taste, then run:
 `
     );
   });
+}
+
+// src/commands/tunnel.ts
+function registerTunnelCommand(program) {
   program.command("tunnel <port>").description("Open a public URL pointing to a local port (great for webhooks).").option("--subdomain <name>", "Hint for a stable subdomain (provider may decline)").option("--host <host>", "Local hostname", "localhost").action(async (port, options) => {
     const portNum = Number(port);
     if (Number.isNaN(portNum) || portNum < 1 || portNum > 65535) {
@@ -2163,9 +2909,62 @@ Edit it to taste, then run:
       process.exit(1);
     }
   });
+}
+
+// src/commands/rag.ts
+function registerRagCommand(program) {
+  const rag = program.command("rag").description("Retrieval-augmented generation utilities.");
+  rag.command("index").description("Index files referenced by config.rag.sources into the vector store.").option(
+    "--source <glob>",
+    "Glob to index (overrides config.rag.sources; repeatable)",
+    (value, prev = []) => [...prev, value],
+    []
+  ).action(async (options) => {
+    const config = await loadConfig();
+    const rawConfig = config?.rag;
+    const overrideSources = options.source;
+    const ragConfig = {
+      ...rawConfig ?? {},
+      sources: overrideSources.length > 0 ? overrideSources : rawConfig?.sources ?? []
+    };
+    if (!ragConfig.sources || ragConfig.sources.length === 0) {
+      process.stderr.write("No RAG sources configured. Set config.rag.sources or pass --source <glob>.\n");
+      process.exit(1);
+    }
+    try {
+      const instance = buildRagFromConfig({ config: ragConfig });
+      const result = await indexSources(instance, ragConfig);
+      process.stdout.write(
+        `Indexed ${result.documentCount} document${result.documentCount === 1 ? "" : "s"}.
+`
+      );
+      for (const source of result.sources) {
+        process.stdout.write(`  \u2022 ${source}
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/index.ts
+function createCli() {
+  const program = new Command();
+  program.name("agentskit").description("AgentsKit CLI for chat demos and project bootstrapping.");
+  registerChatCommand(program);
+  registerRunCommand(program);
+  registerInitCommand(program);
+  registerDoctorCommand(program);
+  registerDevCommand(program);
+  registerConfigCommand(program);
+  registerTunnelCommand(program);
+  registerRagCommand(program);
   return program;
 }
 
-export { ChatApp, createCli, loadConfig, renderChatHeader, renderReport, resolveChatProvider, runAgent, runDoctor, startDev, startTunnel, writeStarterProject };
-//# sourceMappingURL=chunk-V7E4HWTG.js.map
-//# sourceMappingURL=chunk-V7E4HWTG.js.map
+export { ChatApp, HookDispatcher, McpClient, applyPolicyToTool, applyPolicyToTools, bridgeMcpServers, buildRagFromConfig, computeCost, configHooksToHandlers, createCli, createOpenAiEmbedder, defaultPolicy, derivePreview, disposeMcpClients, evaluatePolicy, findLatestSession, findSession, forkSession, generateSessionId, getPricing, indexSources, listSessions, loadConfig, loadPlugins, mergePluginsIntoBundle, registerPricing, renameSession, renderChatHeader, renderReport, resolveChatProvider, resolveSession, runAgent, runDoctor, sessionFilePath, startDev, startTunnel, writeSessionMeta, writeStarterProject };
+//# sourceMappingURL=chunk-72XFU2X2.js.map
+//# sourceMappingURL=chunk-72XFU2X2.js.map