@alejandroroman/agent-kit 0.1.3 → 0.2.0

package/dist/cli/slack-setup.js

@@ -0,0 +1,234 @@
+import * as path from "path";
+import { execFileSync } from "child_process";
+import * as p from "@clack/prompts";
+import { isCancel } from "./ui.js";
+import { upsertEnvKey, loadEnvFile } from "./env.js";
+import { readRawConfig, writeConfig } from "./config-writer.js";
+import { loadConfig } from "../config/index.js";
+const SLACK_MANIFEST = `display_information:
+  name: Agent Kit
+settings:
+  socket_mode_enabled: true
+features:
+  bot_user:
+    display_name: Agent Kit
+    always_online: true
+  event_subscriptions:
+    bot_events:
+      - message.channels
+      - message.groups
+oauth_config:
+  scopes:
+    bot:
+      - chat:write
+      - channels:history
+      - channels:read
+      - groups:history
+      - groups:read`;
+function openBrowser(url) {
+    try {
+        const cmd = process.platform === "darwin" ? "open"
+            : process.platform === "win32" ? "start"
+                : "xdg-open";
+        execFileSync(cmd, [url], { stdio: "ignore" });
+    }
+    catch {
+        p.log.warn(`Could not open browser. Visit: ${url}`);
+    }
+}
+export async function setupSlack(opts) {
+    const envPath = path.join(process.cwd(), ".env");
+    // 1. Opt-in (only during init)
+    if (opts.fromInit) {
+        const wantSlack = await p.confirm({
+            message: "Would you like to connect Slack?",
+        });
+        if (isCancel(wantSlack) || !wantSlack)
+            return;
+    }
+    // Check for existing tokens
+    const existingEnv = loadEnvFile(envPath);
+    const hasAppToken = !!existingEnv.SLACK_APP_TOKEN;
+    const hasBotToken = !!existingEnv.SLACK_BOT_TOKEN;
+    let skipTokens = false;
+    if (hasAppToken && hasBotToken) {
+        const keep = await p.confirm({
+            message: "Slack tokens already exist in .env. Keep them?",
+        });
+        if (isCancel(keep))
+            return;
+        if (keep) {
+            skipTokens = true;
+            process.env.SLACK_APP_TOKEN ??= existingEnv.SLACK_APP_TOKEN;
+            process.env.SLACK_BOT_TOKEN ??= existingEnv.SLACK_BOT_TOKEN;
+            p.log.info("Using existing tokens from .env");
+        }
+    }
+    // 2. Instructions — Create App
+    if (!skipTokens) {
+        p.log.step("Step 1: Create Slack App");
+        console.log();
+        console.log("  Go to api.slack.com/apps → Create New App → From a manifest");
+        console.log();
+        const openPage = await p.confirm({
+            message: "Open api.slack.com in your browser?",
+        });
+        if (!isCancel(openPage) && openPage) {
+            openBrowser("https://api.slack.com/apps");
+        }
+        console.log();
+        console.log("  Select your workspace, then paste this manifest:");
+        console.log();
+        for (const line of SLACK_MANIFEST.split("\n")) {
+            console.log(`    ${line}`);
+        }
+        console.log();
+        console.log("  Click Create.");
+        console.log();
+        // 3. Instructions — App Token
+        p.log.step("Step 2: Generate App-Level Token");
+        console.log();
+        console.log("  Settings → Basic Information → App-Level Tokens");
+        console.log("  Click 'Generate Token and Scopes'");
+        console.log("  Name: socket-mode  |  Scope: connections:write");
+        console.log("  Copy the xapp-... token");
+        console.log();
+        // 4. Collect App Token
+        const appToken = await p.password({
+            message: "Paste App Token (xapp-...):",
+            validate: (val) => {
+                if (!val?.trim())
+                    return "App token is required";
+                if (!val.startsWith("xapp-"))
+                    return "Token should start with xapp-";
+            },
+        });
+        if (isCancel(appToken))
+            return;
+        upsertEnvKey(envPath, "SLACK_APP_TOKEN", appToken.trim());
+        process.env.SLACK_APP_TOKEN = appToken.trim();
+        p.log.success("App token saved to .env");
+        // 5. Instructions — Bot Token
+        p.log.step("Step 3: Install to Workspace");
+        console.log();
+        console.log("  Settings → Install App → Install to Workspace");
+        console.log("  Authorize, then copy the Bot User OAuth Token (xoxb-...)");
+        console.log();
+        // 6. Collect Bot Token
+        const botToken = await p.password({
+            message: "Paste Bot Token (xoxb-...):",
+            validate: (val) => {
+                if (!val?.trim())
+                    return "Bot token is required";
+                if (!val.startsWith("xoxb-"))
+                    return "Token should start with xoxb-";
+            },
+        });
+        if (isCancel(botToken))
+            return;
+        upsertEnvKey(envPath, "SLACK_BOT_TOKEN", botToken.trim());
+        process.env.SLACK_BOT_TOKEN = botToken.trim();
+        p.log.success("Bot token saved to .env");
+    } // end if (!skipTokens)
+    // 7. Channel Binding
+    let config;
+    try {
+        config = loadConfig(opts.configPath);
+    }
+    catch (err) {
+        p.log.error(`Could not load config: ${err instanceof Error ? err.message : err}`);
+        p.log.info("Slack tokens were saved to .env. Run `agent-kit slack-setup` again after fixing your config.");
+        return;
+    }
+    const agentNames = Object.keys(config.agents);
+    if (agentNames.length === 0) {
+        p.log.info("No agents configured yet. Run `agent-kit create` first, then `agent-kit slack-setup` to bind channels.");
+    }
+    else {
+        p.log.step("Step 4: Connect agents to Slack channels");
+        console.log();
+        console.log("  Create channels in Slack, then invite the bot: /invite @Agent Kit");
+        console.log("  Get channel IDs: right-click channel → View channel details → copy ID (starts with C)");
+        console.log();
+        const raw = readRawConfig(opts.configPath);
+        if (!raw) {
+            p.log.error("Could not read agent-kit.json");
+            return;
+        }
+        const agents = raw.agents;
+        if (!agents) {
+            p.log.error("No agents section in config");
+            return;
+        }
+        const usedChannels = new Map(); // channelId → agentName
+        // Collect already-bound channels
+        for (const [name, def] of Object.entries(agents)) {
+            const slack = def.slack;
+            if (slack?.channelId) {
+                usedChannels.set(slack.channelId, name);
+            }
+        }
+        for (const name of agentNames) {
+            const agentDef = config.agents[name];
+            const emoji = agentDef.emoji ?? " ";
+            const display = agentDef.displayName ?? name;
+            // Skip if already bound
+            if (agentDef.slack) {
+                p.log.info(`${emoji}  ${display} — already bound to ${agentDef.slack.channelName}`);
+                continue;
+            }
+            const bind = await p.confirm({
+                message: `Connect ${emoji}  ${display} to a Slack channel?`,
+            });
+            if (isCancel(bind))
+                return;
+            if (!bind)
+                continue;
+            const channelId = await p.text({
+                message: "Channel ID (e.g. C0123456789):",
+                validate: (val) => {
+                    if (!val?.trim())
+                        return "Channel ID is required";
+                    if (!/^[CG][A-Z0-9]{8,}$/.test(val.trim())) {
+                        return "Channel ID should start with C or G followed by uppercase letters/numbers";
+                    }
+                    const existing = usedChannels.get(val.trim());
+                    if (existing) {
+                        return `Channel already bound to agent "${existing}"`;
+                    }
+                },
+            });
+            if (isCancel(channelId))
+                return;
+            const channelName = await p.text({
+                message: "Channel name (e.g. #finances):",
+                validate: (val) => {
+                    if (!val?.trim())
+                        return "Channel name is required";
+                },
+            });
+            if (isCancel(channelName))
+                return;
+            const id = channelId.trim();
+            const cName = channelName.trim();
+            // Update raw config
+            agents[name] = {
+                ...agents[name],
+                slack: { channelId: id, channelName: cName },
+            };
+            usedChannels.set(id, name);
+            p.log.success(`${emoji}  ${display} → ${cName}`);
+        }
+        try {
+            writeConfig(opts.configPath, raw);
+        }
+        catch (err) {
+            p.log.error(`Could not save config: ${err instanceof Error ? err.message : err}`);
+            p.log.info("Slack tokens were saved, but channel bindings were not persisted.");
+            return;
+        }
+    }
+    // 8. Done
+    console.log();
+    p.log.success("Slack configured! Start with `pnpm start` to connect.");
+}

package/dist/cli/start.js

@@ -1,24 +1,44 @@
-import * as readline from "readline";
-import * as path from "path";
 import { loadConfig } from "../config/index.js";
-import { runAgentLoop } from "../agent/loop.js";
-import { compactMessages } from "../session/compaction.js";
 import { CronScheduler } from "../cron/scheduler.js";
 import { HeartbeatRunner } from "../heartbeat/index.js";
 import { createSlackGateway } from "../gateways/slack/index.js";
 import { createApiServer } from "../api/router.js";
 import { createLogger } from "../logger.js";
-import { buildAgentRuntime, buildSystemPrompt, initUsageStore, createAgentExecutor, } from "../bootstrap.js";
+import { buildAgentRuntime, initUsageStore, createAgentExecutor, } from "../bootstrap.js";
 import { ensureOllama } from "./ollama.js";
 import { resolveApiKey } from "./ui.js";
+import { showWhatsNew } from "./whats-new.js";
+import { ConfigWriter } from "../config/writer.js";
+import { CONFIG_PATH, DATA_DIR, SKILLS_DIR } from "./paths.js";
+import { startRepl } from "./repl.js";
+import * as path from "path";
+import { loadEnvIntoProcess } from "./env.js";
+import { initTelemetry, getTelemetryDb } from "../telemetry/index.js";
 const log = createLogger("start");
-const CONFIG_PATH = path.join(process.cwd(), "agent-kit.json");
-const DATA_DIR = path.join(process.cwd(), "data");
-const SKILLS_DIR = path.join(process.cwd(), "skills");
 const DEFAULT_AGENT = "default";
 export async function start() {
     await resolveApiKey({ save: false });
+    showWhatsNew();
+    // Telemetry (OpenTelemetry + Sentry)
+    const shutdownTelemetry = initTelemetry({
+        dbPath: path.join(DATA_DIR, "telemetry.db"),
+    });
+    // Prune telemetry data older than 30 days
+    const telDb = getTelemetryDb();
+    if (telDb) {
+        try {
+            telDb.cleanup(30);
+        }
+        catch (err) {
+            log.warn({ err }, "telemetry cleanup failed");
+        }
+    }
+    // Load Slack tokens from .env (if not already in process.env)
+    const envPath = path.join(process.cwd(), ".env");
+    loadEnvIntoProcess(envPath, ["SLACK_BOT_TOKEN", "SLACK_APP_TOKEN"]);
     const config = loadConfig(CONFIG_PATH);
+    const configWriter = new ConfigWriter(CONFIG_PATH);
+    configWriter.watch();
     // Ollama check (warn only)
     if (config.defaults.memory) {
         const ollama = await ensureOllama();
@@ -32,6 +52,7 @@ export async function start() {
         configPath: CONFIG_PATH,
         usageStore,
         dataDir: DATA_DIR,
+        telemetryDb: getTelemetryDb(),
     }, apiPort);
     // Build primary agent runtime (for REPL)
     const agentNames = Object.keys(config.agents);
@@ -41,17 +62,18 @@ export async function start() {
         console.error(`Agent "${agentName}" not found. Available: ${names}`);
         process.exit(1);
     }
-    const runtime = buildAgentRuntime(agentName, config, {
+    const runtime = await buildAgentRuntime(agentName, config, {
         dataDir: DATA_DIR,
         skillsDir: SKILLS_DIR,
         usageStore,
+        configPath: CONFIG_PATH,
     });
     const warnings = runtime.toolRegistry.validateAgents(config.agents);
     for (const w of warnings)
         log.warn(w);
     const { resolved, toolRegistry, agentRegistry, promptFragments, skillsIndex, soul, session } = runtime;
     // Cron scheduler
-    const scheduler = new CronScheduler(config, toolRegistry, agentRegistry, DATA_DIR, SKILLS_DIR, usageStore);
+    const scheduler = new CronScheduler(config, toolRegistry, agentRegistry, DATA_DIR, SKILLS_DIR, usageStore, configWriter);
     const enabledJobs = scheduler.getJobs().filter((j) => j.enabled);
     // Agent executor for Slack
     const executeAgent = createAgentExecutor(config, {
@@ -60,10 +82,14 @@ export async function start() {
         agentRegistry,
         usageStore,
         source: "slack",
+        configPath: CONFIG_PATH,
     });
     // Slack gateway
     let gateway;
     const hasSlackBindings = Object.values(config.agents).some((a) => a.slack);
+    if (hasSlackBindings && (!process.env.SLACK_BOT_TOKEN || !process.env.SLACK_APP_TOKEN)) {
+        log.warn("Slack bindings configured but SLACK_BOT_TOKEN/SLACK_APP_TOKEN not found — run `agent-kit slack-setup`");
+    }
     if (hasSlackBindings && process.env.SLACK_BOT_TOKEN && process.env.SLACK_APP_TOKEN) {
         try {
             gateway = createSlackGateway(config, { onAgentRequest: executeAgent });
@@ -84,22 +110,35 @@ export async function start() {
         log.warn({ err }, "failed to start API server");
     }
     // Cron
+    const cronCallbacks = {
+        onResult: (jobId, agentName, result) => {
+            log.info({ jobId, tokens: result.usage.inputTokens + result.usage.outputTokens }, "cron job completed");
+            process.stdout.write("You: ");
+            const channelOverride = config.cron.find((j) => j.id === jobId)?.slack?.channelId;
+            gateway?.onJobResult(agentName, jobId, result, channelOverride).catch((err) => log.warn({ err, jobId }, "failed to post cron result to Slack"));
+        },
+        onError: (jobId, agentName, error) => {
+            log.error({ err: error, jobId }, "cron job failed");
+            process.stdout.write("You: ");
+            const channelOverride = config.cron.find((j) => j.id === jobId)?.slack?.channelId;
+            gateway?.onJobError(agentName, jobId, error, channelOverride).catch((err) => log.warn({ err, jobId }, "failed to post cron error to Slack"));
+        },
+    };
     if (enabledJobs.length > 0) {
-        scheduler.start({
-            onResult: (jobId, agentName, result) => {
-                log.info({ jobId, tokens: result.usage.inputTokens + result.usage.outputTokens }, "cron job completed");
-                process.stdout.write("You: ");
-                const channelOverride = config.cron.find((j) => j.id === jobId)?.slack?.channelId;
-                gateway?.onJobResult(agentName, jobId, result, channelOverride).catch((err) => log.warn({ err, jobId }, "failed to post cron result to Slack"));
-            },
-            onError: (jobId, agentName, error) => {
-                log.error({ err: error, jobId }, "cron job failed");
-                process.stdout.write("You: ");
-                const channelOverride = config.cron.find((j) => j.id === jobId)?.slack?.channelId;
-                gateway?.onJobError(agentName, jobId, error, channelOverride).catch((err) => log.warn({ err, jobId }, "failed to post cron error to Slack"));
-            },
-        });
+        scheduler.start(cronCallbacks);
     }
+    // Hot-reload: restart cron when config changes
+    configWriter.on("config:changed", () => {
+        try {
+            const newConfig = loadConfig(CONFIG_PATH);
+            scheduler.reload(newConfig);
+            scheduler.start(cronCallbacks);
+            log.info("hot-reload: cron scheduler restarted");
+        }
+        catch (err) {
+            log.error({ err }, "hot-reload: failed to reload config");
+        }
+    });
     // Heartbeat
     const heartbeat = new HeartbeatRunner(config, agentRegistry, DATA_DIR, SKILLS_DIR, usageStore);
     const heartbeatAgents = heartbeat.getHeartbeatAgents();
@@ -152,87 +191,48 @@ export async function start() {
     console.log(`  Commands: /new (reset), /agents, /help, /quit`);
     console.log();
     // REPL
-    let messages = session.getMessages();
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    const shutdown = async () => {
-        scheduler.stop();
-        heartbeat.stop();
-        await gateway?.stop();
-        await apiServer.stop();
-        try {
-            usageStore?.close();
-        }
-        catch { }
-        rl.close();
-    };
-    const ask = () => {
-        rl.question("You: ", async (input) => {
-            const trimmed = input.trim();
-            if (trimmed === "/quit") {
-                await shutdown();
-                return;
-            }
-            if (trimmed === "/new") {
-                messages = [];
-                console.log("  Session reset.\n");
-                ask();
-                return;
-            }
-            if (trimmed === "/agents") {
+    startRepl({
+        agentName,
+        model: resolved.model,
+        fallbacks: resolved.fallbacks,
+        maxIterations: resolved.maxIterations,
+        compactionThreshold: resolved.compactionThreshold,
+        maxToolResultSize: resolved.maxToolResultSize,
+        toolRegistry,
+        session,
+        soul,
+        skillsIndex,
+        promptFragments,
+        usageStore,
+        commands: {
+            "/agents": () => {
                 for (const [name, def] of agentList) {
                     const emoji = def.emoji ?? " ";
                     const display = def.displayName ?? name;
                     console.log(`  ${emoji}  ${display} (${name})`);
                 }
                 console.log();
-                ask();
-                return;
-            }
-            if (trimmed === "/help") {
+            },
+            "/help": () => {
                 console.log("  /new     — Reset conversation");
                 console.log("  /agents  — List agents");
                 console.log("  /quit    — Shut down\n");
-                ask();
-                return;
-            }
-            if (!trimmed) {
-                ask();
-                return;
-            }
-            const userMsg = { role: "user", content: trimmed };
-            messages.push(userMsg);
-            session.append(userMsg);
-            messages = await compactMessages(messages, resolved.model, resolved.compactionThreshold);
+            },
+        },
+        onQuit: async () => {
+            configWriter.stopWatching();
+            scheduler.stop();
+            heartbeat.stop();
+            await gateway?.stop();
+            await apiServer.stop();
             try {
-                const systemPrompt = buildSystemPrompt(soul, skillsIndex, promptFragments);
-                const result = await runAgentLoop(messages, {
-                    model: resolved.model,
-                    fallbacks: resolved.fallbacks,
-                    systemPrompt,
-                    toolRegistry,
-                    maxIterations: resolved.maxIterations,
-                    compactionThreshold: resolved.compactionThreshold,
-                    maxToolResultSize: resolved.maxToolResultSize,
-                    agentName,
-                    usageStore,
-                    source: "cli",
-                });
-                const newMessages = result.messages.slice(messages.length - 1);
-                for (const msg of newMessages) {
-                    session.append(msg);
-                }
-                messages = result.messages;
-                console.log(`\nAgent: ${result.text}`);
-                console.log(`  (${result.usage.inputTokens + result.usage.outputTokens} tokens)\n`);
+                usageStore?.close();
             }
-            catch (err) {
-                console.error(`\n  Error: ${err instanceof Error ? err.message : err}\n`);
-            }
-            ask();
-        });
-    };
-    ask();
+            catch { }
+            await Promise.race([
+                shutdownTelemetry(),
+                new Promise((r) => setTimeout(r, 5000)),
+            ]);
+        },
+    });
 }

package/dist/cli/ui.d.ts

@@ -1,7 +1,7 @@
+declare const VERSION: any;
+export { VERSION };
 export declare function banner(): void;
-export declare function status(label: string, value: string): void;
 export declare function done(message: string): void;
-export declare function onCancel(): void;
 /**
  * Check if a @clack/prompts value was cancelled. Exits the process if so.
  * The `return` after `isCancel()` in callers is technically unreachable

package/dist/cli/ui.js

@@ -1,18 +1,18 @@
+import { createRequire } from "module";
 import * as fs from "fs";
 import * as path from "path";
 import * as p from "@clack/prompts";
-const VERSION = "0.1.0";
+const require = createRequire(import.meta.url);
+const { version: VERSION } = require("../../package.json");
+export { VERSION };
 export function banner() {
     console.log();
     p.intro(`agent-kit v${VERSION}`);
 }
-export function status(label, value) {
-    p.log.info(`${label}: ${value}`);
-}
 export function done(message) {
     p.outro(message);
 }
-export function onCancel() {
+function onCancel() {
     p.cancel("Cancelled.");
     process.exit(0);
 }

package/dist/cli/validate.js

@@ -1,11 +1,8 @@
-import * as path from "path";
 import { loadConfig } from "../config/index.js";
 import { validateAgent } from "../scripts/validate-agent.js";
+import { CONFIG_PATH, DATA_DIR, SKILLS_DIR } from "./paths.js";
 const PASS = "\u2713";
 const FAIL = "\u2717";
-const CONFIG_PATH = path.join(process.cwd(), "agent-kit.json");
-const SKILLS_DIR = path.join(process.cwd(), "skills");
-const DATA_DIR = path.join(process.cwd(), "data");
 function printResult(result) {
     for (const check of result.checks) {
         const icon = check.passed ? PASS : FAIL;

package/dist/cli/whats-new.d.ts

@@ -0,0 +1 @@
+export declare function showWhatsNew(): void;

package/dist/cli/whats-new.js

@@ -0,0 +1,69 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { VERSION } from "./ui.js";
+const RELEASE_NOTES = {
+    "0.1.6": [
+        "\"What's new\" notification after CLI updates",
+        "Auto-activate skills per agent",
+        "Hot-reload on external config file changes",
+    ],
+    "0.1.5": [
+        "Agent self-configuration tools",
+        "Bookkeeper: bump maxIterations, filter uncategorized by year",
+        "Generate CLAUDE.md and fix pnpm native deps on init",
+    ],
+};
+const VERSION_FILE = path.join(os.homedir(), ".agent-kit", ".last-version");
+function getLastSeenVersion() {
+    try {
+        return fs.readFileSync(VERSION_FILE, "utf-8").trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function setLastSeenVersion(version) {
+    try {
+        fs.mkdirSync(path.dirname(VERSION_FILE), { recursive: true });
+        fs.writeFileSync(VERSION_FILE, version);
+    }
+    catch {
+        // never crash startup
+    }
+}
+export function showWhatsNew() {
+    try {
+        const last = getLastSeenVersion();
+        // First run — just record the version, don't spam
+        if (last === null) {
+            setLastSeenVersion(VERSION);
+            return;
+        }
+        if (last === VERSION)
+            return;
+        // Collect notes for versions newer than last-seen
+        const entries = [];
+        for (const [ver, notes] of Object.entries(RELEASE_NOTES)) {
+            if (ver > last)
+                entries.push([ver, notes]);
+        }
+        if (entries.length > 0) {
+            // Sort descending
+            entries.sort((a, b) => (b[0] > a[0] ? 1 : -1));
+            console.log();
+            console.log("  \u2728 What's new in agent-kit");
+            for (const [ver, notes] of entries) {
+                console.log(`\n  v${ver}`);
+                for (const note of notes) {
+                    console.log(`    • ${note}`);
+                }
+            }
+            console.log();
+        }
+        setLastSeenVersion(VERSION);
+    }
+    catch {
+        // never crash startup
+    }
+}

package/dist/cli.js

@@ -29,6 +29,19 @@ async function main() {
             await chat(args[0]);
             break;
         }
+        case "slack-setup": {
+            const fs = await import("fs");
+            const { setupSlack } = await import("./cli/slack-setup.js");
+            const { banner } = await import("./cli/ui.js");
+            const { CONFIG_PATH } = await import("./cli/paths.js");
+            banner();
+            if (!fs.existsSync(CONFIG_PATH)) {
+                console.error("No agent-kit.json found. Run `agent-kit init` first.");
+                process.exit(1);
+            }
+            await setupSlack({ configPath: CONFIG_PATH, fromInit: false });
+            break;
+        }
         case "validate": {
             const { validate } = await import("./cli/validate.js");
             validate(args[0]);
@@ -44,6 +57,7 @@ async function main() {
     agent-kit create            AI-powered agent creation
     agent-kit list              Show configured agents
     agent-kit chat <agent>      Lightweight single-agent chat
+    agent-kit slack-setup       Interactive Slack setup
     agent-kit validate [agent]  Validate config
 
   Options:

package/dist/config/resolve.d.ts

@@ -8,6 +8,7 @@ export interface ResolvedAgent {
     tools: Tool[];
     skills: SkillManifest[];
     canSpawn: SpawnTarget[];
+    autoActivateSkills: boolean;
     maxIterations: number;
     maxTokens: number;
     compactionThreshold: number;

package/dist/config/resolve.js

@@ -34,6 +34,7 @@ export function resolveAgent(name, config, toolRegistry, skillsDir) {
         tools: toolRegistry.resolve(agentDef.tools),
         skills,
         canSpawn: agentDef.can_spawn,
+        autoActivateSkills: agentDef.autoActivateSkills,
         maxIterations: agentDef.maxIterations ?? config.defaults.maxIterations,
         maxTokens: agentDef.maxTokens ?? config.defaults.maxTokens,
         compactionThreshold: config.defaults.compactionThreshold,