@wrongstack/core 0.89.1 → 0.104.0

package/dist/{parallel-eternal-engine-DyMCj2Pw.d.ts → parallel-eternal-engine-CUtmM_0V.d.ts}

@@ -1,34 +1,17 @@
-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-Dx-CnrDN.js';
-import { A as Agent, c as AgentFactory } from './agent-subagent-runner-CQaLFNnA.js';
-import { J as JournalEntry } from './goal-store-DvWLNu52.js';
-import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from './multi-agent-coordinator-Da9nd8Ic.js';
+import { e as ProviderError, C as Context, T as Tool, m as ToolUseBlock, n as ToolResultBlock } from './context-CNRYfhUv.js';
+import { R as RetryPolicy, E as ErrorHandler, a as RecoveryDecision } from './retry-policy-BcmuT_V0.js';
+import { C as Compactor, a as CompactReport } from './compactor-DXLxLcmU.js';
+import { M as ModelsRegistry } from './models-registry-B6_KfS65.js';
+import { T as ToolExecutorOptions, a as ToolExecutorStrategy, b as ToolBatchResult } from './index-DIKEcfgC.js';
+import { g as Agent, h as AgentFactory } from './agent-subagent-runner-DukQLUcS.js';
+import { b as BrainArbiter } from './brain-Dfv4Y82E.js';
+import { J as JournalEntry } from './goal-store-ht0VmR1A.js';
+import { D as DispatchClassifier, a as DefaultMultiAgentCoordinator } from './multi-agent-coordinator-51LvnXkD.js';
 
-interface CompactorOptions {
-    preserveK?: number | undefined;
-    eliseThreshold?: number | undefined;
-    estimator?: (((text: string) => number)) | undefined;
-}
-
-declare class HybridCompactor implements Compactor {
-    private readonly preserveK;
-    private readonly eliseThreshold;
-    private readonly estimator;
-    constructor(opts?: CompactorOptions);
-    compact(ctx: Context, opts?: {
-        aggressive?: boolean | undefined;
-    }): Promise<CompactReport>;
-    /**
-     * Estimate the full API request token count: messages + systemPrompt + toolDefs.
-     * This is the accurate figure for context-window pressure monitoring.
-     */
-    private estimateFullRequest;
-    private eliseOldToolResults;
-    private collapseAncientTurns;
-    private estimateMessages;
+declare class DefaultRetryPolicy implements RetryPolicy {
+    shouldRetry(err: Error | ProviderError, attempt: number): boolean;
+    maxAttempts(err: Error | ProviderError): number;
+    delayMs(attempt: number): number;
 }
 
 /**
@@ -62,10 +45,28 @@ declare class DefaultErrorHandler implements ErrorHandler {
     recover(err: unknown, ctx: Context): Promise<RecoveryDecision | null>;
 }
 
-declare class DefaultRetryPolicy implements RetryPolicy {
-    shouldRetry(err: Error | ProviderError, attempt: number): boolean;
-    maxAttempts(err: Error | ProviderError): number;
-    delayMs(attempt: number): number;
+interface CompactorOptions {
+    preserveK?: number | undefined;
+    eliseThreshold?: number | undefined;
+    estimator?: (((text: string) => number)) | undefined;
+}
+
+declare class HybridCompactor implements Compactor {
+    private readonly preserveK;
+    private readonly eliseThreshold;
+    private readonly estimator;
+    constructor(opts?: CompactorOptions);
+    compact(ctx: Context, opts?: {
+        aggressive?: boolean | undefined;
+    }): Promise<CompactReport>;
+    /**
+     * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+     * This is the accurate figure for context-window pressure monitoring.
+     */
+    private estimateFullRequest;
+    private eliseOldToolResults;
+    private collapseAncientTurns;
+    private estimateMessages;
 }
 
 declare class ToolExecutor {
@@ -227,6 +228,15 @@ interface EternalAutonomyOptions {
     transientBackoffMaxMs?: number | undefined;
     /** Called when the eternal loop stops for any reason (manual stop, goal complete, etc.). */
     onEternalStop?: ((() => void)) | undefined;
+    /**
+     * Optional brain arbiter for autonomous decision-making. When wired,
+     * the engine consults the brain instead of auto-stopping on:
+     * - Brainstorm DONE threshold reached
+     * - Consecutive failures exceeding failure budget
+     * - Goal completion verification
+     * Without a brain, the engine uses its built-in heuristics.
+     */
+    brain?: BrainArbiter | undefined;
 }
 type EternalEngineState = 'idle' | 'running' | 'stopped';
 /**
@@ -358,6 +368,15 @@ declare class EternalAutonomyEngine {
      */
     private clearGoalManually;
     private appendFailure;
+    /**
+     * Consult the brain on whether the goal is truly complete.
+     * Without a brain, always returns true (use heuristic: DONE threshold met = done).
+     */
+    private consultBrainForDone;
+    /**
+     * Persist a progress update from the agent's [PROGRESS: N%] output.
+     */
+    private updateProgress;
     private persistEngineState;
 }
 
@@ -481,4 +500,4 @@ declare class ParallelEternalEngine {
     private persistState;
 }
 
-export { type CompactorOptions as C, DEFAULT_RECOVERY_STRATEGIES as D, EternalAutonomyEngine as E, HybridCompactor as H, type IterationStage as I, type ParallelEngineState as P, type RecoveryStrategy as R, ToolExecutor as T, DefaultErrorHandler as a, DefaultRetryPolicy as b, type EternalAutonomyOptions as c, type EternalEngineState as d, ParallelEternalEngine as e, type ParallelEternalOptions as f, type ParallelIterationStage as g, buildRecoveryStrategies as h };
+export { type CompactorOptions as C, DefaultErrorHandler as D, EternalAutonomyEngine as E, HybridCompactor as H, type IterationStage as I, type ParallelEngineState as P, type RecoveryStrategy as R, ToolExecutor as T, DefaultRetryPolicy as a, type EternalAutonomyOptions as b, type EternalEngineState as c, ParallelEternalEngine as d, type ParallelEternalOptions as e, type ParallelIterationStage as f, DEFAULT_RECOVERY_STRATEGIES as g, buildRecoveryStrategies as h };

package/dist/{path-resolver-TjBlRKyH.d.ts → path-resolver-DDJiMAtX.d.ts}

@@ -1,6 +1,6 @@
-import { E as EventBus } from './events-DzyLtja6.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 { E as EventBus } from './brain-Dfv4Y82E.js';
+import { M as ModelsRegistry, b as ResolvedModel } from './models-registry-B6_KfS65.js';
+import { c as TokenCounter, U as Usage, d as CacheStats } from './context-CNRYfhUv.js';
 import { P as PathResolver } from './path-resolver-CPRj4bFY.js';
 
 /**

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

@@ -1,4 +1,9 @@
-import { Q as Tool, d as Context, P as Permission } from './context-ToHAp4-U.js';
+import { T as Tool, C as Context, f as Permission } from './context-CNRYfhUv.js';
+
+interface SecretScrubber {
+    scrub(text: string): string;
+    scrubObject<T>(obj: T): T;
+}
 
 interface TrustPolicy {
     [toolNameOrPattern: string]: {
@@ -62,4 +67,4 @@ interface PermissionPolicy {
     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 };
+export type { PermissionPolicy as P, SecretScrubber as S, TrustPolicy as T, PermissionDecision as a };

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

@@ -1,6 +1,6 @@
-import { Q as Tool, d as Context } from './context-ToHAp4-U.js';
+import { T as Tool, C as Context } from './context-CNRYfhUv.js';
 import { I as InputReader } from './input-reader-E-ffP2ee.js';
-import { a as PermissionPolicy, P as PermissionDecision } from './permission-14CChMmO.js';
+import { P as PermissionPolicy, a as PermissionDecision } from './permission-BDv7z0mk.js';
 
 interface PermissionPolicyOptions {
     trustFile: string;

package/dist/{system-prompt-C0rLCeyn.d.ts → pipeline-BqiA_UMr.d.ts}

@@ -1,5 +1,75 @@
-import { l as HookEvent, n as HookMatcher, I as InProcessHook, u as ShellHook, H as HookEntry } from './config-_DZ7dN-T.js';
-import { T as TextBlock, c as ContentBlock, Q as Tool } from './context-ToHAp4-U.js';
+import { T as Tool, l as TextBlock, g as ContentBlock } from './context-CNRYfhUv.js';
+import { H as HookEvent, a as HookMatcher, I as InProcessHook, S as ShellHook, b as HookEntry } from './config-BSU-6vah.js';
+
+/** Model capabilities relevant to prompt composition. */
+interface ModelCapabilities {
+    maxContextTokens: number;
+    supportsTools: boolean;
+    supportsVision: boolean;
+    supportsReasoning: boolean;
+}
+interface BuildContext {
+    cwd: string;
+    projectRoot: string;
+    tools: Tool[];
+    /** Provider id (e.g. "anthropic", "minimax-coding-plan"). */
+    provider?: string | undefined;
+    /** Model id (e.g. "claude-sonnet-4-6", "MiniMax-M2.7"). */
+    model?: string | undefined;
+    /**
+     * True when the prompt is being built for a SUBAGENT, not the host
+     * agent. Subagents are scoped to a single task — they should NOT see
+     * the host's strategic plan board (which is anchoring the host across
+     * turns, not steering individual subtasks). The plan-injection
+     * layer short-circuits when this flag is set.
+     */
+    subagent?: boolean | undefined;
+}
+interface SystemPromptBuilder {
+    build(ctx: BuildContext): Promise<TextBlock[]>;
+}
+
+/**
+ * Registry of lifecycle hooks (both in-process and shell). One instance is
+ * shared per session: the boot path loads `config.hooks` as shell entries and
+ * plugins add in-process entries via `PluginAPI.registerHook`. The
+ * `HookRunner` reads from it at each lifecycle phase.
+ */
+declare class HookRegistry {
+    private readonly entries;
+    /** Register an in-process hook. Returns an unsubscribe function. */
+    registerInProcess(event: HookEvent, matcher: HookMatcher | undefined, hook: InProcessHook, owner?: string | undefined): () => void;
+    /** Register a single shell hook. Returns an unsubscribe function. */
+    registerShell(event: HookEvent, hook: ShellHook): () => void;
+    /** Bulk-load shell hooks from a `config.hooks` map. */
+    loadShellHooks(hooks: Partial<Record<HookEvent, ShellHook[]>> | undefined): void;
+    /** All entries registered for an event, in registration order. */
+    list(event: HookEvent): readonly HookEntry[];
+    /** True when any entry is registered for the event. */
+    has(event: HookEvent): boolean;
+    /** Drop every registered hook (used in teardown / tests). */
+    clear(): void;
+    private remove;
+}
+/**
+ * Does a hook matcher apply to a tool name? `*` (or empty) matches everything;
+ * otherwise the matcher is a case-insensitive pipe-delimited list of exact
+ * tool names (`"edit|write"`). Non-tool events pass `undefined` and always match.
+ */
+declare function hookMatcherMatches(matcher: HookMatcher, toolName: string | undefined): boolean;
+
+interface Renderer {
+    write(text: string | TextBlock): void;
+    writeLine(text?: string): void;
+    writeBlock(block: ContentBlock): void;
+    writeToolCall(name: string, input: unknown): void;
+    writeToolResult(name: string, content: unknown, isError: boolean): void;
+    writeDiff(unifiedDiff: string): void;
+    writeWarning(text: string): void;
+    writeError(text: string): void;
+    writeInfo(text: string): void;
+    clear(): void;
+}
 
 /**
  * Container — dependency injection with explicit bind / override / decorate.
@@ -166,74 +236,4 @@ declare class Pipeline<T> {
     private ensureUnique;
 }
 
-/**
- * Registry of lifecycle hooks (both in-process and shell). One instance is
- * shared per session: the boot path loads `config.hooks` as shell entries and
- * plugins add in-process entries via `PluginAPI.registerHook`. The
- * `HookRunner` reads from it at each lifecycle phase.
- */
-declare class HookRegistry {
-    private readonly entries;
-    /** Register an in-process hook. Returns an unsubscribe function. */
-    registerInProcess(event: HookEvent, matcher: HookMatcher | undefined, hook: InProcessHook, owner?: string | undefined): () => void;
-    /** Register a single shell hook. Returns an unsubscribe function. */
-    registerShell(event: HookEvent, hook: ShellHook): () => void;
-    /** Bulk-load shell hooks from a `config.hooks` map. */
-    loadShellHooks(hooks: Partial<Record<HookEvent, ShellHook[]>> | undefined): void;
-    /** All entries registered for an event, in registration order. */
-    list(event: HookEvent): readonly HookEntry[];
-    /** True when any entry is registered for the event. */
-    has(event: HookEvent): boolean;
-    /** Drop every registered hook (used in teardown / tests). */
-    clear(): void;
-    private remove;
-}
-/**
- * Does a hook matcher apply to a tool name? `*` (or empty) matches everything;
- * otherwise the matcher is a case-insensitive pipe-delimited list of exact
- * tool names (`"edit|write"`). Non-tool events pass `undefined` and always match.
- */
-declare function hookMatcherMatches(matcher: HookMatcher, toolName: string | undefined): boolean;
-
-interface Renderer {
-    write(text: string | TextBlock): void;
-    writeLine(text?: string): void;
-    writeBlock(block: ContentBlock): void;
-    writeToolCall(name: string, input: unknown): void;
-    writeToolResult(name: string, content: unknown, isError: boolean): void;
-    writeDiff(unifiedDiff: string): void;
-    writeWarning(text: string): void;
-    writeError(text: string): void;
-    writeInfo(text: string): void;
-    clear(): void;
-}
-
-/** Model capabilities relevant to prompt composition. */
-interface ModelCapabilities {
-    maxContextTokens: number;
-    supportsTools: boolean;
-    supportsVision: boolean;
-    supportsReasoning: boolean;
-}
-interface BuildContext {
-    cwd: string;
-    projectRoot: string;
-    tools: Tool[];
-    /** Provider id (e.g. "anthropic", "minimax-coding-plan"). */
-    provider?: string | undefined;
-    /** Model id (e.g. "claude-sonnet-4-6", "MiniMax-M2.7"). */
-    model?: string | undefined;
-    /**
-     * True when the prompt is being built for a SUBAGENT, not the host
-     * agent. Subagents are scoped to a single task — they should NOT see
-     * the host's strategic plan board (which is anchoring the host across
-     * turns, not steering individual subtasks). The plan-injection
-     * layer short-circuits when this flag is set.
-     */
-    subagent?: boolean | undefined;
-}
-interface SystemPromptBuilder {
-    build(ctx: BuildContext): Promise<TextBlock[]>;
-}
-
-export { type BindOptions as B, Container as C, type Decorator as D, type Factory as F, HookRegistry as H, type Middleware as M, type NextFn as N, Pipeline as P, type ReadonlyPipeline as R, type SystemPromptBuilder as S, type Token as T, type BuildContext as a, type MiddlewareHandler as b, type ModelCapabilities as c, type PipelineOptions as d, type Renderer as e, hookMatcherMatches as h };
+export { type BuildContext as B, Container as C, type Decorator as D, type Factory as F, HookRegistry as H, type MiddlewareHandler as M, type NextFn as N, Pipeline as P, type ReadonlyPipeline as R, type SystemPromptBuilder as S, type Token as T, type Renderer as a, type ModelCapabilities as b, type BindOptions as c, type Middleware as d, type PipelineOptions as e, hookMatcherMatches as h };

package/dist/{plan-templates-D9UhwoGh.d.ts → plan-templates-BdDxl9cI.d.ts}

@@ -1,10 +1,9 @@
-import { E as EventBus } from './events-DzyLtja6.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-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-BQMvEllz.js';
-import { c as ConfigStore, a as Config, b as ConfigLoader, w as SyncConfig } from './config-_DZ7dN-T.js';
+import { E as EventBus, M as MemoryScope, k as MemoryEntry, l as MemoryStore, m as MemoryRelevanceContext, S as ScoredEntry } from './brain-Dfv4Y82E.js';
+import { S as SecretScrubber } from './permission-BDv7z0mk.js';
+import { i as SessionStore, h as SessionMetadata, a as SessionWriter, p as ResumedSession, q as SessionData, r as SessionSummary, g as ContentBlock, S as SessionEvent, s as TodoItem, t as ConversationState } from './context-CNRYfhUv.js';
+import { A as AttachmentStore, a as AddAttachmentInput, b as AttachmentRef, c as Attachment } from './session-reader-DDz1Ek4V.js';
+import { W as WstackPaths } from './wstack-paths-_lqjzErq.js';
+import { e as ConfigStore, d as Config, f as ConfigLoader, g as SyncConfig } from './config-BSU-6vah.js';
 import { S as SecretVault } from './secret-vault-DoISxaKO.js';
 
 interface SessionStoreOptions {
@@ -141,8 +140,49 @@ declare class DefaultAttachmentStore implements AttachmentStore {
     private toBlock;
 }
 
+interface MemoryBackend {
+    readonly kind: string;
+    remember(scope: MemoryScope, entry: MemoryEntry, filePath: string): Promise<void>;
+    forget(scope: MemoryScope, query: string, filePath: string): Promise<number>;
+    readAll(scope: MemoryScope, filePath: string): Promise<string>;
+    list(scope: MemoryScope, filePath: string, limit?: number | undefined): Promise<MemoryEntry[]>;
+    search(scope: MemoryScope, query: string, filePath: string, limit?: number | undefined): Promise<MemoryEntry[]>;
+    /** Find memories related to the given text via graph traversal. Optional — falls back to search. */
+    findRelated?(scope: MemoryScope, filePath: string, text: string, limit: number): Promise<MemoryEntry[]>;
+    clear(scope: MemoryScope, filePath: string): Promise<void>;
+    consolidate(scope: MemoryScope, filePath: string): Promise<number>;
+}
+interface FileMemoryBackendOptions {
+    paths: WstackPaths;
+}
+declare class FileMemoryBackend implements MemoryBackend {
+    readonly kind = "file";
+    private readonly files;
+    constructor(opts: FileMemoryBackendOptions);
+    private resolveFile;
+    remember(scope: MemoryScope, entry: MemoryEntry, filePath: string): Promise<void>;
+    forget(scope: MemoryScope, query: string, filePath: string): Promise<number>;
+    readAll(scope: MemoryScope, filePath: string): Promise<string>;
+    list(scope: MemoryScope, filePath: string, limit?: number): Promise<MemoryEntry[]>;
+    search(scope: MemoryScope, query: string, filePath: string, limit?: number): Promise<MemoryEntry[]>;
+    clear(scope: MemoryScope, filePath: string): Promise<void>;
+    consolidate(scope: MemoryScope, filePath: string): Promise<number>;
+}
+declare function parseEntries(raw: string, scope?: MemoryScope): MemoryEntry[];
+
 interface MemoryStoreOptions {
     paths: WstackPaths;
+    /**
+     * Optional event bus — when provided, mutations emit events so plugins
+     * and other subsystems can react to memory changes.
+     */
+    events?: EventBus | undefined;
+    /**
+     * Storage backend. Defaults to FileMemoryBackend when omitted.
+     * Plugins can register a custom backend (graph, semantic, vector)
+     * via the DI container to override storage behavior.
+     */
+    backend?: MemoryBackend | undefined;
 }
 /**
  * Three scopes:
@@ -152,6 +192,8 @@ interface MemoryStoreOptions {
  */
 declare class DefaultMemoryStore implements MemoryStore {
     private readonly files;
+    private readonly events?;
+    private readonly backend;
     /**
      * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
      * `clear` are read-modify-write against a single file; without a lock,
@@ -168,16 +210,42 @@ declare class DefaultMemoryStore implements MemoryStore {
     private readonly writeChain;
     /** Last write error per scope — surfaced as warnings on the next readAll(). */
     private readonly writeErrors;
+    /**
+     * When the global root is a temporary directory (opencode, CI sandboxes),
+     * memory files are also mirrored to the project tree so they survive
+     * session cleanup. The primary path stays in the temp root for isolation;
+     * this backup ensures memory is never lost.
+     */
+    private readonly persistBackup;
+    private readonly backupDir;
     constructor(opts: MemoryStoreOptions);
+    /** Expose the backend for plugin introspection and advanced queries. */
+    getBackend(): MemoryBackend;
     private runSerialized;
     readAll(): Promise<string>;
     read(scope: MemoryScope): Promise<string>;
-    remember(text: string, scope?: MemoryScope): Promise<void>;
+    /**
+     * List entries from a scope, newest first. Delegates to the backend
+     * so graph/semantic backends can return enriched or filtered results.
+     */
+    list(scope?: MemoryScope, limit?: number): Promise<MemoryEntry[]>;
+    /**
+     * Find memories related to the given text via graph traversal.
+     * Falls back to content search when no graph backend is available.
+     */
+    findRelated(text: string, scope?: MemoryScope, limit?: number): Promise<MemoryEntry[]>;
+    search(query: string, scope?: MemoryScope, limit?: number): Promise<MemoryEntry[]>;
+    remember(text: string, scope?: MemoryScope, metadata?: Omit<Partial<MemoryEntry>, 'scope' | 'text' | 'ts'>): Promise<void>;
+    /**
+     * Score and rank memories by relevance to the current context.
+     * Returns entries with score >= MIN_RELEVANCE_SCORE, sorted highest first.
+     */
+    scoreRelevant(ctx: MemoryRelevanceContext, scope?: MemoryScope, limit?: number): Promise<ScoredEntry[]>;
     forget(query: string, scope?: MemoryScope): Promise<number>;
-    private forgetUnsafe;
     consolidate(scope: MemoryScope): Promise<void>;
-    private consolidateUnsafe;
     clear(scope?: MemoryScope): Promise<void>;
+    /** Mirror current memory content to the persistent backup directory. */
+    private mirrorBackup;
 }
 
 /**
@@ -571,4 +639,4 @@ declare function listPlanTemplates(): PlanTemplate[];
 declare function getPlanTemplate(name: string): PlanTemplate | undefined;
 declare function formatPlanTemplates(): string;
 
-export { type AbandonedSession as A, loadPlan as B, type ConfigLoaderOptions as C, DEFAULT_CONFIG_MIGRATIONS as D, loadTodosCheckpoint as E, removePlanItem as F, runConfigMigrations as G, savePlan as H, saveTodosCheckpoint as I, setPlanItemStatus as J, type MemoryStoreOptions as M, type PersistedQueueItem as P, QueueStore as Q, RecoveryLock as R, SessionAnalyzer as S, type TodosCheckpointFile as T, type AttachmentStoreOptions as a, type ConfigMigration as b, ConfigMigrationError as c, type ConfigSource as d, DefaultAttachmentStore as e, DefaultConfigLoader as f, DefaultConfigStore as g, DefaultMemoryStore as h, DefaultSessionStore as i, type MigrationContext as j, type MigrationResult as k, type PlanFile as l, type PlanItem as m, type PlanTemplate as n, type RecoveryLockOptions as o, type SessionStoreOptions as p, addPlanItem as q, attachPlanCheckpoint as r, attachTodosCheckpoint as s, clearPlan as t, deriveTodosFromPlanItem as u, emptyPlan as v, formatPlan as w, formatPlanTemplates as x, getPlanTemplate as y, listPlanTemplates as z };
+export { type AbandonedSession as A, getPlanTemplate as B, type ConfigLoaderOptions as C, DEFAULT_CONFIG_MIGRATIONS as D, listPlanTemplates as E, FileMemoryBackend as F, loadPlan as G, loadTodosCheckpoint as H, parseEntries as I, removePlanItem as J, runConfigMigrations as K, savePlan as L, type MemoryBackend as M, saveTodosCheckpoint as N, setPlanItemStatus as O, type PersistedQueueItem as P, QueueStore as Q, RecoveryLock as R, SessionAnalyzer as S, type TodosCheckpointFile as T, type AttachmentStoreOptions as a, type ConfigMigration as b, ConfigMigrationError as c, type ConfigSource as d, DefaultAttachmentStore as e, DefaultConfigLoader as f, DefaultConfigStore as g, DefaultMemoryStore as h, DefaultSessionStore as i, type FileMemoryBackendOptions as j, type MemoryStoreOptions as k, type MigrationContext as l, type MigrationResult as m, type PlanFile as n, type PlanItem as o, type PlanTemplate as p, type RecoveryLockOptions as q, type SessionStoreOptions as r, addPlanItem as s, attachPlanCheckpoint as t, attachTodosCheckpoint as u, clearPlan as v, deriveTodosFromPlanItem as w, emptyPlan as x, formatPlan as y, formatPlanTemplates as z };

package/dist/{provider-runner-BEPWwkxH.d.ts → provider-runner-BUunikwY.d.ts}

@@ -1,8 +1,8 @@
-import { E as EventBus } from './events-DzyLtja6.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';
+import { E as EventBus } from './brain-Dfv4Y82E.js';
+import { L as Logger } from './logger-B63L5bTg.js';
+import { T as Tracer } from './observability-D-HZN_mF.js';
+import { P as Provider, R as Request, C as Context, b as Response } from './context-CNRYfhUv.js';
+import { R as RetryPolicy } from './retry-policy-BcmuT_V0.js';
 
 /**
  * Options passed to a ProviderRunner when calling the provider.

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

@@ -1,4 +1,4 @@
-import { d as Context, q as Response, n as ProviderError } from './context-ToHAp4-U.js';
+import { C as Context, b as Response, e as ProviderError } from './context-CNRYfhUv.js';
 
 type RecoveryDecision = {
     /**
@@ -43,4 +43,4 @@ interface RetryPolicy {
     maxAttempts(err: ProviderError | Error): number;
 }
 
-export type { ErrorHandler as E, RecoveryDecision as R, RetryPolicy as a };
+export type { ErrorHandler as E, RetryPolicy as R, RecoveryDecision as a };

package/dist/sdd/index.d.ts

@@ -1,16 +1,16 @@
-import { h as Specification, S as SpecAnalysis, g as SpecValidationResult, l as TaskGraph, m as TaskNode, k as TaskFilter, p as TaskSort, o as TaskProgress, r as TaskType, n as TaskPriority, e as SpecStatus, f as SpecTemplate, b as SpecRequirement } from '../task-graph-CikNdRTG.js';
-import { E as EventBus } from '../events-DzyLtja6.js';
-import { D as DoneCondition, A as Agent, c as AgentFactory, X as TaskResult } from '../agent-subagent-runner-CQaLFNnA.js';
-import '../context-ToHAp4-U.js';
-import '../index-Dx-CnrDN.js';
-import '../logger-B72yyPc6.js';
-import '../system-prompt-C0rLCeyn.js';
-import '../config-_DZ7dN-T.js';
-import '../models-registry-Be3osGt5.js';
-import '../observability-CoSNZdhX.js';
-import '../secret-scrubber-3MHDDAtm.js';
-import '../permission-14CChMmO.js';
-import '../retry-policy-DSu6O6rD.js';
+import { h as Specification, S as SpecAnalysis, g as SpecValidationResult, e as SpecStatus, f as SpecTemplate, b as SpecRequirement } from '../spec-TBi3Jr6T.js';
+import { d as TaskGraph, e as TaskNode, i as TaskFilter, j as TaskSort, c as TaskProgress, T as TaskType, a as TaskPriority } from '../task-graph-u1q9Jkyk.js';
+import { E as EventBus } from '../brain-Dfv4Y82E.js';
+import { D as DoneCondition, g as Agent, h as AgentFactory, f as TaskResult } from '../agent-subagent-runner-DukQLUcS.js';
+import '../context-CNRYfhUv.js';
+import '../index-DIKEcfgC.js';
+import '../logger-B63L5bTg.js';
+import '../pipeline-BqiA_UMr.js';
+import '../config-BSU-6vah.js';
+import '../models-registry-B6_KfS65.js';
+import '../observability-D-HZN_mF.js';
+import '../permission-BDv7z0mk.js';
+import '../retry-policy-BcmuT_V0.js';
 
 declare class SpecParser {
     parse(content: string): Specification;
@@ -708,26 +708,6 @@ declare class SddTaskDecomposer {
     private hasAnyBlockedTasks;
 }
 
-/**
- * SddParallelRun
- *
- * Drives a TaskGraph through ParallelEternalEngine's infrastructure
- * (DefaultMultiAgentCoordinator + AgentSubagentRunner) but powered by
- * SddTaskDecomposer — producing dependency-aware waves instead of
- * goal-driven iterations.
- *
- * One-shot: completes when all tasks are done OR a deadlock is detected.
- * Does NOT loop — each run() call is a discrete execution.
- *
- * Usage:
- * ```
- * const run = new SddParallelRun({ tracker, graph, agent, projectRoot });
- * await run.run({ onWave });
- * // or with progress callback:
- * await run.run({ onProgress: (p) => console.log(renderProgress(p)) });
- * ```
- */
-
 interface SddParallelRunOptions {
     /** Pre-constructed TaskTracker (must already hold the graph's initial state). */
     tracker: TaskTracker;
@@ -741,6 +721,8 @@ interface SddParallelRunOptions {
     parallelSlots?: number | undefined;
     /** Per-task timeout in ms. Default: 300_000 (5 min). */
     taskTimeoutMs?: number | undefined;
+    /** Maximum retry attempts for failed tasks. Default: 2. */
+    maxRetries?: number | undefined;
     /** Override the default agent factory. */
     subagentFactory?: AgentFactory | undefined;
     /** Called after each wave completes. */
@@ -781,9 +763,11 @@ declare class SddParallelRun {
     private readonly opts;
     private readonly slots;
     private readonly timeoutMs;
+    private readonly maxRetries;
     private decomposer;
     private coordinator;
     private stopRequested;
+    private retryMap;
     constructor(opts: SddParallelRunOptions);
     /** Trigger stop — causes run() to abort after the current wave. */
     stop(): void;