/**
 * The `todo` planning capability: a tiny, per-conversation task list the model
 * can keep in front of itself while it works.
 *
 * Two cooperating tools are exposed. {@link todoSetTool} replaces the entire
 * checklist in one shot — the caller hands over the whole array of items it wants
 * tracked, and any previous list for that context is discarded. {@link todoReadTool}
 * plays the list back so the model can re-read where it stands without mutating
 * anything. Both are authored against the kernel surface alone; the backing store
 * is plain in-process state, so no `ctx.fs` or `ctx.shell` access is needed.
 *
 * State lives in a single module-level {@link TodoStore} keyed by the live
 * {@link ToolContext}. Every distinct conversation threads a distinct context
 * object through `run`, so each conversation gets its own isolated list. The store
 * exposes {@link TodoStore.reset} so a test can wipe all accumulated lists between
 * cases.
 */
import type { ToolContext } from "../kernel";
/** The lifecycle stage of a single checklist entry. */
export type TodoStatus = "pending" | "active" | "done";
/** One line of the checklist. */
export interface TodoItem {
    /** Caller-chosen stable identifier, unique within a single list. */
    readonly id: string;
    /** Human-readable summary of the task. */
    readonly text: string;
    /** Where this task sits in its lifecycle. */
    readonly status: TodoStatus;
}
/**
 * In-process home for every context's checklist.
 *
 * Keys are the identity of the {@link ToolContext} object handed to `run`, so two
 * conversations never see each other's items. The class is a thin wrapper over a
 * {@link Map}; it is deliberately minimal because the tools own all of the
 * validation and presentation logic.
 */
export declare class TodoStore {
    private readonly lists;
    /** Return the list recorded for `ctx`, or an empty array if none was set yet. */
    read(ctx: ToolContext): readonly TodoItem[];
    /** Replace the entire list recorded for `ctx` with `items`. */
    replace(ctx: ToolContext, items: readonly TodoItem[]): void;
    /** Discard every stored list. Intended for test isolation only. */
    reset(): void;
}
/**
 * The shared, module-level store both tools read and write.
 *
 * Exported so tests can call {@link TodoStore.reset} between cases and assert on
 * stored state directly.
 */
export declare const todoStore: TodoStore;
/**
 * Convenience re-export of the store's reset, so a test can wipe state with a
 * single named import instead of reaching through the instance.
 */
export declare function reset(): void;
/** Replace the whole stored checklist for the calling context. */
export declare const todoSetTool: import("..").DefinedTool;
/** Play back the stored checklist for the calling context without changing it. */
export declare const todoReadTool: import("..").DefinedTool;
