@jellyos/agent 0.1.3 → 0.1.5

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

package/dist/session/ContextStore.d.ts

@@ -0,0 +1,96 @@
+/**
+ * ContextStore — Ephemeral task context folders. (#31, #39)
+ *
+ * When an agent task takes >2 tool rounds, a ~/.jelly/tasks/<id>/context.md
+ * file is created. Intermediate tool results are appended there instead of
+ * bloating the message history. The model gets a compact file reference
+ * instead of 10KB of raw JSON. The folder auto-deletes on task completion
+ * unless the user marked it /keep.
+ *
+ * This is the primary mechanism that allows turbo/max mode to stay within
+ * context budget even on complex multi-step research tasks.
+ */
+export interface TaskContext {
+    taskId: string;
+    taskDir: string;
+    contextMd: string;
+    createdAt: number;
+    title: string;
+    keep: boolean;
+    findings: number;
+}
+export declare class ContextStore {
+    private activeTasks;
+    constructor();
+    /** Open a new ephemeral task folder. Returns the TaskContext. */
+    openTask(title: string, keep?: boolean): TaskContext;
+    /** Append a finding / tool result to the task's context.md */
+    appendFinding(taskId: string, section: string, content: string): void;
+    /**
+     * Get a compact reference string for injection into the model context.
+     * Returns something like:
+     * "[Task ctx: ~/.jelly/tasks/.../context.md — 4 findings, 3.2KB. Use read_task_context("abc123")]"
+     */
+    getReference(taskId: string): string;
+    /**
+     * Mark a task complete and optionally delete its folder.
+     * Deletion is deferred 5 seconds to allow model to read final state.
+     */
+    closeTask(taskId: string): void;
+    /** Permanently keep a task folder (user called /keep <taskId>) */
+    keepTask(taskId: string): boolean;
+    getActiveTasks(): TaskContext[];
+    getTask(taskId: string): TaskContext | undefined;
+    readContextTool(_id: string, { taskId }: {
+        taskId: string;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            taskId: string;
+            path: string;
+            sizeBytes: number;
+            status: string;
+            findings?: undefined;
+        };
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            taskId?: undefined;
+            path?: undefined;
+            sizeBytes?: undefined;
+            status?: undefined;
+            findings?: undefined;
+        };
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            taskId: string;
+            path: string;
+            sizeBytes: number;
+            findings: number;
+            status: string;
+        };
+    }>;
+    listTasksTool(): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            activeTasks: number;
+            completedOnDisk: number;
+        };
+    }>;
+}
+/** Singleton — one store per process */
+export declare const contextStore: ContextStore;
+//# sourceMappingURL=ContextStore.d.ts.map

package/dist/session/ContextStore.js

@@ -0,0 +1,207 @@
+/**
+ * ContextStore — Ephemeral task context folders. (#31, #39)
+ *
+ * When an agent task takes >2 tool rounds, a ~/.jelly/tasks/<id>/context.md
+ * file is created. Intermediate tool results are appended there instead of
+ * bloating the message history. The model gets a compact file reference
+ * instead of 10KB of raw JSON. The folder auto-deletes on task completion
+ * unless the user marked it /keep.
+ *
+ * This is the primary mechanism that allows turbo/max mode to stay within
+ * context budget even on complex multi-step research tasks.
+ */
+import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, readdirSync, } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+const JELLY_HOME = process.env.JELLYOS_HOME ?? join(homedir(), ".jelly");
+const TASKS_DIR = join(JELLY_HOME, "tasks");
+export class ContextStore {
+    activeTasks = new Map();
+    constructor() {
+        mkdirSync(TASKS_DIR, { recursive: true });
+    }
+    // ── Task lifecycle ─────────────────────────────────────────────────────────
+    /** Open a new ephemeral task folder. Returns the TaskContext. */
+    openTask(title, keep = false) {
+        const taskId = randomUUID().slice(0, 8);
+        const taskDir = join(TASKS_DIR, `${Date.now()}-${taskId}`);
+        const contextMd = join(taskDir, "context.md");
+        mkdirSync(taskDir, { recursive: true });
+        writeFileSync(contextMd, [
+            `# Task: ${title.slice(0, 120)}`,
+            `**ID:** ${taskId}`,
+            `**Started:** ${new Date().toISOString()}`,
+            `**Status:** in_progress`,
+            ``,
+            `## Findings`,
+            ``,
+        ].join("\n"), "utf-8");
+        const ctx = {
+            taskId, taskDir, contextMd,
+            createdAt: Date.now(), title, keep, findings: 0,
+        };
+        this.activeTasks.set(taskId, ctx);
+        return ctx;
+    }
+    /** Append a finding / tool result to the task's context.md */
+    appendFinding(taskId, section, content) {
+        const ctx = this.activeTasks.get(taskId);
+        if (!ctx || !existsSync(ctx.contextMd))
+            return;
+        // Cap individual entries at 3KB to prevent runaway growth
+        const cappedContent = content.length > 3000
+            ? content.slice(0, 3000) + `\n\n…[truncated ${content.length - 3000} chars]`
+            : content;
+        const entry = [
+            `### ${section}`,
+            `_${new Date().toLocaleTimeString()}_`,
+            ``,
+            cappedContent,
+            ``,
+            `---`,
+            ``,
+        ].join("\n");
+        const existing = readFileSync(ctx.contextMd, "utf-8");
+        writeFileSync(ctx.contextMd, existing + entry, "utf-8");
+        ctx.findings++;
+    }
+    /**
+     * Get a compact reference string for injection into the model context.
+     * Returns something like:
+     * "[Task ctx: ~/.jelly/tasks/.../context.md — 4 findings, 3.2KB. Use read_task_context("abc123")]"
+     */
+    getReference(taskId) {
+        const ctx = this.activeTasks.get(taskId);
+        if (!ctx || !existsSync(ctx.contextMd))
+            return "";
+        const content = readFileSync(ctx.contextMd, "utf-8");
+        const sizeKB = (content.length / 1024).toFixed(1);
+        return `[Task context saved: ${ctx.contextMd} — ${ctx.findings} findings, ${sizeKB}KB. ` +
+            `To read back: use tool read_task_context with taskId="${taskId}"]`;
+    }
+    /**
+     * Mark a task complete and optionally delete its folder.
+     * Deletion is deferred 5 seconds to allow model to read final state.
+     */
+    closeTask(taskId) {
+        const ctx = this.activeTasks.get(taskId);
+        if (!ctx)
+            return;
+        // Update status in the file
+        if (existsSync(ctx.contextMd)) {
+            try {
+                const content = readFileSync(ctx.contextMd, "utf-8");
+                writeFileSync(ctx.contextMd, content
+                    .replace("**Status:** in_progress", `**Status:** completed\n**Completed:** ${new Date().toISOString()}`), "utf-8");
+            }
+            catch { /* best effort */ }
+        }
+        if (!ctx.keep) {
+            // Deferred delete — give agent 5s to read final context if needed
+            setTimeout(() => {
+                try {
+                    rmSync(ctx.taskDir, { recursive: true, force: true });
+                }
+                catch { /* ignore */ }
+            }, 5_000);
+        }
+        this.activeTasks.delete(taskId);
+    }
+    /** Permanently keep a task folder (user called /keep <taskId>) */
+    keepTask(taskId) {
+        const ctx = this.activeTasks.get(taskId);
+        if (!ctx)
+            return false;
+        ctx.keep = true;
+        return true;
+    }
+    getActiveTasks() {
+        return [...this.activeTasks.values()];
+    }
+    getTask(taskId) {
+        return this.activeTasks.get(taskId);
+    }
+    // ── Tool: read_task_context ────────────────────────────────────────────────
+    async readContextTool(_id, { taskId }) {
+        const ctx = this.activeTasks.get(taskId);
+        if (!ctx) {
+            // Try to find a completed task folder on disk by taskId suffix
+            const dirs = existsSync(TASKS_DIR) ? readdirSync(TASKS_DIR) : [];
+            const dir = dirs.find(d => d.endsWith(`-${taskId}`));
+            if (dir) {
+                const mdPath = join(TASKS_DIR, dir, "context.md");
+                if (existsSync(mdPath)) {
+                    const content = readFileSync(mdPath, "utf-8");
+                    return {
+                        content: [{ type: "text", text: content }],
+                        details: { taskId, path: mdPath, sizeBytes: content.length, status: "archived" },
+                    };
+                }
+            }
+            return {
+                content: [{ type: "text", text: `Task "${taskId}" not found. It may have been deleted after completion.` }],
+                details: {},
+            };
+        }
+        if (!existsSync(ctx.contextMd)) {
+            return {
+                content: [{ type: "text", text: `Context file missing for task "${taskId}".` }],
+                details: {},
+            };
+        }
+        const content = readFileSync(ctx.contextMd, "utf-8");
+        return {
+            content: [{ type: "text", text: content }],
+            details: {
+                taskId,
+                path: ctx.contextMd,
+                sizeBytes: content.length,
+                findings: ctx.findings,
+                status: "active",
+            },
+        };
+    }
+    // ── Tool: list_tasks ───────────────────────────────────────────────────────
+    async listTasksTool() {
+        const active = this.getActiveTasks();
+        // Also scan disk for recent completed tasks
+        const onDisk = [];
+        if (existsSync(TASKS_DIR)) {
+            const dirs = readdirSync(TASKS_DIR).slice(-10); // last 10
+            for (const d of dirs) {
+                const mdPath = join(TASKS_DIR, d, "context.md");
+                if (existsSync(mdPath)) {
+                    const size = (readFileSync(mdPath, "utf-8").length / 1024).toFixed(1);
+                    const id = d.split("-").pop() ?? d;
+                    if (!this.activeTasks.has(id))
+                        onDisk.push({ dir: d, id, sizeKB: size });
+                }
+            }
+        }
+        const lines = [];
+        if (active.length > 0) {
+            lines.push(`Active tasks (${active.length}):`);
+            for (const t of active) {
+                const mdContent = existsSync(t.contextMd) ? readFileSync(t.contextMd, "utf-8") : "";
+                const sizeKB = (mdContent.length / 1024).toFixed(1);
+                lines.push(`  📁 [${t.taskId}] ${t.title.slice(0, 50)} — ${t.findings} findings, ${sizeKB}KB`);
+            }
+        }
+        if (onDisk.length > 0) {
+            lines.push(`\nRecent completed tasks:`);
+            for (const t of onDisk) {
+                lines.push(`  📄 [${t.id}] ${t.dir.slice(14, 64)} — ${t.sizeKB}KB`);
+            }
+        }
+        if (lines.length === 0)
+            lines.push("No active or recent task contexts.");
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+            details: { activeTasks: active.length, completedOnDisk: onDisk.length },
+        };
+    }
+}
+/** Singleton — one store per process */
+export const contextStore = new ContextStore();
+//# sourceMappingURL=ContextStore.js.map