@albalink/agent 1.0.0

package/dist/runner/ToolDispatcher.js

@@ -0,0 +1,168 @@
+/**
+ * ToolDispatcher — executes tool calls from the model response.
+ * 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;
+    }
+    async dispatch(calls) {
+        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 {
+                tool_call_id: tc.id,
+                name: tc.function.name,
+                content: `Unknown tool: ${tc.function.name}`,
+                isError: true,
+            };
+        }
+        let params;
+        try {
+            // #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 (repair failed): ${tc.function.arguments}`,
+                isError: true,
+            };
+        }
+        // Validate params against the tool's TypeBox schema
+        if (!Value.Check(tool.parameters, params)) {
+            const errors = [...Value.Errors(tool.parameters, params)]
+                .slice(0, 3)
+                .map(e => `${e.path}: ${e.message}`)
+                .join("; ");
+            return {
+                tool_call_id: tc.id,
+                name: tc.function.name,
+                content: `Parameter validation failed: ${errors}`,
+                isError: true,
+            };
+        }
+        try {
+            const result = await tool.execute(tc.id, params);
+            const content = result.content.map(c => c.text).join("\n");
+            return { tool_call_id: tc.id, name: tc.function.name, content, isError: false };
+        }
+        catch (e) {
+            return {
+                tool_call_id: tc.id,
+                name: tc.function.name,
+                content: `Tool error: ${e?.message ?? String(e)}`,
+                isError: true,
+            };
+        }
+    }
+}
+//# sourceMappingURL=ToolDispatcher.js.map

package/dist/scheduler/AgentScheduler.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 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 ~/.alba/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;
+    private _priceListener?;
+    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,263 @@
+/**
+ * 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 ~/.alba/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 ALBA_HOME = process.env.ALBA_HOME ?? join(homedir(), ".alba");
+const SCHEDULE_FILE = join(ALBA_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;
+    _priceListener;
+    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(ALBA_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);
+        // #18: Also check triggers on every price update (not just poll) for low-latency
+        if (!this._priceListener) {
+            this._priceListener = () => this.tick(onTrigger);
+            priceFeed.on?.("prices", this._priceListener);
+        }
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+        if (this._priceListener) {
+            priceFeed.off?.("prices", this._priceListener);
+            this._priceListener = 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/server-entry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * server-entry.ts — Lean entry point for the dashboard server.
+ * Exports only what app/server/server.js needs, avoiding Ink/React/React DOM deps.
+ *
+ * Import from: import { ModelClient, resolveModelConfig, PriceFeed, NewsFeed, SwarmRouter } from "@albalink/agent";
+ */
+export { ModelClient, resolveModelConfig } from "./runner/ModelClient.js";
+export { PriceFeed, priceFeed } from "./tools/PriceFeed.js";
+export { NewsFeed, newsFeed } from "./tools/NewsSentiment.js";
+export { SwarmRouter, scoreComplexity } from "./runner/SwarmRouter.js";
+//# sourceMappingURL=server-entry.d.ts.map

package/dist/server-entry.js

@@ -0,0 +1,15 @@
+/**
+ * server-entry.ts — Lean entry point for the dashboard server.
+ * Exports only what app/server/server.js needs, avoiding Ink/React/React DOM deps.
+ *
+ * Import from: import { ModelClient, resolveModelConfig, PriceFeed, NewsFeed, SwarmRouter } from "@albalink/agent";
+ */
+// Model client — used by server for OpenAI-compatible chat completions
+export { ModelClient, resolveModelConfig } from "./runner/ModelClient.js";
+// Price feed singleton — real-time crypto prices
+export { PriceFeed, priceFeed } from "./tools/PriceFeed.js";
+// News feed singleton — crypto news sentiment
+export { NewsFeed, newsFeed } from "./tools/NewsSentiment.js";
+// SwarmRouter — sub-agent orchestration
+export { SwarmRouter, scoreComplexity } from "./runner/SwarmRouter.js";
+//# sourceMappingURL=server-entry.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 ~/.alba/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: ~/.alba/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