@wrongstack/core 0.284.0 → 0.285.0

package/dist/storage/index.d.ts

@@ -1,1031 +1,39 @@
-import { M as MemoryBackend, j as FileMemoryBackendOptions } from '../todos-checkpoint-FY7PjmMx.js';
-export { A as AbandonedSession, a as AttachmentStoreOptions, C as ConfigLoaderOptions, b as ConfigMigration, c as ConfigMigrationError, d as ConfigSource, D as DEFAULT_CONFIG_MIGRATIONS, e as DefaultAttachmentStore, f as DefaultConfigLoader, g as DefaultConfigStore, h as DefaultMemoryStore, i as DefaultSessionStore, F as FileMemoryBackend, k as MemoryStoreOptions, l as MigrationContext, m as MigrationResult, P as PersistedQueueItem, n as PlanFile, o as PlanItem, p as PlanTemplate, Q as QueueStore, R as RecoveryLock, q as RecoveryLockOptions, S as SessionAnalyzer, r as SessionStoreOptions, T as TodosCheckpointFile, s as addPlanItem, t as attachPlanCheckpoint, u as attachTodosCheckpoint, v as clearPlan, w as deriveTodosFromPlanItem, x as emptyPlan, y as formatPlan, z as formatPlanTemplates, B as getPlanTemplate, E as listPlanTemplates, G as loadPlan, H as loadTodosCheckpoint, I as mutatePlan, J as parseEntries, K as removePlanItem, L as runConfigMigrations, N as savePlan, O as saveTodosCheckpoint, U as setPlanItemStatus } from '../todos-checkpoint-FY7PjmMx.js';
-import { c as Request, e as Response, W as WorkspaceCheckpointRef, w as WorkspaceMaterializationResult, P as Provider, S as SessionEvent, G as CompletedWorkEvidence } from '../tool-BNlnIJvo.js';
-import { E as EventBus, M as MemoryScope, b as MemoryEntry, c as MemoryStore } from '../events-Bgnh43r9.js';
-import { j as AgentExtension, l as AfterRunHook } from '../index--Gm41aBJ.js';
-import { P as ProviderConfig, ab as SyncCategory, m as SyncConfig } from '../config-MRqn1V-u.js';
-import { S as SecretVault } from '../secret-vault-BAKpgFw_.js';
-export { D as DefaultSessionReader, f as DefaultSessionReaderOptions, S as SessionReader } from '../session-reader-7Esxrkpw.js';
-import { b as SessionRegistry, A as AgentEntry } from '../session-registry-Dvg7i_IA.js';
-export { a as AgentLiveStatus, S as SessionLiveStatus, c as SessionRegistryEntry, g as getSessionRegistry, h as hasSessionRegistry } from '../session-registry-Dvg7i_IA.js';
-import { S as SessionRewinder, C as CheckpointInfo, a as RewindResultExtended } from '../session-rewinder-C9HnMkhP.js';
-import { T as TaskItem } from '../task-format-GX0B1mMC.js';
-export { a as DirectorStateCheckpoint, D as DirectorStateSnapshot, b as DirectorSubagentState, c as DirectorTaskState, l as loadDirectorState } from '../director-state-CMS_bMs4.js';
-export { G as GoalFile, J as JournalEntry, M as MAX_JOURNAL_ENTRIES, a as MAX_PROGRESS_HISTORY, P as ProgressSnapshot, b as appendJournal, e as emptyGoal, f as formatGoal, g as goalFilePath, l as loadGoal, p as parseProgressFromText, r as recordProgress, s as saveGoal, c as setProgress, d as summarizeUsage } from '../goal-store-Datpp-ar.js';
-import { a as PromptEntry } from '../prompt-DLd35n4Q.js';
-import { W as WstackPaths } from '../wstack-paths-C3K40Qst.js';
-import { S as SecretScrubber } from '../secret-scrubber-3MHDDAtm.js';
-export { A as AuditLevel, C as CORE_RECONSTRUCT_EVENTS, a as STANDARD_AUDIT_EVENTS, S as SessionEventBridge, b as SessionEventBridgeOptions, c as SessionSamplingOptions, T as ToolProgressSamplingOptions, d as createSessionEventBridge, r as resolveAuditLevel, e as resolveSessionLoggingConfig } from '../session-event-bridge-D_z_mBwk.js';
-import '../permission-ByDKXEcG.js';
-import '../logger-B63L5bTg.js';
-import '../pipeline-DGDyIohT.js';
-import '../mailbox-types-BGZWrYTJ.js';
-import '../observability-D-HZN_mF.js';
-import '../task-graph-CH3acNQ7.js';
-
-interface PromptStore {
-    list(): Promise<PromptEntry[]>;
-    get(id: string): Promise<PromptEntry | null>;
-    save(entry: PromptEntry): Promise<void>;
-    delete(id: string): Promise<boolean>;
-    find(query: string): Promise<PromptEntry[]>;
-}
-/** sha256 of a prompt's content — used for builtin/synced integrity checks. */
-declare function promptChecksum(content: string): string;
-/**
- * Upgrade any persisted prompt record (v1 or v2) to a fully-populated v2
- * `PromptEntry`. Pure — does not touch disk. v1 records (only
- * `id/title/content/tags/createdAt/updatedAt`) get sensible defaults:
- * slug from title, empty description, `uncategorized` category, `user` source.
- */
-declare function migratePromptEntry(raw: unknown): PromptEntry | null;
-/**
- * DefaultPromptStore — file-per-prompt JSON in a single directory (the global
- * `~/.wrongstack/prompts` by default, or a layer dir the loader passes in).
- * Reads tolerate legacy v1 files via `migratePromptEntry`; writes always emit
- * the current v2 schema.
- */
-declare class DefaultPromptStore implements PromptStore {
-    private readonly dir;
-    constructor(pathsOrDir: WstackPaths | string);
-    list(): Promise<PromptEntry[]>;
-    get(id: string): Promise<PromptEntry | null>;
-    save(entry: PromptEntry): Promise<void>;
-    delete(id: string): Promise<boolean>;
-    find(query: string): Promise<PromptEntry[]>;
-    /** Create a new v2 entry and return it. Does NOT persist — call save() afterwards. */
-    createNew(title: string, content: string, tags?: string[], extra?: Partial<Omit<PromptEntry, 'id' | 'title' | 'content' | 'tags' | 'createdAt' | 'updatedAt'>>): PromptEntry;
-}
-
-interface PromptUsage {
-    count: number;
-    lastUsedAt: string;
-}
-/**
- * Tracks how often each prompt is inserted, keyed by slug, in a single JSON
- * file (`~/.wrongstack/prompt-usage.json`). Kept SEPARATE from the prompt
- * entries so usage can be recorded for read-only builtin prompts without
- * copy-on-writing them into the user layer. Surfaces "recent / most-used"
- * views and a gentle search-ranking boost.
- */
-declare class PromptUsageStore {
-    private readonly file;
-    constructor(file: string);
-    load(): Promise<Record<string, PromptUsage>>;
-    record(slug: string, at?: string): Promise<PromptUsage>;
-    get(slug: string): Promise<PromptUsage | undefined>;
-    /** Slugs ordered by most-recently-used (then by count), capped at `limit`. */
-    recent(limit?: number): Promise<{
-        slug: string;
-        usage: PromptUsage;
-    }[]>;
-    /** Slugs ordered by usage count (then recency), capped at `limit`. */
-    top(limit?: number): Promise<{
-        slug: string;
-        usage: PromptUsage;
-    }[]>;
-}
-
-/**
- * ReplayLogStore — sidecar store for deterministic-replay support
- * (idea #2 from IDEAS.md). One JSONL file per session, recording
- * every provider request/response pair so the same agent loop can
- * be re-run later with frozen API responses.
- *
- * Why a sidecar (not the session JSONL)?
- *
- *   Same reason as `AnnotationsStore` — the session log is
- *   event-sourced and append-only; a provider request payload can be
- *   tens of kilobytes (especially with long conversation history),
- *   and we want replay to be opt-in (recorded only when the user
- *   runs with `--replay` or a future equivalent). Mixing it into
- *   the event log would inflate every read for replay-irrelevant
- *   paths.
- *
- * File layout: `sessionScopedPath(dir, sessionId, '.replay.jsonl')`,
- * one entry per line.
- * Each entry: `{ hash, ts, request, response }`. The `hash` is
- * computed via `hashRequest` so lookups are O(1) by hash.
- *
- * Concurrency: per-session write queue (same pattern as
- * `AnnotationsStore`). Reads are lock-free; the write chain makes
- * the append + rehash sequence atomic.
- */
-interface ReplayEntry {
-    hash: string;
-    ts: string;
-    request: Request;
-    response: Response;
-}
-interface ReplayLogStoreOptions {
-    /** Root sessions directory used with `sessionScopedPath(..., '.replay.jsonl')`. */
-    dir: string;
-    /**
-     * Cap on the number of entries per session. When a `record` would
-     * push the file beyond this, the oldest entries are evicted (LRU
-     * by insertion order). Set to `Infinity` to disable rotation.
-     * Defaults to 1000 — a single LLM call averages ~5KB serialized
-     * (messages + tools + response), so 1000 entries is ~5MB per
-     * session which is a reasonable upper bound.
-     */
-    maxEntries?: number | undefined;
-    events?: EventBus;
-    traceId?: string;
-}
-declare class ReplayLogStore {
-    private readonly dir;
-    private readonly events;
-    private readonly traceId;
-    private readonly writeChains;
-    /** Per-session hash → on-disk location, with lazy entry hydration. */
-    private readonly cache;
-    /** Per-session entry count on disk, to detect when compaction is needed. */
-    private readonly diskCount;
-    private readonly maxEntries;
-    constructor(opts: ReplayLogStoreOptions);
-    /**
-     * Record a request/response pair. Idempotent on hash: a second
-     * `record` for the same hash is a no-op (the existing entry wins).
-     * Returns the hash.
-     */
-    record(input: {
-        sessionId: string;
-        request: Request;
-        response: Response;
-    }): Promise<string>;
-    /**
-     * Look up an entry by hash. Returns `null` when the request has
-     * not been recorded for this session. O(1) after the first call
-     * per session (in-memory cache).
-     */
-    lookup(sessionId: string, hash: string): Promise<ReplayEntry | null>;
-    /** All recorded entries for a session, in insertion order. */
-    load(sessionId: string): Promise<ReplayEntry[]>;
-    /**
-     * List every session id that has a replay log in the store dir.
-     * Returns an array of `{ sessionId, entryCount, path }` sorted
-     * by sessionId for stable output. Used by `wstack replay --list`.
-     */
-    list(): Promise<Array<{
-        sessionId: string;
-        entryCount: number;
-        path: string;
-    }>>;
-    private filePath;
-    private countEntries;
-    private parseReplayLine;
-    private readAll;
-    private writeAll;
-    private ensureCache;
-    private hydrateEntry;
-    private enqueue;
-}
-
-interface CheckpointGitResult {
-    code: number;
-    stdout: string;
-    stderr: string;
-    /** Set when the runner discarded output after its safety limit. */
-    stdoutTruncated?: boolean | undefined;
-    stderrTruncated?: boolean | undefined;
-}
-interface SessionCheckpointCasOptions {
-    rootDir: string;
-    projectRoot: string;
-    runGit?: ((args: string[], cwd: string) => Promise<CheckpointGitResult>) | undefined;
-}
-/**
- * Content-addressed workspace checkpoint store.
- *
- * A manifest references a Git base tree plus CAS blobs for every changed or
- * untracked, non-ignored path. Applying it to a checkout at the same baseHead
- * reproduces the checkpoint without touching the parent working tree.
- */
-declare class SessionCheckpointCas {
-    private readonly rootDir;
-    private readonly projectRoot;
-    private readonly runGit;
-    constructor(opts: SessionCheckpointCasOptions);
-    capture(_sessionId: string, _promptIndex: number): Promise<WorkspaceCheckpointRef | undefined>;
-    materialize(checkpoint: WorkspaceCheckpointRef, targetRoot: string): Promise<WorkspaceMaterializationResult>;
-    private objectPath;
-    private manifestPath;
-    private putBlob;
-    private putManifest;
-    private readBlob;
-    private loadManifest;
-    private safeOutputPath;
-}
-
-/**
- * @deprecated Legacy helper kept for callers that still need filename-safe
- * labels. New session ids are opaque and do not include model/provider names.
- */
-declare function sanitizeModel(model: string): string;
-/**
- * Generate a session ID in the format:
- *   `YYYY-MM-DD/sess_<ULID>`
- *
- * Examples:
- *   `2026-06-06/sess_01JX2S9V7T5M6N7P8Q9R0STXVW`
- *
- * The date prefix becomes a subdirectory so sessions group naturally by day.
- * The leaf is an opaque sortable id; provider/model names belong in metadata,
- * not file paths. Older IDs that contain model/provider text remain readable.
- */
-declare function generateSessionId(startedAt: string, _model?: string): string;
-
-interface GraphNode {
-    id: string;
-    entry: MemoryEntry;
-    firstSeen: string;
-    count: number;
-    /** Extracted metadata for fast lookup. */
-    type?: MemoryEntry['type'] | undefined;
-    tags?: string[] | undefined;
-    priority?: MemoryEntry['priority'] | undefined;
-}
-interface GraphEdge {
-    from: string;
-    to: string;
-    /** Why these nodes are related. */
-    relation: 'co_occurring' | 'similar' | 'same_turn' | 'explicit';
-    weight: number;
-    ts: string;
-}
-interface GraphMemoryBackendOptions extends FileMemoryBackendOptions {
-    /**
-     * Path to the graph metadata file (edges + node metadata).
-     * Defaults to `<projectDir>/memory-graph.json`.
-     */
-    graphPath?: string | undefined;
-}
-/**
- * Graph-based memory backend that tracks relationships between entries.
- * Builds on top of FileMemoryBackend — entries are still persisted as
- * markdown bullets, but the graph layer adds:
- *
- *   - Co-occurrence edges (entries from the same remember() batch)
- *   - Content similarity edges (simple Jaccard on word overlap)
- *   - Turn-based edges (entries created in the same LLM turn)
- *   - Graph traversal queries (find related memories)
- *
- * The graph metadata persists to `<projectDir>/memory-graph.json`.
- */
-declare class GraphMemoryBackend implements MemoryBackend {
-    readonly kind = "graph";
-    private readonly file;
-    private readonly graphFile;
-    private nodes;
-    private edges;
-    private loadedScope;
-    private loaded;
-    /**
-     * Inverted index for O(1) term → node lookup during search.
-     * Built incrementally on remember/forget, rebuilt on loadGraph if absent.
-     * Maps lowercase term (min 3 chars) → Set of node IDs containing that term.
-     */
-    private invertedIndex;
-    /** Minimum term length to index — avoids noise from 1-2 char fragments. */
-    private static readonly MIN_TERM_LEN;
-    /**
-     * Promise that resolves when the current in-flight _saveGraph completes.
-     * Tests call flush() to await this before deleting the backend or its temp dir.
-     * Each save operation chains onto the previous one so concurrent saves are serialised.
-     */
-    private _saveDone;
-    constructor(opts: GraphMemoryBackendOptions);
-    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>;
-    /**
-     * Find memories related to the given entry, ordered by edge weight.
-     */
-    findRelated(scope: MemoryScope, _filePath: string, entryText: string, limit?: number): Promise<MemoryEntry[]>;
-    /**
-     * Get all edges for visualization or traversal.
-     */
-    getGraph(): {
-        nodes: GraphNode[];
-        edges: GraphEdge[];
-    };
-    private nodeId;
-    private loadGraph;
-    /** Fire-and-forget graph persistence. Named _saveGraph to signal it must not be awaited. */
-    private _saveGraph;
-    /**
-     * Wait for all in-flight _saveGraph operations to complete.
-     * Call this before deleting the backend or its temp directory.
-     */
-    flush(): Promise<void>;
-    /**
-     * Build the inverted index from all currently loaded nodes.
-     * Called on loadGraph() to reconstruct the index after loading from disk.
-     */
-    private buildInvertedIndex;
-    /**
-     * Index a node in the inverted index. Adds the node's ID to all term entries.
-     */
-    private indexNode;
-    /**
-     * Remove a node's terms from the inverted index before deleting it.
-     * Used in forget() and when updating existing nodes.
-     */
-    private removeNodeFromIndex;
-    /**
-     * Update an existing node's entries in the inverted index.
-     * Removes old terms and adds new ones.
-     */
-    private updateNodeIndex;
-    /**
-     * Extract searchable terms from a memory entry.
-     * Returns lowercase words from text (min length) and full tag strings.
-     */
-    private extractTerms;
-}
-
-interface ConsolidationOp {
-    action: 'add' | 'edit' | 'delete';
-    /** For add: the fact to remember. For edit: the new text replacing the old. */
-    text?: string | undefined;
-    /** For edit/delete: the query to match existing entries. */
-    query?: string | undefined;
-    /** Memory type for categorization. */
-    type?: string | undefined;
-    /** Tags for grouping. */
-    tags?: string[] | undefined;
-    /** Priority level. */
-    priority?: string | undefined;
-}
-interface MemoryConsolidatorOptions {
-    memoryStore: MemoryStore;
-    /**
-     * Provider used for the consolidation LLM call. Uses the session's
-     * provider by default.
-     */
-    provider?: Provider | undefined;
-    /**
-     * Model override for the consolidation call. Uses the session's model
-     * by default. A smaller/faster model is recommended (e.g. haiku, flash).
-     */
-    model?: string | undefined;
-    /**
-     * Minimum session iterations before consolidation fires.
-     * Sessions shorter than this are skipped (default 2).
-     */
-    minIterations?: number | undefined;
-    /**
-     * Maximum memory entries to include in the prompt as context.
-     */
-    maxExistingEntries?: number | undefined;
-}
-declare class SessionMemoryConsolidator implements AgentExtension {
-    name: string;
-    owner: string;
-    private readonly memoryStore;
-    private readonly provider?;
-    private readonly model?;
-    private readonly minIterations;
-    private readonly maxExistingEntries;
-    constructor(opts: MemoryConsolidatorOptions);
-    afterRun: AfterRunHook;
-}
-
-/**
- * A decrypted snapshot of the credential-bearing slice of `config.json`.
- * `providers` is always present (empty object when the file has none);
- * `apiKey`/`baseUrl` are the top-level fallbacks a provider inherits when its
- * saved entry omits them.
- */
-interface ProviderConfigSnapshot {
-    providers: Record<string, ProviderConfig>;
-    apiKey?: string;
-    baseUrl?: string;
-    /** Display language (Config.uiLocale), surfaced so a cross-process change
-     *  (e.g. the desktop shell) propagates to running webui instances. */
-    uiLocale?: string;
-}
-interface WatchProviderConfigOptions {
-    /** Surface non-fatal read/parse/decrypt issues. */
-    warn?: (msg: string) => void;
-    /** Coalesce bursts of fs events (default 200ms). */
-    debounceMs?: number;
-}
-/**
- * Watch `configPath` for credential changes and invoke `onChange` with a
- * freshly-decrypted snapshot whenever the `providers`/`apiKey`/`baseUrl` slice
- * actually changes. Returns a `close()` that stops watching.
- *
- * The initial on-disk state is read once to seed the no-op guard but does NOT
- * fire `onChange` — only subsequent changes do.
- */
-declare function watchProviderConfig(configPath: string, vault: SecretVault, onChange: (snapshot: ProviderConfigSnapshot) => void, opts?: WatchProviderConfigOptions): {
-    close: () => void;
-};
-
-/**
- * L2-B: AnnotationsStore — sidecar storage for collaboration annotations
- * (Phase 2 of idea #13 from IDEAS.md).
- *
- * Why a sidecar file, not the session JSONL?
- *
- *   The session log is an event-sourced append-only journal
- *   (`packages/core/src/types/session.ts` invariant: events are
- *   append-only, with `truncateToCheckpoint` only as an explicit
- *   rewind). Mixing in human-typed annotations would break that
- *   invariant — the user's note about "this rm looks dangerous"
- *   is not part of the agent's event history; it is meta-commentary
- *   on the history.
- *
- *   So we keep annotations in a sibling file: one JSON document per
- *   session, resolved with `sessionScopedPath(sessionDir, sessionId,
- *   '.annotations.json')`. The shape is a simple versioned array,
- *   written atomically.
- *
- * Concurrency model:
- *
- *   The store uses a per-session Promise chain to serialize writes.
- *   Multiple annotators adding notes at the same time will queue,
- *   not race. The atomic write itself is the second line of
- *   defense (in case the chain is bypassed — e.g. two processes
- *   pointing at the same dir).
- */
-/** Wire/storage shape for one annotation. */
-interface Annotation {
-    /** Stable id (UUIDv4-ish). Referenced by resolve/delete. */
-    id: string;
-    /** Session this annotation belongs to. */
-    sessionId: string;
-    /** Index into the session event log the annotation refers to. */
-    atEventIndex: number;
-    /** Participant id of the annotator (matches WSCollabParticipantJoined.participantId). */
-    authorId: string;
-    /** Human-readable role label snapshot for display (e.g. "annotator"). */
-    authorRole: 'annotator';
-    /** The note itself. Trimmed, capped at `MAX_TEXT_LENGTH` on add. */
-    text: string;
-    /** ISO timestamp of creation. */
-    createdAt: string;
-    /** Resolved state. Annotations start unresolved. */
-    resolved: boolean;
-    /** ISO timestamp when resolved (if resolved). */
-    resolvedAt?: string | undefined;
-    /** Participant id of the resolver (if resolved). */
-    resolvedBy?: string | undefined;
-}
-interface AnnotationsStoreOptions {
-    /** Root sessions directory used with `sessionScopedPath(..., '.annotations.json')`. */
-    dir: string;
-    events?: EventBus;
-    traceId?: string;
-}
-declare class AnnotationsStore {
-    private readonly dir;
-    private readonly events;
-    private readonly traceId;
-    /** Per-session write queue. Created lazily on first add. */
-    private readonly writeChains;
-    constructor(opts: AnnotationsStoreOptions);
-    /**
-     * Return all annotations for `sessionId` in insertion order
-     * (oldest first). Returns an empty array when no file exists
-     * yet (the normal case for a fresh session) and also degrades
-     * gracefully to `[]` on a read error (permissions, corruption) —
-     * the failure is still surfaced via a `storage.read` event so it
-     * never silently hides I/O problems from observers.
-     */
-    list(sessionId: string): Promise<Annotation[]>;
-    /**
-     * Convenience: only unresolved annotations, newest first — the
-     * common UI rendering for "what still needs attention?".
-     */
-    listOpen(sessionId: string): Promise<Annotation[]>;
-    /**
-     * Add a new annotation. Returns the persisted record (with id
-     * and timestamps filled in). Throws when `text` is empty or
-     * exceeds `MAX_TEXT_LENGTH`.
-     */
-    add(input: {
-        sessionId: string;
-        atEventIndex: number;
-        authorId: string;
-        text: string;
-    }): Promise<Annotation>;
-    /**
-     * Mark an annotation as resolved. Returns the updated record, or
-     * `null` if no annotation with that id exists in this session.
-     * Idempotent: resolving an already-resolved annotation refreshes
-     * `resolvedAt` / `resolvedBy` to the latest call.
-     */
-    resolve(input: {
-        sessionId: string;
-        annotationId: string;
-        resolvedBy: string;
-    }): Promise<Annotation | null>;
-    private filePath;
-    private readFile;
-    private writeFile;
-    /**
-     * Serialize writes per-sessionId. We chain promises instead of
-     * using a Mutex class so the contract is obvious from the
-     * call-site: `enqueue(sid, fn)` runs `fn` after every prior
-     * enqueue for `sid` has settled.
-     */
-    private enqueue;
-}
-
-/**
- * Idea #1 from IDEAS.md — Stateful Session Recovery.
- *
- * `SessionRecovery` is the read-side companion to the in-flight
- * marker mechanism. When the agent loop is running, it writes an
- * `in_flight_start` event at the current point in the log. On
- * clean shutdown, a matching `in_flight_end` follows. Provider and
- * tool events may legitimately appear after the start marker, so
- * recovery finds the latest lifecycle boundary rather than assuming
- * the marker is literally the last JSONL record.
- *
- * Detection is diagnostic only. Normal session resume reconstructs the
- * conversation by replaying persisted JSONL events; it must not blindly
- * re-execute tool calls after a crash. `recover()` exposes the tail after the
- * last checkpoint so callers can explain which persisted work was in flight.
- *
- * Concurrency: pure read; no writes. Safe to call from multiple
- * processes simultaneously.
- */
-interface StaleSession {
-    sessionId: string;
-    /** Path to the JSONL log. */
-    path: string;
-    /** Last event ts (the in_flight_start timestamp). */
-    lastEventTs: string;
-    /** Context the agent was working on when it died. */
-    context: string;
-    /** Total events in the log. */
-    eventCount: number;
-}
-interface RecoveryPlan {
-    sessionId: string;
-    /** True if the session is stale (has a dangling in_flight_start). */
-    stale: boolean;
-    /** The last `checkpoint` event before the un-replayed work, or null. */
-    lastCheckpoint: SessionEvent | null;
-    /** All persisted events after the last checkpoint (diagnostic in-flight tail). */
-    pendingEvents: SessionEvent[];
-    /** The dangling in_flight_start event, if any. */
-    inFlightStart: SessionEvent | null;
-    /** Free-form context the agent was working on, if any. */
-    context: string | null;
-}
-/**
- * Result of `SessionRecovery.recover(sessionId)`. Distinct from
- * `StaleSession`: a session is "stale" if its latest lifecycle
- * boundary is an open marker, but a "recovery plan" can also be generated for
- * clean sessions whose last checkpoint is older than the
- * conversation history (e.g. a user-initiated "rewind to last
- * good state" flow). This is a diagnostic plan, not authorization to replay
- * external side effects.
- */
-declare class SessionRecovery {
-    private readonly dir;
-    /**
-     * Scan a session log and return a `StaleSession` if and only if the newest
-     * lifecycle boundary is an `in_flight_start` without a later
-     * `in_flight_end`/`session_end`. Ordinary provider/tool events after the
-     * marker do not make the session clean. Returns `null` when:
-     *   - the log does not exist;
-     *   - the log is empty;
-     *   - the latest lifecycle boundary is `in_flight_end` or `session_end`;
-     *   - there is no lifecycle boundary (legacy/pre-marker log).
-     *
-     * The reverse scanner is chunked and line-aware. It can cross arbitrarily
-     * large JSONL records (for example a large tool result) without imposing a
-     * fixed tail-size correctness limit. Clean logs normally return after the
-     * first chunk; stale logs continue counting lines so `eventCount` remains
-     * the documented total rather than a tail-only approximation.
-     */
-    detectStale(sessionId: string): Promise<StaleSession | null>;
-    /**
-     * Generate a recovery plan for a session. The plan describes
-     * the persisted tail after the last checkpoint, plus the dangling in-flight
-     * marker if present. SessionStore.resume() independently reconstructs state
-     * from the journal and does not re-run these events as commands.
-     *
-     * Returns a non-null plan for ANY session that has at least
-     * one event after a checkpoint (or, for legacy sessions, at
-     * least one event). Pure read; no mutation.
-     */
-    recover(sessionId: string): Promise<RecoveryPlan | null>;
-    /**
-     * List every stale session in a directory. Returns an array
-     * (possibly empty) sorted by `lastEventTs` descending — most
-     * recent crash first.
-     */
-    listResumable(): Promise<StaleSession[]>;
-    private filePath;
-    constructor(dir: string);
-}
-
-/**
- * ToolAuditLog — idea #9 from IDEAS.md.
- *
- * Tamper-evident audit trail for tool calls. Every tool_use /
- * tool_result pair is appended to a sidecar JSONL with a chained
- * SHA-256 — each entry's `prevHash` is the prior entry's `hash`,
- * so any post-hoc modification of a single line breaks the chain
- * from that point forward.
- *
- * Why a sidecar (not the session JSONL)?
- *   Same reason as `AnnotationsStore` and `ReplayLogStore`: the
- *   session log is an event-sourced journal. Mixing in a hash
- *   chain would inflate every read and tightly couple the
- *   integrity check to the event format. Sidecar keeps both
- *   concerns orthogonal.
- *
- * What "tamper-evident" means here:
- *   - The hash covers the full serialized entry: tool name, id,
- *     input, output, timestamp, author. Changing any byte
- *     changes the hash.
- *   - The chain is sequential — a verifier walks the file in
- *     order, recomputing each hash, and checks `prevHash`
- *     matches the previous entry's `hash`.
- *   - Any insertion, deletion, or modification of a single
- *     entry surfaces as a "chain broken at entry N" verdict.
- *
- * What it does NOT defend against:
- *   - An attacker who rewrites the whole file consistently.
- *     For that you'd need an external anchor (signing key,
- *     transparency log, etc.) — out of scope for Phase 1.
- *   - The agent itself misbehaving; this is post-hoc audit, not
- *     real-time enforcement. Use `PermissionPolicy` for that.
- *
- * File layout: `sessionScopedPath(dir, sessionId, '.audit.jsonl')`,
- * one entry per line. The chain starts with a `genesis` entry whose
- * `prevHash` is all zeros.
- */
-interface AuditEntry {
-    /** Monotonic index (0-based). */
-    index: number;
-    /** UUID for cross-referencing with logs. */
-    id: string;
-    /** ISO timestamp. */
-    ts: string;
-    /** Hash of the previous entry (or all-zeros for the genesis entry). */
-    prevHash: string;
-    /** Hash of this entry's content (sha256 over the canonical JSON). */
-    hash: string;
-    toolName: string;
-    toolUseId: string;
-    input: unknown;
-    output: unknown;
-    isError: boolean;
-}
-type VerifyResult = {
-    ok: true;
-    entries: number;
-} | {
-    ok: false;
-    brokenAt: number;
-    reason: string;
-};
-interface ToolAuditLogOptions {
-    /** Root sessions directory used with `sessionScopedPath(..., '.audit.jsonl')`. */
-    dir: string;
-    /**
-     * Flush the file system cache to disk every N writes per session.
-     * Default 100. Lower values = better crash durability, more I/O overhead.
-     * Set to `Infinity` to disable periodic fsync (fastest, but highest data-loss risk).
-     */
-    fsyncEvery?: number | undefined;
-    events?: EventBus;
-    traceId?: string;
-}
-declare class ToolAuditLog {
-    private readonly dir;
-    private readonly events;
-    private readonly traceId;
-    /** In-memory cache of the last entry's hash (per session), to compute chains efficiently. */
-    private readonly tailHash;
-    /** In-memory counter for entry indices — avoids re-reading the file on every write. */
-    private readonly tailIndex;
-    /**
-     * File mtime+size recorded after our last write, per session. Used to
-     * detect cross-process writes (session handoff, recovery) that would
-     * invalidate the in-memory tail cache: if the stat no longer matches
-     * we re-read the file to re-establish the chain tip before appending.
-     */
-    private readonly tailStat;
-    /** Tracks writes since last fsync, per session. */
-    private readonly unSyncedWrites;
-    private readonly writeChains;
-    private readonly fsyncEvery;
-    constructor(opts: ToolAuditLogOptions);
-    /**
-     * Append a tool call/result pair to the chain. Returns the
-     * resulting entry. Idempotency is not guaranteed — if you
-     * record the same tool_use twice you get two entries. That's
-     * intentional: the audit log is a record, not a cache.
-     */
-    record(input: {
-        sessionId: string;
-        toolName: string;
-        toolUseId: string;
-        input: unknown;
-        output: unknown;
-        isError: boolean;
-    }): Promise<AuditEntry>;
-    /**
-     * Resolve the chain tip (previous hash + next index) for an append.
-     * Uses the in-memory `tailHash`/`tailIndex` cache when the file's
-     * stat matches our last known write; falls back to a full read on
-     * cache miss or when an external writer has extended the file.
-     */
-    private _resolveChainTip;
-    /**
-     * Walk the chain and verify every entry's hash and prevHash.
-     * Returns a structured verdict — never throws.
-     */
-    verify(sessionId: string): Promise<VerifyResult>;
-    /** All entries for a session, in insertion order. */
-    load(sessionId: string): Promise<AuditEntry[]>;
-    private filePath;
-    private readAll;
-    /**
-     * Tracks writes since last fsync and triggers periodic fsync.
-     * Called after each O(1) append to maintain the same durability
-     * guarantees as the old writeAll approach.
-     */
-    private _trackUnsynced;
-    /**
-     * Explicitly sync the file to disk. Called automatically every
-     * `fsyncEvery` writes, and available for callers who want to
-     * force a sync before closing or during graceful shutdown.
-     */
-    flush(sessionId: string): Promise<void>;
-    private sync;
-    private enqueue;
-}
-
-/**
- * AgentStatusTracker — subscribes to EventBus events and keeps the
- * SessionRegistry updated with live agent status.
- *
- * Created once per process during boot. Listens for:
- * - agent.run.started / agent.run.completed → agent status changes
- * - tool.started / tool.executed → current tool tracking
- * - brain.ask_human → waiting_user status
- * - fleet events (subagent spawn/start/done) → agent entries
- *
- * @module agent-status-tracker
- */
-
-interface AgentStatusTrackerOptions {
-    events: EventBus;
-    registry: SessionRegistry;
-    /** Session id whose live agent state is mirrored by this tracker. */
-    sessionId?: string | (() => string | undefined) | undefined;
-    /** Leader agent name shown in the registry. Default: "leader". */
-    leaderName?: string | undefined;
-    /**
-     * Best-effort callback fired after each registry write settles. Used to nudge
-     * local WebUI servers (FleetNotifier) so cross-process status reaches the map
-     * without waiting on their file-watch/poll. Never block or throw.
-     */
-    onUpdate?: (() => void) | undefined;
-}
-declare class AgentStatusTracker {
-    private readonly events;
-    private readonly registry;
-    private readonly sessionId;
-    private readonly leaderName;
-    private agents;
-    private lastAgents;
-    private leaderStatus;
-    private leaderCurrentTool;
-    private leaderIterations;
-    private leaderToolCalls;
-    private leaderCostUsd;
-    private leaderTokensIn;
-    private leaderTokensOut;
-    private leaderCtxPct;
-    private leaderModel;
-    private leaderPartialText;
-    private leaderStartedAt;
-    private unsubscribers;
-    private readonly onUpdate;
-    private sweepTimer;
-    private partialTimer;
-    constructor(opts: AgentStatusTrackerOptions);
-    /** Current full agent list (leader + subagents) as of the last flush. */
-    getAgents(): AgentEntry[];
-    start(): void;
-    stop(): void;
-    /**
-     * Coalesce streamed-text flushes: at most one registry write per
-     * {@link PARTIAL_FLUSH_THROTTLE_MS} while text streams in, so per-token
-     * deltas never thrash the cross-process registry file.
-     */
-    private schedulePartialFlush;
-    /**
-     * Remove subagents that have been finished (idle/error) for longer than
-     * {@link AGENT_REAP_MS}. Running / streaming / waiting_user agents are kept
-     * regardless of age — only *not-working* agents are reaped.
-     */
-    private sweep;
-    private flush;
-    private currentSessionId;
-    private acceptsSession;
-    private markLeaderStarted;
-    private captureLeaderContext;
-}
-
-interface FleetNotifierOptions {
-    /** WrongStack global dir (`~/.wrongstack`) holding `webui-instances.json`. */
-    baseDir: string;
-    /** This process's project root — only WebUIs on the same project are pinged. */
-    projectRoot: string;
-    /** This process's pid, so a WebUI never pings itself. */
-    selfPid?: number | undefined;
-    /** Injectable POST for tests. Defaults to a timed `fetch`. */
-    post?: ((url: string) => Promise<void>) | undefined;
-}
-declare class FleetNotifier {
-    private readonly baseDir;
-    private readonly projectRoot;
-    private readonly selfPid;
-    private readonly doPost;
-    private cache;
-    private timer;
-    private disposed;
-    constructor(opts: FleetNotifierOptions);
-    /** Coalesced, best-effort nudge. Safe to call on every status change. */
-    notify(): void;
-    /** Resolve same-project WebUI ping URLs (cached briefly). Exposed for tests. */
-    endpoints(): Promise<string[]>;
-    dispose(): void;
-    private flush;
-    private discover;
-}
-
-interface SessionRewinderOptions {
-    sessionsDir: string;
-    /** The project root directory; used to validate rewind targets stay inside it. */
-    projectRoot: string;
-}
-/**
- * Rewind engine that reads session JSONL files and reverts file system
- * changes to any previous checkpoint.
- */
-declare class DefaultSessionRewinder implements SessionRewinder {
-    private readonly sessionsDir;
-    private readonly projectRoot;
-    constructor(sessionsDir: string, projectRoot: string);
-    private sessionFile;
-    listCheckpoints(sessionId: string): Promise<CheckpointInfo[]>;
-    rewindToCheckpoint(sessionId: string, checkpointIndex: number): Promise<RewindResultExtended>;
-    rewindLastN(sessionId: string, n: number): Promise<RewindResultExtended>;
-    rewindToStart(sessionId: string): Promise<RewindResultExtended>;
-}
-
-interface CompletedWorkCheckpointFile {
-    version: 1;
-    sessionId: string;
-    updatedAt: string;
-    completedWork: CompletedWorkEvidence[];
-}
-declare function loadCompletedWorkCheckpoint(filePath: string, events?: EventBus, traceId?: string): Promise<CompletedWorkEvidence[] | null>;
-declare function saveCompletedWorkCheckpoint(filePath: string, sessionId: string, completedWork: readonly CompletedWorkEvidence[], events?: EventBus, traceId?: string): Promise<void>;
-
-interface TaskFile {
-    version: 1;
-    sessionId: string;
-    updatedAt: string;
-    tasks: TaskItem[];
-}
-declare function emptyTaskFile(sessionId: string): TaskFile;
-/** Read the task file. Returns null when the file doesn't exist. */
-declare function loadTasks(filePath: string, events?: EventBus, traceId?: string): Promise<TaskFile | null>;
-/**
- * Write the task file atomically. Prefer `mutateTasks` for read-modify-write
- * cycles — this low-level function does NOT acquire a lock.
- */
-/**
- * Persist the task file. Returns `true` on success, `false` if the write
- * failed (still emits `storage.error` + warns — does NOT throw). `mutateTasks`
- * inspects the result and throws so the task TOOL can report `ok:false`
- * instead of falsely claiming the tasks were saved.
- */
-declare function saveTasks(filePath: string, tasks: TaskFile, events?: EventBus, traceId?: string): Promise<boolean>;
-/**
- * Load, modify, and save the task file under a file-level lock.
- * `fn` receives the current TaskFile (or a fresh empty one) and must
- * return the mutated TaskFile (mutating in-place is fine — the returned
- * reference is what gets saved).
- *
- * This is the primary API for any code path that reads *and then writes*
- * the task file — it prevents races from parallel `batch_tool_use` calls.
- */
-declare function mutateTasks(filePath: string, sessionId: string, fn: (file: TaskFile) => TaskFile | Promise<TaskFile>, events?: EventBus, traceId?: string): Promise<TaskFile>;
-
-declare const INPUT_HISTORY_DEFAULT_MAX = 100;
-/**
- * Per-project TUI prompt input history.
- *
- * Backed by a single JSON file at `~/.wrongstack/projects/<slug>/input-
- * history.json`. Entries are newest-first, capped at `maxEntries`. Before
- * any entry is written to disk it is passed through a `SecretScrubber` and
- * dropped if it still contains a redacted marker — leaking a pasted API
- * key into a history file would be a real incident, so the scrubber is
- * mandatory, not optional.
- *
- * The store is intentionally small and synchronous-ish (load once at TUI
- * boot, save debounced on change). It mirrors PromptUsageStore's shape so
- * the two read as a family.
- */
-declare class InputHistoryStore {
-    private readonly file;
-    private readonly scrubber;
-    private readonly maxEntries;
-    /**
-     * @param file Absolute path to the per-project input-history.json.
-     * @param scrubber SecretScrubber used to filter secrets before write.
-     * @param maxEntries Cap on the number of entries persisted. Default 100.
-     */
-    constructor(file: string, scrubber: SecretScrubber, maxEntries?: number);
-    /**
-     * Load the persisted entries. Missing or corrupt file → empty list
-     * (never throws — history is best-effort).
-     */
-    load(): Promise<string[]>;
-    /**
-     * Persist `entries` to disk after scrubbing each one. Entries that still
-     * contain a redaction marker AFTER scrubbing are dropped — a half-scrubbed
-     * prompt like "export API_KEY=***REDACTED***" is useless as history and
-     * keeping it risks confusing the agent. Dedup is the caller's job (the
-     * reducer already dedups); this method only scrubs, caps, and writes.
-     */
-    save(entries: string[]): Promise<void>;
-    /** Truncate the file to an empty entry list (used by /clear). */
-    clear(): Promise<void>;
-    /**
-     * Run each entry through the scrubber and drop any that still contain a
-     * redaction marker. Internal so the test suite can pin the policy.
-     */
-    private scrubAndFilter;
-    /**
-     * Heuristic: did the scrubber actually redact anything? DefaultSecretScrubber
-     * replaces matches with "***REDACTED***", so a residual marker means a secret
-     * was detected. Subclasses of SecretScrubber that use a different sentinel
-     * can be accommodated by widening this check in the future; for now the
-     * marker check covers the shipped scrubber.
-     */
-    private looksRedacted;
-}
-
-declare const ALL_SYNC_CATEGORIES: SyncCategory[];
-interface SyncResult {
-    ok: boolean;
-    action: 'push' | 'pull';
-    categories: SyncCategory[];
-    committedAt?: string | undefined;
-    message: string;
-}
-/**
- * CloudSync — push/pull user-selected ~/.wrongstack categories to a
- * private GitHub repo. No git CLI needed; uses GitHub REST API via fetch.
- * The token is stored encrypted via SecretVault (field named `githubToken`
- * so the vault walker picks it up automatically).
- */
-declare class CloudSync {
-    private readonly paths;
-    private readonly getConfig;
-    private readonly setConfig;
-    private readonly statePath;
-    private state;
-    constructor(paths: WstackPaths, getConfig: () => SyncConfig | null, setConfig: (c: SyncConfig) => Promise<void>);
-    status(): Promise<string>;
-    enable(_repo: string, _categories: SyncCategory[]): Promise<string>;
-    disable(): Promise<string>;
-    push(token: string): Promise<SyncResult>;
-    pull(token: string): Promise<SyncResult>;
-    hasLocalChanges(): Promise<boolean>;
-    loadState(): Promise<void>;
-    private githubFetch;
-    private getRef;
-    private updateRef;
-    private getCommit;
-    private getTreeEntries;
-    private createCommit;
-    private createGitTree;
-    private getBlob;
-    private buildLocalTree;
-    private hashLocalCategories;
-    private categoryToPath;
-    private walkDir;
-}
-
-export { ALL_SYNC_CATEGORIES, AgentEntry, AgentStatusTracker, type AgentStatusTrackerOptions, type Annotation, AnnotationsStore, type AnnotationsStoreOptions, type AuditEntry, type CheckpointGitResult, CloudSync, type CompletedWorkCheckpointFile, type ConsolidationOp, DefaultPromptStore, DefaultSessionRewinder, FileMemoryBackendOptions, FleetNotifier, type FleetNotifierOptions, GraphMemoryBackend, type GraphMemoryBackendOptions, INPUT_HISTORY_DEFAULT_MAX, InputHistoryStore, MemoryBackend, type MemoryConsolidatorOptions, PromptEntry, type PromptStore, type PromptUsage, PromptUsageStore, type ProviderConfigSnapshot, type RecoveryPlan, type ReplayEntry, ReplayLogStore, type ReplayLogStoreOptions, SessionCheckpointCas, type SessionCheckpointCasOptions, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, type SessionRewinderOptions, type StaleSession, SyncCategory, SyncConfig, type SyncResult, type TaskFile, ToolAuditLog, type ToolAuditLogOptions, type VerifyResult, type WatchProviderConfigOptions, emptyTaskFile, generateSessionId, loadCompletedWorkCheckpoint, loadTasks, migratePromptEntry, mutateTasks, promptChecksum, sanitizeModel, saveCompletedWorkCheckpoint, saveTasks, watchProviderConfig };
+export { DefaultSessionStore, type SessionStoreOptions, } from './session-store.js';
+export { SessionCheckpointCas, type CheckpointGitResult, type SessionCheckpointCasOptions, } from './session-checkpoint-cas.js';
+export { generateSessionId, sanitizeModel } from './session-id.js';
+export { QueueStore, type PersistedQueueItem, } from './queue-store.js';
+export { DefaultAttachmentStore, type AttachmentStoreOptions, } from './attachment-store.js';
+export { DefaultMemoryStore, type MemoryStoreOptions, } from './memory-store.js';
+export { FileMemoryBackend, type FileMemoryBackendOptions, type MemoryBackend, parseEntries, } from './memory-backend.js';
+export { GraphMemoryBackend, type GraphMemoryBackendOptions, } from './memory-graph-backend.js';
+export { SessionMemoryConsolidator, type MemoryConsolidatorOptions, type ConsolidationOp, } from './memory-consolidator.js';
+export { DefaultConfigStore } from './config-store.js';
+export { watchProviderConfig, type ProviderConfigSnapshot, type WatchProviderConfigOptions, } from './provider-config-watcher.js';
+export { DefaultConfigLoader, type ConfigLoaderOptions, type ConfigSource, } from './config-loader.js';
+export { runConfigMigrations, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, type ConfigMigration, type MigrationContext, type MigrationResult, } from './config-migration.js';
+export { RecoveryLock, type RecoveryLockOptions, type AbandonedSession, } from './recovery-lock.js';
+export { DefaultSessionReader } from './session-reader.js';
+export type { SessionReader, DefaultSessionReaderOptions } from '../types/session-reader.js';
+export { AnnotationsStore, type Annotation, type AnnotationsStoreOptions, } from './annotations-store.js';
+export { ReplayLogStore, type ReplayEntry, type ReplayLogStoreOptions, } from './replay-log-store.js';
+export { SessionRecovery, type StaleSession, type RecoveryPlan, } from './session-recovery.js';
+export { ToolAuditLog, type AuditEntry, type ToolAuditLogOptions, type VerifyResult, } from './tool-audit-log.js';
+export { SessionAnalyzer } from './session-analyzer.js';
+export { SessionRegistry, getSessionRegistry, hasSessionRegistry, type SessionRegistryEntry, type AgentEntry, type AgentLiveStatus, type SessionLiveStatus, } from '../session-registry.js';
+export { AgentStatusTracker, type AgentStatusTrackerOptions, } from '../agent-status-tracker.js';
+export { FleetNotifier, type FleetNotifierOptions, } from '../fleet-notifier.js';
+export { DefaultSessionRewinder, type SessionRewinderOptions, } from './session-rewinder.js';
+export { attachTodosCheckpoint, loadTodosCheckpoint, saveTodosCheckpoint, type TodosCheckpointFile, } from './todos-checkpoint.js';
+export { loadCompletedWorkCheckpoint, saveCompletedWorkCheckpoint, type CompletedWorkCheckpointFile, } from './completed-work-checkpoint.js';
+export { attachPlanCheckpoint, loadPlan, savePlan, emptyPlan, addPlanItem, removePlanItem, setPlanItemStatus, clearPlan, formatPlan, deriveTodosFromPlanItem, mutatePlan, type PlanItem, type PlanFile, } from './plan-store.js';
+export { listPlanTemplates, getPlanTemplate, formatPlanTemplates, type PlanTemplate, } from './plan-templates.js';
+export { loadTasks, saveTasks, emptyTaskFile, mutateTasks, type TaskFile, } from './task-store.js';
+export { DirectorStateCheckpoint, loadDirectorState, type DirectorStateSnapshot, type DirectorTaskState, type DirectorSubagentState, } from './director-state.js';
+export { loadGoal, saveGoal, emptyGoal, appendJournal, formatGoal, setProgress, recordProgress, parseProgressFromText, goalFilePath, summarizeUsage, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, type GoalFile, type JournalEntry, type ProgressSnapshot, } from './goal-store.js';
+export { DefaultPromptStore, migratePromptEntry, promptChecksum, type PromptStore, type PromptEntry, } from './prompt-store.js';
+export { PromptUsageStore, type PromptUsage } from './prompt-usage-store.js';
+export { InputHistoryStore, INPUT_HISTORY_DEFAULT_MAX, } from './input-history-store.js';
+export { CloudSync, type SyncResult, ALL_SYNC_CATEGORIES, } from './cloud-sync.js';
+export { createSessionEventBridge, resolveAuditLevel, resolveSessionLoggingConfig, type SessionEventBridge, type AuditLevel, type SessionEventBridgeOptions, type SessionSamplingOptions, type ToolProgressSamplingOptions, CORE_RECONSTRUCT_EVENTS, STANDARD_AUDIT_EVENTS, } from './session-event-bridge.js';
+export type { SyncConfig, SyncCategory } from '../types/config.js';
+//# sourceMappingURL=index.d.ts.map