@agentskit/cli 0.5.3 → 0.7.0

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

@@ -1,33 +1,37 @@
 #!/usr/bin/env node
-import { mkdir, writeFile, readFile } from 'fs/promises';
-import path, { resolve, join, basename } from 'path';
+import { readdir, stat, mkdir, writeFile, glob, readFile } from 'fs/promises';
+import { homedir } from 'os';
+import path, { join, resolve, isAbsolute, basename } from 'path';
 import { kimi, grok, deepseek, ollama, gemini, anthropic, openai } from '@agentskit/adapters';
-import React3, { useMemo, useState, 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, ThinkingIndicator, InputBar } from '@agentskit/ink';
-import { shell, filesystem, webSearch } from '@agentskit/tools';
+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 { fileVectorMemory, fileChatMemory, sqliteChatMemory } from '@agentskit/memory';
 import { jsxs, jsx } from 'react/jsx-runtime';
+import { pathToFileURL } from 'url';
 import { createRuntime } from '@agentskit/runtime';
-import { existsSync } from 'fs';
-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;
@@ -45,16 +49,39 @@ async function loadPackageJsonConfig(dir) {
     return void 0;
   }
 }
-async function loadConfig(options) {
-  const cwd = resolve(options?.cwd ?? process.cwd());
-  const tsPath = join(cwd, ".agentskit.config.ts");
-  const tsConfig = await loadTsConfig(tsPath);
+function mergeConfigs(base, override) {
+  if (!base && !override) return void 0;
+  if (!base) return override;
+  if (!override) return base;
+  return {
+    ...base,
+    ...override,
+    tools: { ...base.tools, ...override.tools },
+    defaults: { ...base.defaults, ...override.defaults },
+    runtime: { ...base.runtime, ...override.runtime },
+    observability: { ...base.observability, ...override.observability }
+  };
+}
+async function loadLocalConfig(cwd) {
+  const tsConfig = await loadTsConfig(join(cwd, ".agentskit.config.ts"));
   if (tsConfig) return tsConfig;
-  const jsonPath = join(cwd, ".agentskit.config.json");
-  const jsonConfig = await loadJsonConfig(jsonPath);
+  const jsonConfig = await loadJsonConfig(join(cwd, ".agentskit.config.json"));
   if (jsonConfig) return jsonConfig;
   return await loadPackageJsonConfig(cwd);
 }
+async function loadGlobalConfig(home) {
+  if (home === null) return void 0;
+  const globalDir = join(home ?? homedir(), ".agentskit");
+  const tsConfig = await loadTsConfig(join(globalDir, "config.ts"));
+  if (tsConfig) return tsConfig;
+  return await loadJsonConfig(join(globalDir, "config.json"));
+}
+async function loadConfig(options) {
+  const cwd = resolve(options?.cwd ?? process.cwd());
+  const global = await loadGlobalConfig(options?.home);
+  const local = await loadLocalConfig(cwd);
+  return mergeConfigs(global, local);
+}
 var providers = {
   openai: {
     label: "OpenAI",
@@ -114,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" };
@@ -165,6 +192,533 @@ function resolveChatProvider(options) {
     summary: `${entry.label} live adapter`
   };
 }
+var ROOT = join(homedir(), ".agentskit", "sessions");
+var META_SUFFIX = ".meta.json";
+function cwdHash(cwd = process.cwd()) {
+  return createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+}
+function dirFor(cwd = process.cwd()) {
+  return join(ROOT, cwdHash(cwd));
+}
+function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+function generateSessionId() {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const suffix = randomBytes(3).toString("hex");
+  return `${ts}-${suffix}`;
+}
+function sessionFilePath(id, cwd = process.cwd()) {
+  ensureDir(dirFor(cwd));
+  return join(dirFor(cwd), `${id}.json`);
+}
+function metaPath(id, cwd = process.cwd()) {
+  return join(dirFor(cwd), `${id}${META_SUFFIX}`);
+}
+function readMeta(id, cwd = process.cwd()) {
+  const path5 = metaPath(id, cwd);
+  if (!existsSync(path5)) return null;
+  try {
+    return JSON.parse(readFileSync(path5, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeSessionMeta(meta, cwd = process.cwd()) {
+  ensureDir(dirFor(cwd));
+  writeFileSync(metaPath(meta.id, cwd), JSON.stringify(meta, null, 2));
+}
+function derivePreview(messages) {
+  const firstUser = messages.find((m) => m.role === "user" && m.content.trim());
+  if (!firstUser) return "(empty)";
+  const single = firstUser.content.replace(/\s+/g, " ").trim();
+  return single.length > 80 ? `${single.slice(0, 80)}\u2026` : single;
+}
+function listSessions(cwd = process.cwd()) {
+  const dir = dirFor(cwd);
+  if (!existsSync(dir)) return [];
+  const entries = readdirSync(dir);
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json") || entry.endsWith(META_SUFFIX)) continue;
+    const id = entry.replace(/\.json$/, "");
+    const meta = readMeta(id, cwd);
+    const file = join(dir, entry);
+    if (meta) {
+      records.push({ metadata: meta, file });
+    } else {
+      const stats = statSync(file);
+      records.push({
+        metadata: {
+          id,
+          cwd,
+          createdAt: stats.birthtime.toISOString(),
+          updatedAt: stats.mtime.toISOString(),
+          messageCount: 0,
+          preview: "(legacy session)"
+        },
+        file
+      });
+    }
+  }
+  records.sort((a, b) => b.metadata.updatedAt.localeCompare(a.metadata.updatedAt));
+  return records;
+}
+function findLatestSession(cwd = process.cwd()) {
+  const all = listSessions(cwd);
+  return all[0] ?? null;
+}
+function findSession(id, cwd = process.cwd()) {
+  const all = listSessions(cwd);
+  const exact = all.find((s) => s.metadata.id === id || s.metadata.label === id);
+  if (exact) return exact;
+  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) {
+    return { id: "custom", file: input2.explicitPath, isNew: !existsSync(input2.explicitPath) };
+  }
+  if (input2.forceNew) {
+    const id2 = generateSessionId();
+    return { id: id2, file: sessionFilePath(id2, cwd), isNew: true };
+  }
+  if (input2.resumeId) {
+    const target = input2.resumeId === true ? findLatestSession(cwd) : findSession(input2.resumeId, cwd);
+    if (target) {
+      return { id: target.metadata.id, file: target.file, isNew: false };
+    }
+    process.stderr.write(
+      `No session matching "${String(input2.resumeId)}" \u2014 starting a new one.
+`
+    );
+  }
+  const latest = findLatestSession(cwd);
+  if (latest) return { id: latest.metadata.id, file: latest.file, isNew: false };
+  const id = generateSessionId();
+  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;
+  const match = input2.slice(1).match(/^(\S+)\s*([\s\S]*)$/);
+  if (!match) return null;
+  return { name: match[1], args: match[2] ?? "" };
+}
+function createSlashRegistry(commands) {
+  const map = /* @__PURE__ */ new Map();
+  for (const cmd of commands) {
+    map.set(cmd.name, cmd);
+    for (const alias of cmd.aliases ?? []) map.set(alias, cmd);
+  }
+  return map;
+}
+var builtinSlashCommands = [
+  {
+    name: "help",
+    aliases: ["?"],
+    description: "List available slash commands.",
+    run(ctx) {
+      const seen = /* @__PURE__ */ new Set();
+      const lines = [];
+      for (const cmd of ctx.commands) {
+        if (seen.has(cmd.name)) continue;
+        seen.add(cmd.name);
+        const suffix = cmd.usage ? `  (${cmd.usage})` : "";
+        lines.push(`  /${cmd.name.padEnd(10)} ${cmd.description}${suffix}`);
+      }
+      ctx.feedback(`Slash commands:
+${lines.join("\n")}`, "info");
+    }
+  },
+  {
+    name: "model",
+    description: "Switch the active model.",
+    usage: "/model <name>",
+    run(ctx, args) {
+      const value = args.trim();
+      if (!value) {
+        ctx.feedback(
+          `Current model: ${ctx.runtime.model ?? "unset"}. Usage: /model <name>`,
+          "warn"
+        );
+        return;
+      }
+      ctx.setModel(value);
+      ctx.feedback(`Model \u2192 ${value}`, "success");
+    }
+  },
+  {
+    name: "provider",
+    description: "Switch the adapter provider.",
+    usage: "/provider openai|anthropic|gemini|ollama|deepseek|grok|kimi|demo",
+    run(ctx, args) {
+      const value = args.trim();
+      if (!value) {
+        ctx.feedback(
+          `Current provider: ${ctx.runtime.provider}. Usage: /provider <name>`,
+          "warn"
+        );
+        return;
+      }
+      ctx.setProvider(value);
+      ctx.feedback(`Provider \u2192 ${value}`, "success");
+    }
+  },
+  {
+    name: "base-url",
+    aliases: ["baseurl"],
+    description: "Override provider base URL.",
+    usage: "/base-url <url|clear>",
+    run(ctx, args) {
+      const value = args.trim();
+      if (!value || value === "clear") {
+        ctx.setBaseUrl(void 0);
+        ctx.feedback("Base URL cleared.", "success");
+        return;
+      }
+      ctx.setBaseUrl(value);
+      ctx.feedback(`Base URL \u2192 ${value}`, "success");
+    }
+  },
+  {
+    name: "tools",
+    description: "Set active tools (comma-separated) or clear them.",
+    usage: "/tools web_search,fetch_url | /tools clear",
+    run(ctx, args) {
+      const value = args.trim();
+      if (!value || value === "clear") {
+        ctx.setTools(void 0);
+        ctx.feedback("Tools reset to defaults.", "success");
+        return;
+      }
+      ctx.setTools(value);
+      ctx.feedback(`Tools \u2192 ${value}`, "success");
+    }
+  },
+  {
+    name: "skill",
+    description: "Set active skill(s) (comma-separated) or clear them.",
+    usage: "/skill researcher,coder | /skill clear",
+    run(ctx, args) {
+      const value = args.trim();
+      if (!value || value === "clear") {
+        ctx.setSkill(void 0);
+        ctx.feedback("Skills cleared.", "success");
+        return;
+      }
+      ctx.setSkill(value);
+      ctx.feedback(`Skills \u2192 ${value}`, "success");
+    }
+  },
+  {
+    name: "clear",
+    aliases: ["reset"],
+    description: "Clear the conversation history in this session.",
+    async run(ctx) {
+      await ctx.chat.clear();
+      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"],
+    description: "Exit the chat.",
+    run() {
+      process.exit(0);
+    }
+  }
+];
 var skillRegistry = {
   researcher,
   coder,
@@ -172,19 +726,34 @@ var skillRegistry = {
   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 [];
+  if (!toolNames) {
+    return [...instantiate("web_search"), ...instantiate("fetch_url")].map(gateTool);
+  }
   const tools = [];
-  for (const name of toolNames.split(",").map((s) => s.trim())) {
+  for (const name of toolNames.split(",").map((s) => s.trim()).filter(Boolean)) {
     switch (name) {
       case "web_search":
-        tools.push(webSearch());
-        break;
+      case "fetch_url":
       case "filesystem":
-        tools.push(...filesystem({ basePath: process.cwd() }));
-        break;
       case "shell":
-        tools.push(shell({ timeout: 3e4 }));
+        tools.push(...instantiate(name));
         break;
       default:
         process.stderr.write(`Unknown tool: ${name}
@@ -224,6 +793,108 @@ function resolveMemory(backend, memoryPath) {
       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 ?? []) {
+        if (call.status === "requires_confirmation" && sessionAllowed.has(call.name) && !autoApprovedRef.current.has(call.id)) {
+          autoApprovedRef.current.add(call.id);
+          void chat.approve(call.id);
+        }
+      }
+    }
+  }, [chat.messages, sessionAllowed, chat.approve]);
+  const handleApproveAlways = (toolCallId, toolName) => {
+    setSessionAllowed((prev) => {
+      if (prev.has(toolName)) return prev;
+      const next = new Set(prev);
+      next.add(toolName);
+      return next;
+    });
+    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 = options.messages.length;
+  const firstUserContent = options.messages.find((m) => m.role === "user")?.content ?? "";
+  useEffect(() => {
+    const sessionId = options.sessionId;
+    if (!sessionId || sessionId === "custom") return;
+    if (!sessionCreatedAtRef.current) {
+      sessionCreatedAtRef.current = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    try {
+      writeSessionMeta({
+        id: sessionId,
+        cwd: process.cwd(),
+        createdAt: sessionCreatedAtRef.current,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        messageCount,
+        preview: derivePreview(options.messages),
+        provider: options.provider,
+        model: options.model
+      });
+    } catch {
+    }
+  }, [options.sessionId, messageCount, firstUserContent, options.provider, options.model]);
+}
 function groupIntoTurns(messages) {
   const turns = [];
   let current = [];
@@ -243,33 +914,121 @@ function groupIntoTurns(messages) {
   return turns;
 }
 function ChatApp(options) {
-  const runtime = useMemo(() => resolveChatProvider(options), [
-    options.apiKey,
-    options.baseUrl,
-    options.model,
-    options.provider
-  ]);
-  const memory = useMemo(
-    () => resolveMemory(options.memoryBackend, options.memoryPath ?? ".agentskit-history.json"),
-    [options.memoryPath, options.memoryBackend]
-  );
-  const tools = useMemo(() => resolveTools(options.tools), [options.tools]);
-  const skills = useMemo(() => {
-    if (!options.skill) return void 0;
-    const names = options.skill.split(",").map((s) => s.trim());
-    const resolved = names.map((n) => skillRegistry[n]).filter(Boolean);
-    if (resolved.length === 0) return void 0;
-    return resolved;
-  }, [options.skill]);
+  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: tools.length > 0 ? tools : void 0,
-    skills
+    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 = options.tools ? options.tools.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  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]
+  );
+  const slashRegistry = useMemo(() => createSlashRegistry(slashCommands), [slashCommands]);
+  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;
+    }
+    const cmd = slashRegistry.get(parsed.name);
+    if (!cmd) {
+      setFeedback({
+        message: `Unknown command: /${parsed.name}. Type /help for the list.`,
+        kind: "error"
+      });
+      return true;
+    }
+    const ctx = {
+      chat,
+      runtime: {
+        provider: runtime.provider,
+        model: runtime.model,
+        mode: runtime.mode,
+        baseUrl,
+        tools: toolsFlag,
+        skill: skillFlag,
+        sessionId: options.sessionId
+      },
+      setProvider,
+      setModel,
+      setApiKey,
+      setBaseUrl,
+      setTools: setToolsFlag,
+      setSkill: setSkillFlag,
+      feedback: (message, kind = "info") => setFeedback({ message, kind }),
+      commands: slashCommands
+    };
+    try {
+      await cmd.run(ctx, parsed.args);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setFeedback({ message: `/${parsed.name} failed: ${message}`, kind: "error" });
+    }
+    return true;
+  };
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", gap: 1, children: [
     /* @__PURE__ */ jsx(
       StatusHeader,
@@ -278,7 +1037,8 @@ function ChatApp(options) {
         model: runtime.model,
         mode: runtime.mode,
         tools: toolNames,
-        messageCount: chat.messages.length
+        messageCount: chat.messages.length,
+        sessionId: options.sessionId
       }
     ),
     /* @__PURE__ */ jsx(ChatContainer, { children: turns.map((turn, turnIdx) => {
@@ -295,7 +1055,18 @@ function ChatApp(options) {
             assistantSteps
           ] }) : null,
           /* @__PURE__ */ jsx(Message, { message }),
-          message.toolCalls?.map((toolCall) => /* @__PURE__ */ jsx(ToolCallView, { toolCall, expanded: true }, toolCall.id))
+          message.toolCalls?.map((toolCall) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsx(ToolCallView, { toolCall, expanded: true }),
+            toolCall.status === "requires_confirmation" && !sessionAllowed.has(toolCall.name) ? /* @__PURE__ */ jsx(
+              ToolConfirmation,
+              {
+                toolCall,
+                onApprove: chat.approve,
+                onDeny: chat.deny,
+                onApproveAlways: handleApproveAlways
+              }
+            ) : null
+          ] }, toolCall.id))
         ] }, message.id);
       }) }, `turn-${turnIdx}`);
     }) }),
@@ -306,9 +1077,38 @@ function ChatApp(options) {
         label: toolNames.length > 0 ? "agent working" : "thinking"
       }
     ),
-    /* @__PURE__ */ jsx(InputBar, { chat, placeholder: "Type a message and press Enter\u2026" })
+    chat.error ? /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: "red", paddingX: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { color: "red", bold: true, children: [
+        "\u2717 ",
+        chat.error.name || "Error"
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: "red", children: chat.error.message })
+    ] }) : null,
+    feedback ? /* @__PURE__ */ jsx(Box, { borderStyle: "round", borderColor: feedbackBorder(feedback.kind), paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: feedbackBorder(feedback.kind), children: feedback.message }) }) : null,
+    /* @__PURE__ */ jsx(
+      InputBar,
+      {
+        chat,
+        placeholder: "Type a message or /help for commands",
+        disabled: awaitingConfirmation,
+        onSubmitInput: handleSubmitInput
+      }
+    )
   ] });
 }
+function feedbackBorder(kind) {
+  switch (kind) {
+    case "error":
+      return "red";
+    case "warn":
+      return "yellow";
+    case "success":
+      return "green";
+    case "info":
+    default:
+      return "cyan";
+  }
+}
 function renderChatHeader(options) {
   const runtime = resolveChatProvider(options);
   const parts = [`provider=${runtime.provider}`];
@@ -319,32 +1119,317 @@ function renderChatHeader(options) {
   if (options.memoryBackend) parts.push(`memory=${options.memoryBackend}`);
   return parts.join(" ");
 }
-var PROVIDER_IMPORT = {
-  openai: "openai",
-  anthropic: "anthropic",
-  gemini: "gemini",
-  ollama: "ollama"
-};
-var PROVIDER_DEFAULT_MODEL = {
-  openai: "gpt-4o-mini",
-  anthropic: "claude-sonnet-4-6",
-  gemini: "gemini-2.5-flash",
-  ollama: "llama3.1",
-  demo: "demo"
-};
-var PROVIDER_ENV_KEY = {
-  openai: "OPENAI_API_KEY",
-  anthropic: "ANTHROPIC_API_KEY",
-  gemini: "GEMINI_API_KEY",
-  ollama: null,
-  demo: null
-};
-function adapterCall(provider, prefix = "process.env") {
-  const model = PROVIDER_DEFAULT_MODEL[provider];
-  if (provider === "demo") return `demoAdapter()`;
-  if (provider === "ollama") return `ollama({ model: '${model}' })`;
-  const envKey = PROVIDER_ENV_KEY[provider];
-  return `${PROVIDER_IMPORT[provider]}({ apiKey: ${prefix}.${envKey} ?? '', model: '${model}' })`;
+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",
+  gemini: "gemini",
+  ollama: "ollama"
+};
+var PROVIDER_DEFAULT_MODEL = {
+  openai: "gpt-4o-mini",
+  anthropic: "claude-sonnet-4-6",
+  gemini: "gemini-2.5-flash",
+  ollama: "llama3.1",
+  demo: "demo"
+};
+var PROVIDER_ENV_KEY = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  gemini: "GEMINI_API_KEY",
+  ollama: null,
+  demo: null
+};
+function adapterCall(provider, prefix = "process.env") {
+  const model = PROVIDER_DEFAULT_MODEL[provider];
+  if (provider === "demo") return `demoAdapter()`;
+  if (provider === "ollama") return `ollama({ model: '${model}' })`;
+  const envKey = PROVIDER_ENV_KEY[provider];
+  return `${PROVIDER_IMPORT[provider]}({ apiKey: ${prefix}.${envKey} ?? '', model: '${model}' })`;
 }
 function viteAdapterCall(provider) {
   if (provider === "demo") return `demoAdapter()`;
@@ -792,62 +1877,6 @@ async function writeStarterProject(options) {
     })
   );
 }
-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",
@@ -907,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",
@@ -917,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 ?? {}
@@ -1179,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");
       }
@@ -1284,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 = 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" }
-      ]
+
+// 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 })
     });
-    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" }
-        ]
-      });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`embedder ${model} HTTP ${res.status}: ${body}`);
     }
-    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;
+    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 = 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")}
-`
-    );
+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");
@@ -1510,38 +2612,8 @@ function RunApp({ task, options }) {
   ] });
 }
 
-// src/commands.ts
-function mergeWithConfig(options, config) {
-  if (!config) return options;
-  return {
-    ...options,
-    // Config defaults — only apply if CLI flag wasn't set
-    provider: options.provider !== "demo" ? options.provider : config.defaults?.provider ?? options.provider,
-    model: options.model ?? config.defaults?.model
-  };
-}
-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>", "Path for file-based memory", ".agentskit-history.json").option("--tools <tools>", "Comma-separated tools: web_search,filesystem,shell").option("--skill <skills>", "Comma-separated skills: researcher,coder,planner,critic,summarizer").option("--memory-backend <backend>", "Memory backend: file (default), sqlite").option("--no-config", "Skip loading .agentskit.config.json").action(async (options) => {
-    const config = options.config !== false ? await loadConfig() : void 0;
-    const merged = mergeWithConfig(options, config);
-    const chatOptions = {
-      apiKey: merged.apiKey ?? options.apiKey,
-      baseUrl: merged.baseUrl ?? options.baseUrl,
-      provider: merged.provider,
-      model: merged.model,
-      system: options.system,
-      memoryPath: options.memory,
-      tools: options.tools,
-      skill: options.skill,
-      memoryBackend: options.memoryBackend,
-      agentsKitConfig: config
-    };
-    process.stdout.write(`${renderChatHeader(chatOptions)}
-`);
-    render(React3.createElement(ChatApp, chatOptions));
-  });
+// 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) {
@@ -1551,7 +2623,7 @@ function createCli() {
     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 });
@@ -1562,6 +2634,137 @@ function createCli() {
       }
     }
   });
+}
+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;
@@ -1595,6 +2798,10 @@ function createCli() {
       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)"
@@ -1611,6 +2818,10 @@ function createCli() {
     }
     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;
@@ -1629,6 +2840,55 @@ function createCli() {
       process.exit(1);
     }
   });
+}
+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 ? 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");
+      return;
+    }
+    if (action !== "init") {
+      process.stderr.write(`Unknown action: ${action}. Use "init" or "show".
+`);
+      process.exit(2);
+    }
+    if (existsSync(targetPath) && !options.force) {
+      process.stderr.write(
+        `Config already exists at ${targetPath}. Re-run with --force to overwrite.
+`
+      );
+      process.exit(1);
+    }
+    const template = {
+      defaults: {
+        provider: "openai",
+        baseUrl: "https://openrouter.ai/api",
+        apiKeyEnv: "OPENROUTER_API_KEY",
+        model: "openai/gpt-oss-120b:free",
+        tools: "web_search,fetch_url"
+      }
+    };
+    mkdirSync(path.dirname(targetPath), { recursive: true });
+    writeFileSync(targetPath, JSON.stringify(template, null, 2) + "\n");
+    process.stdout.write(
+      `Wrote ${targetPath}
+Edit it to taste, then run:
+  agentskit chat
+(flags on the CLI still win over config values.)
+`
+    );
+  });
+}
+
+// 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) {
@@ -1649,9 +2909,62 @@ function createCli() {
       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-CCPJYGHP.js.map
-//# sourceMappingURL=chunk-CCPJYGHP.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