@wrongstack/core 0.284.1 → 0.286.0

package/dist/todos-checkpoint-FY7PjmMx.d.ts

@@ -1,850 +0,0 @@
-import { A as AttachmentStore, a as AddAttachmentInput, b as AttachmentRef, c as Attachment } from './session-reader-7Esxrkpw.js';
-import { i as ContentBlock, u as ConversationState, k as SessionStore, S as SessionEvent, j as SessionMetadata, b as SessionWriter, v as SessionForkOptions, F as ForkedSession, W as WorkspaceCheckpointRef, w as WorkspaceMaterializationResult, x as ResumedSession, y as SessionData, z as SessionSummary, A as TodoItem } from './tool-BNlnIJvo.js';
-import { E as EventBus, M as MemoryScope, b as MemoryEntry, c as MemoryStore, d as MemoryRelevanceContext, S as ScoredEntry } from './events-Bgnh43r9.js';
-import { j as Config, l as ConfigLoader, m as SyncConfig, n as ConfigStore } from './config-MRqn1V-u.js';
-import { S as SecretVault } from './secret-vault-BAKpgFw_.js';
-import { W as WstackPaths } from './wstack-paths-C3K40Qst.js';
-import { S as SecretScrubber } from './secret-scrubber-3MHDDAtm.js';
-
-interface AttachmentStoreOptions {
-    /**
-     * Directory for spooling payloads larger than `spoolThresholdBytes`.
-     * When omitted, all payloads stay in memory.
-     */
-    spoolDir?: string | undefined;
-    spoolThresholdBytes?: number | undefined;
-}
-/**
- * In-memory attachment store with optional disk spool. Placeholder syntax
- * is `[<kind> #<seq>]` (seq-keyed) or `[file:<path>]` (path-keyed) where kind
- * is `pasted` / `image` / `file`. Unknown placeholders are passed through
- * as-is so users can write that literal text without losing it.
- */
-declare class DefaultAttachmentStore implements AttachmentStore {
-    private readonly items;
-    private readonly refs;
-    private nextSeq;
-    private readonly spoolDir;
-    private readonly spoolThreshold;
-    constructor(opts?: AttachmentStoreOptions);
-    add(input: AddAttachmentInput): Promise<AttachmentRef>;
-    get(id: string): Promise<Attachment | undefined>;
-    list(): AttachmentRef[];
-    expand(text: string): Promise<ContentBlock[]>;
-    clear(): Promise<void>;
-    private toBlock;
-}
-
-/**
- * A single config source. Higher priority wins in merges.
- * Sources are applied in priority order (lowest first), so a source
- * with priority=10 overrides one with priority=1.
- */
-interface ConfigSource {
-    /** Unique name for debugging and error messages. */
-    name: string;
-    /** Lower numbers merge first, higher numbers override lower. Default: 50. */
-    priority?: number | undefined;
-    /**
-     * Read the raw config patch. Return an empty object if unavailable.
-     * Errors are surfaced but do not abort loading — the source is skipped.
-     */
-    read(): Promise<Partial<Config>>;
-}
-interface ConfigLoaderOptions {
-    paths: WstackPaths;
-    strict?: boolean | undefined;
-    vault?: SecretVault | undefined;
-    /** Extra sources merged after the built-in layers. */
-    sources?: ConfigSource[] | undefined;
-    events?: EventBus;
-    traceId?: string;
-}
-declare class DefaultConfigLoader implements ConfigLoader {
-    private readonly paths;
-    private readonly strict;
-    private readonly vault;
-    private readonly extraSources;
-    private readonly events;
-    private readonly traceId;
-    private readonly jsonCache;
-    constructor(opts: ConfigLoaderOptions);
-    load(opts?: {
-        cliFlags?: Partial<Config> | undefined;
-        cwd?: string | undefined;
-    }): Promise<Config>;
-    private ensureGlobalDefaults;
-    /**
-     * Persist a sync config to ~/.wrongstack/sync.json, with the token encrypted
-     * by the vault (if provided). The file is isolated from the main config
-     * hierarchy to prevent accidental commits.
-     */
-    persistSyncConfig(cfg: SyncConfig): Promise<void>;
-    /**
-     * Read ~/.wrongstack/sync.json (encrypted GitHub token storage) and decrypt
-     * the token if a vault is available. Returns null if the file doesn't exist.
-     * This is separate from main config loading because sync.json is intentionally
-     * isolated — it should never be part of project-local or env-driven config.
-     */
-    loadSyncConfig(): Promise<SyncConfig | null>;
-    private readJson;
-    private validateBehavior;
-    private validateIdentity;
-}
-
-/**
- * L2-D: Config version migration framework. Pure functions, decoupled
- * from disk/CLI — caller passes a parsed JSON object and gets back the
- * up-to-date `Config` shape (or a structured error explaining why
- * migration failed).
- *
- * Migrations are registered as `{ from, to, migrate }` triples and run
- * sequentially. Each migration is independently testable. Adding a new
- * version means appending one migration; existing user configs are
- * upgraded in place at load time.
- */
-interface MigrationContext {
-    /**
-     * Original on-disk version of the input. Migrations may use this to
-     * decide between in-place patches and rewrites.
-     */
-    fromVersion: number;
-    /**
-     * Set when the migration writes back to disk. Callers persist the
-     * migrated config when this is true so the user doesn't see the same
-     * migration banner on every boot.
-     */
-    shouldPersist: boolean;
-}
-interface ConfigMigration {
-    /** Version of the input this migration accepts. */
-    from: number;
-    /** Version of the output it produces. */
-    to: number;
-    /** Pure transform — no I/O. */
-    migrate(input: Record<string, unknown>, ctx: MigrationContext): Record<string, unknown>;
-    /** Optional human-readable description for migration logs / banners. */
-    describe?: string | undefined;
-}
-interface MigrationResult {
-    /** Final config (still typed as `unknown`-keyed — caller validates). */
-    config: Record<string, unknown>;
-    /** Ordered list of `from→to` versions that ran. */
-    applied: string[];
-    /** True when at least one migration produced changes worth persisting. */
-    shouldPersist: boolean;
-}
-declare class ConfigMigrationError extends Error {
-    readonly fromVersion: number;
-    readonly targetVersion: number;
-    readonly missingStep: number | null;
-    constructor(opts: {
-        message: string;
-        fromVersion: number;
-        targetVersion: number;
-        missingStep: number | null;
-    });
-}
-/**
- * Run registered migrations until the input reaches `targetVersion`.
- *
- * Resolution rules:
- * 1. If `input.version === targetVersion`, no migrations run; `shouldPersist`
- *    is false.
- * 2. Otherwise walk the migration chain from `input.version` upward,
- *    picking the migration whose `from` matches the current version.
- * 3. Stop when `current.version === targetVersion`.
- * 4. If no migration matches at some point, throw `ConfigMigrationError`
- *    with the missing step recorded for diagnostics.
- *
- * Migrations may be downward (e.g. for staged rollouts), but `targetVersion`
- * must be reachable strictly via the registered chain — there's no implicit
- * "skip" or transitive resolution.
- */
-declare function runConfigMigrations(input: Record<string, unknown>, targetVersion: number, migrations: readonly ConfigMigration[]): MigrationResult;
-/**
- * Default empty migration registry. Real migrations are appended as new
- * Config versions are introduced. Example (when v2 lands):
- *
- *   export const CONFIG_MIGRATIONS: readonly ConfigMigration[] = [
- *     {
- *       from: 1, to: 2, describe: 'rename `apiKey` → `auth.apiKey`',
- *       migrate(cfg) {
- *         const apiKey = cfg.apiKey;
- *         delete cfg.apiKey;
- *         return { ...cfg, auth: { ...(cfg.auth ?? {}), apiKey } };
- *       },
- *     },
- *   ];
- */
-declare const DEFAULT_CONFIG_MIGRATIONS: readonly ConfigMigration[];
-
-/**
- * Reference implementation of `ConfigStore`. Stores a single frozen Config
- * and notifies watchers synchronously on every update. Updates use a deep
- * clone so callers can mutate their `partial` argument freely without
- * tainting state.
- *
- * For the CLI: instantiate once at boot, pass the store (not the Config)
- * to subsystems that care about runtime changes (provider switching,
- * extension reload).
- */
-declare class DefaultConfigStore implements ConfigStore {
-    private current;
-    private watchers;
-    constructor(initial: Config);
-    get(): Readonly<Config>;
-    getSection<K extends keyof Config>(key: K): Readonly<Config[K]>;
-    getExtension(pluginName: string): Readonly<Record<string, unknown>>;
-    update(partial: Partial<Config>): Readonly<Config>;
-    watch(cb: (next: Readonly<Config>, prev: Readonly<Config>) => void): () => void;
-}
-
-interface MemoryBackend {
-    readonly kind: string;
-    remember(scope: MemoryScope, entry: MemoryEntry, filePath: string): Promise<void>;
-    forget(scope: MemoryScope, query: string, filePath: string): Promise<number>;
-    readAll(scope: MemoryScope, filePath: string): Promise<string>;
-    list(scope: MemoryScope, filePath: string, limit?: number | undefined): Promise<MemoryEntry[]>;
-    search(scope: MemoryScope, query: string, filePath: string, limit?: number | undefined): Promise<MemoryEntry[]>;
-    /** Find memories related to the given text via graph traversal. Optional — falls back to search. */
-    findRelated?(scope: MemoryScope, filePath: string, text: string, limit: number): Promise<MemoryEntry[]>;
-    clear(scope: MemoryScope, filePath: string): Promise<void>;
-    consolidate(scope: MemoryScope, filePath: string): Promise<number>;
-}
-interface FileMemoryBackendOptions {
-    paths: WstackPaths;
-}
-declare class FileMemoryBackend implements MemoryBackend {
-    readonly kind = "file";
-    private readonly files;
-    /** Cache of parsed entries per file path. */
-    private readonly entryCache;
-    /** Inverted index per file path. */
-    private readonly indexCache;
-    /** File mtime cache for invalidation. */
-    private readonly mtimeCache;
-    constructor(opts: FileMemoryBackendOptions);
-    private resolveFile;
-    private getMtime;
-    private invalidateCache;
-    /**
-     * Load (and cache) the parsed entries for a file. Callers that have already
-     * stat'd the file this tick (e.g. `getIndex`) can pass the known `mtime` to
-     * avoid a redundant `fs.stat` — otherwise it's fetched here.
-     */
-    private loadEntries;
-    private getIndex;
-    remember(scope: MemoryScope, entry: MemoryEntry, filePath: string): Promise<void>;
-    forget(scope: MemoryScope, query: string, filePath: string): Promise<number>;
-    readAll(scope: MemoryScope, filePath: string): Promise<string>;
-    list(scope: MemoryScope, filePath: string, limit?: number): Promise<MemoryEntry[]>;
-    search(scope: MemoryScope, query: string, filePath: string, limit?: number): Promise<MemoryEntry[]>;
-    clear(scope: MemoryScope, filePath: string): Promise<void>;
-    consolidate(scope: MemoryScope, filePath: string): Promise<number>;
-}
-declare function parseEntries(raw: string, scope?: MemoryScope): MemoryEntry[];
-
-interface MemoryStoreOptions {
-    paths: WstackPaths;
-    /**
-     * Optional event bus — when provided, mutations emit events so plugins
-     * and other subsystems can react to memory changes.
-     */
-    events?: EventBus | undefined;
-    /**
-     * Storage backend. Defaults to FileMemoryBackend when omitted.
-     * Plugins can register a custom backend (graph, semantic, vector)
-     * via the DI container to override storage behavior.
-     */
-    backend?: MemoryBackend | undefined;
-}
-/**
- * Three scopes:
- *   project-agents → <project>/.wrongstack/AGENTS.md     (committed)
- *   project-memory → ~/.wrongstack/projects/<hash>/memory.md   (per-project agent notes)
- *   user-memory    → ~/.wrongstack/memory.md             (global personal memory)
- */
-declare class DefaultMemoryStore implements MemoryStore {
-    private readonly files;
-    private readonly events?;
-    private traceId?;
-    private readonly backend;
-    /**
-     * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
-     * `clear` are read-modify-write against a single file; without a lock,
-     * two concurrent calls on the same scope can read the same baseline and
-     * the later write silently drops the earlier entry. We chain each
-     * mutation onto the prior promise for the same scope so they run in
-     * issue order. Different scopes still proceed in parallel.
-     *
-     * The chain tracks only the last pending write. If a write fails, its
-     * error is caught and swallowed so the chain stays alive for subsequent
-     * calls. The error is stored in `writeErrors` so callers can learn about
-     * it on the next read operation.
-     */
-    private readonly writeChain;
-    /** Last write error per scope — surfaced as warnings on the next readAll(). */
-    private readonly writeErrors;
-    /**
-     * When the global root is a temporary directory (opencode, CI sandboxes),
-     * memory files are also mirrored to the project tree so they survive
-     * session cleanup. The primary path stays in the temp root for isolation;
-     * this backup ensures memory is never lost.
-     */
-    private readonly persistBackup;
-    private readonly backupDir;
-    /**
-     * Per-scope tracked byte sizes — incremented on `remember()`, decremented on
-     * `forget()`, recalculated after `consolidate()`. Eliminates the redundant
-     * readAll() call that previously checked the file size after every write.
-     */
-    private readonly _trackedByteSizes;
-    /** Result cache for scoreRelevant() — keyed by scope + context hash, TTL 30s. */
-    private readonly _scoreCache;
-    /**
-     * Per-entry cached lowercase strings — lazily allocated once and reused
-     * across scoreRelevant() calls so repeated scoring of the same entries skips
-     * re-lowercasing. Keyed by entry object identity; cleared (set to null) on
-     * every mutation (remember/forget/consolidate/clear) via invalidateScoreCaches().
-     */
-    private _cachedLower;
-    constructor(opts: MemoryStoreOptions);
-    /** Expose the backend for plugin introspection and advanced queries. */
-    getBackend(): MemoryBackend;
-    private runSerialized;
-    /**
-     * Recalculate the tracked byte size for a scope by re-reading the file and
-     * summing the serialized byte length of each line. Called after consolidate()
-     * (which modifies the file) to keep the tracker accurate.
-     */
-    private _recalcTrackedByteSize;
-    readAll(): Promise<string>;
-    read(scope: MemoryScope): Promise<string>;
-    /**
-     * List entries from a scope, newest first. Delegates to the backend
-     * so graph/semantic backends can return enriched or filtered results.
-     */
-    list(scope?: MemoryScope, limit?: number): Promise<MemoryEntry[]>;
-    /**
-     * Find memories related to the given text via graph traversal.
-     * Falls back to content search when no graph backend is available.
-     */
-    findRelated(text: string, scope?: MemoryScope, limit?: number): Promise<MemoryEntry[]>;
-    search(query: string, scope?: MemoryScope, limit?: number): Promise<MemoryEntry[]>;
-    remember(text: string, scope?: MemoryScope, metadata?: Omit<Partial<MemoryEntry>, 'scope' | 'text' | 'ts'>): Promise<void>;
-    /**
-     * Drop the relevance caches after a mutation. Both the per-context score
-     * cache and the per-entry lowercase cache are keyed on entry objects that a
-     * mutation invalidates, so they must be cleared together when entries change.
-     */
-    private invalidateScoreCaches;
-    /**
-     * Score and rank memories by relevance to the current context.
-     * Returns entries with score >= MIN_RELEVANCE_SCORE, sorted highest first.
-     */
-    scoreRelevant(ctx: MemoryRelevanceContext, scope?: MemoryScope, limit?: number): Promise<ScoredEntry[]>;
-    forget(query: string, scope?: MemoryScope): Promise<number>;
-    consolidate(scope: MemoryScope): Promise<void>;
-    clear(scope?: MemoryScope): Promise<void>;
-    /**
-     * Return a new MemoryStore proxy that carries `traceId` on every storage
-     * event. The original store is left unchanged — callers that need a
-     * trace-decorated view (e.g. session-run tools) receive the proxy while
-     * the singleton remains trace-free for boot-time use.
-     *
-     * The proxy implements the full `MemoryStore` interface; all other
-     * properties (backend, etc.) are delegated to the original store.
-     */
-    withTraceId(traceId: string): MemoryStore;
-    private mirrorBackup;
-}
-
-/**
- * Plan items are the strategic counterpart to todos. Where `ctx.todos`
- * is the moment-to-moment task board the LLM mutates per-turn, a plan
- * captures the higher-level approach — the steps the user (or LLM)
- * laid out before any work began.
- *
- * Plans persist by default (per session) so a resumed session can show
- * "you were on step 3 of 5". Todos are derived/transient. Both can
- * coexist: think roadmap (plan) vs. sprint board (todos).
- */
-interface PlanItem {
-    id: string;
-    title: string;
-    /** Optional longer-form context or rationale. */
-    details?: string | undefined;
-    status: 'open' | 'in_progress' | 'done';
-    createdAt: string;
-    updatedAt: string;
-}
-interface PlanFile {
-    version: 1;
-    sessionId: string;
-    title?: string | undefined;
-    updatedAt: string;
-    items: PlanItem[];
-}
-declare function loadPlan(filePath: string, events?: EventBus): Promise<PlanFile | null>;
-/**
- * Persist a plan. Returns `true` on success, `false` if the write failed
- * (still emits `storage.error` + warns — it does NOT throw, so callers that
- * treat a lost plan-save as non-fatal keep working). `mutatePlan` inspects the
- * result and throws so the plan TOOL can report `ok:false` instead of falsely
- * claiming the plan was persisted.
- */
-declare function savePlan(filePath: string, plan: PlanFile, events?: EventBus): Promise<boolean>;
-/** Create a new PlanFile when none exists on disk. */
-declare function emptyPlan(sessionId: string, title?: string): PlanFile;
-declare function addPlanItem(plan: PlanFile, title: string, details?: string | undefined): {
-    plan: PlanFile;
-    item: PlanItem;
-};
-declare function removePlanItem(plan: PlanFile, idOrIndex: string): PlanFile;
-declare function setPlanItemStatus(plan: PlanFile, idOrIndex: string, status: PlanItem['status']): PlanFile;
-declare function clearPlan(plan: PlanFile): PlanFile;
-/** Render the plan as a short markdown-ish string suitable for slash output. */
-declare function formatPlan(plan: PlanFile): string;
-/**
- * Promote a plan item to a set of todo items.
- * The plan item is marked 'in_progress' (if not already done) and its
- * title + details become the first todo; additional subtasks are appended.
- * Returns the derived todo list so the caller can pass it to `todoTool`
- * or `ctx.state.replaceTodos()`.
- */
-declare function deriveTodosFromPlanItem(plan: PlanFile, idOrIndex: string, subtasks?: string[] | undefined): {
-    plan: PlanFile;
-    todos: Array<{
-        id: string;
-        content: string;
-        status: 'pending' | 'in_progress' | 'completed';
-        activeForm?: string | undefined;
-        promotedFromPlan?: string | undefined;
-    }>;
-} | null;
-/**
- * Load, modify, and save the plan file under a file-level lock.
- * Prevents races from parallel tool invocations (e.g. batch_tool_use).
- */
-declare function mutatePlan(filePath: string, sessionId: string, fn: (plan: PlanFile) => PlanFile | Promise<PlanFile>): Promise<PlanFile>;
-/**
- * Optional: attach a state-listener so meta operations (storing a plan
- * id on ctx.meta) trigger a save. Currently a stub — plans don't live
- * on Context, but this keeps the API surface symmetric with the todos
- * checkpoint so future refactors can flip plans into Context if needed.
- */
-declare function attachPlanCheckpoint(_state: ConversationState, _filePath: string, _sessionId: string): () => void;
-
-/**
- * Plan templates — pre-defined plan skeletons for common workflows.
- *
- * Templates are stored in-memory (no disk I/O). Users instantiate them
- * via `/plan template use <name>` or `planTool(action: 'template_use')`.
- * Each template is a function that returns an array of item titles, so
- * dynamic content (dates, project names) can be injected later.
- */
-interface PlanTemplate {
-    name: string;
-    description: string;
-    category: 'development' | 'release' | 'maintenance' | 'infrastructure';
-    items: Array<{
-        title: string;
-        details?: string | undefined;
-    }>;
-}
-declare function listPlanTemplates(): PlanTemplate[];
-declare function getPlanTemplate(name: string): PlanTemplate | undefined;
-declare function formatPlanTemplates(): string;
-
-/**
- * The persisted form of a single queued user message. The TUI's
- * in-memory QueueItem has a render id; that's pure UI bookkeeping, so
- * we drop it when serializing — fresh ids are assigned on rehydrate.
- */
-interface PersistedQueueItem {
-    displayText: string;
-    blocks: ContentBlock[];
-}
-/**
- * Side-file storage for a session's pending input queue. Lives at
- * `<sessionDir>/queue.json` next to the attachment spool. Reads are
- * tolerant (missing/malformed file → empty array); writes are atomic
- * (tmp + rename) so a crash mid-write can never leave a partial file
- * the next launch would choke on.
- *
- * The contract is "snapshot replacement": every mutation hands the
- * full queue and we rewrite the file. The queue is small (rarely more
- * than a handful of messages), so this is cheaper than delta logging
- * and avoids the replay complexity.
- */
-declare class QueueStore {
-    private readonly file;
-    private readonly events;
-    private readonly traceId;
-    constructor(opts: {
-        dir: string;
-        events?: EventBus;
-        traceId?: string;
-    });
-    write(items: PersistedQueueItem[]): Promise<void>;
-    read(): Promise<PersistedQueueItem[]>;
-    clear(): Promise<void>;
-}
-
-/**
- * Per-project lockfile used for crash detection. The CLI writes one of
- * these alongside the session JSONLs (`<projectSessions>/active.json`)
- * when an interactive run starts, and deletes it on clean exit. If we
- * find one on the next launch whose owning PID is dead (or whose host
- * doesn't match), we know the previous run was killed mid-flight and
- * the session it was writing to is a recovery candidate.
- *
- * The lockfile is intentionally per-project (already isolated by
- * `wpaths.projectSessions`), so two TUIs in two different repos do not
- * fight each other.
- */
-interface RecoveryLockOptions {
-    /** Directory the lockfile lives in. Usually `wpaths.projectSessions`. */
-    dir: string;
-    /** This process's PID. Default: `process.pid`. */
-    pid?: number | undefined;
-    /** Hostname recorded for the lock. Default: `os.hostname()`. */
-    hostname?: string | undefined;
-    /** Locks older than this are considered orphaned (disk wiped, etc.). Default 24h. */
-    maxAgeMs?: number | undefined;
-    /** Used to check whether the abandoned session was actually closed cleanly. */
-    sessionStore?: SessionStore | undefined;
-    /**
-     * Override the PID-liveness probe. Default: `process.kill(pid, 0)` —
-     * succeeds (or throws EPERM) when the PID is alive, throws ESRCH when
-     * it is gone. Tests inject a deterministic stub.
-     */
-    isPidAlive?: (((pid: number) => boolean)) | undefined;
-}
-interface AbandonedSession {
-    sessionId: string;
-    pid: number;
-    startedAt: string;
-    /** Lockfile age in ms at the time of the check. */
-    ageMs: number;
-    /** Number of messages already on disk for this session. */
-    messageCount: number;
-}
-declare class RecoveryLock {
-    private readonly file;
-    private readonly pid;
-    private readonly hostname;
-    private readonly maxAgeMs;
-    private readonly sessionStore?;
-    private readonly probe;
-    constructor(opts: RecoveryLockOptions);
-    /**
-     * Examine the lockfile and decide whether it represents an abandoned
-     * session. Returns `null` if the file is missing, points to a live
-     * instance, references a clean-closed session, is too old, or is
-     * malformed. Otherwise returns enough detail to prompt the user.
-     *
-     * Important: this is a read-only check. We never delete an active
-     * lock from here — if another wstack instance is alive, the caller
-     * should bail or run with a fresh session instead.
-     */
-    checkAbandoned(): Promise<AbandonedSession | null>;
-    /**
-     * Claim the lock for the given session. Uses exclusive-create (`O_EXCL`)
-     * to detect whether another process acquired the lock between our
-     * `checkAbandoned()` call and now. If the file already exists, it means
-     * another process won the race and we throw instead of silently
-     * overwriting their recovery record.
-     *
-     * The caller MUST have already called `checkAbandoned()` and handled its
-     * null return before calling this.
-     */
-    write(sessionId: string): Promise<void>;
-    /**
-     * Release the lock. Idempotent — silently succeeds if the file is
-     * already gone (e.g. someone else cleared it, or the directory was
-     * wiped).
-     */
-    clear(): Promise<void>;
-    private readLock;
-}
-
-interface QueryFilter {
-    eventTypes?: string[] | undefined;
-    toolNames?: string[] | undefined;
-    timeRange?: {
-        start: string;
-        end: string;
-    } | undefined;
-}
-interface ModeChange {
-    ts: string;
-    from: string;
-    to: string;
-}
-interface TaskSummary {
-    taskId: string;
-    title: string;
-    status: string;
-    createdAt: string;
-    completedAt?: string | undefined;
-}
-interface SessionAnalysis {
-    sessionId: string;
-    totalDuration: number;
-    toolUsageCount: Record<string, number>;
-    errorCount: number;
-    modeChanges: ModeChange[];
-    tasks: TaskSummary[];
-}
-declare class SessionAnalyzer {
-    analyze(events: SessionEvent[]): SessionAnalysis;
-    query(events: SessionEvent[], filter: QueryFilter): SessionEvent[];
-    private calcDuration;
-}
-
-interface SessionStoreOptions {
-    dir: string;
-    /**
-     * Active project root used to revalidate persisted file-observation hashes
-     * during resume. Omit for stores that only inspect/archive transcripts.
-     */
-    projectRoot?: string | undefined;
-    /** Optional EventBus for emitting session diagnostics. */
-    events?: EventBus | undefined;
-    /**
-     * Optional secret scrubber. When set, `user_input` and `llm_response` event
-     * content is scrubbed before being persisted to the JSONL log and the
-     * summary sidecar — so a secret a user pastes or the model echoes does not
-     * sit in cleartext on disk (and does not ride along in history cloud-sync).
-     * Tool output is already scrubbed upstream by the executor; this closes the
-     * conversation-turn gap (finding F-06).
-     */
-    secretScrubber?: SecretScrubber | undefined;
-    /**
-     * Optional guard consulted by {@link DefaultSessionStore.delete} before
-     * removing a session. Returns `true` if the session is currently in use by
-     * any live process (e.g. it is the active session of another terminal, TUI,
-     * or WebUI in this project). The store ALWAYS also checks `active.json`
-     * directly; this callback widens the check to cross-process live sessions
-     * via the SessionRegistry. When omitted, only the `active.json` check runs.
-     * Resolves to a human-readable reason when in use, or `null` when safe.
-     */
-    isSessionInUse?: ((sessionId: string) => Promise<string | null>) | undefined;
-}
-declare class DefaultSessionStore implements SessionStore {
-    private readonly dir;
-    private readonly events?;
-    private readonly secretScrubber?;
-    private readonly projectRoot?;
-    private readonly checkpointCas?;
-    private readonly isSessionInUse?;
-    /**
-     * In-memory cache for load() results, keyed by session ID. The cache is
-     * invalidated when the file's mtimeMs or size changes (indicating the
-     * file was written to). This eliminates redundant full-file reads and
-     * JSON parses when the same session is loaded multiple times within the
-     * store's lifetime (e.g., webui session detail views, list() fallbacks).
-     *
-     * Max size is capped to prevent unbounded memory growth in long-running
-     * processes. When the limit is reached, the oldest entry is evicted.
-     */
-    private readonly _loadCache;
-    private _indexCache;
-    private readonly shardManifestCache;
-    private static readonly LOAD_CACHE_MAX_ENTRIES;
-    private static readonly LIST_SCAN_CONCURRENCY;
-    constructor(opts: SessionStoreOptions);
-    /**
-     * Clear the load() cache. Useful for testing or when the caller knows
-     * the file has changed externally (e.g., another process wrote to it).
-     */
-    clearLoadCache(sessionId?: string): void;
-    private emitRead;
-    private emitWrite;
-    private emitError;
-    /** Absolute path to the session index file. */
-    private get indexFile();
-    /** Join session ID to its absolute path within the store directory. */
-    private sessionPath;
-    private shardManifestPath;
-    private shardKeyForSessionId;
-    private invalidateShardManifestBySessionId;
-    /**
-     * Ensure the directory implied by the session ID exists. When the ID
-     * contains a date prefix like `2026-06-06/...`, this creates the date
-     * subdirectory so sessions group naturally by day.
-     */
-    private ensureShardDir;
-    create(meta: Omit<SessionMetadata, 'startedAt'>): Promise<SessionWriter>;
-    fork(id: string, opts?: SessionForkOptions): Promise<ForkedSession>;
-    materializeWorkspaceCheckpoint(checkpoint: WorkspaceCheckpointRef, targetRoot: string): Promise<WorkspaceMaterializationResult>;
-    resume(id: string): Promise<ResumedSession>;
-    load(id: string): Promise<SessionData>;
-    /**
-     * Fast-path loader that skips message reconstruction and adjacency repair.
-     *
-     * Use this for callers that only need the raw event stream + session
-     * metadata — e.g. session listers, analytics, audit, and the TUI's
-     * "events only" views. It avoids the message array build and
-     * repairToolUseAdjacency cost on large session files (a long agent
-     * run can have 50k+ events; rebuilding messages is O(events) and
-     * allocates per-block, so skipping it is a meaningful win).
-     *
-     * The returned data.messages is an empty array; data.toolCallEnds
-     * is computed from the raw events. usage is the sum across all
-     * llm_response events — same as full load().
-     */
-    loadEventsOnly(id: string): Promise<SessionData>;
-    private loadInternal;
-    /**
-     * Streaming search over a session's JSONL. Walks the file once, parses
-     * each event lazily, and yields only the events that match `predicate`.
-     * Stops as soon as `opts.limit` matches are collected.
-     *
-     * Why this exists: `load()` parses the entire file into memory and
-     * rebuilds `messages`/`toolCallEnds` for every caller. `search()` only
-     * needs to know which events contain matching text — a per-line
-     * predicate is enough. The full parse work (and the `_loadCache` poll)
-     * is wasted in that case.
-     *
-     * Memory: O(hits) regardless of file size. Disk: one linear scan,
-     * terminated at `limit` if the caller asked for one.
-     *
-     * Errors: missing file yields []. Corrupt lines are skipped (same
-     * policy as `load()`). Aborting via `signal` rejects with `AbortError`.
-     */
-    searchEvents(id: string, predicate: (event: SessionEvent, eventIndex: number, ts: string) => boolean, opts?: {
-        limit?: number | undefined;
-        signal?: AbortSignal | undefined;
-    }): Promise<Array<{
-        event: SessionEvent;
-        eventIndex: number;
-        ts: string;
-    }>>;
-    list(limit?: number): Promise<SessionSummary[]>;
-    /**
-     * List sessions matching filter criteria, using the cached index.
-     * Filters are applied BEFORE sorting and slicing, so the caller gets
-     * exactly `limit` matching sessions — not a slice of a larger fetch.
-     *
-     * This avoids the DefaultSessionReader pattern of fetching 1000 sessions
-     * then linear-filtering: the index is already in memory (readIndex
-     * caches it), and the filter runs over the cached array without any
-     * additional disk I/O.
-     */
-    listFiltered(criteria: {
-        since?: string | undefined;
-        until?: string | undefined;
-        provider?: string | undefined;
-        model?: string | undefined;
-        minTokens?: number | undefined;
-        titleContains?: string | undefined;
-        limit?: number | undefined;
-    }): Promise<SessionSummary[]>;
-    private indexAppendCount;
-    private static readonly COMPACT_EVERY;
-    /** Append a session summary to the index. */
-    private appendToIndex;
-    /** Append a tombstone entry for a deleted session. */
-    private writeTombstone;
-    /**
-     * Compact the index: read all entries, drop tombstones, deduplicate
-     * (keep latest per session), and rewrite atomically. Acquires the index
-     * file lock so a concurrent append (this process or another wstack in the
-     * same project) can't be overwritten by the rewrite.
-     */
-    private compactIndex;
-    /**
-     * Lock-free compaction body. The caller MUST already hold the index file
-     * lock (via withFileLock(this.indexFile, ...)). Uses atomicWrite for the
-     * rewrite so the temp file gets a random suffix (no collision between two
-     * compactions) and the Windows transient-EPERM rename retry.
-     */
-    private compactIndexInner;
-    /**
-     * Read the index file and return deduplicated session summaries.
-     * Entries with a matching tombstone are filtered out.
-     * Returns empty array when the index doesn't exist or is corrupt.
-     */
-    private readIndex;
-    /**
-     * Rebuild the index from disk by scanning all sessions and writing a
-     * fresh _index.jsonl. Useful after manual cleanup or index corruption.
-     */
-    rebuildIndex(): Promise<number>;
-    private listFromDirectoryScan;
-    private collectShardKeys;
-    private readOrBuildShardManifest;
-    private collectSessionFilesInShard;
-    private collectSessionFiles;
-    /** Recursively collect session IDs from date-shard subdirectories.
-     *  IDs include the date-prefix path (e.g. "2026-06-06/17-46-57Z_…").
-     *  Skips `.jsonl`/`.summary.json` root files, dot-files, and
-     *  sub-directories that belong to fleet/subagent sessions. */
-    private collectSessionIds;
-    private summaryFor;
-    private readSummaryManifest;
-    private summaryHeaderFor;
-    /**
-     * Delete a session and all associated files: JSONL, summary, plan/todos
-     * sidecars, and the session directory (fleet.json, shared/, subagents/).
-     *
-     * Individual file deletions are best-effort (logged as structured warnings),
-     * but a tombstone is always written so readIndex() filters this session out.
-     * If the session directory itself can't be removed, the error is surfaced
-     * to the caller so prune() can report it.
-     */
-    private deleteSession;
-    /**
-     * Read the session id currently marked active in `active.json`, or `null`
-     * when the lock is absent/unreadable. Shared by {@link delete} and
-     * {@link prune} to avoid clobbering a session a live process is writing to.
-     */
-    private readActiveSessionId;
-    delete(id: string): Promise<void>;
-    rename(id: string, name: string): Promise<SessionSummary>;
-    prune(maxAgeDays?: number): Promise<number>;
-    clearHistory(id: string): Promise<void>;
-    private summarize;
-    private iterSessionEvents;
-}
-
-/**
- * On-disk checkpoint for `ctx.todos`. Written atomically every time the
- * todo list changes, read once on session resume. This is the missing
- * piece that lets `wstack resume <id>` rehydrate where the previous run
- * stopped instead of starting with an empty board.
- *
- * Schema is intentionally small — a single JSON object so a future
- * format bump is easy. The `version` field is the only contract; the
- * shape under `todos` mirrors `TodoItem` so reading is a straight assign.
- */
-interface TodosCheckpointFile {
-    version: 1;
-    sessionId: string;
-    updatedAt: string;
-    todos: TodoItem[];
-}
-type TodosCheckpointDetach = () => Promise<void>;
-/** Read a checkpoint from disk. Returns null when the file doesn't
- *  exist or is corrupt — callers treat both cases as "no prior state".
- */
-declare function loadTodosCheckpoint(filePath: string, events?: EventBus, traceId?: string): Promise<TodoItem[] | null>;
-/** Write the checkpoint atomically. Best-effort: a write failure is
- *  logged but does not throw — losing one checkpoint shouldn't bring
- *  down the agent run.
- */
-declare function saveTodosCheckpoint(filePath: string, sessionId: string, todos: readonly TodoItem[], events?: EventBus, traceId?: string): Promise<void>;
-/**
- * Subscribe a `ConversationState` so every `todos_replaced` mutation
- * triggers an atomic write to disk. Returns the unsubscribe function.
- *
- * Writes are debounced by 150ms so a flurry of edits (e.g. the LLM
- * marking three items done in the same tool call) coalesces into one
- * disk hit.
- */
-declare function attachTodosCheckpoint(state: ConversationState, filePath: string, sessionId: string, events?: EventBus, traceId?: string): TodosCheckpointDetach;
-
-export { type AbandonedSession as A, getPlanTemplate as B, type ConfigLoaderOptions as C, DEFAULT_CONFIG_MIGRATIONS as D, listPlanTemplates as E, FileMemoryBackend as F, loadPlan as G, loadTodosCheckpoint as H, mutatePlan as I, parseEntries as J, removePlanItem as K, runConfigMigrations as L, type MemoryBackend as M, savePlan as N, saveTodosCheckpoint as O, type PersistedQueueItem as P, QueueStore as Q, RecoveryLock as R, SessionAnalyzer as S, type TodosCheckpointFile as T, setPlanItemStatus as U, type AttachmentStoreOptions as a, type ConfigMigration as b, ConfigMigrationError as c, type ConfigSource as d, DefaultAttachmentStore as e, DefaultConfigLoader as f, DefaultConfigStore as g, DefaultMemoryStore as h, DefaultSessionStore as i, type FileMemoryBackendOptions as j, type MemoryStoreOptions as k, type MigrationContext as l, type MigrationResult as m, type PlanFile as n, type PlanItem as o, type PlanTemplate as p, type RecoveryLockOptions as q, type SessionStoreOptions as r, addPlanItem as s, attachPlanCheckpoint as t, attachTodosCheckpoint as u, clearPlan as v, deriveTodosFromPlanItem as w, emptyPlan as x, formatPlan as y, formatPlanTemplates as z };