@wrongstack/core 0.5.5 → 0.5.7

package/dist/extension/index.d.ts

@@ -1,9 +1,9 @@
-export { A as AfterIterationHook, p as AfterRunHook, q as AfterToolExecutionHook, s as AgentExtension, B as BeforeIterationHook, w as BeforeRunHook, x as BeforeToolExecutionHook, E as ExtensionRegistry, O as OnErrorHook, G as ProviderRunnerFn, z as ProviderRunnerWrapper } from '../index-DPLJw_ZI.js';
-import '../context-CLZXPPYk.js';
+export { A as AfterIterationHook, p as AfterRunHook, q as AfterToolExecutionHook, s as AgentExtension, B as BeforeIterationHook, w as BeforeRunHook, x as BeforeToolExecutionHook, E as ExtensionRegistry, O as OnErrorHook, G as ProviderRunnerFn, z as ProviderRunnerWrapper } from '../index-j2WyAyML.js';
+import '../context-CDRyrkKQ.js';
 import '../logger-BMQgxvdy.js';
-import '../system-prompt-DI4Dtc1I.js';
+import '../system-prompt-Dl2QY1_B.js';
 import '../observability-BhnVLBLS.js';
-import '../events-qnDZbrtb.js';
-import '../secret-scrubber-BhJTNr9v.js';
-import '../config-BgM0BIpz.js';
+import '../events-DPQKFX7W.js';
+import '../secret-scrubber-CfMdAJ_l.js';
+import '../config-BGGuP_Ar.js';
 import '../models-registry-Y2xbog0E.js';

package/dist/{index-De4R4rQ7.d.ts → index-Bf9Bpkdc.d.ts}

@@ -1,9 +1,98 @@
-import { M as MultiAgentConfig, i as SubagentRunner, c as SubagentConfig, k as TaskSpec, j as TaskResult, a as CoordinatorStatus, b as MultiAgentCoordinator, S as SpawnResult, l as BridgeMessage, A as AgentBridge } from './multi-agent-Cv8wk47i.js';
-import { r as SessionWriter, v as Tool, p as SessionStore } from './context-CLZXPPYk.js';
-import { I as InMemoryAgentBridge } from './agent-bridge-B07AYFBk.js';
-import { E as EventBus } from './events-qnDZbrtb.js';
+import { a as DirectorStateSnapshot } from './director-state-BmYi3DGA.js';
+import { c as SubagentConfig, j as TaskResult, a as CoordinatorStatus, k as TaskSpec, M as MultiAgentConfig, i as SubagentRunner, b as MultiAgentCoordinator, S as SpawnResult, l as BridgeMessage, A as AgentBridge } from './multi-agent-Cpp7FXUl.js';
+import { r as SessionWriter, v as Tool, p as SessionStore } from './context-CDRyrkKQ.js';
+import { I as InMemoryAgentBridge } from './agent-bridge-BKNiE1VH.js';
+import { E as EventBus } from './events-DPQKFX7W.js';
 import { EventEmitter } from 'node:events';
-import { r as Agent, u as AgentInput } from './index-DPLJw_ZI.js';
+import { r as Agent, u as AgentInput } from './index-j2WyAyML.js';
+
+/**
+ * Interface for a fleet coordinator. Implemented by both `Director`
+ * (full LLM-driven orchestration with fleet policy) and
+ * `DefaultMultiAgentCoordinator` (direct API-driven, no fleet policy).
+ *
+ * External callers — CLI slash commands, tests, the delegate tool —
+ * use this to stay agnostic to the orchestration mode.
+ *
+ * The interface captures the **orchestration contract**: spawn, assign,
+ * terminate, await, and query. Fleet-level policy (cost caps, manifest
+ * writing, checkpointing) lives behind this surface and is optional
+ * from the caller's perspective.
+ *
+ * @example
+ * ```typescript
+ * let coordinator: ICoordinator = isDirectorMode
+ *   ? new Director({ config, ... })
+ *   : new DefaultMultiAgentCoordinator(config);
+ * const id = await coordinator.spawn({ name: 'worker', role: 'researcher' });
+ * await coordinator.assign({ id: 't-1', description: 'research X', subagentId: id });
+ * const results = await coordinator.awaitTasks(['t-1']);
+ * ```
+ */
+interface ICoordinator {
+    /** Stable identifier for this coordinator instance. */
+    readonly coordinatorId: string;
+    /**
+     * Spawn a new subagent and return its id. In director mode this
+     * enforces fleet-wide spawn caps and cost limits; in raw coordinator
+     * mode it is a direct pass-through.
+     */
+    spawn(config: SubagentConfig): Promise<string>;
+    /**
+     * Assign a task to a subagent (or to the fleet for auto-routing).
+     * Returns the assigned task id.
+     */
+    assign(task: {
+        id: string;
+        description: string;
+        subagentId?: string;
+    }): Promise<string>;
+    /**
+     * Synchronously ask a subagent something via the in-memory bridge.
+     * The subagent must have been spawned and must handle `bridge.subscribe()`
+     * in its task loop. Returns the reply payload or throws on timeout.
+     *
+     * Only available in director mode — raw coordinator has no bridge.
+     */
+    ask<T = unknown>(subagentId: string, payload: unknown, timeoutMs?: number): Promise<T>;
+    /**
+     * Wait for one or more tasks to complete and return their results.
+     * If a task is already done when called, returns immediately.
+     * Resolves to an array in the same order as `taskIds`.
+     */
+    awaitTasks(taskIds: string[]): Promise<TaskResult[]>;
+    /**
+     * Gracefully stop a single subagent. The subagent finishes its current
+     * in-flight work and exits cleanly — it does not hard-kill.
+     */
+    terminate(subagentId: string): Promise<void>;
+    /**
+     * Stop all subagents. In-flight tasks are allowed to complete;
+     * no new tasks are dispatched.
+     */
+    terminateAll(): Promise<void>;
+    /**
+     * Live coordinator status — subagent list, pending task count,
+     * completed task count, iteration totals.
+     */
+    status(): CoordinatorStatus;
+    /**
+     * Snapshot of completed task results. In director mode this returns
+     * every `TaskResult` from the fleet; in raw coordinator mode this
+     * may return an empty array if the coordinator doesn't cache results.
+     */
+    completedResults(): TaskResult[];
+    /**
+     * Subscribe to coordinator lifecycle events. Currently supports
+     * `task.completed` — the payload carries the task spec and result.
+     *
+     * Returns a disposer function; call it to unsubscribe.
+     */
+    on(event: 'task.completed', handler: (payload: {
+        task: TaskSpec;
+        result: TaskResult;
+    }) => void): () => void;
+}
 
 /**
  * Single fleet-wide event with subagent attribution. Whatever a child
@@ -117,6 +206,215 @@ declare class FleetUsageAggregator {
     private onIterationStarted;
 }
 
+/**
+ * Interface for fleet-level lifecycle and policy. Covers:
+ * - Spawn lifecycle hooks (canSpawn check, recordSpawn after-effects)
+ * - Budget enforcement (fleet-wide cost cap, spawn count/depth caps)
+ * - Fleet manifest assembly and writing
+ * - Subagent metadata and usage tracking
+ *
+ * `FleetBus` is pure event fan-out and implements no policy.
+ * `FleetManager` encapsulates all fleet-level policy decisions.
+ * `Director` currently owns all of this — this interface lets us
+ * extract it into a swappable component in Phase 5.
+ */
+interface IFleetManager {
+    /** The FleetBus this manager publishes lifecycle events to. */
+    readonly fleetBus: FleetBus;
+    /**
+     * Snapshot of fleet-wide token usage and cost rollup.
+     * Safe to call from a tool's execute() body.
+     */
+    snapshot(): FleetUsage;
+    /**
+     * Per-subagent metadata captured at spawn time (provider/model/name).
+     * Returns undefined if the subagent is not known to this manager.
+     */
+    getSubagentMeta(id: string): {
+        provider?: string;
+        model?: string;
+        name?: string;
+    } | undefined;
+    /**
+     * Called before a spawn is recorded. Returns a reason string if the
+     * spawn should be rejected (budget cap, depth limit, cost cap, etc.),
+     * or null to proceed. Director.spawn() calls this internally.
+     */
+    canSpawn(config: SubagentConfig): {
+        kind: 'max_spawns' | 'max_spawn_depth' | 'max_cost_usd';
+        limit: number;
+        observed: number;
+    } | null;
+    /**
+     * Called after a spawn succeeds. Records metadata for the usage
+     * aggregator and manifest.
+     *
+     * @param priceLookup Per-token rate lookup for cost calculation.
+     *   When omitted the cost column in usage snapshots stays at 0.
+     */
+    recordSpawn(subagentId: string, config: SubagentConfig, priceLookup?: Record<string, number>): void;
+    /**
+     * Write the fleet manifest to disk. Returns the path written
+     * or null when no manifest path is configured.
+     */
+    writeManifest(): Promise<string | null>;
+    /**
+     * Aggregate fleet-wide status: pending tasks with descriptions and
+     * live subagent snapshot from the coordinator. Used by
+     * `MultiAgentHost.status()` to eliminate host-side state duplication.
+     */
+    getFleetStatus(): {
+        pending: {
+            taskId: string;
+            description: string;
+            subagentId: string;
+        }[];
+        live: {
+            subagentId: string;
+            status: string;
+            task?: string;
+        }[];
+    };
+    /**
+     * Register a pending task with its description. Called by
+     * `MultiAgentHost.spawn()` after `_spawnAndAssign()` returns so
+     * the description is available in `status()` without host-side storage.
+     */
+    addPendingTask(taskId: string, subagentId: string, description: string): void;
+    /**
+     * Remove a pending task. Called when the task completes so the
+     * pending list stays accurate.
+     */
+    removePendingTask(taskId: string): void;
+}
+
+/** Options for constructing a FleetManager. */
+interface FleetManagerOptions {
+    manifestPath?: string;
+    sessionsRoot?: string;
+    directorRunId?: string;
+    maxSpawns?: number;
+    maxSpawnDepth?: number;
+    spawnDepth?: number;
+    stateCheckpointPath?: string;
+    sessionWriter?: SessionWriter;
+    manifestDebounceMs?: number;
+    checkpointDebounceMs?: number;
+    directorBudget?: {
+        maxCostUsd?: number;
+    };
+}
+/**
+ * Fleet-level policy container extracted from `Director`. Owns:
+ * - FleetBus + FleetUsageAggregator
+ * - Spawn caps and counters
+ * - Manifest entries and debounced writing
+ * - State checkpointing
+ *
+ * This lets the `Director` focus on orchestration (spawn/assign/await/ask)
+ * while fleet-level decisions live in one place. The class implements
+ * `IFleetManager` so it remains swappable in future.
+ *
+ * @example
+ * ```typescript
+ * const fm = new FleetManager({ manifestPath: '/tmp/fleet.json' });
+ * const err = fm.canSpawn({ name: 'worker' });
+ * if (!err) fm.recordSpawn('sub-1', { name: 'worker' });
+ * await fm.writeManifest();
+ * ```
+ */
+declare class FleetManager implements IFleetManager {
+    /** The fleet-wide event bus. */
+    readonly fleet: FleetBus;
+    /** Usage rollup across all subagents. */
+    readonly usage: FleetUsageAggregator;
+    private readonly manifestPath?;
+    private readonly sessionsRoot?;
+    private readonly directorRunId;
+    /** Spawn cap (lifetime total). Infinity means unlimited. */
+    readonly maxSpawns: number;
+    /** Nesting cap. */
+    readonly maxSpawnDepth: number;
+    /** This director's depth in a director chain. Root = 0. */
+    readonly spawnDepth: number;
+    /** Live spawn counter. */
+    private spawnCount;
+    private readonly stateCheckpoint;
+    private readonly sessionWriter;
+    private manifestTimer;
+    private readonly manifestDebounceMs;
+    /** Fleet-wide cost cap. Infinity = no cap. Distinct from SubagentBudget limits,
+     *  which track per-subagent spend — this field caps the entire fleet total. */
+    private readonly maxFleetCostUsd;
+    private readonly manifestEntries;
+    /** Pending tasks with their descriptions — populated by `addPendingTask`
+     *  and cleared by `removePendingTask`. Replaces the host-side `pending`
+     *  Map so task descriptions live in one place (FleetManager). */
+    private readonly pendingTasks;
+    private readonly subagentMeta;
+    private readonly priceLookups;
+    constructor(opts?: FleetManagerOptions);
+    get fleetBus(): FleetBus;
+    snapshot(): FleetUsage;
+    getSubagentMeta(id: string): {
+        provider?: string;
+        model?: string;
+        name?: string;
+    } | undefined;
+    /**
+     * Returns null if the spawn is allowed, or an object describing
+     * which cap was exceeded. Does NOT throw — the caller decides
+     * how to surface the rejection.
+     */
+    canSpawn(config: SubagentConfig): {
+        kind: 'max_spawns' | 'max_spawn_depth' | 'max_cost_usd';
+        limit: number;
+        observed: number;
+    } | null;
+    /**
+     * Records a spawn: increments counter, stores metadata, updates state checkpoint,
+     * and schedules a debounced manifest write. Call AFTER the coordinator
+     * has successfully spawned the subagent.
+     *
+     * @param subagentId The subagent's id (from coordinator.spawn result)
+     * @param config The SubagentConfig that was used
+     * @param priceLookup Optional per-subagent pricing data
+     */
+    recordSpawn(subagentId: string, config: SubagentConfig, priceLookup?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+    }): void;
+    writeManifest(): Promise<string | null>;
+    /**
+     * Attach task ids to an already-spawned subagent. Called by
+     * `Director.assign()` after the coordinator assigns a task.
+     */
+    addTaskToSubagent(subagentId: string, taskId: string): void;
+    /**
+     * Debounced manifest write. Call after any state mutation
+     * (spawn, assign, complete) so a burst collapses into one write.
+     */
+    scheduleManifest(): void;
+    /** Best-effort session event writer. Swallows failures. */
+    private appendSessionEvent;
+    addPendingTask(taskId: string, subagentId: string, description: string): void;
+    removePendingTask(taskId: string): void;
+    getFleetStatus(): {
+        pending: {
+            taskId: string;
+            description: string;
+            subagentId: string;
+        }[];
+        live: {
+            subagentId: string;
+            status: string;
+            task?: string;
+        }[];
+    };
+}
+
 /**
  * Director — high-level orchestrator that owns a `MultiAgentCoordinator`,
  * a `FleetBus`, and a `FleetUsageAggregator`. Exposes a small imperative
@@ -174,7 +472,7 @@ interface DirectorOptions {
      * lifetime. Default: unlimited. Acts as a hard fleet-wide cost cap —
      * a runaway leader that keeps spawning workers gets cut off cleanly
      * instead of burning provider tokens until the user kills the
-     * process. The N+1-th spawn call rejects with a `DirectorBudgetError`.
+     * process. The N+1-th spawn call rejects with a `FleetSpawnBudgetError`.
      */
     maxSpawns?: number;
     /**
@@ -217,6 +515,65 @@ interface DirectorOptions {
      * writes (the manifest will then only be written on `shutdown()`).
      */
     manifestDebounceMs?: number;
+    /**
+     * Fleet-wide cost ceiling. When set, `spawn()` refuses any new subagent
+     * that would push the fleet's total cost above this limit. The cap
+     * is checked BEFORE the spawn is recorded — a refused spawn must not
+     * leak partial state into the manifest or fleet bus. Let in-flight
+     * tasks complete; refuse new spawns only. When omitted or Infinity,
+     * no cost cap applies.
+     *
+     * Distinct from SubagentBudget.maxCostUsd (per-subagent spend) — this
+     * field caps the *entire fleet* total.
+     */
+    directorBudget?: {
+        /**
+         * Maximum total USD the fleet may spend across all subagents.
+         * Default: Infinity (no cap).
+         */
+        maxCostUsd?: number;
+    };
+    /**
+     * Maximum auto-extensions per subagent per budget kind before the
+     * director denies further extensions. A subagent hitting the same
+     * soft limit repeatedly (e.g. 3× budget.threshold_reached for
+     * tool_calls) is likely looping on a prompt/config issue, not
+     * making legitimate progress. Default: 2. Set to Infinity to
+     * disable the cap (use with caution — a misconfigured subagent
+     * could burn unlimited budget).
+     */
+    maxBudgetExtensions?: number;
+    /**
+     * Debounce window for state-checkpoint writes. Default: 250ms.
+     * Bursts of spawn/assign/complete events collapse into one disk
+     * hit. Higher values reduce write amplification on fast machines;
+     * lower values improve crash-recovery fidelity (less state lost
+     * on sudden process exit).
+     */
+    checkpointDebounceMs?: number;
+    /**
+     * Sessions root directory for per-subagent JSONL transcripts.
+     * When set, the director can read subagent transcripts directly for
+     * `fleet_session` tool — no bridge round-trip needed. Path convention:
+     * `<sessionsRoot>/<directorRunId>/<subagentId>.jsonl`.
+     */
+    sessionsRoot?: string;
+    /**
+     * Director run id — namespaced under `sessionsRoot` to locate per-subagent
+     * JSONLs. Defaults to the director's own `id` when omitted.
+     */
+    directorRunId?: string;
+    /**
+     * Pre-built fleet manager. When provided the Director delegates all
+     * fleet-level policy (spawn budgets, manifest assembly, checkpointing)
+     * to this instance and takes ownership of the coordinator + bridge
+     * layer only. This enables unit-testing fleet policy in isolation
+     * and swapping implementations without changing the Director surface.
+     *
+     * When omitted the Director creates its own fleet infrastructure
+     * (same behavior as before this field was added).
+     */
+    fleetManager?: FleetManager;
 }
 /**
  * Thrown by `Director.spawn()` when a configured spawn cap (`maxSpawns`,
@@ -224,16 +581,44 @@ interface DirectorOptions {
  * the `spawn_subagent` tool surface — can recognize the budget case and
  * report it cleanly instead of treating it like an unexpected failure.
  */
-declare class DirectorBudgetError extends Error {
+declare class FleetSpawnBudgetError extends Error {
     readonly kind: 'max_spawns' | 'max_spawn_depth';
     readonly limit: number;
     readonly observed: number;
     constructor(kind: 'max_spawns' | 'max_spawn_depth', limit: number, observed: number);
 }
-declare class Director {
+/**
+ * Thrown by `Director.spawn()` when the fleet-wide cost cap is exceeded.
+ * Distinct from `FleetSpawnBudgetError` (spawn count/depth) — this is a
+ * dollar-denominated ceiling that tracks cumulative spend across all
+ * subagents in the fleet.
+ */
+declare class FleetCostCapError extends Error {
+    readonly kind: 'max_cost_usd';
+    readonly limit: number;
+    readonly observed: number;
+    constructor(limit: number, observed: number);
+}
+declare class Director implements ICoordinator {
+    /** Alias for the ICoordinator contract. `id` is retained for backward compatibility. */
+    get coordinatorId(): string;
     readonly id: string;
+    /**
+     * The fleet event bus. Backed by `fleetManager?.fleet` when a FleetManager
+     * is injected; otherwise own FleetBus instance (preserves existing behavior).
+     */
     readonly fleet: FleetBus;
+    /**
+     * Usage rollup. Backed by `fleetManager?.usage` when a FleetManager is
+     * injected; otherwise own FleetUsageAggregator.
+     */
     readonly usage: FleetUsageAggregator;
+    /**
+     * Optional fleet-level policy container. When provided the Director
+     * delegates spawn budgeting, manifest entries, and checkpointing to it
+     * instead of managing those internally. All other behavior is unchanged.
+     */
+    readonly fleetManager: FleetManager | undefined;
     /**
      * Director-side bridge endpoint. Subagents are wired to the same
      * in-memory transport so the director can `ask()` them synchronously
@@ -284,6 +669,14 @@ declare class Director {
     /** Debounce timer for periodic manifest writes. */
     private manifestTimer;
     private readonly manifestDebounceMs;
+    /** Fleet-wide cost cap (entire fleet total, distinct from SubagentBudget limits). Infinity means no cap. */
+    private readonly maxFleetCostUsd;
+    /** Max auto-extensions per subagent per budget kind before denying. */
+    private readonly maxBudgetExtensions;
+    /** Sessions root for direct subagent JSONL reads (fleet_session tool). */
+    private readonly sessionsRoot?;
+    /** Director run id for JSONL path resolution. */
+    private readonly directorRunId;
     /** Resolves task descriptions back from `assign()` so completion events
      *  can also carry a human-readable title. */
     private readonly taskDescriptions;
@@ -404,6 +797,28 @@ declare class Director {
      * paint the completed table without reaching into private state.
      */
     completedResults(): TaskResult[];
+    /**
+     * Inject a previously-saved checkpoint snapshot. Call this right after
+     * constructing a Director during a `--resume` run so the in-memory state
+     * (subagents, tasks, waiters) reflects the pre-crash reality instead of
+     * starting from a blank slate. The director then resumes from there —
+     * completing any in-flight tasks and ignoring tasks that already reached
+     * a terminal state in the prior run.
+     */
+    setCheckpointState(snapshot: DirectorStateSnapshot): void;
+    /**
+     * Read a subagent's JSONL transcript directly from disk (no bridge
+     * round-trip needed). Returns the last assistant text, stop reason,
+     * tool-use count, and line count — or null if the file is unavailable.
+     * Requires `sessionsRoot` to be set on construction.
+     */
+    readSession(subagentId: string, tail?: number): Promise<{
+        lastAssistantText?: string;
+        lastStopReason?: string;
+        toolUsesObserved: number;
+        events: number;
+        path?: string;
+    } | null>;
     snapshot(): FleetUsage;
     /**
      * Look up provider/model metadata for a spawned subagent. Returns
@@ -453,6 +868,18 @@ declare class Director {
      * still permission-checked normally.
      */
     tools(roster?: Record<string, SubagentConfig>): Tool[];
+    /**
+     * Attempt to acquire the checkpoint lock. Must be called before
+     * resuming — if another director process is alive, this returns
+     * false and the caller should not proceed with the resume.
+     */
+    acquireCheckpointLock(): Promise<boolean>;
+    /**
+     * Resume from a prior checkpoint snapshot (loaded via
+     * `loadDirectorState()`). Re-attach to the fleet mid-flight so
+     * subsequent spawn/assign calls update the checkpoint normally.
+     */
+    resumeFromCheckpoint(snapshot: DirectorStateSnapshot): void;
 }
 
 /**
@@ -511,6 +938,13 @@ interface CreateDelegateToolOptions {
      * JSONLs at `<sessionsRoot>/<runId>/<subagentId>.jsonl`.
      */
     directorRunId?: string;
+    /**
+     * Buffer subtracted from the caller's `timeoutMs` before passing it
+     * to the subagent. Gives the host a window to detect a subagent that
+     * has gone silent and surface a partial result rather than a generic
+     * timeout. Default: 30_000 ms.
+     */
+    subagentTimeoutBufferMs?: number;
 }
 /**
  * `delegate` — the only multi-agent tool a regular (non-director) agent
@@ -896,4 +1330,13 @@ declare function applyRosterBudget(cfg: SubagentConfig): SubagentConfig;
 /** Quick-access list for spawning all at once. */
 declare const ALL_FLEET_AGENTS: SubagentConfig[];
 
-export { ALL_FLEET_AGENTS as A, BUG_HUNTER_AGENT as B, type CreateDelegateToolOptions as C, DEFAULT_DIRECTOR_PREAMBLE as D, rosterSummaryFromConfigs as E, FLEET_ROSTER as F, type MultiAgentCoordinatorOptions as M, REFACTOR_PLANNER_AGENT as R, SECURITY_SCANNER_AGENT as S, AUDIT_LOG_AGENT as a, type AgentFactory as b, type AgentFactoryResult as c, type AgentRunnerOptions as d, DEFAULT_SUBAGENT_BASELINE as e, DefaultMultiAgentCoordinator as f, type DelegateHost as g, Director as h, DirectorBudgetError as i, type DirectorPromptParts as j, type DirectorSessionFactory as k, type DirectorSessionFactoryOptions as l, FLEET_ROSTER_BUDGETS as m, FleetBus as n, type FleetEvent as o, type FleetHandler as p, type FleetUsage as q, FleetUsageAggregator as r, type SubagentPromptParts as s, type SubagentUsageSnapshot as t, applyRosterBudget as u, composeDirectorPrompt as v, composeSubagentPrompt as w, createDelegateTool as x, makeAgentSubagentRunner as y, makeDirectorSessionFactory as z };
+/**
+ * A no-op FleetBus that discards all events. Used when no real fleet
+ * bus is available (non-director mode) so the runner's `fleetBus`
+ * field is always valid and the `attach()` call is always safe.
+ *
+ * One singleton instance is sufficient — it has no state to reset.
+ */
+declare const NULL_FLEET_BUS: FleetBus;
+
+export { ALL_FLEET_AGENTS as A, BUG_HUNTER_AGENT as B, type CreateDelegateToolOptions as C, DEFAULT_DIRECTOR_PREAMBLE as D, createDelegateTool as E, FLEET_ROSTER as F, makeAgentSubagentRunner as G, makeDirectorSessionFactory as H, type ICoordinator as I, rosterSummaryFromConfigs as J, FleetCostCapError as K, type MultiAgentCoordinatorOptions as M, NULL_FLEET_BUS as N, REFACTOR_PLANNER_AGENT as R, SECURITY_SCANNER_AGENT as S, AUDIT_LOG_AGENT as a, type AgentFactory as b, type AgentFactoryResult as c, type AgentRunnerOptions as d, DEFAULT_SUBAGENT_BASELINE as e, DefaultMultiAgentCoordinator as f, type DelegateHost as g, Director as h, type DirectorPromptParts as i, type DirectorSessionFactory as j, type DirectorSessionFactoryOptions as k, FLEET_ROSTER_BUDGETS as l, FleetBus as m, type FleetEvent as n, type FleetHandler as o, FleetManager as p, type FleetManagerOptions as q, FleetSpawnBudgetError as r, type FleetUsage as s, FleetUsageAggregator as t, type IFleetManager as u, type SubagentPromptParts as v, type SubagentUsageSnapshot as w, applyRosterBudget as x, composeDirectorPrompt as y, composeSubagentPrompt as z };

package/dist/{index-DPLJw_ZI.d.ts → index-j2WyAyML.d.ts}

@@ -1,10 +1,10 @@
-import { v as Tool, B as ToolResultBlock, T as TextBlock, a2 as Context, R as Request, j as Response, G as ToolUseBlock, g as Provider, W as WrongStackError, b as ContentBlock, aa as RunOptions, J as JSONSchema } from './context-CLZXPPYk.js';
+import { v as Tool, B as ToolResultBlock, T as TextBlock, a2 as Context, R as Request, j as Response, G as ToolUseBlock, g as Provider, W as WrongStackError, b as ContentBlock, aa as RunOptions, J as JSONSchema } from './context-CDRyrkKQ.js';
 import { L as Logger } from './logger-BMQgxvdy.js';
-import { R as Renderer, B as BuildContext, C as Container, P as Pipeline, e as ReadonlyPipeline } from './system-prompt-DI4Dtc1I.js';
+import { R as Renderer, B as BuildContext, C as Container, P as Pipeline, e as ReadonlyPipeline } from './system-prompt-Dl2QY1_B.js';
 import { T as Tracer } from './observability-BhnVLBLS.js';
-import { E as EventBus, a as EventName, L as Listener } from './events-qnDZbrtb.js';
-import { a as PermissionPolicy, S as SecretScrubber } from './secret-scrubber-BhJTNr9v.js';
-import { l as ProviderConfig, a as Config } from './config-BgM0BIpz.js';
+import { E as EventBus, a as EventName, L as Listener } from './events-DPQKFX7W.js';
+import { a as PermissionPolicy, S as SecretScrubber } from './secret-scrubber-CfMdAJ_l.js';
+import { l as ProviderConfig, a as Config } from './config-BGGuP_Ar.js';
 import { W as WireFamily } from './models-registry-Y2xbog0E.js';
 
 /**
@@ -440,6 +440,19 @@ interface AgentInit {
      * emit `iteration.limit_reached` and wait for a listener to grant/deny.
      */
     autoExtendLimit?: boolean;
+    /**
+     * When true, the agent supports autonomous continuation — the model
+     * can signal "keep going" either via the `continue_to_next_iteration()`
+     * tool or by placing a `[continue]` / `[next step]` / `[proceed]` /
+     * `[done]` marker on its own line in the final text output. The agent
+     * loop re-runs without returning to the caller when `continue` is
+     * signalled, or exits with `status: 'done'` when `stop` is signalled.
+     *
+     * The text-marker parser runs in `processResponse()` before the
+     * loop-exit check so markers in the final text block are honoured
+     * even when no tool was called.
+     */
+    autonomousContinue?: boolean;
     /**
      * Optional confirm handler. When set, the executor calls it synchronously
      * when a tool needs user confirmation (CLI path). When omitted, the
@@ -507,6 +520,8 @@ declare class Agent {
     private readonly plugins;
     private readonly toolExecutor;
     private readonly autoExtendLimit;
+    /** Enables autonomous continue: model can signal `[continue]` or call continue_to_next_iteration() to re-run. */
+    private readonly autonomousContinue;
     private readonly tracer;
     readonly extensions: ExtensionRegistry;
     constructor(init: AgentInit);