@wrongstack/core 0.1.9 → 0.1.10

package/dist/selector-BbJqiEP4.d.ts

@@ -0,0 +1,51 @@
+import { M as Message } from './context-BmM2xGUZ.js';
+
+/**
+ * Result of LLM-driven message importance analysis.
+ * The selector marks each message range with an importance tier,
+ * and optionally provides a natural-language summary for collapsed ranges.
+ */
+interface SelectorResult {
+    /**
+     * Ordered list of kept message ranges. Each entry describes a
+     * message range that should be preserved verbatim in the context.
+     */
+    kept: Array<{
+        from: number;
+        to: number;
+        importance: 'critical' | 'high' | 'medium';
+    }>;
+    /**
+     * Collapsed ranges — either replaced by the compactor or omitted.
+     * Each entry may carry a summary text produced by the LLM.
+     */
+    collapsed: Array<{
+        from: number;
+        to: number;
+        summary?: string;
+    }>;
+    /**
+     * Raw reasoning from the selector LLM (for debugging / audit).
+     */
+    reasoning: string;
+}
+/**
+ * Message selector that uses an LLM to decide which message ranges
+ * to keep vs collapse/summarize. The selector runs as a separate API
+ * call before compaction, making it more surgical than fixed-window
+ * or rules-based approaches.
+ */
+interface MessageSelector {
+    /**
+     * Analyze `messages` and return a structured plan for what to keep
+     * vs collapse. May modify the messages array in-place if needed,
+     * or return a plan that the caller (Compactor) executes.
+     *
+     * @param messages  Current message history (may be modified in-place)
+     * @param maxToKeep Token budget — selector should aim to keep total
+     *                  retained message content under this threshold
+     */
+    select(messages: Message[], maxToKeep: number): Promise<SelectorResult>;
+}
+
+export type { MessageSelector as M, SelectorResult as S };

package/dist/session-reader-Drq8RvJu.d.ts

@@ -0,0 +1,150 @@
+import { b as ContentBlock, m as SessionEvent, n as SessionMetadata, o as SessionStore } from './context-BmM2xGUZ.js';
+
+type AttachmentKind = 'text' | 'image' | 'file';
+interface AttachmentMeta {
+    /** Display label for the placeholder e.g. "123 lines" or "PNG 412 KB". */
+    label?: string;
+    /** Original filename if known. */
+    filename?: string;
+    /** MIME type if known. Required for images. */
+    mediaType?: string;
+}
+interface Attachment {
+    readonly id: string;
+    readonly kind: AttachmentKind;
+    readonly meta: AttachmentMeta;
+    /** In-memory payload. For images this is base64; for text/file it's the raw text. */
+    readonly data?: string;
+    /** Disk location if spooled. Mutually exclusive with `data` for large payloads. */
+    readonly path?: string;
+    readonly bytes: number;
+    readonly createdAt: string;
+}
+interface AttachmentRef {
+    readonly id: string;
+    readonly kind: AttachmentKind;
+    /** Index for display, e.g. `#1`. Stable for the lifetime of a session. */
+    readonly seq: number;
+    readonly meta: AttachmentMeta;
+}
+interface AddAttachmentInput {
+    kind: AttachmentKind;
+    data: string;
+    meta?: AttachmentMeta;
+}
+/**
+ * Session-scoped store for content that is too big to inline in display
+ * but must be sent to the model as a real ContentBlock. The input layer
+ * (CLI/TUI) puts pasted text, dropped files, and pasted images here, gets
+ * back a stable AttachmentRef, and shows a placeholder like `[pasted #1]`
+ * to the user. At submit time, `expand()` swaps placeholders for the real
+ * payload as ContentBlock[].
+ */
+interface AttachmentStore {
+    add(input: AddAttachmentInput): Promise<AttachmentRef>;
+    get(id: string): Promise<Attachment | undefined>;
+    list(): AttachmentRef[];
+    /**
+     * Replace all known placeholder tokens in `text` (e.g. `[pasted #1]`,
+     * `[image #2]`) with the corresponding ContentBlock(s) and return the
+     * mixed array. Unknown placeholders are left as plain text.
+     */
+    expand(text: string): Promise<ContentBlock[]>;
+    clear(): Promise<void>;
+}
+
+/**
+ * L2-A: SessionReader — query, replay, search, export over a `SessionStore`.
+ *
+ * Keeps a clean read-only interface (no `append`, no `delete`) so analytics
+ * code can be wired against a store without granting it the writer surface.
+ */
+type SessionEventType = SessionEvent['type'];
+interface SessionQuery {
+    /** Filter by start timestamp (ISO). Sessions started before this are excluded. */
+    since?: string;
+    /** Filter by start timestamp (ISO). Sessions started after this are excluded. */
+    until?: string;
+    /** Substring match against title (case-insensitive). */
+    titleContains?: string;
+    /** Filter by provider id. */
+    provider?: string;
+    /** Filter by model id. */
+    model?: string;
+    /** Minimum total tokens (input+output) to keep. */
+    minTokens?: number;
+    /** Limit result count. Defaults to no limit. */
+    limit?: number;
+}
+interface SessionSearchHit {
+    sessionId: string;
+    eventIndex: number;
+    ts: string;
+    type: SessionEventType;
+    /** Short snippet of the matched text — null for events without text content. */
+    snippet: string | null;
+}
+interface SessionSearchQuery {
+    /** Plain text or regex pattern. */
+    query: string;
+    /** Treat `query` as a regex. Defaults to false (literal substring). */
+    regex?: boolean;
+    /** Case-insensitive match. Defaults to true. */
+    caseInsensitive?: boolean;
+    /** Limit only to these event types. Defaults to all event types. */
+    types?: SessionEventType[];
+    /** Limit hit count. Defaults to 100. */
+    limit?: number;
+}
+interface SessionExportOptions {
+    /** "markdown" produces a human-readable chat log; "json" passes through raw events. */
+    format: 'markdown' | 'json' | 'text';
+    /** Include tool_use/tool_result blocks. Defaults to true. */
+    includeTools?: boolean;
+    /** Include system/diagnostic events (errors, compaction). Defaults to true. */
+    includeDiagnostics?: boolean;
+}
+interface SessionSummaryLite {
+    id: string;
+    title: string;
+    startedAt: string;
+    endedAt?: string;
+    provider: string;
+    model: string;
+    tokenTotal: number;
+}
+interface SessionReader {
+    /** List sessions matching the query. Uses the underlying store's summary cache. */
+    query(q?: SessionQuery): Promise<SessionSummaryLite[]>;
+    /** Yield events for `sessionId` in chronological order. */
+    replay(sessionId: string): AsyncIterable<SessionEvent>;
+    /** Full-text/regex search across one or all sessions. */
+    search(q: SessionSearchQuery, sessionId?: string): Promise<SessionSearchHit[]>;
+    /** Render a session for human or downstream-tool consumption. */
+    export(sessionId: string, opts: SessionExportOptions): Promise<string>;
+    /** Read the metadata header without loading the full event stream. */
+    metadata(sessionId: string): Promise<SessionMetadata>;
+}
+interface DefaultSessionReaderOptions {
+    store: SessionStore;
+}
+
+/**
+ * L2-A: read-only view over a `SessionStore` with query, replay, search,
+ * and export helpers. Implemented on top of the public `SessionStore`
+ * surface so any concrete store can be inspected without re-implementation.
+ *
+ * The heavy operations re-parse the JSONL stream on every call — fine for
+ * /resume and one-off analytics. Wrap with a memoizing decorator if needed.
+ */
+declare class DefaultSessionReader implements SessionReader {
+    private readonly store;
+    constructor(opts: DefaultSessionReaderOptions);
+    query(q?: SessionQuery): Promise<SessionSummaryLite[]>;
+    replay(sessionId: string): AsyncIterable<SessionEvent>;
+    search(q: SessionSearchQuery, sessionId?: string): Promise<SessionSearchHit[]>;
+    export(sessionId: string, opts: SessionExportOptions): Promise<string>;
+    metadata(sessionId: string): Promise<SessionMetadata>;
+}
+
+export { type AddAttachmentInput as A, DefaultSessionReader as D, type Attachment as a, type AttachmentKind as b, type AttachmentMeta as c, type AttachmentRef as d, type AttachmentStore as e };

package/dist/skill-DhfSizKv.d.ts

@@ -0,0 +1,72 @@
+import { j as Response, a0 as Context, h as ProviderError } from './context-BmM2xGUZ.js';
+
+type RecoveryDecision = {
+    /**
+     * Recovery mutated state or waited for capacity and the agent should
+     * rebuild the provider request and try the turn again.
+     */
+    action: 'retry';
+    reason: string;
+    model?: string;
+} | {
+    /**
+     * Recovery produced a substitute provider response that should be
+     * processed exactly like a normal model response.
+     */
+    action: 'continue';
+    response: Response;
+    reason?: string;
+} | {
+    /** Recovery inspected the error and decided the agent must fail. */
+    action: 'fail';
+    reason: string;
+    error?: unknown;
+};
+interface ErrorHandler {
+    /**
+     * Attempt to recover from an unretried provider/tool boundary error.
+     *
+     * `null` means "no strategy matched". Non-null decisions are explicit:
+     * retry the current turn, continue with a substitute response, or fail
+     * deliberately. Callers should not infer control flow from truthiness.
+     */
+    recover(err: unknown, ctx: Context): Promise<RecoveryDecision | null>;
+    classify(err: unknown): {
+        kind: 'rate_limit' | 'overloaded' | 'server' | 'client' | 'network' | 'abort' | 'context_overflow' | 'unknown';
+        retryable: boolean;
+    };
+}
+
+interface RetryPolicy {
+    shouldRetry(err: ProviderError | Error, attempt: number): boolean;
+    delayMs(attempt: number): number;
+    maxAttempts(err: ProviderError | Error): number;
+}
+
+interface SkillManifest {
+    name: string;
+    description: string;
+    version?: string;
+    path: string;
+    source: 'project' | 'user' | 'bundled';
+}
+/** Parsed skill entry for structured rendering in system prompt. */
+interface SkillEntry {
+    name: string;
+    /** "Use when..." trigger condition — one-liner */
+    trigger: string;
+    /** Comma-separated scope items */
+    scope: string[];
+    source: SkillManifest['source'];
+    path: string;
+}
+interface SkillLoader {
+    list(): Promise<SkillManifest[]>;
+    /** Structured entries with trigger/scope for system prompt rendering. */
+    listEntries(): Promise<SkillEntry[]>;
+    find(name: string): Promise<SkillManifest | undefined>;
+    manifestText(): Promise<string>;
+    readBody(name: string): Promise<string>;
+}
+
+export type { ErrorHandler as E, RecoveryDecision as R, SkillEntry as S, SkillLoader as a, SkillManifest as b, RetryPolicy as c };

package/dist/storage/index.d.ts

@@ -0,0 +1,382 @@
+import { E as EventBus } from '../events-BMNaEFZl.js';
+import { o as SessionStore, n as SessionMetadata, q as SessionWriter, k as ResumedSession, S as SessionData, p as SessionSummary, b as ContentBlock, m as SessionEvent } from '../context-BmM2xGUZ.js';
+import { e as AttachmentStore, A as AddAttachmentInput, d as AttachmentRef, a as Attachment } from '../session-reader-Drq8RvJu.js';
+export { D as DefaultSessionReader } from '../session-reader-Drq8RvJu.js';
+import { b as MemoryStore, a as MemoryScope } from '../memory-CEXuo7sz.js';
+import { a as WstackPaths } from '../wstack-paths-BGu2INTm.js';
+import { b as ConfigStore, C as Config, a as ConfigLoader } from '../config-BU9f_5yH.js';
+import { S as SecretVault } from '../secret-vault-DoISxaKO.js';
+import '../models-registry-Y2xbog0E.js';
+
+interface SessionStoreOptions {
+    dir: string;
+    /** Optional EventBus for emitting session diagnostics. */
+    events?: EventBus;
+}
+declare class DefaultSessionStore implements SessionStore {
+    private readonly dir;
+    private readonly events?;
+    constructor(opts: SessionStoreOptions);
+    create(meta: Omit<SessionMetadata, 'startedAt'>): Promise<SessionWriter>;
+    resume(id: string): Promise<ResumedSession>;
+    load(id: string): Promise<SessionData>;
+    list(limit?: number): Promise<SessionSummary[]>;
+    private summaryFor;
+    delete(id: string): Promise<void>;
+    private summarize;
+    private metaFromEvents;
+    private replay;
+}
+
+/**
+ * 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;
+    constructor(opts: {
+        dir: string;
+    });
+    write(items: PersistedQueueItem[]): Promise<void>;
+    read(): Promise<PersistedQueueItem[]>;
+    clear(): Promise<void>;
+}
+
+interface AttachmentStoreOptions {
+    /**
+     * Directory for spooling payloads larger than `spoolThresholdBytes`.
+     * When omitted, all payloads stay in memory.
+     */
+    spoolDir?: string;
+    spoolThresholdBytes?: number;
+}
+/**
+ * In-memory attachment store with optional disk spool. Placeholder syntax
+ * is `[<kind> #<seq>]` 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;
+}
+
+interface MemoryStoreOptions {
+    paths: WstackPaths;
+}
+/**
+ * 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;
+    /**
+     * 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 (line 43) so the chain stays alive for
+     * subsequent calls. A crash between atomicWrite() and backup copy leaves
+     * the file at its new content with no backup — acceptable for an optional
+     * backup whose worst case is losing a memory consolidation pass.
+     */
+    private readonly writeChain;
+    constructor(opts: MemoryStoreOptions);
+    private runSerialized;
+    readAll(): Promise<string>;
+    read(scope: MemoryScope): Promise<string>;
+    remember(text: string, scope?: MemoryScope): Promise<void>;
+    forget(query: string, scope?: MemoryScope): Promise<number>;
+    private forgetUnsafe;
+    consolidate(scope: MemoryScope): Promise<void>;
+    private consolidateUnsafe;
+    clear(scope?: MemoryScope): Promise<void>;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+    /**
+     * 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;
+    vault?: SecretVault;
+    /** Extra sources merged after the built-in layers. */
+    sources?: ConfigSource[];
+}
+declare class DefaultConfigLoader implements ConfigLoader {
+    private readonly paths;
+    private readonly strict;
+    private readonly vault;
+    private readonly extraSources;
+    constructor(opts: ConfigLoaderOptions);
+    load(opts?: {
+        cliFlags?: Partial<Config>;
+        cwd?: string;
+    }): Promise<Config>;
+    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;
+}
+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[];
+
+/**
+ * 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;
+    /** Hostname recorded for the lock. Default: `os.hostname()`. */
+    hostname?: string;
+    /** Locks older than this are considered orphaned (disk wiped, etc.). Default 24h. */
+    maxAgeMs?: number;
+    /** Used to check whether the abandoned session was actually closed cleanly. */
+    sessionStore?: SessionStore;
+    /**
+     * 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;
+}
+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. Overwrites any existing lock
+     * — the caller should have already handled abandonment (via
+     * `checkAbandoned`) 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[];
+    toolNames?: string[];
+    timeRange?: {
+        start: string;
+        end: string;
+    };
+}
+interface ModeChange {
+    ts: string;
+    from: string;
+    to: string;
+}
+interface TaskSummary {
+    taskId: string;
+    title: string;
+    status: string;
+    createdAt: string;
+    completedAt?: string;
+}
+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;
+}
+
+export { type AbandonedSession, type AttachmentStoreOptions, type ConfigLoaderOptions, type ConfigMigration, ConfigMigrationError, type ConfigSource, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultSessionStore, type MemoryStoreOptions, type MigrationContext, type MigrationResult, type PersistedQueueItem, QueueStore, RecoveryLock, type RecoveryLockOptions, SessionAnalyzer, type SessionStoreOptions, runConfigMigrations };