@agentskit/cli 0.5.3 → 0.7.0

package/dist/bin.cjs

@@ -1,42 +1,46 @@
 #!/usr/bin/env node
 'use strict';
 
-var React3 = require('react');
-var ink = require('ink');
 var commander = require('commander');
-var path = require('path');
+var React2 = require('react');
+var ink = require('ink');
 var promises = require('fs/promises');
+var os = require('os');
+var path = require('path');
 var ink$1 = require('@agentskit/ink');
 var adapters = require('@agentskit/adapters');
+var crypto = require('crypto');
+var fs = require('fs');
 var tools = require('@agentskit/tools');
 var skills = require('@agentskit/skills');
 var memory = require('@agentskit/memory');
+var child_process = require('child_process');
 var jsxRuntime = require('react/jsx-runtime');
+var url = require('url');
+var runtime = require('@agentskit/runtime');
 var prompts = require('@inquirer/prompts');
 var kleur = require('kleur');
-var fs = require('fs');
-var runtime = require('@agentskit/runtime');
-var child_process = require('child_process');
 var chokidar = require('chokidar');
+var rag = require('@agentskit/rag');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var React3__default = /*#__PURE__*/_interopDefault(React3);
+var React2__default = /*#__PURE__*/_interopDefault(React2);
 var path__default = /*#__PURE__*/_interopDefault(path);
 var kleur__default = /*#__PURE__*/_interopDefault(kleur);
 var chokidar__default = /*#__PURE__*/_interopDefault(chokidar);
 
-async function loadJsonConfig(path4) {
+async function loadJsonConfig(path5) {
   try {
-    const raw = await promises.readFile(path4, "utf8");
+    const raw = await promises.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;
@@ -54,16 +58,38 @@ async function loadPackageJsonConfig(dir) {
     return void 0;
   }
 }
-async function loadConfig(options) {
-  const cwd = path.resolve(process.cwd());
-  const tsPath = path.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(path.join(cwd, ".agentskit.config.ts"));
   if (tsConfig) return tsConfig;
-  const jsonPath = path.join(cwd, ".agentskit.config.json");
-  const jsonConfig = await loadJsonConfig(jsonPath);
+  const jsonConfig = await loadJsonConfig(path.join(cwd, ".agentskit.config.json"));
   if (jsonConfig) return jsonConfig;
   return await loadPackageJsonConfig(cwd);
 }
+async function loadGlobalConfig(home) {
+  const globalDir = path.join(os.homedir(), ".agentskit");
+  const tsConfig = await loadTsConfig(path.join(globalDir, "config.ts"));
+  if (tsConfig) return tsConfig;
+  return await loadJsonConfig(path.join(globalDir, "config.json"));
+}
+async function loadConfig(options) {
+  const cwd = path.resolve(process.cwd());
+  const global = await loadGlobalConfig();
+  const local = await loadLocalConfig(cwd);
+  return mergeConfigs(global, local);
+}
 var providers = {
   openai: {
     label: "OpenAI",
@@ -123,7 +149,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" };
@@ -174,159 +200,1461 @@ function resolveChatProvider(options) {
     summary: `${entry.label} live adapter`
   };
 }
-var skillRegistry = {
-  researcher: skills.researcher,
-  coder: skills.coder,
-  planner: skills.planner,
-  critic: skills.critic,
-  summarizer: skills.summarizer
-};
-function resolveTools(toolNames) {
-  if (!toolNames) return [];
-  const tools$1 = [];
-  for (const name of toolNames.split(",").map((s) => s.trim())) {
-    switch (name) {
-      case "web_search":
-        tools$1.push(tools.webSearch());
-        break;
-      case "filesystem":
-        tools$1.push(...tools.filesystem({ basePath: process.cwd() }));
-        break;
-      case "shell":
-        tools$1.push(tools.shell({ timeout: 3e4 }));
-        break;
-      default:
-        process.stderr.write(`Unknown tool: ${name}
-`);
+var ROOT = path.join(os.homedir(), ".agentskit", "sessions");
+var META_SUFFIX = ".meta.json";
+function cwdHash(cwd = process.cwd()) {
+  return crypto.createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+}
+function dirFor(cwd = process.cwd()) {
+  return path.join(ROOT, cwdHash(cwd));
+}
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+function generateSessionId() {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const suffix = crypto.randomBytes(3).toString("hex");
+  return `${ts}-${suffix}`;
+}
+function sessionFilePath(id, cwd = process.cwd()) {
+  ensureDir(dirFor(cwd));
+  return path.join(dirFor(cwd), `${id}.json`);
+}
+function metaPath(id, cwd = process.cwd()) {
+  return path.join(dirFor(cwd), `${id}${META_SUFFIX}`);
+}
+function readMeta(id, cwd = process.cwd()) {
+  const path5 = metaPath(id, cwd);
+  if (!fs.existsSync(path5)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(path5, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeSessionMeta(meta, cwd = process.cwd()) {
+  ensureDir(dirFor(cwd));
+  fs.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 (!fs.existsSync(dir)) return [];
+  const entries = fs.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 = path.join(dir, entry);
+    if (meta) {
+      records.push({ metadata: meta, file });
+    } else {
+      const stats = fs.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 (fs.existsSync(record.file)) {
+    fs.writeFileSync(newFile, fs.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: !fs.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 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/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: skills.researcher,
+  coder: skills.coder,
+  planner: skills.planner,
+  critic: skills.critic,
+  summarizer: skills.summarizer
+};
+function instantiate(kind) {
+  switch (kind) {
+    case "web_search":
+      return [tools.webSearch()];
+    case "fetch_url":
+      return [tools.fetchUrl()];
+    case "filesystem":
+      return tools.filesystem({ basePath: process.cwd() });
+    case "shell":
+      return [tools.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 skills.composeSkills(...resolved);
+}
+function resolveMemory(backend, memoryPath) {
+  switch (backend) {
+    case "sqlite":
+      return memory.sqliteChatMemory({ path: memoryPath.replace(/\.json$/, ".db") });
+    case "file":
+    default:
+      return memory.fileChatMemory(memoryPath);
+  }
+}
+
+// src/extensibility/permissions/policy.ts
+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/runtime/use-runtime.ts
+function useRuntime(options) {
+  const [provider, setProvider] = React2.useState(options.provider);
+  const [model, setModel] = React2.useState(options.model);
+  const [apiKey, setApiKey] = React2.useState(options.apiKey);
+  const [baseUrl, setBaseUrl] = React2.useState(options.baseUrl);
+  const [toolsFlag, setToolsFlag] = React2.useState(options.tools);
+  const [skillFlag, setSkillFlag] = React2.useState(options.skill);
+  const runtime = React2.useMemo(
+    () => resolveChatProvider({ provider, model, apiKey, baseUrl }),
+    [provider, model, apiKey, baseUrl]
+  );
+  const memory = React2.useMemo(
+    () => resolveMemory(options.memoryBackend, options.memoryPath ?? ".agentskit-history.json"),
+    [options.memoryPath, options.memoryBackend]
+  );
+  const tools = React2.useMemo(() => {
+    const resolved = resolveTools(toolsFlag);
+    if (!options.permissionPolicy) return resolved;
+    return applyPolicyToTools(options.permissionPolicy, resolved);
+  }, [toolsFlag, options.permissionPolicy]);
+  const skills = React2.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] = React2.useState(/* @__PURE__ */ new Set());
+  const autoApprovedRef = React2.useRef(/* @__PURE__ */ new Set());
+  React2.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 = React2.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 = React2.useRef(void 0);
+  const messageCount = options.messages.length;
+  const firstUserContent = options.messages.find((m) => m.role === "user")?.content ?? "";
+  React2.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]);
+}
+
+// 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 = child_process.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 {
+    }
+  });
+}
+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 = React2.useMemo(() => {
+    const extra = options.extraTools ?? [];
+    return [...tools, ...extra];
+  }, [tools, options.extraTools]);
+  const mergedSkills = React2.useMemo(() => {
+    const extra = options.extraSkills ?? [];
+    if (!skills && extra.length === 0) return void 0;
+    return [...skills ?? [], ...extra];
+  }, [skills, options.extraSkills]);
+  const chat = ink$1.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 = React2.useMemo(() => groupIntoTurns(chat.messages), [chat.messages]);
+  const toolNames = toolsFlag ? toolsFlag.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  const [feedback, setFeedback] = React2.useState(null);
+  const hookDispatcher = React2.useMemo(
+    () => new HookDispatcher(options.hookHandlers ?? []),
+    [options.hookHandlers]
+  );
+  React2.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 = React2.useMemo(
+    () => [...builtinSlashCommands, ...options.slashCommands ?? []],
+    [options.slashCommands]
+  );
+  const slashRegistry = React2.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__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      ink$1.StatusHeader,
+      {
+        provider: runtime.provider,
+        model: runtime.model,
+        mode: runtime.mode,
+        tools: toolNames,
+        messageCount: chat.messages.length,
+        sessionId: options.sessionId
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(ink$1.ChatContainer, { children: turns.map((turn, turnIdx) => {
+      const assistantSteps = turn.filter((m) => m.role === "assistant").length;
+      let stepIndex = 0;
+      return /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { flexDirection: "column", gap: 1, children: turn.map((message) => {
+        const showStep = message.role === "assistant" && assistantSteps > 1;
+        if (showStep) stepIndex++;
+        return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
+          showStep ? /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { dimColor: true, children: [
+            "\u21BB step ",
+            stepIndex,
+            "/",
+            assistantSteps
+          ] }) : null,
+          /* @__PURE__ */ jsxRuntime.jsx(ink$1.Message, { message }),
+          message.toolCalls?.map((toolCall) => /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(ink$1.ToolCallView, { toolCall, expanded: true }),
+            toolCall.status === "requires_confirmation" && !sessionAllowed.has(toolCall.name) ? /* @__PURE__ */ jsxRuntime.jsx(
+              ink$1.ToolConfirmation,
+              {
+                toolCall,
+                onApprove: chat.approve,
+                onDeny: chat.deny,
+                onApproveAlways: handleApproveAlways
+              }
+            ) : null
+          ] }, toolCall.id))
+        ] }, message.id);
+      }) }, `turn-${turnIdx}`);
+    }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      ink$1.ThinkingIndicator,
+      {
+        visible: chat.status === "streaming",
+        label: toolNames.length > 0 ? "agent working" : "thinking"
+      }
+    ),
+    chat.error ? /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { borderStyle: "round", borderColor: "red", paddingX: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "red", bold: true, children: [
+        "\u2717 ",
+        chat.error.name || "Error"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "red", children: chat.error.message })
+    ] }) : null,
+    feedback ? /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { borderStyle: "round", borderColor: feedbackBorder(feedback.kind), paddingX: 1, children: /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: feedbackBorder(feedback.kind), children: feedback.message }) }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx(
+      ink$1.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}`];
+  if (runtime.model) parts.push(`model=${runtime.model}`);
+  parts.push(`mode=${runtime.mode}`);
+  if (options.tools) parts.push(`tools=${options.tools}`);
+  if (options.skill) parts.push(`skill=${options.skill}`);
+  if (options.memoryBackend) parts.push(`memory=${options.memoryBackend}`);
+  return parts.join(" ");
+}
+
+// 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
+  };
+}
+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(path.join(os.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 promises.readdir(dir);
+    const absolutes = entries.filter((name) => /\.(m?js|ts)$/i.test(name)).map((name) => path.join(dir, name));
+    const validated = [];
+    for (const p of absolutes) {
+      try {
+        const s = await promises.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("../") || path.isAbsolute(spec);
+  const importTarget = isPath ? url.pathToFileURL(path.resolve(cwd, spec)).href : spec;
+  const mod = await import(importTarget);
+  const exported = mod.default ?? mod.plugin ?? mod;
+  const sourcePath = isPath ? path.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 = child_process.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();
+}
+
+// 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)}
+`);
+    const instance = ink.render(React2__default.default.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 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$1 = runtime.createRuntime({
+    adapter,
+    tools,
+    memory,
+    systemPrompt: options.systemPrompt,
+    maxSteps: options.maxSteps ? parseInt(options.maxSteps, 10) : void 0,
+    observers
+  });
+  const result = await runtime$1.run(task, {
+    skill: skill ?? void 0
+  });
+  process.stdout.write(result.content + "\n");
+}
+function RunApp({ task, options }) {
+  const [status, setStatus] = React2.useState("running");
+  const [currentStep, setCurrentStep] = React2.useState(0);
+  const [toolCalls, setToolCalls] = React2.useState([]);
+  const [result, setResult] = React2.useState("");
+  const [error, setError] = React2.useState("");
+  const [durationMs, setDurationMs] = React2.useState(0);
+  React2.useEffect(() => {
+    async function execute() {
+      if (options.skill && options.skills) {
+        setError("--skill and --skills are mutually exclusive.");
+        setStatus("error");
+        return;
+      }
+      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 = [{
+        name: "run-ui",
+        on(event) {
+          switch (event.type) {
+            case "agent:step":
+              setCurrentStep(event.step);
+              break;
+            case "tool:start":
+              setToolCalls((prev) => [...prev, { name: event.name, status: "running" }]);
+              break;
+            case "tool:end":
+              setToolCalls((prev) => prev.map(
+                (tc) => tc.name === event.name && tc.status === "running" ? { ...tc, status: "done", durationMs: event.durationMs } : tc
+              ));
+              break;
+            case "error":
+              setToolCalls((prev) => prev.map(
+                (tc) => tc.status === "running" ? { ...tc, status: "error" } : tc
+              ));
+              break;
+          }
+        }
+      }];
+      const runtime$1 = runtime.createRuntime({
+        adapter,
+        tools,
+        memory,
+        systemPrompt: options.systemPrompt,
+        maxSteps: options.maxSteps ? parseInt(options.maxSteps, 10) : void 0,
+        observers
+      });
+      try {
+        const runResult = await runtime$1.run(task, { skill: skill ?? void 0 });
+        setResult(runResult.content);
+        setDurationMs(runResult.durationMs);
+        setStatus("done");
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setStatus("error");
+      }
+    }
+    void execute();
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, color: "cyan", children: "agentskit run" }),
+    /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { dimColor: true, children: [
+      "Task: ",
+      task
+    ] }),
+    status === "running" && currentStep > 0 && /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "yellow", children: [
+      "\u27F3",
+      " Step ",
+      currentStep
+    ] }),
+    toolCalls.map((tc, i) => /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { marginLeft: 2, children: /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: tc.status === "running" ? "yellow" : tc.status === "done" ? "green" : "red", children: [
+      tc.status === "running" ? "\u27F3" : tc.status === "done" ? "\u2713" : "\u2717",
+      " ",
+      tc.name,
+      tc.durationMs !== void 0 ? ` (${tc.durationMs}ms)` : ""
+    ] }) }, i)),
+    status === "running" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "yellow", children: "Running..." }),
+    status === "done" && /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "green", bold: true, children: [
+        "Done (",
+        durationMs,
+        "ms)"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { children: result })
+    ] }),
+    status === "error" && /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "red", bold: true, children: [
+      "Error: ",
+      error
+    ] })
+  ] });
+}
+
+// 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) {
+      process.stderr.write("Error: task is required. Pass as argument or use --task.\n");
+      process.exit(1);
     }
-  }
-  return tools$1;
-}
-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 skills.composeSkills(...resolved);
-}
-function resolveMemory(backend, memoryPath) {
-  switch (backend) {
-    case "sqlite":
-      return memory.sqliteChatMemory({ path: memoryPath.replace(/\.json$/, ".db") });
-    case "file":
-    default:
-      return memory.fileChatMemory(memoryPath);
-  }
-}
-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 = [];
+    const config = options.config !== false ? await loadConfig() : void 0;
+    const merged = mergeWithConfig(options, config);
+    if (options.pretty) {
+      ink.render(React2__default.default.createElement(RunApp, { task, options }));
     } else {
-      current.push(message);
+      try {
+        await runAgent(task, { ...options, provider: merged.provider, model: merged.model });
+      } catch (err) {
+        process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+        process.exit(1);
+      }
     }
-  }
-  if (current.length > 0) turns.push(current);
-  return turns;
-}
-function ChatApp(options) {
-  const runtime = React3.useMemo(() => resolveChatProvider(options), [
-    options.apiKey,
-    options.baseUrl,
-    options.model,
-    options.provider
-  ]);
-  const memory = React3.useMemo(
-    () => resolveMemory(options.memoryBackend, options.memoryPath ?? ".agentskit-history.json"),
-    [options.memoryPath, options.memoryBackend]
-  );
-  const tools = React3.useMemo(() => resolveTools(options.tools), [options.tools]);
-  const skills = React3.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 chat = ink$1.useChat({
-    adapter: runtime.adapter,
-    memory,
-    systemPrompt: options.system,
-    tools: tools.length > 0 ? tools : void 0,
-    skills
   });
-  const turns = React3.useMemo(() => groupIntoTurns(chat.messages), [chat.messages]);
-  const toolNames = options.tools ? options.tools.split(",").map((s) => s.trim()).filter(Boolean) : [];
-  return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", gap: 1, children: [
-    /* @__PURE__ */ jsxRuntime.jsx(
-      ink$1.StatusHeader,
-      {
-        provider: runtime.provider,
-        model: runtime.model,
-        mode: runtime.mode,
-        tools: toolNames,
-        messageCount: chat.messages.length
-      }
-    ),
-    /* @__PURE__ */ jsxRuntime.jsx(ink$1.ChatContainer, { children: turns.map((turn, turnIdx) => {
-      const assistantSteps = turn.filter((m) => m.role === "assistant").length;
-      let stepIndex = 0;
-      return /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { flexDirection: "column", gap: 1, children: turn.map((message) => {
-        const showStep = message.role === "assistant" && assistantSteps > 1;
-        if (showStep) stepIndex++;
-        return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-          showStep ? /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { dimColor: true, children: [
-            "\u21BB step ",
-            stepIndex,
-            "/",
-            assistantSteps
-          ] }) : null,
-          /* @__PURE__ */ jsxRuntime.jsx(ink$1.Message, { message }),
-          message.toolCalls?.map((toolCall) => /* @__PURE__ */ jsxRuntime.jsx(ink$1.ToolCallView, { toolCall, expanded: true }, toolCall.id))
-        ] }, message.id);
-      }) }, `turn-${turnIdx}`);
-    }) }),
-    /* @__PURE__ */ jsxRuntime.jsx(
-      ink$1.ThinkingIndicator,
-      {
-        visible: chat.status === "streaming",
-        label: toolNames.length > 0 ? "agent working" : "thinking"
-      }
-    ),
-    /* @__PURE__ */ jsxRuntime.jsx(ink$1.InputBar, { chat, placeholder: "Type a message and press Enter\u2026" })
-  ] });
-}
-function renderChatHeader(options) {
-  const runtime = resolveChatProvider(options);
-  const parts = [`provider=${runtime.provider}`];
-  if (runtime.model) parts.push(`model=${runtime.model}`);
-  parts.push(`mode=${runtime.mode}`);
-  if (options.tools) parts.push(`tools=${options.tools}`);
-  if (options.skill) parts.push(`skill=${options.skill}`);
-  if (options.memoryBackend) parts.push(`memory=${options.memoryBackend}`);
-  return parts.join(" ");
 }
 var PROVIDER_IMPORT = {
   openai: "openai",
@@ -928,159 +2256,42 @@ function printNextSteps(options) {
 `);
   process.stdout.write(kleur__default.default.dim("  Docs: https://www.agentskit.io/docs\n\n"));
 }
-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$1 = runtime.createRuntime({
-    adapter,
-    tools,
-    memory,
-    systemPrompt: options.systemPrompt,
-    maxSteps: options.maxSteps ? parseInt(options.maxSteps, 10) : void 0,
-    observers
-  });
-  const result = await runtime$1.run(task, {
-    skill: skill ?? void 0
-  });
-  process.stdout.write(result.content + "\n");
-}
-function RunApp({ task, options }) {
-  const [status, setStatus] = React3.useState("running");
-  const [currentStep, setCurrentStep] = React3.useState(0);
-  const [toolCalls, setToolCalls] = React3.useState([]);
-  const [result, setResult] = React3.useState("");
-  const [error, setError] = React3.useState("");
-  const [durationMs, setDurationMs] = React3.useState(0);
-  React3.useEffect(() => {
-    async function execute() {
-      if (options.skill && options.skills) {
-        setError("--skill and --skills are mutually exclusive.");
-        setStatus("error");
-        return;
-      }
-      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 = [{
-        name: "run-ui",
-        on(event) {
-          switch (event.type) {
-            case "agent:step":
-              setCurrentStep(event.step);
-              break;
-            case "tool:start":
-              setToolCalls((prev) => [...prev, { name: event.name, status: "running" }]);
-              break;
-            case "tool:end":
-              setToolCalls((prev) => prev.map(
-                (tc) => tc.name === event.name && tc.status === "running" ? { ...tc, status: "done", durationMs: event.durationMs } : tc
-              ));
-              break;
-            case "error":
-              setToolCalls((prev) => prev.map(
-                (tc) => tc.status === "running" ? { ...tc, status: "error" } : tc
-              ));
-              break;
-          }
-        }
-      }];
-      const runtime$1 = runtime.createRuntime({
-        adapter,
-        tools,
-        memory,
-        systemPrompt: options.systemPrompt,
-        maxSteps: options.maxSteps ? parseInt(options.maxSteps, 10) : void 0,
-        observers
+
+// 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: path__default.default.resolve(process.cwd(), rawOptions.dir),
+        template,
+        provider: rawOptions.provider ?? "demo",
+        tools: rawOptions.tools ? rawOptions.tools.split(",").map((t) => t.trim()) : [],
+        memory: rawOptions.memory ?? "none",
+        packageManager: rawOptions.pm ?? "pnpm"
+      };
+    } else {
+      const result = await runInteractiveInit({
+        dir: rawOptions.dir,
+        template: rawOptions.template
       });
-      try {
-        const runResult = await runtime$1.run(task, { skill: skill ?? void 0 });
-        setResult(runResult.content);
-        setDurationMs(runResult.durationMs);
-        setStatus("done");
-      } catch (err) {
-        setError(err instanceof Error ? err.message : String(err));
-        setStatus("error");
+      if (result.cancelled) {
+        process.exit(0);
       }
+      resolved = result.options;
     }
-    void execute();
-  }, []);
-  return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", gap: 1, children: [
-    /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, color: "cyan", children: "agentskit run" }),
-    /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { dimColor: true, children: [
-      "Task: ",
-      task
-    ] }),
-    status === "running" && currentStep > 0 && /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "yellow", children: [
-      "\u27F3",
-      " Step ",
-      currentStep
-    ] }),
-    toolCalls.map((tc, i) => /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { marginLeft: 2, children: /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: tc.status === "running" ? "yellow" : tc.status === "done" ? "green" : "red", children: [
-      tc.status === "running" ? "\u27F3" : tc.status === "done" ? "\u2713" : "\u2717",
-      " ",
-      tc.name,
-      tc.durationMs !== void 0 ? ` (${tc.durationMs}ms)` : ""
-    ] }) }, i)),
-    status === "running" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "yellow", children: "Running..." }),
-    status === "done" && /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "green", bold: true, children: [
-        "Done (",
-        durationMs,
-        "ms)"
-      ] }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { children: result })
-    ] }),
-    status === "error" && /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "red", bold: true, children: [
-      "Error: ",
-      error
-    ] })
-  ] });
+    await writeStarterProject(resolved);
+    if (isCi) {
+      process.stdout.write(
+        `Created ${resolved.template} starter in ${path__default.default.relative(process.cwd(), resolved.targetDir) || "."}
+`
+      );
+    } else {
+      printNextSteps(resolved);
+    }
+  });
 }
 var PROVIDER_ENV_KEYS = {
   openai: "OPENAI_API_KEY",
@@ -1141,8 +2352,8 @@ async function checkPnpm() {
   };
 }
 async function checkPackageJson() {
-  const path4 = path.join(process.cwd(), "package.json");
-  if (!fs.existsSync(path4)) {
+  const path5 = path.join(process.cwd(), "package.json");
+  if (!fs.existsSync(path5)) {
     return {
       status: "warn",
       name: "package.json",
@@ -1151,7 +2362,7 @@ async function checkPackageJson() {
     };
   }
   try {
-    const pkg = JSON.parse(await promises.readFile(path4, "utf8"));
+    const pkg = JSON.parse(await promises.readFile(path5, "utf8"));
     const deps = {
       ...pkg.dependencies ?? {},
       ...pkg.devDependencies ?? {}
@@ -1347,6 +2558,26 @@ function renderReport(report, opts = {}) {
   lines.push("");
   return lines.join("\n");
 }
+
+// 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)"
+  ).option("--json", "Emit JSON instead of formatted output").action(async (options) => {
+    const providers2 = options.providers ? options.providers.split(",").map((p) => p.trim()).filter(Boolean) : void 0;
+    const report = await runDoctor({
+      providers: providers2,
+      noNetwork: options.network === false
+    });
+    if (options.json) {
+      process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    } else {
+      process.stdout.write(renderReport(report, { color: process.stdout.isTTY }));
+    }
+    if (report.fail > 0) process.exit(1);
+  });
+}
 var DEFAULT_WATCH = [
   "**/*.ts",
   "**/*.tsx",
@@ -1413,11 +2644,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");
       }
@@ -1454,6 +2685,73 @@ function startDev(options) {
     restarts: () => restartCount
   };
 }
+
+// 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;
+    const ignore = options.ignore ? options.ignore.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+    try {
+      const controller = startDev({
+        entry,
+        watch,
+        ignore,
+        debounceMs: Number(options.debounce) || 200
+      });
+      await controller.done;
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}
+`);
+      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__default.default.join(process.cwd(), ".agentskit.config.json") : path__default.default.join(os.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 (fs.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"
+      }
+    };
+    fs.mkdirSync(path__default.default.dirname(targetPath), { recursive: true });
+    fs.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.)
+`
+    );
+  });
+}
 async function startTunnel(options) {
   const stdout = options.stdout ?? process.stdout;
   const open = options.open ?? (async (opts) => {
@@ -1519,125 +2817,8 @@ async function startTunnel(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 commander.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)}
-`);
-    ink.render(React3__default.default.createElement(ChatApp, chatOptions));
-  });
-  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) {
-      process.stderr.write("Error: task is required. Pass as argument or use --task.\n");
-      process.exit(1);
-    }
-    const config = options.config !== false ? await loadConfig() : void 0;
-    const merged = mergeWithConfig(options, config);
-    if (options.pretty) {
-      ink.render(React3__default.default.createElement(RunApp, { task, options }));
-    } else {
-      try {
-        await runAgent(task, { ...options, provider: merged.provider, model: merged.model });
-      } catch (err) {
-        process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
-`);
-        process.exit(1);
-      }
-    }
-  });
-  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: path__default.default.resolve(process.cwd(), rawOptions.dir),
-        template,
-        provider: rawOptions.provider ?? "demo",
-        tools: rawOptions.tools ? rawOptions.tools.split(",").map((t) => t.trim()) : [],
-        memory: rawOptions.memory ?? "none",
-        packageManager: rawOptions.pm ?? "pnpm"
-      };
-    } else {
-      const result = await runInteractiveInit({
-        dir: rawOptions.dir,
-        template: rawOptions.template
-      });
-      if (result.cancelled) {
-        process.exit(0);
-      }
-      resolved = result.options;
-    }
-    await writeStarterProject(resolved);
-    if (isCi) {
-      process.stdout.write(
-        `Created ${resolved.template} starter in ${path__default.default.relative(process.cwd(), resolved.targetDir) || "."}
-`
-      );
-    } else {
-      printNextSteps(resolved);
-    }
-  });
-  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)"
-  ).option("--json", "Emit JSON instead of formatted output").action(async (options) => {
-    const providers2 = options.providers ? options.providers.split(",").map((p) => p.trim()).filter(Boolean) : void 0;
-    const report = await runDoctor({
-      providers: providers2,
-      noNetwork: options.network === false
-    });
-    if (options.json) {
-      process.stdout.write(JSON.stringify(report, null, 2) + "\n");
-    } else {
-      process.stdout.write(renderReport(report, { color: process.stdout.isTTY }));
-    }
-    if (report.fail > 0) process.exit(1);
-  });
-  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;
-    const ignore = options.ignore ? options.ignore.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
-    try {
-      const controller = startDev({
-        entry,
-        watch,
-        ignore,
-        debounceMs: Number(options.debounce) || 200
-      });
-      await controller.done;
-    } catch (err) {
-      process.stderr.write(`Error: ${err.message}
-`);
-      process.exit(1);
-    }
-  });
+// 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) {
@@ -1658,6 +2839,130 @@ function createCli() {
       process.exit(1);
     }
   });
+}
+
+// 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}`);
+    }
+    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 buildRagFromConfig(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const dir = path.resolve(cwd, options.config.dir ?? "./.agentskit-rag");
+  const store = memory.fileVectorMemory({ path: `${dir}/store.json` });
+  const embed = options.embedder ?? resolveEmbedder(options.config);
+  return rag.createRAG({
+    embed,
+    store,
+    chunkSize: options.config.chunkSize,
+    topK: options.config.topK
+  });
+}
+async function indexSources(rag, config, cwd) {
+  const root = process.cwd();
+  const sources = config.sources ?? [];
+  const absolutePaths = [];
+  for (const pattern of sources) {
+    for await (const match of promises.glob(pattern, { cwd: root })) {
+      absolutePaths.push(path.resolve(root, match));
+    }
+  }
+  const documents = await Promise.all(
+    absolutePaths.map(async (path5) => ({
+      id: path5,
+      content: await promises.readFile(path5, "utf8"),
+      source: path5
+    }))
+  );
+  if (documents.length > 0) await rag.ingest(documents);
+  return { documentCount: documents.length, sources: absolutePaths };
+}
+
+// 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 commander.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;
 }