@wrongstack/core 0.155.0 → 0.236.0

package/dist/{parallel-eternal-engine-CYoTKjsz.d.ts → parallel-eternal-engine-DtG1fjc9.d.ts}

@@ -1,12 +1,12 @@
-import { e as ProviderError, C as Context, T as Tool, m as ToolUseBlock, n as ToolResultBlock } from './context-C7G_MtLV.js';
-import { R as RetryPolicy, E as ErrorHandler, a as RecoveryDecision } from './retry-policy-rutAfVeR.js';
-import { C as Compactor, a as CompactReport } from './compactor-BueGt7LG.js';
-import { M as ModelsRegistry } from './config-BaVThgnT.js';
-import { T as ToolExecutorOptions, a as ToolExecutorStrategy, b as ToolBatchResult } from './index-B5wz-GXm.js';
-import { g as Agent, h as AgentFactory } from './agent-subagent-runner-Bsueu0J2.js';
-import { b as BrainArbiter } from './brain-CS_B0vIE.js';
+import { e as ProviderError, C as Context, T as Tool, l as ToolUseBlock, m as ToolResultBlock } from './context-CLz3z_E8.js';
+import { R as RetryPolicy, E as ErrorHandler, a as RecoveryDecision } from './retry-policy-BVnkbMET.js';
+import { C as Compactor, a as CompactReport } from './compactor-BRfg3QPd.js';
+import { M as ModelsRegistry } from './config-Koq6f3fs.js';
+import { T as ToolExecutorOptions, a as ToolExecutorStrategy, b as ToolBatchResult } from './index-C2eSNPsB.js';
+import { g as Agent, h as AgentFactory } from './agent-subagent-runner-C658wj_c.js';
+import { B as BrainArbiter } from './brain-sCZ3lCjq.js';
 import { J as JournalEntry } from './goal-store-CV9Yz2X_.js';
-import { D as DispatchClassifier, a as DefaultMultiAgentCoordinator } from './multi-agent-coordinator-BSKSFNhv.js';
+import { D as DispatchClassifier, a as DefaultMultiAgentCoordinator } from './multi-agent-coordinator-60weDZoA.js';
 
 declare class DefaultRetryPolicy implements RetryPolicy {
     shouldRetry(err: Error | ProviderError, attempt: number): boolean;
@@ -94,6 +94,10 @@ declare class HybridCompactor implements Compactor {
 declare class ToolExecutor {
     private readonly registry;
     private opts;
+    /** Minimum gap between coalesced `partial_output` tool.progress emits. */
+    static readonly PROGRESS_EMIT_INTERVAL_MS = 100;
+    /** Max chars of accumulated stream text carried per coalesced emit. */
+    static readonly PROGRESS_TAIL_CHARS = 16384;
     private readonly serializer;
     private readonly iterationTimeoutMs;
     private readonly maxToolTimeoutMs;
@@ -523,4 +527,4 @@ declare class ParallelEternalEngine {
     private persistState;
 }
 
-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 };
+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 };

package/dist/{path-resolver-DuhlmPil.d.ts → path-resolver-CA1ULU0J.d.ts}

@@ -1,6 +1,6 @@
-import { E as EventBus } from './brain-CS_B0vIE.js';
-import { M as ModelsRegistry, b as ResolvedModel } from './config-BaVThgnT.js';
-import { c as TokenCounter, U as Usage, d as CacheStats } from './context-C7G_MtLV.js';
+import { E as EventBus } from './brain-sCZ3lCjq.js';
+import { M as ModelsRegistry, b as ResolvedModel } from './config-Koq6f3fs.js';
+import { c as TokenCounter, U as Usage, d as CacheStats } from './context-CLz3z_E8.js';
 import { P as PathResolver } from './path-resolver-CPRj4bFY.js';
 
 /**

package/dist/{permission-B7nKnEvQ.d.ts → permission-DbWPbuoA.d.ts}

@@ -1,4 +1,4 @@
-import { T as Tool, C as Context, f as Permission } from './context-C7G_MtLV.js';
+import { T as Tool, C as Context, f as Permission } from './context-CLz3z_E8.js';
 
 interface SecretScrubber {
     scrub(text: string): string;

package/dist/{permission-policy-8-6zBmfA.d.ts → permission-policy-AOk0LVsV.d.ts}

@@ -1,6 +1,6 @@
-import { T as Tool, C as Context } from './context-C7G_MtLV.js';
+import { T as Tool, C as Context } from './context-CLz3z_E8.js';
 import { I as InputReader } from './input-reader-E-ffP2ee.js';
-import { P as PermissionPolicy, a as PermissionDecision } from './permission-B7nKnEvQ.js';
+import { P as PermissionPolicy, a as PermissionDecision } from './permission-DbWPbuoA.js';
 
 interface PermissionPolicyOptions {
     trustFile: string;

package/dist/pipeline-DsmlwTXu.d.ts

@@ -0,0 +1,493 @@
+import { T as Tool, n as TextBlock, g as ContentBlock } from './context-CLz3z_E8.js';
+import { H as HookEvent, e as HookMatcher, I as InProcessHook, S as ShellHook, f as HookEntry } from './config-Koq6f3fs.js';
+
+/**
+ * Mailbox — persistent inter-agent messaging system with cross-session support.
+ *
+ * Agents can leave notes for specific agents or broadcast to all. Each agent
+ * periodically checks the mailbox or retrieves messages via tool calls.
+ *
+ * ## Cross-session communication
+ *
+ * The mailbox is stored at **project level** (`~/.wrongstack/projects/<slug>/_mailbox.jsonl`),
+ * so agents in different terminal sessions / WebUI tabs working on the same
+ * project can communicate live.
+ *
+ * ## Agent registration
+ *
+ * Every agent that uses the mailbox registers itself with a heartbeat.
+ * Other agents can discover online agents via `getOnlineAgents()`.
+ * Stale agents (no heartbeat > 60s) are pruned automatically.
+ *
+ * ## Read receipts
+ *
+ * Each message tracks per-recipient read status via a `readBy` map:
+ * `{ "agentId": "ISO8601" }`. When agent X reads a message, its entry
+ * is added. The WebUI shows who read what and when.
+ *
+ * @module mailbox-types
+ */
+type MailboxMessageType = 'note' | 'ask' | 'assign' | 'steer' | 'btw' | 'broadcast' | 'status' | 'result';
+/**
+ * Per-recipient read status. `readBy` maps agentId → ISO8601 timestamp of
+ * when that agent first read the message. An empty map means unread by all.
+ */
+interface ReadReceipts {
+    [agentId: string]: string;
+}
+interface MailboxMessage {
+    /** Unique message id (UUID). */
+    id: string;
+    /** Sender agent id. */
+    from: string;
+    /** Recipient agent id, or '*' for broadcast. */
+    to: string;
+    /** Message category. */
+    type: MailboxMessageType;
+    /** Short subject line — one sentence. */
+    subject: string;
+    /** Full message content. */
+    body: string;
+    /** Priority — high priority messages surface first. */
+    priority: 'low' | 'normal' | 'high';
+    /**
+     * Per-recipient read receipts. agentId → ISO8601 when they first read it.
+     * Replaces the old single `read: boolean` + `readAt` fields.
+     */
+    readBy: ReadReceipts;
+    /** Has any recipient acted on / completed this? */
+    completed: boolean;
+    /** Who completed it (agentId). */
+    completedBy?: string | undefined;
+    /** Optional summary of what happened after handling. */
+    outcome?: string | undefined;
+    /** ISO8601 — when the message was sent. */
+    timestamp: string;
+    /** ISO8601 — when the message was marked complete. */
+    completedAt?: string | undefined;
+    /** If this is a reply, the id of the parent message. */
+    replyTo?: string | undefined;
+    /** For assign-type messages — task context for agent discovery. */
+    taskContext?: MailboxTaskContext | undefined;
+    /** Session id of the sender. Enables cross-session communication. */
+    senderSessionId?: string | undefined;
+}
+interface MailboxTaskContext {
+    /** The role that should handle this task (e.g. "tech-stack", "audit-log"). */
+    agentRole?: string | undefined;
+    /** Human-readable agent name (e.g. "Tesla (Executor)"). */
+    agentName?: string | undefined;
+    /** Task id if already assigned via coordinator. */
+    taskId?: string | undefined;
+    /** Current task status. */
+    status?: 'pending' | 'in_progress' | 'completed' | 'failed' | undefined;
+}
+interface RegisteredAgent {
+    /** Unique agent id. */
+    agentId: string;
+    /** Session id this agent belongs to. */
+    sessionId: string;
+    /** Human-readable name. */
+    name: string;
+    /** Role (e.g. "leader", "tech-stack", "bug-hunter"). */
+    role?: string | undefined;
+    /** Current status. */
+    status: 'idle' | 'running' | 'streaming' | 'waiting_user' | 'error';
+    /** Current tool being executed, if any. */
+    currentTool?: string | undefined;
+    /** Current task description. */
+    currentTask?: string | undefined;
+    /** Iteration count so far. */
+    iterations: number;
+    /** Tool calls so far. */
+    toolCalls: number;
+    /** ISO8601 — registered at. */
+    registeredAt: string;
+    /** ISO8601 — last heartbeat (updated on every mailbox op). */
+    lastSeenAt: string;
+    /** Which process registered this agent (PID). */
+    pid: number;
+    /** Where the agent is running (e.g. "cli", "webui"). */
+    source?: 'cli' | 'webui' | 'mcp' | 'acp' | undefined;
+}
+interface MailboxAgentStatus {
+    /** Agent id. */
+    agentId: string;
+    /** Human-readable name. */
+    name: string;
+    /** Role. */
+    role?: string | undefined;
+    /** Session id. */
+    sessionId: string;
+    /** Current status. */
+    status: 'idle' | 'running' | 'streaming' | 'waiting_user' | 'error' | 'offline';
+    /** Current tool being executed, if any. */
+    currentTool?: string | undefined;
+    /** Current task description. */
+    currentTask?: string | undefined;
+    /** Iteration count so far. */
+    iterations: number;
+    /** Tool calls so far. */
+    toolCalls: number;
+    /** ISO8601 — last activity timestamp. */
+    lastActivityAt: string;
+    /** ISO8601 — last heartbeat. */
+    lastSeenAt: string;
+    /** Whether this agent is currently online (heartbeat within threshold). */
+    online: boolean;
+    /** Which process. */
+    pid: number;
+    /** Source. */
+    source?: 'cli' | 'webui' | 'mcp' | 'acp' | undefined;
+}
+interface MailboxQuery {
+    /** Filter by recipient agent id. */
+    to?: string | undefined;
+    /** Filter by sender agent id. */
+    from?: string | undefined;
+    /** Only messages unread by this agent. */
+    unreadBy?: string | undefined;
+    /** Only incomplete messages. */
+    incompleteOnly?: boolean | undefined;
+    /** Filter by message type. */
+    type?: MailboxMessageType | undefined;
+    /** Filter by priority (>= this level). */
+    minPriority?: 'low' | 'normal' | 'high' | undefined;
+    /** Maximum number of messages to return. */
+    limit?: number | undefined;
+    /** ISO8601 — only messages after this timestamp. */
+    since?: string | undefined;
+}
+/**
+ * Normalize a recipient address. `"all"` (any casing) is an accepted
+ * spelling of the broadcast address and is canonicalized to `'*'` at send
+ * time — both agents and humans reach for "all" naturally, and a literal
+ * "all" recipient would otherwise be deliverable to nobody. The word is
+ * therefore RESERVED: no agent may register under the base id "all".
+ */
+declare function normalizeRecipient(to: string): string;
+interface MailboxSendInput {
+    /** Sender agent id. */
+    from: string;
+    /** Recipient agent id, '*' for broadcast (alias: "all"). */
+    to: string;
+    /** Message category. */
+    type: MailboxMessageType;
+    /** Short subject line. */
+    subject: string;
+    /** Full message content. */
+    body: string;
+    /** Priority. Default: 'normal'. */
+    priority?: 'low' | 'normal' | 'high' | undefined;
+    /** If replying, the id of the parent message. */
+    replyTo?: string | undefined;
+    /** Task context for assign-type messages. */
+    taskContext?: MailboxTaskContext | undefined;
+}
+interface MailboxAckInput {
+    /** Message id to acknowledge. */
+    messageId: string;
+    /** Agent id of who is reading/acking. */
+    readerId: string;
+    /** Mark as read by this agent? Defaults to true if not specified. */
+    read?: boolean | undefined;
+    /** Mark as completed? */
+    completed?: boolean | undefined;
+    /** Optional outcome summary. */
+    outcome?: string | undefined;
+}
+interface AgentRegistrationInput {
+    agentId: string;
+    sessionId: string;
+    name: string;
+    role?: string | undefined;
+    pid: number;
+    source?: 'cli' | 'webui' | 'mcp' | 'acp' | undefined;
+}
+interface AgentHeartbeatInput {
+    agentId: string;
+    status?: RegisteredAgent['status'] | undefined;
+    currentTool?: string | undefined;
+    currentTask?: string | undefined;
+    iterations?: number | undefined;
+    toolCalls?: number | undefined;
+}
+interface Mailbox {
+    /** Send a message. Returns the created message. */
+    send(input: MailboxSendInput): Promise<MailboxMessage>;
+    /** Query messages matching criteria. */
+    query(query: MailboxQuery): Promise<MailboxMessage[]>;
+    /** Acknowledge a message (read/complete). Returns updated message. */
+    ack(input: MailboxAckInput): Promise<MailboxMessage | null>;
+    /** Get a snapshot of online/offline agents and their current tasks. */
+    getAgentStatuses(): Promise<MailboxAgentStatus[]>;
+    /**
+     * Get only online agents (heartbeat within 60s).
+     * Useful for "who can I talk to right now?" queries.
+     */
+    getOnlineAgents(): Promise<MailboxAgentStatus[]>;
+    /**
+     * Register an agent. Called once per agent on first mailbox use.
+     * Subsequent calls are idempotent — they update lastSeenAt.
+     */
+    registerAgent(input: AgentRegistrationInput): Promise<void>;
+    /**
+     * Update agent heartbeat and optional status fields.
+     * Called periodically (every tool call / iteration).
+     */
+    heartbeat(input: AgentHeartbeatInput): Promise<void>;
+    /**
+     * Count unread messages for a specific agent.
+     * Used for "new mail" notifications without pulling full message bodies.
+     */
+    unreadCount(forAgentId: string): Promise<number>;
+    /** Close and flush any pending writes. */
+    close(): Promise<void>;
+    /**
+     * Delete all messages from the mailbox file.
+     * Agents and read receipts are preserved; only messages are cleared.
+     */
+    clearAll(): Promise<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;
+    /**
+     * List of currently online agents in the shared mailbox system.
+     * Includes agents from all sessions (TUI, WebUI, CLI) in the same project.
+     */
+    onlineAgents?: MailboxAgentStatus[] | 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.
+ *
+ * Invariants:
+ *   bind()     — throws if token already bound
+ *   override() — throws if nothing to replace
+ *   decorate() — stacks; cached value cleared on register
+ */
+type Token<T> = symbol & {
+    readonly __type?: T;
+};
+type Factory<T> = (c: Container) => T;
+type Decorator<T> = (inner: T, c: Container) => T;
+interface BindOptions {
+    singleton?: boolean | undefined;
+    owner?: string | undefined;
+}
+declare class Container {
+    private readonly entries;
+    /**
+     * Tokens currently mid-resolve. Tracked so we can detect circular
+     * dependencies (A → B → A) and throw a structured error instead of
+     * overflowing the call stack with "Maximum call stack size exceeded".
+     *
+     * Not a memoization cache — the per-entry `cache` field is the source
+     * of truth for "have I built this before?". This set only lives for
+     * the duration of a single resolve call.
+     */
+    private readonly resolving;
+    bind<T>(token: Token<T>, factory: Factory<T>, opts?: BindOptions): void;
+    override<T>(token: Token<T>, factory: Factory<T>, opts?: BindOptions): void;
+    decorate<T>(token: Token<T>, decorator: Decorator<T>, owner?: string): void;
+    resolve<T>(token: Token<T>): T;
+    /**
+     * Build a human-readable description of the dependency cycle that
+     * caused the resolution to re-enter. Lists the tokens in the order
+     * they were entered, then appends the re-entered token to close the
+     * loop. Falls back to a generic message if the resolving set is
+     * somehow empty (shouldn't happen, but defensive).
+     */
+    private describeCycle;
+    has<T>(token: Token<T>): boolean;
+    /**
+     * Resolve a token if it is bound, otherwise return undefined.
+     * Unlike resolve(), this does not throw if the token is unbound.
+     */
+    safeResolve<T>(token: Token<T>): T | undefined;
+    ownerOf<T>(token: Token<T>): string | undefined;
+    /**
+     * Remove a token's binding (along with any decorators stacked on it).
+     * Returns true if the token existed. Use this to withdraw temporary
+     * bindings installed by a short-lived run or plugin — without it, the
+     * entry persists in the map forever.
+     */
+    unbind<T>(token: Token<T>): boolean;
+    /**
+     * Drop every binding. Intended for tests and short-lived CLI invocations
+     * that rebuild the container from scratch. Production code should prefer
+     * `unbind` on the specific tokens it owns.
+     */
+    clear(): void;
+    list(): Array<{
+        token: symbol;
+        owner: string;
+    }>;
+    /**
+     * Inspect a binding's full shape, including decorator count and whether
+     * a singleton value is cached. Returns null if the token is unbound.
+     * Decorator and factory function references are not exposed — only counts
+     * and metadata, to keep internal state hidden.
+     */
+    inspect<T>(token: Token<T>): {
+        owner: string;
+        singleton: boolean;
+        decoratorCount: number;
+        cached: boolean;
+    } | null;
+}
+
+/**
+ * Pipeline — Koa-style middleware chain with named middleware
+ * and position-aware insertion. Generic over input type T.
+ */
+type NextFn<T> = (value: T) => Promise<T>;
+type MiddlewareHandler<T> = (value: T, next: NextFn<T>) => Promise<T>;
+/**
+ * Called when a middleware crashes (throws or rejects). Used by the
+ * Pipeline's error boundary to log the offender without aborting the run.
+ *
+ * Return `'rethrow'` to propagate the error (default for core middleware),
+ * or `'swallow'` to skip past the crashing middleware and continue with the
+ * value the previous one produced. Plugin middleware should usually be
+ * swallowed so one bad plugin can't kill an agent run.
+ */
+type PipelineErrorPolicy = 'rethrow' | 'swallow';
+interface PipelineErrorEvent {
+    middleware: string;
+    owner?: string | undefined;
+    err: unknown;
+}
+type PipelineErrorHandler = (ev: PipelineErrorEvent) => PipelineErrorPolicy | Promise<PipelineErrorPolicy>;
+interface Middleware<T> {
+    name: string;
+    handler: MiddlewareHandler<T>;
+    owner?: string | undefined;
+}
+interface PipelineOptions {
+    /** When true and the target middleware is not found, operations silently no-op instead of throwing. */
+    optional?: boolean | undefined;
+}
+/**
+ * Read-only view of a pipeline. Returned to consumers (plugins, hooks)
+ * so they can inspect but not mutate the chain.
+ */
+interface ReadonlyPipeline<T> {
+    readonly size: number;
+    list(): readonly string[];
+    run(input: T): Promise<T>;
+}
+declare class Pipeline<T> {
+    private readonly chain;
+    private errorHandler?;
+    /**
+     * Install an error boundary. When a middleware throws or rejects, the
+     * handler is called and decides whether to swallow (continue with the
+     * pre-handler value) or rethrow. Without a handler, errors propagate.
+     *
+     * Wire one per pipeline at boot — the host CLI typically installs a
+     * single boundary that logs to the operational log and emits a
+     * `pipeline.error` event for /diag.
+     */
+    setErrorHandler(handler: PipelineErrorHandler | undefined): this;
+    use(mw: Middleware<T> | Middleware<unknown>): this;
+    prepend(mw: Middleware<T>): this;
+    /**
+     * Insert middleware at an explicit index. Out-of-range indices are clamped.
+     * Use this when insertBefore/insertAfter are insufficient (e.g. to place
+     * a middleware at a known position regardless of named targets).
+     */
+    insertAt(index: number, mw: Middleware<T>): this;
+    /**
+     * Insert mw immediately before the first occurrence of target.
+     * If called multiple times with the same target, each call inserts
+     * before the target's current position — so after insertBefore('B', X)
+     * then insertBefore('B', Y), the order is Y → X → B.
+     */
+    insertBefore(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
+    /**
+     * Insert mw immediately after the first occurrence of target.
+     * If called multiple times with the same target, each call inserts
+     * after the target's current position — so after insertAfter('B', X)
+     * then insertAfter('B', Y), the order is B → X → Y.
+     */
+    insertAfter(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
+    replace(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
+    remove(name: string, opts?: PipelineOptions): this;
+    list(): readonly string[];
+    size(): number;
+    /** Return a read-only view suitable for passing to plugins. */
+    asReadonly(): ReadonlyPipeline<T>;
+    run(input: T): Promise<T>;
+    private indexOf;
+    private ensureUnique;
+}
+
+export { type AgentRegistrationInput as A, 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 Mailbox as b, type MailboxSendInput as c, type MailboxMessage as d, type MailboxQuery as e, type MailboxAckInput as f, type MailboxAgentStatus as g, type AgentHeartbeatInput as h, type MailboxMessageType as i, type MailboxTaskContext as j, type ReadReceipts as k, type RegisteredAgent as l, type ModelCapabilities as m, normalizeRecipient as n, type BindOptions as o, type Middleware as p, type PipelineOptions as q, hookMatcherMatches as r };

package/dist/{plan-templates-DbH7lg-t.d.ts → plan-templates-DPABrDvy.d.ts}

@@ -1,9 +1,9 @@
-import { E as EventBus, M as MemoryScope, k as MemoryEntry, l as MemoryStore, m as MemoryRelevanceContext, S as ScoredEntry } from './brain-CS_B0vIE.js';
-import { S as SecretScrubber } from './permission-B7nKnEvQ.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-C7G_MtLV.js';
-import { A as AttachmentStore, a as AddAttachmentInput, b as AttachmentRef, c as Attachment } from './session-reader-BAtCxdaw.js';
-import { W as WstackPaths } from './wstack-paths-DD50Omgn.js';
-import { i as ConfigStore, h as Config, j as ConfigLoader, k as SyncConfig } from './config-BaVThgnT.js';
+import { E as EventBus, M as MemoryScope, k as MemoryEntry, l as MemoryStore, m as MemoryRelevanceContext, S as ScoredEntry } from './brain-sCZ3lCjq.js';
+import { S as SecretScrubber } from './permission-DbWPbuoA.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-CLz3z_E8.js';
+import { A as AttachmentStore, a as AddAttachmentInput, b as AttachmentRef, c as Attachment } from './session-reader-CCOssnBS.js';
+import { W as WstackPaths } from './wstack-paths-CJjEwPXn.js';
+import { i as ConfigStore, h as Config, j as ConfigLoader, k as SyncConfig } from './config-Koq6f3fs.js';
 import { S as SecretVault } from './secret-vault-BJDY28ev.js';
 
 interface SessionStoreOptions {
@@ -70,6 +70,11 @@ declare class DefaultSessionStore implements SessionStore {
     /**
      * Delete a session and all associated files: JSONL, summary, plan/todos
      * sidecars, and the session directory (fleet.json, shared/, subagents/).
+     *
+     * Individual file deletions are best-effort (logged as structured warnings),
+     * but a tombstone is always written so readIndex() filters this session out.
+     * If the session directory itself can't be removed, the error is surfaced
+     * to the caller so prune() can report it.
      */
     private deleteSession;
     delete(id: string): Promise<void>;
@@ -608,8 +613,14 @@ declare function deriveTodosFromPlanItem(plan: PlanFile, idOrIndex: string, subt
         content: string;
         status: 'pending' | 'in_progress' | 'completed';
         activeForm?: string | undefined;
+        promotedFromPlan?: string | undefined;
     }>;
 } | null;
+/**
+ * Load, modify, and save the plan file under a file-level lock.
+ * Prevents races from parallel tool invocations (e.g. batch_tool_use).
+ */
+declare function mutatePlan(filePath: string, sessionId: string, fn: (plan: PlanFile) => PlanFile | Promise<PlanFile>): Promise<PlanFile>;
 /**
  * Optional: attach a state-listener so meta operations (storing a plan
  * id on ctx.meta) trigger a save. Currently a stub — plans don't live
@@ -639,4 +650,4 @@ declare function listPlanTemplates(): PlanTemplate[];
 declare function getPlanTemplate(name: string): PlanTemplate | undefined;
 declare function formatPlanTemplates(): string;
 
-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 };
+export { type AbandonedSession as A, getPlanTemplate as B, type ConfigLoaderOptions as C, DEFAULT_CONFIG_MIGRATIONS as D, listPlanTemplates as E, FileMemoryBackend as F, loadPlan as G, loadTodosCheckpoint as H, mutatePlan as I, parseEntries as J, removePlanItem as K, runConfigMigrations as L, type MemoryBackend as M, savePlan as N, saveTodosCheckpoint as O, type PersistedQueueItem as P, QueueStore as Q, RecoveryLock as R, SessionAnalyzer as S, type TodosCheckpointFile as T, setPlanItemStatus as U, type AttachmentStoreOptions as a, type ConfigMigration as b, ConfigMigrationError as c, type ConfigSource as d, DefaultAttachmentStore as e, DefaultConfigLoader as f, DefaultConfigStore as g, DefaultMemoryStore as h, DefaultSessionStore as i, type FileMemoryBackendOptions as j, type MemoryStoreOptions as k, type MigrationContext as l, type MigrationResult as m, type PlanFile as n, type PlanItem as o, type PlanTemplate as p, type RecoveryLockOptions as q, type SessionStoreOptions as r, addPlanItem as s, attachPlanCheckpoint as t, attachTodosCheckpoint as u, clearPlan as v, deriveTodosFromPlanItem as w, emptyPlan as x, formatPlan as y, formatPlanTemplates as z };

package/dist/{provider-runner-Cocq0O9E.d.ts → provider-runner-D0HgUqwV.d.ts}

@@ -1,8 +1,8 @@
-import { E as EventBus } from './brain-CS_B0vIE.js';
+import { E as EventBus } from './brain-sCZ3lCjq.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-C7G_MtLV.js';
-import { R as RetryPolicy } from './retry-policy-rutAfVeR.js';
+import { P as Provider, R as Request, C as Context, b as Response } from './context-CLz3z_E8.js';
+import { R as RetryPolicy } from './retry-policy-BVnkbMET.js';
 
 /**
  * Options passed to a ProviderRunner when calling the provider.

package/dist/{retry-policy-rutAfVeR.d.ts → retry-policy-BVnkbMET.d.ts}

@@ -1,4 +1,4 @@
-import { C as Context, b as Response, e as ProviderError } from './context-C7G_MtLV.js';
+import { C as Context, b as Response, e as ProviderError } from './context-CLz3z_E8.js';
 
 type RecoveryDecision = {
     /**

package/dist/sdd/index.d.ts

@@ -1,15 +1,15 @@
 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-CS_B0vIE.js';
-import { D as DoneCondition, g as Agent, h as AgentFactory, f as TaskResult } from '../agent-subagent-runner-Bsueu0J2.js';
-import '../context-C7G_MtLV.js';
-import '../index-B5wz-GXm.js';
+import { E as EventBus } from '../brain-sCZ3lCjq.js';
+import { D as DoneCondition, g as Agent, h as AgentFactory, f as TaskResult } from '../agent-subagent-runner-C658wj_c.js';
+import '../context-CLz3z_E8.js';
+import '../index-C2eSNPsB.js';
 import '../logger-B63L5bTg.js';
-import '../pipeline-BG7UgbDc.js';
-import '../config-BaVThgnT.js';
+import '../pipeline-DsmlwTXu.js';
+import '../config-Koq6f3fs.js';
 import '../observability-D-HZN_mF.js';
-import '../permission-B7nKnEvQ.js';
-import '../retry-policy-rutAfVeR.js';
+import '../permission-DbWPbuoA.js';
+import '../retry-policy-BVnkbMET.js';
 
 declare class SpecParser {
     parse(content: string): Specification;