@herdctl/core 0.0.1 → 0.0.2

package/dist/fleet-manager/fleet-manager.d.ts

@@ -1,88 +1,28 @@
 /**
- * FleetManager class for library consumers
+ * FleetManager - High-level orchestration layer for autonomous agents
  *
- * Provides a simple, high-level API to initialize and run a fleet of agents
- * with minimal configuration. Handles config loading, state directory setup,
- * and scheduler orchestration internally.
- *
- * @example
- * ```typescript
- * import { FleetManager } from '@herdctl/core';
- *
- * const manager = new FleetManager({
- *   configPath: './herdctl.yaml',
- *   stateDir: './.herdctl',
- * });
- *
- * await manager.initialize();
- * await manager.start();
+ * The FleetManager class provides a simple interface for library consumers
+ * to initialize and run agent fleets. It coordinates between:
+ * - Configuration loading and validation
+ * - State directory management
+ * - Scheduler setup and lifecycle
+ * - Event emission for monitoring
  *
- * // Later...
- * await manager.stop();
- * ```
+ * @module fleet-manager
  */
 import { EventEmitter } from "node:events";
 import { type ResolvedConfig, type ResolvedAgent } from "../config/index.js";
-import type { FleetManagerOptions, FleetManagerState, ConfigReloadedPayload, AgentStartedPayload, AgentStoppedPayload, ScheduleSkippedPayload, JobCreatedPayload, JobOutputPayload, JobCompletedPayload, JobFailedPayload, JobCancelledPayload, JobForkedPayload, FleetStatus, AgentInfo, ScheduleInfo, TriggerOptions, TriggerResult, JobModifications, CancelJobResult, ForkJobResult, FleetManagerStopOptions, LogEntry, LogStreamOptions } from "./types.js";
+import { type StateDirectory } from "../state/index.js";
+import { Scheduler } from "../scheduler/index.js";
+import type { FleetManagerContext } from "./context.js";
+import type { FleetManagerOptions, FleetManagerState, FleetManagerStatus, FleetManagerLogger, FleetManagerStopOptions, FleetStatus, AgentInfo, ScheduleInfo, TriggerOptions, TriggerResult, JobModifications, CancelJobResult, ForkJobResult, LogEntry, LogStreamOptions, ConfigChange, ConfigReloadedPayload } from "./types.js";
 /**
- * FleetManager provides a simple API to manage a fleet of agents
- *
- * This class is the primary entry point for library consumers who want to
- * run herdctl programmatically. It handles:
- *
- * - Configuration loading and validation
- * - State directory initialization
- * - Scheduler lifecycle management
- * - Event emission for monitoring
- *
- * ## Lifecycle
- *
- * 1. **Construction**: Create with options (configPath, stateDir)
- * 2. **Initialize**: Call `initialize()` to load config and prepare state
- * 3. **Start**: Call `start()` to begin scheduler and process schedules
- * 4. **Stop**: Call `stop()` to gracefully shut down
- *
- * ## Events
- *
- * The FleetManager emits events for monitoring:
- * - `initialized` - After successful initialization
- * - `started` - When the scheduler starts running
- * - `stopped` - When the scheduler stops
- * - `error` - When an error occurs
- * - `schedule:trigger` - When a schedule triggers an agent
- * - `schedule:complete` - When an agent run completes
- * - `schedule:error` - When an agent run fails
- *
- * ## Typed Events (US-2)
+ * FleetManager provides high-level orchestration for autonomous agents
  *
- * The FleetManager also supports strongly-typed events via TypeScript:
- * - `config:reloaded` - When configuration is hot-reloaded
- * - `agent:started` - When an agent is started
- * - `agent:stopped` - When an agent is stopped
- * - `schedule:triggered` - When a schedule triggers (with payload)
- * - `schedule:skipped` - When a schedule is skipped
- * - `job:created` - When a job is created
- * - `job:output` - When a job produces output
- * - `job:completed` - When a job completes successfully
- * - `job:failed` - When a job fails
- *
- * @example
- * ```typescript
- * // Subscribe to typed events
- * manager.on('job:created', (payload) => {
- *   console.log(`Job ${payload.job.id} created for ${payload.agentName}`);
- * });
- *
- * manager.on('job:output', (payload) => {
- *   process.stdout.write(payload.output);
- * });
- *
- * manager.on('job:completed', (payload) => {
- *   console.log(`Job completed in ${payload.durationSeconds}s`);
- * });
- * ```
+ * Implements FleetManagerContext to provide clean access to internal state
+ * for composed module classes.
  */
-export declare class FleetManager extends EventEmitter {
+export declare class FleetManager extends EventEmitter implements FleetManagerContext {
     private readonly configPath?;
     private readonly stateDir;
     private readonly logger;
@@ -95,605 +35,52 @@ export declare class FleetManager extends EventEmitter {
     private startedAt;
     private stoppedAt;
     private lastError;
-    /**
-     * Create a new FleetManager instance
-     *
-     * @param options - Configuration options
-     *
-     * @example
-     * ```typescript
-     * // Minimal configuration
-     * const manager = new FleetManager({
-     *   configPath: './herdctl.yaml',
-     *   stateDir: './.herdctl',
-     * });
-     *
-     * // With custom logger
-     * const manager = new FleetManager({
-     *   configPath: './herdctl.yaml',
-     *   stateDir: './.herdctl',
-     *   logger: myLogger,
-     *   checkInterval: 5000, // 5 seconds
-     * });
-     * ```
-     */
+    private statusQueries;
+    private scheduleManagement;
+    private configReloadModule;
+    private jobControl;
+    private logStreaming;
+    private scheduleExecutor;
     constructor(options: FleetManagerOptions);
-    /**
-     * Get the current fleet manager state
-     *
-     * This provides a snapshot of the fleet manager's current status and
-     * configuration for monitoring purposes.
-     */
-    get state(): FleetManagerState;
-    /**
-     * Get the loaded configuration
-     *
-     * @returns The resolved configuration, or null if not initialized
-     */
     getConfig(): ResolvedConfig | null;
-    /**
-     * Get the loaded agents
-     *
-     * @returns Array of resolved agents, or empty array if not initialized
-     */
+    getStateDir(): string;
+    getStateDirInfo(): StateDirectory | null;
+    getLogger(): FleetManagerLogger;
+    getScheduler(): Scheduler | null;
+    getStatus(): FleetManagerStatus;
+    getInitializedAt(): string | null;
+    getStartedAt(): string | null;
+    getStoppedAt(): string | null;
+    getLastError(): string | null;
+    getCheckInterval(): number;
+    getEmitter(): EventEmitter;
+    get state(): FleetManagerState;
     getAgents(): ResolvedAgent[];
-    /**
-     * Get overall fleet status
-     *
-     * Returns a comprehensive snapshot of the fleet state including:
-     * - Current state and uptime
-     * - Agent counts (total, idle, running, error)
-     * - Job counts
-     * - Scheduler information
-     *
-     * This method works whether the fleet is running or stopped.
-     *
-     * @returns A consistent FleetStatus snapshot
-     *
-     * @example
-     * ```typescript
-     * const status = await manager.getFleetStatus();
-     * console.log(`Fleet: ${status.state}`);
-     * console.log(`Uptime: ${status.uptimeSeconds}s`);
-     * console.log(`Running jobs: ${status.counts.runningJobs}`);
-     * ```
-     */
+    initialize(): Promise<void>;
+    start(): Promise<void>;
+    stop(options?: FleetManagerStopOptions): Promise<void>;
     getFleetStatus(): Promise<FleetStatus>;
-    /**
-     * Get information about all configured agents
-     *
-     * Returns detailed information for each agent including:
-     * - Current status and job information
-     * - Schedule details with runtime state
-     * - Configuration details
-     *
-     * This method works whether the fleet is running or stopped.
-     *
-     * @returns Array of AgentInfo objects with current state
-     *
-     * @example
-     * ```typescript
-     * const agents = await manager.getAgentInfo();
-     * for (const agent of agents) {
-     *   console.log(`${agent.name}: ${agent.status}`);
-     *   console.log(`  Schedules: ${agent.scheduleCount}`);
-     * }
-     * ```
-     */
     getAgentInfo(): Promise<AgentInfo[]>;
-    /**
-     * Get information about a specific agent by name
-     *
-     * Returns detailed information for the specified agent including:
-     * - Current status and job information
-     * - Schedule details with runtime state
-     * - Configuration details
-     *
-     * This method works whether the fleet is running or stopped.
-     *
-     * @param name - The agent name to look up
-     * @returns AgentInfo for the specified agent
-     * @throws {AgentNotFoundError} If no agent with that name exists
-     *
-     * @example
-     * ```typescript
-     * const agent = await manager.getAgentInfoByName('my-agent');
-     * console.log(`Agent: ${agent.name}`);
-     * console.log(`Status: ${agent.status}`);
-     * console.log(`Running: ${agent.runningCount}/${agent.maxConcurrent}`);
-     * ```
-     */
     getAgentInfoByName(name: string): Promise<AgentInfo>;
-    /**
-     * Read fleet state from disk for status queries
-     *
-     * This provides a consistent snapshot of the fleet state.
-     */
-    private readFleetStateSnapshot;
-    /**
-     * Build AgentInfo from configuration and state
-     */
-    private buildAgentInfo;
-    /**
-     * Build schedule info list from agent configuration and state
-     */
-    private buildScheduleInfoList;
-    /**
-     * Compute fleet counts from agent info list
-     */
-    private computeFleetCounts;
-    /**
-     * Get all schedules across all agents
-     *
-     * Returns a list of all configured schedules with their current state,
-     * including next trigger times.
-     *
-     * @returns Array of ScheduleInfo objects with current state
-     *
-     * @example
-     * ```typescript
-     * const schedules = await manager.getSchedules();
-     * for (const schedule of schedules) {
-     *   console.log(`${schedule.agentName}/${schedule.name}: ${schedule.status}`);
-     *   console.log(`  Next run: ${schedule.nextRunAt}`);
-     * }
-     * ```
-     */
     getSchedules(): Promise<ScheduleInfo[]>;
-    /**
-     * Get a specific schedule by agent name and schedule name
-     *
-     * @param agentName - The name of the agent
-     * @param scheduleName - The name of the schedule
-     * @returns The schedule info with current state
-     * @throws {AgentNotFoundError} If the agent doesn't exist
-     * @throws {ScheduleNotFoundError} If the schedule doesn't exist
-     *
-     * @example
-     * ```typescript
-     * const schedule = await manager.getSchedule('my-agent', 'hourly');
-     * console.log(`Status: ${schedule.status}`);
-     * console.log(`Last run: ${schedule.lastRunAt}`);
-     * console.log(`Next run: ${schedule.nextRunAt}`);
-     * ```
-     */
     getSchedule(agentName: string, scheduleName: string): Promise<ScheduleInfo>;
-    /**
-     * Enable a disabled schedule
-     *
-     * Enables a schedule that was previously disabled, allowing it to trigger
-     * again on its configured interval. The enabled state is persisted to the
-     * state directory and survives restarts.
-     *
-     * @param agentName - The name of the agent
-     * @param scheduleName - The name of the schedule
-     * @returns The updated schedule info
-     * @throws {AgentNotFoundError} If the agent doesn't exist
-     * @throws {ScheduleNotFoundError} If the schedule doesn't exist
-     *
-     * @example
-     * ```typescript
-     * // Enable a previously disabled schedule
-     * const schedule = await manager.enableSchedule('my-agent', 'hourly');
-     * console.log(`Schedule status: ${schedule.status}`); // 'idle'
-     * ```
-     */
     enableSchedule(agentName: string, scheduleName: string): Promise<ScheduleInfo>;
-    /**
-     * Disable a schedule
-     *
-     * Disables a schedule, preventing it from triggering on its configured
-     * interval. The schedule remains in the configuration but won't run until
-     * re-enabled. The disabled state is persisted to the state directory and
-     * survives restarts.
-     *
-     * @param agentName - The name of the agent
-     * @param scheduleName - The name of the schedule
-     * @returns The updated schedule info
-     * @throws {AgentNotFoundError} If the agent doesn't exist
-     * @throws {ScheduleNotFoundError} If the schedule doesn't exist
-     *
-     * @example
-     * ```typescript
-     * // Disable a schedule temporarily
-     * const schedule = await manager.disableSchedule('my-agent', 'hourly');
-     * console.log(`Schedule status: ${schedule.status}`); // 'disabled'
-     *
-     * // Later, re-enable it
-     * await manager.enableSchedule('my-agent', 'hourly');
-     * ```
-     */
     disableSchedule(agentName: string, scheduleName: string): Promise<ScheduleInfo>;
-    /**
-     * Initialize the fleet manager
-     *
-     * This method:
-     * 1. Loads and validates the configuration file
-     * 2. Initializes the state directory structure
-     * 3. Prepares the scheduler (but does not start it)
-     *
-     * After initialization, the fleet manager is ready to start.
-     *
-     * @throws {FleetManagerStateError} If already initialized or running
-     * @throws {FleetManagerConfigError} If configuration is invalid or not found
-     * @throws {FleetManagerStateDirError} If state directory cannot be created
-     *
-     * @example
-     * ```typescript
-     * const manager = new FleetManager({ ... });
-     * await manager.initialize();
-     * console.log(`Loaded ${manager.state.agentCount} agents`);
-     * ```
-     */
-    initialize(): Promise<void>;
-    /**
-     * Start the fleet manager
-     *
-     * This begins the scheduler, which will:
-     * 1. Check agent schedules at the configured interval
-     * 2. Trigger agents when their schedules are due
-     * 3. Track schedule state in the state directory
-     *
-     * @throws {FleetManagerStateError} If not initialized
-     *
-     * @example
-     * ```typescript
-     * await manager.initialize();
-     * await manager.start();
-     *
-     * // The manager is now running and processing schedules
-     * manager.on('schedule:trigger', (agent, schedule) => {
-     *   console.log(`Triggered ${agent}/${schedule}`);
-     * });
-     * ```
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the fleet manager gracefully
-     *
-     * This will:
-     * 1. Signal the scheduler to stop accepting new triggers
-     * 2. Wait for running jobs to complete (with timeout)
-     * 3. If timeout is reached and cancelOnTimeout is true, cancel remaining jobs
-     * 4. Persist all state before shutdown completes
-     * 5. Emit 'stopped' event when complete
-     *
-     * @param options - Stop options for controlling shutdown behavior
-     * @throws {FleetManagerShutdownError} If shutdown times out and cancelOnTimeout is false
-     *
-     * @example
-     * ```typescript
-     * // Normal shutdown - wait for jobs with default 30s timeout
-     * await manager.stop();
-     *
-     * // Shutdown with custom timeout
-     * await manager.stop({ timeout: 60000 });
-     *
-     * // Shutdown without waiting for jobs (not recommended)
-     * await manager.stop({ waitForJobs: false });
-     *
-     * // Cancel jobs if they don't complete in time
-     * await manager.stop({
-     *   timeout: 30000,
-     *   cancelOnTimeout: true,
-     *   cancelTimeout: 10000,
-     * });
-     * ```
-     */
-    stop(options?: FleetManagerStopOptions): Promise<void>;
-    /**
-     * Reload configuration without restarting the fleet
-     *
-     * This method provides hot configuration reload capability:
-     * 1. Loads and validates the new configuration
-     * 2. If validation fails, keeps the old configuration (fails gracefully)
-     * 3. Running jobs continue with their original configuration
-     * 4. New jobs will use the new configuration
-     * 5. Updates the scheduler with new agent definitions and schedules
-     * 6. Emits a 'config:reloaded' event with a list of changes
-     *
-     * @returns The reload result with change details
-     * @throws {InvalidStateError} If the fleet manager is not initialized
-     * @throws {FleetManagerConfigError} If the new configuration is invalid (re-thrown after logging)
-     *
-     * @example
-     * ```typescript
-     * // Reload configuration
-     * const result = await manager.reload();
-     * console.log(`Reloaded with ${result.changes.length} changes`);
-     *
-     * // Subscribe to reload events
-     * manager.on('config:reloaded', (payload) => {
-     *   console.log(`Config reloaded: ${payload.changes.length} changes`);
-     *   for (const change of payload.changes) {
-     *     console.log(`  ${change.type} ${change.category}: ${change.name}`);
-     *   }
-     * });
-     * ```
-     */
     reload(): Promise<ConfigReloadedPayload>;
-    /**
-     * Compute the list of changes between old and new configuration
-     */
-    private computeConfigChanges;
-    /**
-     * Check if an agent configuration has been modified
-     * Returns a description of what changed, or null if not modified
-     */
-    private isAgentModified;
-    /**
-     * Check if a schedule configuration has been modified
-     */
-    private isScheduleModified;
-    /**
-     * Get a description of what changed in a schedule
-     */
-    private getScheduleModificationDetails;
-    /**
-     * Cancel all running jobs during shutdown
-     *
-     * @param cancelTimeout - Timeout for each job cancellation
-     */
-    private cancelRunningJobs;
-    /**
-     * Persist shutdown state to ensure all state is saved before completing
-     */
-    private persistShutdownState;
-    /**
-     * Manually trigger an agent outside its normal schedule
-     *
-     * This method allows you to trigger an agent on-demand for testing or
-     * handling urgent situations. You can optionally specify a schedule to use
-     * for configuration (prompt, work source, etc.) or pass runtime options
-     * to override defaults.
-     *
-     * @param agentName - Name of the agent to trigger
-     * @param scheduleName - Optional schedule name to use for configuration
-     * @param options - Optional runtime options to override defaults
-     * @returns The created job information
-     * @throws {InvalidStateError} If the fleet manager is not initialized
-     * @throws {AgentNotFoundError} If the agent doesn't exist
-     * @throws {ScheduleNotFoundError} If the specified schedule doesn't exist
-     * @throws {ConcurrencyLimitError} If the agent is at capacity and bypassConcurrencyLimit is false
-     *
-     * @example
-     * ```typescript
-     * // Trigger with agent defaults
-     * const job = await manager.trigger('my-agent');
-     *
-     * // Trigger a specific schedule
-     * const job = await manager.trigger('my-agent', 'hourly');
-     *
-     * // Trigger with custom prompt
-     * const job = await manager.trigger('my-agent', undefined, {
-     *   prompt: 'Review the latest security updates',
-     * });
-     *
-     * // Force trigger even at capacity
-     * const job = await manager.trigger('my-agent', undefined, {
-     *   bypassConcurrencyLimit: true,
-     * });
-     * ```
-     */
+    computeConfigChanges(oldConfig: ResolvedConfig | null, newConfig: ResolvedConfig): ConfigChange[];
     trigger(agentName: string, scheduleName?: string, options?: TriggerOptions): Promise<TriggerResult>;
-    /**
-     * Cancel a running job gracefully
-     *
-     * This method cancels a running job by first sending SIGTERM to allow
-     * graceful shutdown. If the job doesn't terminate within the timeout,
-     * it will be forcefully killed with SIGKILL.
-     *
-     * @param jobId - ID of the job to cancel
-     * @param options - Optional cancellation options
-     * @param options.timeout - Time in ms to wait for graceful shutdown (default: 10000)
-     * @returns Result of the cancellation operation
-     * @throws {InvalidStateError} If the fleet manager is not initialized
-     * @throws {JobNotFoundError} If the job doesn't exist
-     *
-     * @example
-     * ```typescript
-     * // Cancel with default timeout
-     * const result = await manager.cancelJob('job-2024-01-15-abc123');
-     * console.log(`Job cancelled: ${result.terminationType}`);
-     *
-     * // Cancel with custom timeout
-     * const result = await manager.cancelJob('job-2024-01-15-abc123', {
-     *   timeout: 30000, // 30 seconds
-     * });
-     * ```
-     */
     cancelJob(jobId: string, options?: {
         timeout?: number;
     }): Promise<CancelJobResult>;
-    /**
-     * Fork a job to create a new job based on an existing one
-     *
-     * This method creates a new job that is based on an existing job's
-     * configuration. The new job will have the same agent and can optionally
-     * have modifications applied (different prompt, schedule, etc.).
-     *
-     * If the original job has a session ID, the new job will fork from that
-     * session, preserving conversation context.
-     *
-     * @param jobId - ID of the job to fork
-     * @param modifications - Optional modifications to apply to the forked job
-     * @returns Result of the fork operation including the new job ID
-     * @throws {InvalidStateError} If the fleet manager is not initialized
-     * @throws {JobNotFoundError} If the original job doesn't exist
-     * @throws {JobForkError} If the job cannot be forked (e.g., no session)
-     *
-     * @example
-     * ```typescript
-     * // Fork with same configuration
-     * const result = await manager.forkJob('job-2024-01-15-abc123');
-     * console.log(`Forked to: ${result.jobId}`);
-     *
-     * // Fork with modified prompt
-     * const result = await manager.forkJob('job-2024-01-15-abc123', {
-     *   prompt: 'Continue the previous task but focus on testing',
-     * });
-     *
-     * // Fork with different schedule
-     * const result = await manager.forkJob('job-2024-01-15-abc123', {
-     *   schedule: 'nightly',
-     * });
-     * ```
-     */
     forkJob(jobId: string, modifications?: JobModifications): Promise<ForkJobResult>;
-    /**
-     * Stream all fleet logs as an async iterable
-     *
-     * Provides a unified stream of logs from all sources in the fleet including
-     * agents, jobs, and the scheduler. Logs can be filtered by level and optionally
-     * by agent or job.
-     *
-     * For completed jobs, this will replay their history (if includeHistory is true)
-     * before streaming new logs from running jobs.
-     *
-     * @param options - Options for filtering and configuring the stream
-     * @returns An async iterable of LogEntry objects
-     *
-     * @example
-     * ```typescript
-     * // Stream all info+ logs
-     * for await (const log of manager.streamLogs()) {
-     *   console.log(`[${log.level}] ${log.message}`);
-     * }
-     *
-     * // Stream only errors for a specific agent
-     * for await (const log of manager.streamLogs({
-     *   level: 'error',
-     *   agentName: 'my-agent',
-     * })) {
-     *   console.error(log.message);
-     * }
-     * ```
-     */
     streamLogs(options?: LogStreamOptions): AsyncIterable<LogEntry>;
-    /**
-     * Stream output from a specific job as an async iterable
-     *
-     * Provides a stream of log entries for a specific job. For completed jobs,
-     * this will replay the job's history and then complete. For running jobs,
-     * it will continue streaming until the job completes.
-     *
-     * @param jobId - The ID of the job to stream output from
-     * @returns An async iterable of LogEntry objects
-     * @throws {JobNotFoundError} If the job doesn't exist
-     *
-     * @example
-     * ```typescript
-     * // Stream job output
-     * for await (const log of manager.streamJobOutput('job-2024-01-15-abc123')) {
-     *   console.log(`[${log.level}] ${log.message}`);
-     * }
-     * ```
-     */
     streamJobOutput(jobId: string): AsyncIterable<LogEntry>;
-    /**
-     * Stream logs for a specific agent as an async iterable
-     *
-     * Provides a stream of log entries for all jobs belonging to a specific agent.
-     * For completed jobs, this will replay their history. For running jobs, it
-     * will continue streaming until the iterator is stopped.
-     *
-     * @param agentName - The name of the agent to stream logs for
-     * @returns An async iterable of LogEntry objects
-     * @throws {AgentNotFoundError} If the agent doesn't exist in the configuration
-     *
-     * @example
-     * ```typescript
-     * // Stream all logs for an agent
-     * for await (const log of manager.streamAgentLogs('my-agent')) {
-     *   console.log(`[${log.jobId}] ${log.message}`);
-     * }
-     * ```
-     */
     streamAgentLogs(agentName: string): AsyncIterable<LogEntry>;
-    /**
-     * Convert a job output message to a LogEntry
-     */
-    private jobOutputToLogEntry;
-    /**
-     * Determine if a log entry should be yielded based on filters
-     */
-    private shouldYieldLog;
-    /**
-     * Load configuration with proper error handling
-     */
+    private initializeModules;
     private loadConfiguration;
-    /**
-     * Initialize state directory with proper error handling
-     */
     private initializeStateDir;
-    /**
-     * Start the scheduler asynchronously (don't block on the loop)
-     */
     private startSchedulerAsync;
-    /**
-     * Handle schedule trigger callback from scheduler
-     */
     private handleScheduleTrigger;
-    /**
-     * Emit a config:reloaded event
-     *
-     * Called when configuration is hot-reloaded.
-     */
-    emitConfigReloaded(payload: ConfigReloadedPayload): void;
-    /**
-     * Emit an agent:started event
-     *
-     * Called when an agent is started/registered with the fleet.
-     */
-    emitAgentStarted(payload: AgentStartedPayload): void;
-    /**
-     * Emit an agent:stopped event
-     *
-     * Called when an agent is stopped/unregistered from the fleet.
-     */
-    emitAgentStopped(payload: AgentStoppedPayload): void;
-    /**
-     * Emit a schedule:skipped event
-     *
-     * Called when a schedule check is skipped (already running, disabled, etc.).
-     */
-    emitScheduleSkipped(payload: ScheduleSkippedPayload): void;
-    /**
-     * Emit a job:created event
-     *
-     * Called when a new job is created.
-     */
-    emitJobCreated(payload: JobCreatedPayload): void;
-    /**
-     * Emit a job:output event
-     *
-     * Called when a job produces output during execution.
-     * This enables real-time streaming of output to UIs.
-     */
-    emitJobOutput(payload: JobOutputPayload): void;
-    /**
-     * Emit a job:completed event
-     *
-     * Called when a job completes successfully.
-     */
-    emitJobCompleted(payload: JobCompletedPayload): void;
-    /**
-     * Emit a job:failed event
-     *
-     * Called when a job fails.
-     */
-    emitJobFailed(payload: JobFailedPayload): void;
-    /**
-     * Emit a job:cancelled event (US-6)
-     *
-     * Called when a job is cancelled.
-     */
-    emitJobCancelled(payload: JobCancelledPayload): void;
-    /**
-     * Emit a job:forked event (US-6)
-     *
-     * Called when a job is forked to create a new job.
-     */
-    emitJobForked(payload: JobForkedPayload): void;
+    private persistShutdownState;
 }
 //# sourceMappingURL=fleet-manager.d.ts.map