@alejandroroman/agent-kit 0.1.4 → 0.2.1

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

@@ -7,13 +7,38 @@ import { createLogger } from "../logger.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 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();
@@ -27,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);
@@ -36,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, {
@@ -55,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 });
@@ -79,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();
@@ -176,6 +220,7 @@ export async function start() {
             },
         },
         onQuit: async () => {
+            configWriter.stopWatching();
             scheduler.stop();
             heartbeat.stop();
             await gateway?.stop();
@@ -184,6 +229,10 @@ export async function start() {
                 usageStore?.close();
             }
             catch { }
+            await Promise.race([
+                shutdownTelemetry(),
+                new Promise((r) => setTimeout(r, 5000)),
+            ]);
         },
     });
 }

package/dist/cli/ui.d.ts

@@ -1,3 +1,5 @@
+declare const VERSION: any;
+export { VERSION };
 export declare function banner(): void;
 export declare function done(message: string): void;
 /**

package/dist/cli/ui.js

@@ -1,7 +1,10 @@
+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}`);

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,

package/dist/config/schema.d.ts

@@ -56,6 +56,7 @@ declare const AgentSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
     tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
     skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    autoActivateSkills: z.ZodDefault<z.ZodBoolean>;
     spawn_only: z.ZodDefault<z.ZodBoolean>;
     can_spawn: z.ZodDefault<z.ZodArray<z.ZodObject<{
         agent: z.ZodString;
@@ -150,6 +151,7 @@ export declare const ConfigSchema: z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
         tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
         skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        autoActivateSkills: z.ZodDefault<z.ZodBoolean>;
         spawn_only: z.ZodDefault<z.ZodBoolean>;
         can_spawn: z.ZodDefault<z.ZodArray<z.ZodObject<{
             agent: z.ZodString;

package/dist/config/schema.js

@@ -83,6 +83,7 @@ const AgentSchema = z.object({
     model: z.string().min(1).optional(),
     tools: z.array(z.string()).default([]),
     skills: z.array(z.string().min(1)).default([]),
+    autoActivateSkills: z.boolean().default(false),
     spawn_only: z.boolean().default(false),
     can_spawn: z.array(SpawnTargetSchema).default([]),
     maxIterations: z.number().positive().int().optional(),

package/dist/config/writer.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter } from "events";
+export declare class ConfigWriter extends EventEmitter {
+    private configPath;
+    private lockPromise;
+    private watcher?;
+    private debounceTimer?;
+    private lastSelfWriteMs;
+    constructor(configPath: string);
+    /** Read the current config from disk (fresh read, no cache). */
+    read(): Record<string, any>;
+    /** Write config atomically (temp file + rename). Emits config:changed. */
+    write(config: Record<string, any>): void;
+    /** Watch the config file for external changes. Debounced, ignores self-writes. */
+    watch(): void;
+    stopWatching(): void;
+    /** Mutex-protected read-modify-write. The callback mutates config in place. */
+    mutate(fn: (config: Record<string, any>) => void): Promise<void>;
+}

package/dist/config/writer.js

@@ -0,0 +1,85 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { EventEmitter } from "events";
+import { createLogger } from "../logger.js";
+const log = createLogger("config:writer");
+export class ConfigWriter extends EventEmitter {
+    configPath;
+    lockPromise = Promise.resolve();
+    watcher;
+    debounceTimer;
+    lastSelfWriteMs = 0;
+    constructor(configPath) {
+        super();
+        this.configPath = configPath;
+    }
+    /** Read the current config from disk (fresh read, no cache). */
+    read() {
+        const raw = fs.readFileSync(this.configPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    /** Write config atomically (temp file + rename). Emits config:changed. */
+    write(config) {
+        const tmp = path.join(path.dirname(this.configPath), `.agent-kit-${process.pid}-${Date.now()}.tmp`);
+        fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + os.EOL);
+        try {
+            fs.renameSync(tmp, this.configPath);
+        }
+        catch (err) {
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch { /* ignore cleanup error */ }
+            throw err;
+        }
+        log.info("config written");
+        this.lastSelfWriteMs = Date.now();
+        this.emit("config:changed", config);
+    }
+    /** Watch the config file for external changes. Debounced, ignores self-writes. */
+    watch() {
+        if (this.watcher)
+            return;
+        const DEBOUNCE_MS = 250;
+        const SELF_WRITE_WINDOW_MS = 1000;
+        this.watcher = fs.watch(this.configPath, () => {
+            if (this.debounceTimer)
+                clearTimeout(this.debounceTimer);
+            this.debounceTimer = setTimeout(() => {
+                // Ignore fs events triggered by our own write()
+                if (Date.now() - this.lastSelfWriteMs < SELF_WRITE_WINDOW_MS)
+                    return;
+                try {
+                    const config = this.read();
+                    log.info("external config change detected");
+                    this.emit("config:changed", config);
+                }
+                catch (err) {
+                    log.error({ err }, "failed to read config after external change");
+                }
+            }, DEBOUNCE_MS);
+        });
+    }
+    stopWatching() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.watcher?.close();
+        this.watcher = undefined;
+    }
+    /** Mutex-protected read-modify-write. The callback mutates config in place. */
+    async mutate(fn) {
+        const prev = this.lockPromise;
+        let resolve;
+        this.lockPromise = new Promise((r) => { resolve = r; });
+        await prev;
+        try {
+            const config = this.read();
+            fn(config);
+            this.write(config);
+        }
+        finally {
+            resolve();
+        }
+    }
+}

package/dist/cron/scheduler.d.ts

@@ -2,6 +2,7 @@ import type { Config, CronJobDef } from "../config/schema.js";
 import type { ToolRegistry } from "../tools/registry.js";
 import type { AgentResult } from "../agent/types.js";
 import type { AgentRegistry } from "../multi/registry.js";
+import type { ConfigWriter } from "../config/writer.js";
 import type { UsageStore } from "../usage/store.js";
 export declare class CronScheduler {
     private tasks;
@@ -11,12 +12,14 @@ export declare class CronScheduler {
     private dataDir;
     private skillsDir;
     private usageStore?;
-    constructor(config: Config, toolRegistry: ToolRegistry, agentRegistry: AgentRegistry, dataDir: string, skillsDir?: string, usageStore?: UsageStore);
+    private configWriter?;
+    constructor(config: Config, toolRegistry: ToolRegistry, agentRegistry: AgentRegistry, dataDir: string, skillsDir?: string, usageStore?: UsageStore, configWriter?: ConfigWriter);
     getJobs(): CronJobDef[];
     runJob(jobId: string): Promise<AgentResult | undefined>;
     start(callbacks?: {
         onResult?: (jobId: string, agentName: string, result: AgentResult) => void;
         onError?: (jobId: string, agentName: string, error: Error) => void;
     }): void;
+    reload(newConfig: Config): void;
     stop(): void;
 }