@alejandroroman/agent-kit 0.1.4 → 0.2.0

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;
 }

package/dist/cron/scheduler.js

@@ -4,10 +4,13 @@ import { setupAgentSession } from "../agent/setup.js";
 import { resolveAgent, resolveWebSearch } from "../config/resolve.js";
 import { createBuiltinRegistry } from "../tools/builtin/index.js";
 import { registerSpawnWrappers } from "../tools/builtin/spawn.js";
+import { createUpdateAgentConfigTool, createManageCronTool } from "../tools/builtin/self-config.js";
 import * as path from "path";
-import { createActivateSkillTool } from "../skills/index.js";
+import { createActivateSkillTool, preActivateSkills } from "../skills/index.js";
 import { createLogger } from "../logger.js";
 import { dateContext } from "../text.js";
+import { context, trace, SpanStatusCode } from "@opentelemetry/api";
+import { getTracer, ATTR } from "../telemetry/index.js";
 const log = createLogger("cron");
 export class CronScheduler {
     tasks = [];
@@ -17,13 +20,15 @@ export class CronScheduler {
     dataDir;
     skillsDir;
     usageStore;
-    constructor(config, toolRegistry, agentRegistry, dataDir, skillsDir, usageStore) {
+    configWriter;
+    constructor(config, toolRegistry, agentRegistry, dataDir, skillsDir, usageStore, configWriter) {
         this.config = config;
         this.toolRegistry = toolRegistry;
         this.agentRegistry = agentRegistry;
         this.dataDir = dataDir;
         this.skillsDir = skillsDir ?? path.join(process.cwd(), "skills");
         this.usageStore = usageStore;
+        this.configWriter = configWriter;
     }
     getJobs() {
         return this.config.cron;
@@ -32,59 +37,96 @@ export class CronScheduler {
         const job = this.config.cron.find((j) => j.id === jobId);
         if (!job)
             return undefined;
-        // Resolve sandbox for this job's agent
-        const agentDef = this.config.agents[job.agent];
-        const sandbox = agentDef?.sandbox ?? this.config.defaults.sandbox;
-        const memoryConfig = this.config.defaults.memory;
-        const jobRegistry = createBuiltinRegistry({
-            allowedCommands: sandbox?.allowedCommands,
-            allowedPaths: sandbox?.allowedPaths,
-            memoryConfig,
-            webSearch: resolveWebSearch(job.agent, this.config),
+        const tracer = getTracer("cron");
+        const span = tracer.startSpan("source.cron", {
+            attributes: {
+                [ATTR.JOB_ID]: job.id,
+                [ATTR.AGENT]: job.agent,
+                [ATTR.SCHEDULE]: job.schedule,
+                [ATTR.SOURCE]: "cron",
+            },
         });
-        const resolved = resolveAgent(job.agent, this.config, jobRegistry, this.skillsDir);
-        // Skills setup for this job
-        const promptFragments = [];
-        let skillsIndex = "";
-        if (resolved.skills.length > 0) {
-            const ctx = {
-                manifests: resolved.skills,
-                skillsDir: this.skillsDir,
-                toolRegistry: jobRegistry,
-                promptFragments,
-                activatedSkills: new Set(),
-            };
-            jobRegistry.register(createActivateSkillTool(ctx));
-            skillsIndex = "\n\nYou have the following skills available:\n\n"
-                + resolved.skills.map((s) => `- **${s.name}**: ${s.description}`).join("\n")
-                + "\n\nTo use a skill, call the `activate_skill` tool with the skill name.";
+        const spanCtx = trace.setSpan(context.active(), span);
+        try {
+            return await context.with(spanCtx, async () => {
+                // Resolve sandbox for this job's agent
+                const agentDef = this.config.agents[job.agent];
+                const sandbox = agentDef?.sandbox ?? this.config.defaults.sandbox;
+                const memoryConfig = this.config.defaults.memory;
+                const jobRegistry = createBuiltinRegistry({
+                    allowedCommands: sandbox?.allowedCommands,
+                    allowedPaths: sandbox?.allowedPaths,
+                    memoryConfig,
+                    webSearch: resolveWebSearch(job.agent, this.config),
+                });
+                const resolved = resolveAgent(job.agent, this.config, jobRegistry, this.skillsDir);
+                // Skills setup for this job
+                const promptFragments = [];
+                let skillsIndex = "";
+                if (resolved.skills.length > 0) {
+                    const ctx = {
+                        manifests: resolved.skills,
+                        skillsDir: this.skillsDir,
+                        toolRegistry: jobRegistry,
+                        promptFragments,
+                        activatedSkills: new Set(),
+                    };
+                    const activateTool = createActivateSkillTool(ctx);
+                    jobRegistry.register(activateTool);
+                    if (resolved.autoActivateSkills) {
+                        skillsIndex = await preActivateSkills(ctx, activateTool, log);
+                    }
+                    else {
+                        skillsIndex = "\n\nYou have the following skills available:\n\n"
+                            + resolved.skills.map((s) => `- **${s.name}**: ${s.description}`).join("\n")
+                            + "\n\nTo use a skill, call the `activate_skill` tool with the skill name.";
+                    }
+                }
+                // Spawn wrapper registration
+                if (resolved.canSpawn.length > 0) {
+                    registerSpawnWrappers(resolved.canSpawn, this.config, this.agentRegistry, jobRegistry, this.usageStore);
+                }
+                // Self-config tool registration
+                if (this.configWriter && agentDef) {
+                    if (agentDef.tools.includes("update_agent_config")) {
+                        jobRegistry.register(createUpdateAgentConfigTool(job.agent, this.configWriter));
+                    }
+                    if (agentDef.tools.includes("manage_cron")) {
+                        jobRegistry.register(createManageCronTool(job.agent, this.configWriter));
+                    }
+                }
+                const sessionId = `cron-${job.id}`;
+                const { soul, session } = setupAgentSession(this.dataDir, job.agent, sessionId);
+                const userMsg = { role: "user", content: job.prompt };
+                session.append(userMsg);
+                const systemPrompt = [soul, dateContext(), skillsIndex, ...promptFragments]
+                    .filter(Boolean)
+                    .join("\n\n") || undefined;
+                const result = await runAgentLoop([userMsg], {
+                    model: resolved.model,
+                    fallbacks: resolved.fallbacks,
+                    systemPrompt,
+                    toolRegistry: jobRegistry,
+                    maxIterations: resolved.maxIterations,
+                    compactionThreshold: resolved.compactionThreshold,
+                    maxToolResultSize: resolved.maxToolResultSize,
+                    agentName: job.agent,
+                    usageStore: this.usageStore,
+                    source: "cron",
+                });
+                const lastMsg = result.messages[result.messages.length - 1];
+                session.append(lastMsg);
+                return result;
+            });
         }
-        // Spawn wrapper registration
-        if (resolved.canSpawn.length > 0) {
-            registerSpawnWrappers(resolved.canSpawn, this.config, this.agentRegistry, jobRegistry, this.usageStore);
+        catch (err) {
+            span.setStatus({ code: SpanStatusCode.ERROR, message: String(err) });
+            span.recordException(err instanceof Error ? err : new Error(String(err)));
+            throw err;
+        }
+        finally {
+            span.end();
         }
-        const sessionId = `cron-${job.id}`;
-        const { soul, session } = setupAgentSession(this.dataDir, job.agent, sessionId);
-        const userMsg = { role: "user", content: job.prompt };
-        session.append(userMsg);
-        const systemPrompt = [soul, dateContext(), skillsIndex, ...promptFragments]
-            .filter(Boolean)
-            .join("\n\n") || undefined;
-        const result = await runAgentLoop([userMsg], {
-            model: resolved.model,
-            fallbacks: resolved.fallbacks,
-            systemPrompt,
-            toolRegistry: jobRegistry,
-            maxIterations: resolved.maxIterations,
-            compactionThreshold: resolved.compactionThreshold,
-            maxToolResultSize: resolved.maxToolResultSize,
-            agentName: job.agent,
-            usageStore: this.usageStore,
-            source: "cron",
-        });
-        const lastMsg = result.messages[result.messages.length - 1];
-        session.append(lastMsg);
-        return result;
     }
     start(callbacks) {
         for (const job of this.config.cron) {
@@ -107,6 +149,11 @@ export class CronScheduler {
             this.tasks.push(task);
         }
     }
+    reload(newConfig) {
+        this.stop();
+        this.config = newConfig;
+        log.info({ jobs: newConfig.cron.length }, "config reloaded");
+    }
     stop() {
         for (const task of this.tasks)
             task.stop();

package/dist/gateways/slack/client.d.ts

@@ -8,6 +8,7 @@ export interface SlackClient {
     postMessage(channelId: string, text: string, blocks?: unknown[], threadTs?: string): Promise<{
         ok: boolean;
     }>;
+    downloadFile(urlPrivateDownload: string): Promise<Buffer>;
     app: import("@slack/bolt").App;
 }
 export declare function createSlackClient(options: SlackClientOptions): SlackClient;

package/dist/gateways/slack/client.js

@@ -28,6 +28,15 @@ export function createSlackClient(options) {
         async stop() {
             await app.stop();
         },
+        async downloadFile(urlPrivateDownload) {
+            const response = await fetch(urlPrivateDownload, {
+                headers: { Authorization: `Bearer ${options.botToken}` },
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to download Slack file: ${response.status} ${response.statusText}`);
+            }
+            return Buffer.from(await response.arrayBuffer());
+        },
         async postMessage(channelId, text, blocks, threadTs) {
             const result = await app.client.chat.postMessage({
                 channel: channelId,