@jellyos/agent 0.1.4 → 0.1.5

package/dist/runner/SwarmRouter.js

@@ -31,46 +31,83 @@ export function scoreComplexity(prompt) {
         questions * 5 +
         Math.floor(wordCount / 8));
 }
-// ── Task decomposition ───────────────────────────────────────────────────────
+// ── Task decomposition (# 29: LLM planner with heuristic fallback) ───────────
 /**
- * Splits a complex prompt into 2–5 focused sub-task strings.
- * Uses simple heuristics so no extra model call is needed.
+ * LLM-based task planner. Uses a cheap worker model to decompose the prompt
+ * into focused sub-tasks as a JSON array. Falls back to heuristics on failure.
  */
-export function decompose(prompt, maxTasks) {
+async function planSubtasks(prompt, maxTasks, modelReg) {
+    const cap = Math.max(2, Math.min(maxTasks, 5));
+    // Attempt LLM decomposition with a cheap/fast model
+    try {
+        const chain = resolveModelChain(modelReg);
+        // Prefer a worker-tier model for planning (fast + cheap)
+        const plannerCfg = chain.find(c => modelReg?.getTier(c.model) === "worker") ?? chain[chain.length - 1] ?? chain[0];
+        const client = new ModelClient({ ...plannerCfg, temperature: 0.2 }, modelReg);
+        const plannerPrompt = `Split the following request into exactly ${cap} focused, non-overlapping sub-tasks.\n` +
+            `Each sub-task must be independently answerable using data tools.\n` +
+            `Output ONLY a valid JSON array of strings. No explanation, no markdown.\n\n` +
+            `Request: ${prompt}`;
+        let output = "";
+        for await (const chunk of client.stream([
+            { role: "system", content: "You output only valid JSON arrays of strings. No markdown, no explanation." },
+            { role: "user", content: plannerPrompt },
+        ], [])) {
+            if (chunk.type === "delta" && chunk.text)
+                output += chunk.text;
+            if (chunk.type === "error")
+                throw new Error(chunk.error);
+        }
+        // Extract JSON array from output (model might wrap in markdown)
+        const jsonMatch = output.match(/\[\s*"[\s\S]*?"\s*(?:,\s*"[\s\S]*?"\s*)*\]/);
+        if (jsonMatch) {
+            const tasks = JSON.parse(jsonMatch[0]);
+            if (Array.isArray(tasks) && tasks.every((t) => typeof t === "string") && tasks.length >= 2) {
+                return tasks.slice(0, cap);
+            }
+        }
+    }
+    catch {
+        // Fall through to heuristic decomposition
+    }
+    return decomposeHeuristic(prompt, cap);
+}
+/** Original heuristic decomposer — used as fallback when LLM planner fails */
+export function decomposeHeuristic(prompt, maxTasks) {
     const cap = Math.max(2, Math.min(maxTasks, 5));
-    // Split on explicit conjunctions / punctuation
     const parts = prompt
         .split(/,\s*| and | also | then | additionally | plus /i)
         .map(s => s.trim())
         .filter(s => s.length > 4);
-    if (parts.length >= 2) {
+    if (parts.length >= 2)
         return parts.slice(0, cap);
-    }
-    // Fallback: split action verbs into separate sub-questions
     const verbMatches = [...prompt.matchAll(/\b(analyze|compare|predict|scan|check|estimate|evaluate)\b[^,.?]*/gi)];
-    if (verbMatches.length >= 2) {
+    if (verbMatches.length >= 2)
         return verbMatches.slice(0, cap).map(m => m[0].trim());
-    }
-    // Cannot decompose meaningfully → return as-is (single task)
     return [prompt];
 }
-// ── Reviewer synthesis ───────────────────────────────────────────────────────
-async function reviewerSynthesize(originalPrompt, allResults, systemPrompt, modelReg) {
+/** Exported for tests — heuristic only, no model call */
+export const decompose = decomposeHeuristic;
+// ── Reviewer synthesis (#39: compact refs via ContextStore) ─────────────────
+async function reviewerSynthesize(originalPrompt, allResults, systemPrompt, modelReg, contextRef) {
     const chain = resolveModelChain(modelReg);
     const cfg = chain[0];
     const client = new ModelClient(cfg, modelReg);
-    // Filter out sub-tasks that errored — don't feed garbage into the reviewer
     const results = allResults.filter(r => !r.error);
-    const context = results
-        .map((r, i) => `### Sub-task ${i + 1}: ${r.task}\n${r.result}`)
-        .join("\n\n");
+    // #39: If ContextStore holds the full results, send compact summaries + reference
+    const context = contextRef
+        ? results.map((r, i) => `Sub-task ${i + 1} (${r.task.slice(0, 50)}): ${r.result.slice(0, 300)}...`).join("\n") + `\n\n${contextRef}`
+        : results
+            .map((r, i) => `### Sub-task ${i + 1}: ${r.task}\n${r.result}`)
+            .join("\n\n");
     const messages = [
         { role: "system", content: systemPrompt },
         {
             role: "user",
-            content: `You are a synthesis reviewer. The following sub-tasks were run in response to the user's original request.\n\n` +
-                `**Original request:** ${originalPrompt}\n\n${context}\n\n` +
-                `Write a concise, unified answer that directly addresses the original request using all the above findings.`,
+            content: `You are a synthesis reviewer. Sub-tasks were executed for the following request.\n\n` +
+                `**Original request:** ${originalPrompt}\n\n` +
+                `**Sub-task results:**\n${context}\n\n` +
+                `Write a concise, unified answer that directly addresses the original request.`,
         },
     ];
     let out = "";
@@ -109,10 +146,13 @@ export class SwarmRouter {
      * @param systemPrompt  - Current system prompt (passed to each sub-agent + reviewer)
      * @param onProgress    - Called as each sub-task completes
      */
-    async run(prompt, systemPrompt, onProgress) {
-        const tasks = decompose(prompt, this.maxAgents);
-        const chain = resolveModelChain();
+    async run(prompt, systemPrompt, onProgress, contextStore) {
+        // #29: Use LLM planner for task decomposition (falls back to heuristic)
+        const tasks = await planSubtasks(prompt, this.maxAgents, this.modelRegistry);
+        const chain = resolveModelChain(this.modelRegistry);
         const subResults = [];
+        // #39: Open a task context folder to offload sub-results (saves context window)
+        const taskCtx = contextStore?.openTask(`Swarm: ${prompt.slice(0, 60)}`);
         // Split tasks into groups of 3 (the required "groups-of-3" planner)
         const GROUP_SIZE = 3;
         const batches = [];
@@ -144,6 +184,10 @@ export class SwarmRouter {
                 error,
             };
             subResults.push(r);
+            // #39: Write sub-result to context file instead of keeping raw in memory
+            if (taskCtx && contextStore) {
+                contextStore.appendFinding(taskCtx.taskId, `Sub-task: ${task.slice(0, 50)}`, r.result);
+            }
             onProgress(r, remaining);
         };
         // Execute batches sequentially; within each batch run up to 3 in parallel
@@ -154,7 +198,12 @@ export class SwarmRouter {
                 return runOne(task, modelIdx++, remaining);
             }));
         }
-        const synthesis = await reviewerSynthesize(prompt, subResults, systemPrompt, this.modelRegistry);
+        // #39: Pass context reference to reviewer (compact path vs raw dump)
+        const contextRef = taskCtx ? contextStore?.getReference(taskCtx.taskId) : undefined;
+        const synthesis = await reviewerSynthesize(prompt, subResults, systemPrompt, this.modelRegistry, contextRef);
+        // Close the context folder (auto-deletes in 5s)
+        if (taskCtx)
+            contextStore?.closeTask(taskCtx.taskId);
         return { synthesis, subResults };
     }
 }

package/dist/runner/ToolDispatcher.d.ts

@@ -10,10 +10,20 @@ export interface ToolResult {
     content: string;
     isError: boolean;
 }
+/** #40: Estimate chars that will be added to context by dispatching these calls */
+export declare function forecastContextGrowth(calls: {
+    function: {
+        name: string;
+    };
+}[]): number;
 export declare class ToolDispatcher {
     private registry;
+    private failureCounts;
+    private openCircuits;
     constructor(registry: Registry);
     dispatch(calls: ToolCall[]): Promise<ToolResult[]>;
     private execute;
+    private executeWithTimeout;
+    private executeInner;
 }
 //# sourceMappingURL=ToolDispatcher.d.ts.map

package/dist/runner/ToolDispatcher.js

@@ -3,8 +3,65 @@
  * Looks up tool by name in the Registry, validates params, runs execute().
  */
 import { Value } from "@sinclair/typebox/value";
+/**
+ * Attempt to repair common JSON errors from model output.
+ * Handles trailing commas, single quotes, unquoted keys.
+ * Returns original string if repair doesn't help.
+ */
+function repairJson(raw) {
+    try {
+        JSON.parse(raw);
+        return raw;
+    }
+    catch { /* fall through to repair */ }
+    const repaired = raw
+        .replace(/,\s*}/g, "}")
+        .replace(/,\s*]/g, "]")
+        .replace(/([{,]\s*)(\w+)(\s*:)/g, '$1"$2"$3') // unquoted keys
+        .replace(/:\s*'([^']*)'/g, ': "$1"'); // single-quoted values
+    try {
+        JSON.parse(repaired);
+        return repaired;
+    }
+    catch {
+        return raw;
+    }
+}
+const TOOL_TIMEOUT_MS = 30_000;
+const CIRCUIT_OPEN_MS = 300_000;
+const CIRCUIT_THRESHOLD = 3;
+// #40: Estimated output sizes per tool (chars) for pre-dispatch budget forecasting
+const TOOL_OUTPUT_ESTIMATES = {
+    get_candles: 8_000, // 100 OHLCV + TA = ~8KB
+    analyze_ta: 2_000,
+    get_prices: 500,
+    get_top_movers: 800,
+    get_market_overview: 1_000,
+    get_news: 4_000,
+    get_fear_greed: 400,
+    get_funding_rates: 600,
+    get_btc_mempool: 400,
+    get_defi_tvl: 2_000,
+    get_solana_stats: 300,
+    list_models: 3_000,
+    list_tasks: 500,
+    read_task_context: 6_000,
+    cost_report: 400,
+    list_goals: 600,
+    model_summary: 400,
+    _default: 2_000,
+};
+/** #40: Estimate chars that will be added to context by dispatching these calls */
+export function forecastContextGrowth(calls) {
+    return calls.reduce((sum, tc) => {
+        const est = TOOL_OUTPUT_ESTIMATES[tc.function.name] ?? TOOL_OUTPUT_ESTIMATES["_default"];
+        return sum + est;
+    }, 0);
+}
 export class ToolDispatcher {
     registry;
+    failureCounts = new Map();
+    openCircuits = new Map(); // toolName → openUntil timestamp
     constructor(registry) {
         this.registry = registry;
     }
@@ -12,6 +69,52 @@ export class ToolDispatcher {
         return Promise.all(calls.map(tc => this.execute(tc)));
     }
     async execute(tc) {
+        const toolName = tc.function.name;
+        // #6: Circuit breaker — fast-fail if tool has been consistently broken
+        const openUntil = this.openCircuits.get(toolName) ?? 0;
+        if (Date.now() < openUntil) {
+            const remainMs = Math.ceil((openUntil - Date.now()) / 1000);
+            return {
+                tool_call_id: tc.id,
+                name: toolName,
+                content: `Tool "${toolName}" is temporarily unavailable (circuit open for ${remainMs}s after repeated failures). Use a different approach or try again later.`,
+                isError: true,
+            };
+        }
+        try {
+            const result = await this.executeWithTimeout(tc);
+            // Reset failure count on success
+            this.failureCounts.delete(toolName);
+            return result;
+        }
+        catch (e) {
+            const errMsg = e instanceof Error ? e.message : String(e);
+            const failures = (this.failureCounts.get(toolName) ?? 0) + 1;
+            this.failureCounts.set(toolName, failures);
+            if (failures >= CIRCUIT_THRESHOLD) {
+                this.openCircuits.set(toolName, Date.now() + CIRCUIT_OPEN_MS);
+                this.failureCounts.delete(toolName);
+                return {
+                    tool_call_id: tc.id,
+                    name: toolName,
+                    content: `Tool "${toolName}" failed ${CIRCUIT_THRESHOLD} times in a row. Circuit opened for 5 minutes. Error: ${errMsg}`,
+                    isError: true,
+                };
+            }
+            return {
+                tool_call_id: tc.id,
+                name: toolName,
+                content: `Tool error (failure ${failures}/${CIRCUIT_THRESHOLD}): ${errMsg}`,
+                isError: true,
+            };
+        }
+    }
+    async executeWithTimeout(tc) {
+        // Race tool execution against a hard timeout
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Tool "${tc.function.name}" timed out after ${TOOL_TIMEOUT_MS / 1000}s`)), TOOL_TIMEOUT_MS));
+        return Promise.race([this.executeInner(tc), timeoutPromise]);
+    }
+    async executeInner(tc) {
         const tool = this.registry.getTool(tc.function.name);
         if (!tool) {
             return {
@@ -23,13 +126,14 @@ export class ToolDispatcher {
         }
         let params;
         try {
-            params = JSON.parse(tc.function.arguments || "{}");
+            // #8: attempt JSON repair before hard-failing on malformed model output
+            params = JSON.parse(repairJson(tc.function.arguments || "{}"));
         }
         catch {
             return {
                 tool_call_id: tc.id,
                 name: tc.function.name,
-                content: `Invalid JSON arguments: ${tc.function.arguments}`,
+                content: `Invalid JSON arguments (repair failed): ${tc.function.arguments}`,
                 isError: true,
             };
         }

package/dist/scheduler/AgentScheduler.d.ts

@@ -0,0 +1,118 @@
+/**
+ * AgentScheduler — autonomous task scheduling. (#11)
+ *
+ * Enables the agent to act without user input:
+ *   - Cron-style recurring tasks ("every 15 minutes, check BTC funding rates")
+ *   - Price triggers ("when ETH drops below $2000, alert me")
+ *   - One-shot future tasks ("in 30 minutes, summarize market conditions")
+ *
+ * Tasks are persisted to ~/.jelly/schedule.json and survive restarts.
+ * The scheduler polls every 60s and fires tasks via the provided callback.
+ *
+ * Usage:
+ *   scheduler.addTask({ name: "BTC check", prompt: "check BTC price and RSI", cron: "@every_15m" });
+ *   scheduler.start((task) => runner.run(task.prompt));
+ */
+import { type Static } from "@sinclair/typebox";
+export interface PriceTrigger {
+    symbol: string;
+    above?: number;
+    below?: number;
+    /** Percent change threshold (e.g. 5 = 5% move either direction) */
+    changePct?: number;
+}
+export interface ScheduledTask {
+    id: string;
+    name: string;
+    prompt: string;
+    /** Cron expression e.g. "@every_15m" or "0 * * * *" (hourly).
+     * Shorthand: @every_5m @every_15m @every_30m @every_1h @every_6h @hourly @daily
+     */
+    cron?: string;
+    /** Price-based trigger */
+    trigger?: PriceTrigger;
+    /** One-shot run time (epoch ms) */
+    runAt?: number;
+    /** If true, disable after first run */
+    runOnce: boolean;
+    enabled: boolean;
+    createdAt: number;
+    lastRun?: number;
+    runCount: number;
+}
+export declare class AgentScheduler {
+    private tasks;
+    private timer?;
+    private lastTickMinute;
+    constructor();
+    private load;
+    private save;
+    start(onTrigger: (task: ScheduledTask) => void): void;
+    stop(): void;
+    private tick;
+    private checkPriceTrigger;
+    addTask(task: Omit<ScheduledTask, "id" | "createdAt" | "runCount">): ScheduledTask;
+    removeTask(id: string): boolean;
+    enableTask(id: string, enabled: boolean): boolean;
+    listTasks(): ScheduledTask[];
+    getTask(id: string): ScheduledTask | undefined;
+    readonly addTaskParams: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        prompt: import("@sinclair/typebox").TString;
+        cron: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        trigger_symbol: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        trigger_above: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        trigger_below: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        trigger_change_pct: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        run_in_minutes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        run_once: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    }>;
+    addTaskTool(_id: string, params: Static<typeof this.addTaskParams>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            taskId: string;
+            task: ScheduledTask;
+        };
+    }>;
+    readonly listTasksParams: import("@sinclair/typebox").TObject<{
+        enabled_only: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    }>;
+    listTasksTool(_id: string, params: Static<typeof this.listTasksParams>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            count?: undefined;
+            tasks?: undefined;
+        };
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            count: number;
+            tasks: ScheduledTask[];
+        };
+    }>;
+    readonly removeTaskParams: import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+    }>;
+    removeTaskTool(_id: string, params: Static<typeof this.removeTaskParams>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            taskId: string;
+            success: boolean;
+        };
+    }>;
+}
+/** Singleton */
+export declare const agentScheduler: AgentScheduler;
+//# sourceMappingURL=AgentScheduler.d.ts.map

package/dist/scheduler/AgentScheduler.js

@@ -0,0 +1,253 @@
+/**
+ * AgentScheduler — autonomous task scheduling. (#11)
+ *
+ * Enables the agent to act without user input:
+ *   - Cron-style recurring tasks ("every 15 minutes, check BTC funding rates")
+ *   - Price triggers ("when ETH drops below $2000, alert me")
+ *   - One-shot future tasks ("in 30 minutes, summarize market conditions")
+ *
+ * Tasks are persisted to ~/.jelly/schedule.json and survive restarts.
+ * The scheduler polls every 60s and fires tasks via the provided callback.
+ *
+ * Usage:
+ *   scheduler.addTask({ name: "BTC check", prompt: "check BTC price and RSI", cron: "@every_15m" });
+ *   scheduler.start((task) => runner.run(task.prompt));
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { priceFeed } from "../tools/PriceFeed.js";
+import { Type } from "@sinclair/typebox";
+const JELLY_HOME = process.env.JELLYOS_HOME ?? join(homedir(), ".jelly");
+const SCHEDULE_FILE = join(JELLY_HOME, "schedule.json");
+// ── Cron parser (minimal subset) ──────────────────────────────────────────────
+const SHORTHAND_MAP = {
+    "@hourly": "0 * * * *",
+    "@daily": "0 0 * * *",
+    "@every_5m": "*/5 * * * *",
+    "@every_15m": "*/15 * * * *",
+    "@every_30m": "*/30 * * * *",
+    "@every_1h": "0 * * * *",
+    "@every_6h": "0 */6 * * *",
+    "@every_12h": "0 */12 * * *",
+};
+function parseCron(expr) {
+    const resolved = SHORTHAND_MAP[expr] ?? expr;
+    const parts = resolved.trim().split(/\s+/);
+    if (parts.length < 5)
+        return () => false;
+    const [minuteExpr, hourExpr] = parts;
+    function matchField(expr, value) {
+        if (expr === "*")
+            return true;
+        if (expr.startsWith("*/")) {
+            const step = parseInt(expr.slice(2));
+            return !isNaN(step) && value % step === 0;
+        }
+        const num = parseInt(expr);
+        return !isNaN(num) && num === value;
+    }
+    return (now) => matchField(minuteExpr, now.getMinutes()) &&
+        matchField(hourExpr, now.getHours());
+}
+// ── AgentScheduler ─────────────────────────────────────────────────────────────
+export class AgentScheduler {
+    tasks = [];
+    timer;
+    lastTickMinute = -1;
+    constructor() {
+        this.load();
+    }
+    // ── Persistence ────────────────────────────────────────────────────────────
+    load() {
+        try {
+            if (!existsSync(SCHEDULE_FILE))
+                return;
+            const raw = JSON.parse(readFileSync(SCHEDULE_FILE, "utf-8"));
+            if (Array.isArray(raw))
+                this.tasks = raw;
+        }
+        catch { /* start fresh */ }
+    }
+    save() {
+        try {
+            mkdirSync(JELLY_HOME, { recursive: true });
+            writeFileSync(SCHEDULE_FILE, JSON.stringify(this.tasks, null, 2), "utf-8");
+        }
+        catch { /* best effort */ }
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────────────
+    start(onTrigger) {
+        if (this.timer)
+            return;
+        // Poll every 60 seconds — aligned to minute boundaries
+        this.timer = setInterval(() => this.tick(onTrigger), 60_000);
+        // Run once immediately on start to catch any missed tasks
+        this.tick(onTrigger);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+    }
+    tick(onTrigger) {
+        const now = new Date();
+        const minute = now.getMinutes();
+        // Prevent double-firing within the same minute
+        if (minute === this.lastTickMinute)
+            return;
+        this.lastTickMinute = minute;
+        for (const task of this.tasks) {
+            if (!task.enabled)
+                continue;
+            let shouldRun = false;
+            // One-shot: run at specific time
+            if (task.runAt && !task.lastRun) {
+                shouldRun = Date.now() >= task.runAt;
+            }
+            // Cron schedule
+            if (task.cron && !shouldRun) {
+                const matches = parseCron(task.cron);
+                shouldRun = matches(now);
+                // Prevent re-firing within same minute
+                if (shouldRun && task.lastRun && Date.now() - task.lastRun < 58_000) {
+                    shouldRun = false;
+                }
+            }
+            // Price trigger
+            if (task.trigger && !shouldRun) {
+                shouldRun = this.checkPriceTrigger(task.trigger);
+            }
+            if (shouldRun) {
+                task.lastRun = Date.now();
+                task.runCount = (task.runCount ?? 0) + 1;
+                if (task.runOnce)
+                    task.enabled = false;
+                this.save();
+                onTrigger(task);
+            }
+        }
+    }
+    checkPriceTrigger(trigger) {
+        const tick = priceFeed.get(trigger.symbol.toLowerCase());
+        if (!tick)
+            return false;
+        if (trigger.above !== undefined && tick.price >= trigger.above)
+            return true;
+        if (trigger.below !== undefined && tick.price <= trigger.below)
+            return true;
+        if (trigger.changePct !== undefined && Math.abs(tick.change24h) >= trigger.changePct)
+            return true;
+        return false;
+    }
+    // ── Task CRUD ──────────────────────────────────────────────────────────────
+    addTask(task) {
+        const full = {
+            ...task,
+            id: randomUUID().slice(0, 8),
+            createdAt: Date.now(),
+            runCount: 0,
+        };
+        this.tasks.push(full);
+        this.save();
+        return full;
+    }
+    removeTask(id) {
+        const before = this.tasks.length;
+        this.tasks = this.tasks.filter(t => t.id !== id);
+        if (this.tasks.length < before) {
+            this.save();
+            return true;
+        }
+        return false;
+    }
+    enableTask(id, enabled) {
+        const t = this.tasks.find(t => t.id === id);
+        if (!t)
+            return false;
+        t.enabled = enabled;
+        this.save();
+        return true;
+    }
+    listTasks() { return [...this.tasks]; }
+    getTask(id) {
+        return this.tasks.find(t => t.id === id);
+    }
+    // ── Tools ──────────────────────────────────────────────────────────────────
+    addTaskParams = Type.Object({
+        name: Type.String({ description: "Task name" }),
+        prompt: Type.String({ description: "The message the agent will run" }),
+        cron: Type.Optional(Type.String({
+            description: "Cron schedule: '*/15 * * * *' or shorthand @every_15m @hourly @daily",
+        })),
+        trigger_symbol: Type.Optional(Type.String({ description: "Symbol for price trigger e.g. BTC" })),
+        trigger_above: Type.Optional(Type.Number({ description: "Fire when price goes above this" })),
+        trigger_below: Type.Optional(Type.Number({ description: "Fire when price goes below this" })),
+        trigger_change_pct: Type.Optional(Type.Number({ description: "Fire when 24h change exceeds this %" })),
+        run_in_minutes: Type.Optional(Type.Number({ description: "One-shot: run after N minutes" })),
+        run_once: Type.Optional(Type.Boolean({ description: "Disable after first run (default: false)" })),
+    });
+    async addTaskTool(_id, params) {
+        let trigger;
+        if (params.trigger_symbol) {
+            trigger = {
+                symbol: params.trigger_symbol,
+                above: params.trigger_above,
+                below: params.trigger_below,
+                changePct: params.trigger_change_pct,
+            };
+        }
+        const task = this.addTask({
+            name: params.name,
+            prompt: params.prompt,
+            cron: params.cron,
+            trigger,
+            runAt: params.run_in_minutes ? Date.now() + params.run_in_minutes * 60_000 : undefined,
+            runOnce: params.run_once ?? false,
+            enabled: true,
+        });
+        const desc = [
+            params.cron ? `cron: ${params.cron}` : "",
+            trigger ? `trigger: ${params.trigger_symbol} ${trigger.above ? `>$${trigger.above}` : ""} ${trigger.below ? `<$${trigger.below}` : ""}` : "",
+            params.run_in_minutes ? `runs in ${params.run_in_minutes}m` : "",
+        ].filter(Boolean).join(", ");
+        return {
+            content: [{ type: "text", text: `Scheduled: [${task.id}] ${task.name}${desc ? ` (${desc})` : ""}` }],
+            details: { taskId: task.id, task },
+        };
+    }
+    listTasksParams = Type.Object({
+        enabled_only: Type.Optional(Type.Boolean({ description: "Only show enabled tasks (default: false)" })),
+    });
+    async listTasksTool(_id, params) {
+        const tasks = params.enabled_only ? this.tasks.filter(t => t.enabled) : this.tasks;
+        if (tasks.length === 0) {
+            return { content: [{ type: "text", text: "No scheduled tasks." }], details: {} };
+        }
+        const lines = tasks.map(t => {
+            const icon = t.enabled ? "🟢" : "⚪";
+            const schedule = t.cron ?? (t.trigger ? `price trigger ${t.trigger.symbol}` : t.runAt ? `at ${new Date(t.runAt).toLocaleTimeString()}` : "manual");
+            const runs = t.runCount > 0 ? ` (${t.runCount} runs)` : "";
+            return `${icon} [${t.id}] ${t.name} — ${schedule}${runs}`;
+        });
+        return {
+            content: [{ type: "text", text: `Scheduled tasks (${tasks.length}):\n${lines.join("\n")}` }],
+            details: { count: tasks.length, tasks },
+        };
+    }
+    removeTaskParams = Type.Object({
+        id: Type.String({ description: "Task ID to remove" }),
+    });
+    async removeTaskTool(_id, params) {
+        const ok = this.removeTask(params.id);
+        return {
+            content: [{ type: "text", text: ok ? `Task ${params.id} removed.` : `Task ${params.id} not found.` }],
+            details: { taskId: params.id, success: ok },
+        };
+    }
+}
+/** Singleton */
+export const agentScheduler = new AgentScheduler();
+//# sourceMappingURL=AgentScheduler.js.map