@wrongstack/core 0.73.1 → 0.82.6

package/dist/{parallel-eternal-engine-CjAYGaCw.d.ts → parallel-eternal-engine-D402RASp.d.ts}

@@ -1,16 +1,16 @@
-import { d as Context, n as ProviderError, Q as Tool, _ as ToolUseBlock, Y as ToolResultBlock } from './context-y87Jc5ei.js';
-import { a as Compactor, C as CompactReport } from './compactor-D_ExJajC.js';
-import { R as RecoveryDecision, E as ErrorHandler, a as RetryPolicy } from './retry-policy-CG3qvH_e.js';
-import { b as ModelsRegistry } from './models-registry-BcYJDKLm.js';
-import { r as ToolExecutorOptions, s as ToolExecutorStrategy, T as ToolBatchResult } from './index-BN6i2Nfg.js';
-import { A as Agent, c as AgentFactory } from './agent-subagent-runner-BmITbs1Q.js';
-import { J as JournalEntry } from './goal-store-C7jcumEh.js';
-import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from './multi-agent-coordinator-BSBbZt0e.js';
+import { d as Context, n as ProviderError, Q as Tool, _ as ToolUseBlock, Y as ToolResultBlock } from './context-ToHAp4-U.js';
+import { a as Compactor, C as CompactReport } from './compactor-CJq7LQev.js';
+import { R as RecoveryDecision, E as ErrorHandler, a as RetryPolicy } from './retry-policy-DSu6O6rD.js';
+import { b as ModelsRegistry } from './models-registry-Be3osGt5.js';
+import { r as ToolExecutorOptions, s as ToolExecutorStrategy, T as ToolBatchResult } from './index-N0_c4bHQ.js';
+import { A as Agent, c as AgentFactory } from './agent-subagent-runner-2Aq0jOSj.js';
+import { J as JournalEntry } from './goal-store-DvWLNu52.js';
+import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from './multi-agent-coordinator-DllpCVkF.js';
 
 interface CompactorOptions {
-    preserveK?: number;
-    eliseThreshold?: number;
-    estimator?: (text: string) => number;
+    preserveK?: number | undefined;
+    eliseThreshold?: number | undefined;
+    estimator?: (((text: string) => number)) | undefined;
 }
 
 declare class HybridCompactor implements Compactor {
@@ -19,7 +19,7 @@ declare class HybridCompactor implements Compactor {
     private readonly estimator;
     constructor(opts?: CompactorOptions);
     compact(ctx: Context, opts?: {
-        aggressive?: boolean;
+        aggressive?: boolean | undefined;
     }): Promise<CompactReport>;
     /**
      * Estimate the full API request token count: messages + systemPrompt + toolDefs.
@@ -39,7 +39,7 @@ interface RecoveryStrategy {
     /** Human-readable label for logs. */
     label: string;
     /** Optional compactor for context_overflow recovery. */
-    compactor?: Compactor;
+    compactor?: Compactor | undefined;
     /** Returns an explicit recovery decision, or null to fall through. */
     attempt: (err: unknown, ctx: Context) => Promise<RecoveryDecision | null>;
 }
@@ -48,8 +48,8 @@ interface RecoveryStrategy {
  * Exported so callers can customise or extend the strategy chain.
  */
 declare function buildRecoveryStrategies(opts?: {
-    compactor?: Compactor;
-    modelsRegistry?: ModelsRegistry;
+    compactor?: Compactor | undefined;
+    modelsRegistry?: ModelsRegistry | undefined;
 }): RecoveryStrategy[];
 declare const DEFAULT_RECOVERY_STRATEGIES: RecoveryStrategy[];
 declare class DefaultErrorHandler implements ErrorHandler {
@@ -132,7 +132,7 @@ interface EternalAutonomyOptions {
      * Per-iteration agent timeout. Defaults to 5 minutes. A single hung
      * provider call should not freeze the whole eternal loop.
      */
-    iterationTimeoutMs?: number;
+    iterationTimeoutMs?: number | undefined;
     /**
      * Maximum number of internal agent.run iterations the engine grants per
      * eternal-loop tick. The engine sets `autonomousContinue: true` so the
@@ -140,18 +140,18 @@ interface EternalAutonomyOptions {
      * bouncing back to the engine after every single tool call. Default 500.
      * Previous 50 was far too low — agents hit the limit and restart constantly.
      */
-    iterationMaxAgentSteps?: number;
+    iterationMaxAgentSteps?: number | undefined;
     /**
      * Minimum sleep between iterations. Defaults to 1 s — enough for
      * SIGINT handlers to fire mid-loop without pegging a core when the
      * provider is being rate-limited.
      */
-    cycleGapMs?: number;
+    cycleGapMs?: number | undefined;
     /**
      * Maximum consecutive failures before the source rotation forces a
      * brainstorm cycle. Default 3. Acts as a soft-recovery, not a stop.
      */
-    failureBudget?: number;
+    failureBudget?: number | undefined;
     /**
      * Per-todo failed-attempt ceiling. When the engine picks the same todo
      * and the iteration fails this many times in total, the todo is taken
@@ -159,7 +159,7 @@ interface EternalAutonomyOptions {
      * status. Default 3. Prevents the loop from spinning forever on one
      * stuck task.
      */
-    todoMaxAttempts?: number;
+    todoMaxAttempts?: number | undefined;
     /**
      * Consecutive brainstorm-DONE responses required to consider the goal
      * complete and stop the engine. When the LLM's brainstorm step keeps
@@ -167,26 +167,26 @@ interface EternalAutonomyOptions {
      * this many in a row, marks the goal as completed instead of sleeping
      * forever. Default 3.
      */
-    brainstormDoneStopThreshold?: number;
+    brainstormDoneStopThreshold?: number | undefined;
     /** Side-channel notifications (logging, UI updates). */
-    onIteration?: (entry: JournalEntry) => void;
-    onError?: (err: Error, iteration: number) => void;
+    onIteration?: (((entry: JournalEntry) => void)) | undefined;
+    onError?: (err: Error | undefined, iteration: number) => void;
     /**
      * Per-iteration phase notifications for live UI updates (TUI status bar,
      * etc.). Fires at each major stage transition: idle → decide → execute →
      * reflect → (sleep | paused | stopped). Fire-and-forget — the engine
      * does not await the callback.
      */
-    onStage?: (stage: IterationStage) => void;
+    onStage?: (((stage: IterationStage) => void)) | undefined;
     /**
      * Optional injected git status reader — production code uses git, tests
      * stub this out so they don't shell out.
      */
-    gitStatusReader?: () => Promise<string>;
+    gitStatusReader?: ((() => Promise<string>)) | undefined;
     /**
      * Optional clock — tests stub for deterministic timestamps.
      */
-    now?: () => Date;
+    now?: ((() => Date)) | undefined;
     /**
      * Optional compactor. When provided, the engine runs compaction every
      * `compactEveryNIterations` iterations to keep the agent's message
@@ -194,22 +194,22 @@ interface EternalAutonomyOptions {
      * compaction, an infinite loop will eventually overflow the provider's
      * context window and start failing.
      */
-    compactor?: Compactor;
+    compactor?: Compactor | undefined;
     /** How many iterations between compaction calls. Default 25. */
-    compactEveryNIterations?: number;
+    compactEveryNIterations?: number | undefined;
     /**
      * Aggressive compaction threshold. When ctx token usage exceeds this
      * fraction of `maxContextTokens`, compaction runs in aggressive mode
      * regardless of the iteration cadence. 0.85 by default.
      */
-    aggressiveCompactRatio?: number;
+    aggressiveCompactRatio?: number | undefined;
     /**
      * Model's max context window in tokens. When set, the engine watches
      * `currentRequestTokens()` against this and triggers aggressive compact
      * before the next iteration would overflow. Omit to disable threshold
      * checks (iteration cadence still applies).
      */
-    maxContextTokens?: number;
+    maxContextTokens?: number | undefined;
     /**
      * Base delay (ms) for the first transient-error backoff. Subsequent
      * transient failures double this, capped at `transientBackoffMaxMs`.
@@ -221,11 +221,11 @@ interface EternalAutonomyOptions {
      * backoff and count toward `failureBudget` like before — backing off
      * on a permanent failure is wasted time.
      */
-    transientBackoffBaseMs?: number;
+    transientBackoffBaseMs?: number | undefined;
     /** Ceiling for the exponential backoff. Default 60_000 (60 s). */
-    transientBackoffMaxMs?: number;
+    transientBackoffMaxMs?: number | undefined;
     /** Called when the eternal loop stops for any reason (manual stop, goal complete, etc.). */
-    onEternalStop?: () => void;
+    onEternalStop?: ((() => void)) | undefined;
 }
 type EternalEngineState = 'idle' | 'running' | 'stopped';
 /**
@@ -243,7 +243,7 @@ type IterationStage = {
 } | {
     phase: 'reflect';
     status: 'success' | 'failure' | 'aborted' | 'skipped';
-    note?: string;
+    note?: string | undefined;
 } | {
     phase: 'sleep';
     ms: number;
@@ -395,26 +395,26 @@ interface ParallelEternalOptions {
      * `goalFilePath(projectRoot)` (a hashed location under the home dir).
      * Primarily for tests that want an isolated goal file under a temp dir.
      */
-    goalPath?: string;
+    goalPath?: string | undefined;
     /**
      * Number of parallel subagent slots per tick.
      * Default: 4. Range 1–16; values >8 are for high-throughput machines.
      */
-    parallelSlots?: number;
+    parallelSlots?: number | undefined;
     /** Per-subagent default timeout in ms. Default: 300_000 (5 min). */
-    iterationTimeoutMs?: number;
-    onIteration?: (entry: JournalEntry) => void;
-    onError?: (err: Error, iteration: number) => void;
+    iterationTimeoutMs?: number | undefined;
+    onIteration?: (((entry: JournalEntry) => void)) | undefined;
+    onError?: (err: Error | undefined, iteration: number) => void;
     /** Per-tick phase notifications for live UI/status updates. */
-    onStage?: (stage: ParallelIterationStage) => void;
-    gitStatusReader?: () => Promise<string>;
-    now?: () => Date;
-    compactor?: Compactor;
-    compactEveryNIterations?: number;
-    aggressiveCompactRatio?: number;
-    maxContextTokens?: number;
+    onStage?: (((stage: ParallelIterationStage) => void)) | undefined;
+    gitStatusReader?: ((() => Promise<string>)) | undefined;
+    now?: ((() => Date)) | undefined;
+    compactor?: Compactor | undefined;
+    compactEveryNIterations?: number | undefined;
+    aggressiveCompactRatio?: number | undefined;
+    maxContextTokens?: number | undefined;
     /** Override the default agent factory (uses main agent if not provided). */
-    subagentFactory?: AgentFactory;
+    subagentFactory?: AgentFactory | undefined;
     /**
      * Route each decomposed slot task to the best-fit catalog agent via the
      * smart dispatcher (heuristic keyword scoring). When enabled (default), each
@@ -422,13 +422,13 @@ interface ParallelEternalOptions {
      * injected into the task — instead of as a faceless generic worker. Set
      * false to keep the legacy generic spawn.
      */
-    dispatch?: boolean;
+    dispatch?: boolean | undefined;
     /**
      * Optional LLM fallback for ambiguous tasks. Passed straight to
      * `dispatchAgent`; when omitted, routing is pure heuristic (instant, no
      * provider call — preferred for a continuously-ticking autonomous loop).
      */
-    dispatchClassifier?: DispatchClassifier;
+    dispatchClassifier?: DispatchClassifier | undefined;
 }
 /**
  * Sense → Decide → Fan-out (4–8 parallel agents) → Aggregate → Loop.

package/dist/{path-resolver-BnqXa9Ze.d.ts → path-resolver-UPFTsDyD.d.ts}

@@ -1,6 +1,6 @@
-import { E as EventBus } from './events-BBAlxBuw.js';
-import { b as ModelsRegistry, R as ResolvedModel } from './models-registry-BcYJDKLm.js';
-import { O as TokenCounter, $ as Usage, C as CacheStats } from './context-y87Jc5ei.js';
+import { E as EventBus } from './events-DnRqXaZ3.js';
+import { b as ModelsRegistry, R as ResolvedModel } from './models-registry-Be3osGt5.js';
+import { O as TokenCounter, $ as Usage, C as CacheStats } from './context-ToHAp4-U.js';
 import { P as PathResolver } from './path-resolver-CPRj4bFY.js';
 
 /**
@@ -23,9 +23,9 @@ declare class DefaultTokenCounter implements TokenCounter {
     private lastInput;
     private lastCacheRead;
     constructor(opts?: {
-        registry?: ModelsRegistry;
-        providerId?: string;
-        events?: EventBus;
+        registry?: ModelsRegistry | undefined;
+        providerId?: string | undefined;
+        events?: EventBus | undefined;
     });
     account(usage: Usage, model?: string): void;
     /** Synchronous variant for code paths that have already resolved the model. */

package/dist/{permission-V5BLOrY6.d.ts → permission-14CChMmO.d.ts}

@@ -1,20 +1,20 @@
-import { Q as Tool, d as Context, P as Permission } from './context-y87Jc5ei.js';
+import { Q as Tool, d as Context, P as Permission } from './context-ToHAp4-U.js';
 
 interface TrustPolicy {
     [toolNameOrPattern: string]: {
-        allow?: string[];
-        deny?: string[];
-        auto?: boolean;
-        trustWorkdir?: boolean;
-        denyPrivate?: boolean;
+        allow?: string[] | undefined;
+        deny?: string[] | undefined;
+        auto?: boolean | undefined;
+        trustWorkdir?: boolean | undefined;
+        denyPrivate?: boolean | undefined;
     };
 }
 interface PermissionDecision {
     permission: Permission;
-    reason?: string;
+    reason?: string | undefined;
     source: 'default' | 'trust' | 'yolo' | 'yolo_destructive' | 'user' | 'deny' | 'context' | 'subagent_guard';
     /** Risk tier of the tool, if classified. */
-    riskTier?: 'safe' | 'standard' | 'destructive';
+    riskTier?: 'safe' | 'standard' | 'destructive' | undefined;
 }
 interface PermissionPolicy {
     evaluate(tool: Tool, input: unknown, ctx: Context): Promise<PermissionDecision>;
@@ -58,6 +58,8 @@ interface PermissionPolicy {
     getConfirmDestructive?(): boolean;
     /** Enable/disable destructive-operation confirmation (only meaningful in yolo mode). */
     setConfirmDestructive?(enabled: boolean): void;
+    /** Set the prompt delegate (optional). */
+    setPromptDelegate?(delegate: ((tool: Tool, input: unknown, suggestedPattern: string) => Promise<'yes' | 'no' | 'always' | 'deny'>) | undefined): void;
 }
 
 export type { PermissionDecision as P, TrustPolicy as T, PermissionPolicy as a };

package/dist/{permission-policy-CBVx-d-8.d.ts → permission-policy-gW5htOo1.d.ts}

@@ -1,27 +1,27 @@
-import { Q as Tool, d as Context } from './context-y87Jc5ei.js';
+import { Q as Tool, d as Context } from './context-ToHAp4-U.js';
 import { I as InputReader } from './input-reader-E-ffP2ee.js';
-import { a as PermissionPolicy, P as PermissionDecision } from './permission-V5BLOrY6.js';
+import { a as PermissionPolicy, P as PermissionDecision } from './permission-14CChMmO.js';
 
 interface PermissionPolicyOptions {
     trustFile: string;
-    yolo?: boolean;
+    yolo?: boolean | undefined;
     /**
      * When true, YOLO mode auto-approves even destructive calls without confirm.
      * @deprecated YOLO now auto-approves everything by default. Use `confirmDestructive`
      *   to opt back into destructive-operation confirmation prompts.
      */
-    yoloDestructive?: boolean;
+    yoloDestructive?: boolean | undefined;
     /** @deprecated Use `yoloDestructive`. */
-    forceAllYolo?: boolean;
+    forceAllYolo?: boolean | undefined;
     /**
      * When true AND yolo is true, destructive operations still require confirmation.
      * This is the opt-in safety net: set this if you want YOLO for normal work but
      * explicit approval for `rm -rf`, project-escaping writes, etc.
      * Has no effect when yolo is false (normal permission flow applies).
      */
-    confirmDestructive?: boolean;
+    confirmDestructive?: boolean | undefined;
     promptDelegate?: (tool: Tool, input: unknown, suggestedPattern: string) => Promise<'yes' | 'no' | 'always' | 'deny'>;
-    inputReader?: InputReader;
+    inputReader?: InputReader | undefined;
 }
 declare class DefaultPermissionPolicy implements PermissionPolicy {
     private policy;

package/dist/{plan-templates-DBgrTGPu.d.ts → plan-templates-DRvPgkfZ.d.ts}

@@ -1,16 +1,16 @@
-import { E as EventBus } from './events-BBAlxBuw.js';
+import { E as EventBus } from './events-DnRqXaZ3.js';
 import { S as SecretScrubber } from './secret-scrubber-3MHDDAtm.js';
-import { y as SessionStore, x as SessionMetadata, B as SessionWriter, r as ResumedSession, S as SessionData, z as SessionSummary, c as ContentBlock, w as SessionEvent, N as TodoItem, f as ConversationState } from './context-y87Jc5ei.js';
-import { e as AttachmentStore, A as AddAttachmentInput, d as AttachmentRef, a as Attachment } from './session-reader-BIpwM60D.js';
+import { y as SessionStore, x as SessionMetadata, B as SessionWriter, r as ResumedSession, S as SessionData, z as SessionSummary, c as ContentBlock, w as SessionEvent, N as TodoItem, f as ConversationState } from './context-ToHAp4-U.js';
+import { e as AttachmentStore, A as AddAttachmentInput, d as AttachmentRef, a as Attachment } from './session-reader-BQU-toaN.js';
 import { b as MemoryStore, a as MemoryScope } from './memory-CEXuo7sz.js';
-import { a as WstackPaths } from './wstack-paths-eMXnY1_X.js';
-import { c as ConfigStore, a as Config, b as ConfigLoader, w as SyncConfig } from './config-Dy0CK_o6.js';
+import { a as WstackPaths } from './wstack-paths-BQMvEllz.js';
+import { c as ConfigStore, a as Config, b as ConfigLoader, w as SyncConfig } from './config-_DZ7dN-T.js';
 import { S as SecretVault } from './secret-vault-DoISxaKO.js';
 
 interface SessionStoreOptions {
     dir: string;
     /** Optional EventBus for emitting session diagnostics. */
-    events?: EventBus;
+    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
@@ -19,24 +19,62 @@ interface SessionStoreOptions {
      * Tool output is already scrubbed upstream by the executor; this closes the
      * conversation-turn gap (finding F-06).
      */
-    secretScrubber?: SecretScrubber;
+    secretScrubber?: SecretScrubber | undefined;
 }
 declare class DefaultSessionStore implements SessionStore {
     private readonly dir;
     private readonly events?;
     private readonly secretScrubber?;
     constructor(opts: SessionStoreOptions);
+    /** Absolute path to the session index file. */
+    private get indexFile();
     /** Join session ID to its absolute path within the store directory. */
     private sessionPath;
+    /**
+     * 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>;
     resume(id: string): Promise<ResumedSession>;
     load(id: string): Promise<SessionData>;
     list(limit?: number): Promise<SessionSummary[]>;
-    /** Recursively collect all session IDs from shard subdirectories. */
+    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. Atomic via temp+rename.
+     */
+    private compactIndex;
+    /**
+     * 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>;
+    /** 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;
+    /**
+     * Delete a session and all associated files: JSONL, summary, plan/todos
+     * sidecars, and the session directory (fleet.json, shared/, subagents/).
+     */
+    private deleteSession;
     delete(id: string): Promise<void>;
+    prune(maxAgeDays?: number): Promise<number>;
     clearHistory(id: string): Promise<void>;
     private summarize;
     private metaFromEvents;
@@ -79,8 +117,8 @@ interface AttachmentStoreOptions {
      * Directory for spooling payloads larger than `spoolThresholdBytes`.
      * When omitted, all payloads stay in memory.
      */
-    spoolDir?: string;
-    spoolThresholdBytes?: number;
+    spoolDir?: string | undefined;
+    spoolThresholdBytes?: number | undefined;
 }
 /**
  * In-memory attachment store with optional disk spool. Placeholder syntax
@@ -172,7 +210,7 @@ interface ConfigSource {
     /** Unique name for debugging and error messages. */
     name: string;
     /** Lower numbers merge first, higher numbers override lower. Default: 50. */
-    priority?: number;
+    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.
@@ -181,10 +219,10 @@ interface ConfigSource {
 }
 interface ConfigLoaderOptions {
     paths: WstackPaths;
-    strict?: boolean;
-    vault?: SecretVault;
+    strict?: boolean | undefined;
+    vault?: SecretVault | undefined;
     /** Extra sources merged after the built-in layers. */
-    sources?: ConfigSource[];
+    sources?: ConfigSource[] | undefined;
 }
 declare class DefaultConfigLoader implements ConfigLoader {
     private readonly paths;
@@ -193,8 +231,8 @@ declare class DefaultConfigLoader implements ConfigLoader {
     private readonly extraSources;
     constructor(opts: ConfigLoaderOptions);
     load(opts?: {
-        cliFlags?: Partial<Config>;
-        cwd?: string;
+        cliFlags?: Partial<Config> | undefined;
+        cwd?: string | undefined;
     }): Promise<Config>;
     /**
      * Persist a sync config to ~/.wrongstack/sync.json, with the token encrypted
@@ -246,7 +284,7 @@ interface ConfigMigration {
     /** 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;
+    describe?: string | undefined;
 }
 interface MigrationResult {
     /** Final config (still typed as `unknown`-keyed — caller validates). */
@@ -317,19 +355,19 @@ interface RecoveryLockOptions {
     /** Directory the lockfile lives in. Usually `wpaths.projectSessions`. */
     dir: string;
     /** This process's PID. Default: `process.pid`. */
-    pid?: number;
+    pid?: number | undefined;
     /** Hostname recorded for the lock. Default: `os.hostname()`. */
-    hostname?: string;
+    hostname?: string | undefined;
     /** Locks older than this are considered orphaned (disk wiped, etc.). Default 24h. */
-    maxAgeMs?: number;
+    maxAgeMs?: number | undefined;
     /** Used to check whether the abandoned session was actually closed cleanly. */
-    sessionStore?: SessionStore;
+    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;
+    isPidAlive?: (((pid: number) => boolean)) | undefined;
 }
 interface AbandonedSession {
     sessionId: string;
@@ -380,12 +418,12 @@ declare class RecoveryLock {
 }
 
 interface QueryFilter {
-    eventTypes?: string[];
-    toolNames?: string[];
+    eventTypes?: string[] | undefined;
+    toolNames?: string[] | undefined;
     timeRange?: {
         start: string;
         end: string;
-    };
+    } | undefined;
 }
 interface ModeChange {
     ts: string;
@@ -397,7 +435,7 @@ interface TaskSummary {
     title: string;
     status: string;
     createdAt: string;
-    completedAt?: string;
+    completedAt?: string | undefined;
 }
 interface SessionAnalysis {
     sessionId: string;
@@ -463,7 +501,7 @@ interface PlanItem {
     id: string;
     title: string;
     /** Optional longer-form context or rationale. */
-    details?: string;
+    details?: string | undefined;
     status: 'open' | 'in_progress' | 'done';
     createdAt: string;
     updatedAt: string;
@@ -471,7 +509,7 @@ interface PlanItem {
 interface PlanFile {
     version: 1;
     sessionId: string;
-    title?: string;
+    title?: string | undefined;
     updatedAt: string;
     items: PlanItem[];
 }
@@ -479,7 +517,7 @@ declare function loadPlan(filePath: string): Promise<PlanFile | null>;
 declare function savePlan(filePath: string, plan: PlanFile): Promise<void>;
 /** 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): {
+declare function addPlanItem(plan: PlanFile, title: string, details?: string | undefined): {
     plan: PlanFile;
     item: PlanItem;
 };
@@ -495,13 +533,13 @@ declare function formatPlan(plan: PlanFile): string;
  * 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[]): {
+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;
+        activeForm?: string | undefined;
     }>;
 } | null;
 /**
@@ -526,7 +564,7 @@ interface PlanTemplate {
     category: 'development' | 'release' | 'maintenance' | 'infrastructure';
     items: Array<{
         title: string;
-        details?: string;
+        details?: string | undefined;
     }>;
 }
 declare function listPlanTemplates(): PlanTemplate[];

package/dist/{provider-runner-n3KkHT_w.d.ts → provider-runner-COAJM8tC.d.ts}

@@ -1,8 +1,8 @@
-import { E as EventBus } from './events-BBAlxBuw.js';
-import { a as Logger } from './logger-DDd5C--Z.js';
-import { T as Tracer } from './observability-BhnVLBLS.js';
-import { m as Provider, p as Request, d as Context, q as Response } from './context-y87Jc5ei.js';
-import { a as RetryPolicy } from './retry-policy-CG3qvH_e.js';
+import { E as EventBus } from './events-DnRqXaZ3.js';
+import { a as Logger } from './logger-B72yyPc6.js';
+import { T as Tracer } from './observability-CoSNZdhX.js';
+import { m as Provider, p as Request, d as Context, q as Response } from './context-ToHAp4-U.js';
+import { a as RetryPolicy } from './retry-policy-DSu6O6rD.js';
 
 /**
  * Options passed to a ProviderRunner when calling the provider.
@@ -17,7 +17,7 @@ interface RunProviderOptions {
     events: EventBus;
     retry: RetryPolicy;
     logger: Logger;
-    tracer?: Tracer;
+    tracer?: Tracer | undefined;
 }
 /**
  * A replaceable service for calling a provider with retry logic,

package/dist/{retry-policy-CG3qvH_e.d.ts → retry-policy-DSu6O6rD.d.ts}

@@ -1,4 +1,4 @@
-import { d as Context, q as Response, n as ProviderError } from './context-y87Jc5ei.js';
+import { d as Context, q as Response, n as ProviderError } from './context-ToHAp4-U.js';
 
 type RecoveryDecision = {
     /**
@@ -7,7 +7,7 @@ type RecoveryDecision = {
      */
     action: 'retry';
     reason: string;
-    model?: string;
+    model?: string | undefined;
 } | {
     /**
      * Recovery produced a substitute provider response that should be
@@ -15,12 +15,12 @@ type RecoveryDecision = {
      */
     action: 'continue';
     response: Response;
-    reason?: string;
+    reason?: string | undefined;
 } | {
     /** Recovery inspected the error and decided the agent must fail. */
     action: 'fail';
     reason: string;
-    error?: unknown;
+    error?: unknown | undefined;
 };
 interface ErrorHandler {
     /**