@fenixforce/kernel 0.1.0

package/dist/interrupt.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Interrupt and Resume — allow users to interrupt a running agent loop
+ * mid-execution, save a checkpoint, and resume later.
+ *
+ * The agent loop checks an AbortSignal between iterations. When interrupted:
+ *   1. Save checkpoint via CheckpointManager
+ *   2. Emit agent:interrupted event
+ *   3. Return partial results with resume instructions
+ *
+ * Channel implementations:
+ *   - Telegram: /stop command
+ *   - HTTP: POST /api/v1/conversations/:id/interrupt
+ *   - WebSocket: { type: "interrupt" }
+ *
+ * Depends on Checkpoint (Task 3.10).
+ */
+import type { CheckpointManager, CheckpointMessage, Checkpoint } from "./checkpoint.js";
+export interface InterruptState {
+    /** Whether an interrupt has been requested. */
+    readonly interrupted: boolean;
+    /** The AbortSignal to check in the agent loop. */
+    readonly signal: AbortSignal;
+    /** Request an interrupt. */
+    interrupt(): void;
+    /** Reset for a new run. */
+    reset(): void;
+}
+export interface InterruptResult {
+    /** The checkpoint saved at interrupt time. */
+    checkpoint: Checkpoint;
+    /** Partial results collected before interruption. */
+    partialMessages: CheckpointMessage[];
+    /** Human-readable status message. */
+    message: string;
+}
+export interface ResumeRequest {
+    /** Session to resume. */
+    sessionId: string;
+    /** Specific checkpoint to resume from (default: latest). */
+    checkpointId?: string;
+}
+export interface ResumeResult {
+    /** The checkpoint being resumed from. */
+    checkpoint: Checkpoint;
+    /** Messages to feed back into the agent loop. */
+    messages: CheckpointMessage[];
+    /** Restored memory snapshot. */
+    memorySnapshot: Record<string, unknown>;
+    /** Restored tool state. */
+    toolState: Record<string, unknown>;
+    /** Restored task tracker state. */
+    taskTrackerState: Record<string, unknown>;
+}
+export type InterruptEventType = "agent:interrupted" | "agent:resuming" | "agent:resumed";
+export interface InterruptEvent {
+    type: InterruptEventType;
+    timestamp: Date;
+    sessionId: string;
+    checkpointId?: string;
+    detail: string;
+}
+export type InterruptEventListener = (event: InterruptEvent) => void;
+export declare function createInterruptState(): InterruptState;
+export interface InterruptManagerConfig {
+    checkpoints: CheckpointManager;
+}
+export interface InterruptManager {
+    /** Create an interrupt state for a session. */
+    createState(sessionId: string): InterruptState;
+    /** Get the interrupt state for a session. */
+    getState(sessionId: string): InterruptState | undefined;
+    /** Interrupt a running session, saving a checkpoint. */
+    interruptSession(sessionId: string, currentMessages: CheckpointMessage[], state?: {
+        memorySnapshot?: Record<string, unknown>;
+        toolState?: Record<string, unknown>;
+        taskTrackerState?: Record<string, unknown>;
+    }): InterruptResult | undefined;
+    /** Resume a session from a checkpoint. */
+    resume(request: ResumeRequest): ResumeResult | undefined;
+    /** Events. */
+    on(listener: InterruptEventListener): void;
+    off(listener: InterruptEventListener): void;
+}
+export declare function createInterruptManager(config: InterruptManagerConfig): InterruptManager;

package/dist/job-queue.d.ts

@@ -0,0 +1,69 @@
+type Listener = (...args: any[]) => void;
+declare class TypedEmitter {
+    private _listeners;
+    on(event: string, fn: Listener): this;
+    off(event: string, fn: Listener): this;
+    emit(event: string, ...args: unknown[]): boolean;
+}
+export type JobStatus = "queued" | "running" | "completed" | "dead" | "cancelled";
+export type JobPriority = "critical" | "high" | "normal" | "low";
+export interface Job<T = unknown> {
+    id: string;
+    type: string;
+    status: JobStatus;
+    priority: JobPriority;
+    payload: T;
+    result: unknown | null;
+    error: string | null;
+    attempts: number;
+    maxRetries: number;
+    retryBaseMs: number;
+    retryJitter: boolean;
+    nextRetryAt: Date | null;
+    concurrencyGroup: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    startedAt: Date | null;
+    completedAt: Date | null;
+}
+export interface JobOptions {
+    priority?: JobPriority;
+    maxRetries?: number;
+    retryBaseMs?: number;
+    retryJitter?: boolean;
+    concurrencyGroup?: string;
+}
+export type JobHandler = (job: Job) => Promise<unknown>;
+export interface ConcurrencyGroupConfig {
+    [group: string]: number;
+}
+export interface JobQueueConfig {
+    pollIntervalMs?: number;
+    workerPoolSize?: number;
+    concurrencyGroups?: ConcurrencyGroupConfig;
+}
+export interface StorageAdapter {
+    query<R = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<{
+        rows: R[];
+    }>;
+}
+export declare class JobQueue extends TypedEmitter {
+    private storage;
+    private config;
+    private workerRunning;
+    private shutdownRequested;
+    private activeJobs;
+    constructor(storage: StorageAdapter, config?: JobQueueConfig);
+    enqueue<T>(type: string, payload: T, opts?: JobOptions): Promise<string>;
+    claimNext(workerTypes?: string[]): Promise<Job | null>;
+    completeJob(jobId: string, result?: unknown): Promise<void>;
+    failJob(jobId: string, error: Error): Promise<void>;
+    cancelJob(jobId: string): Promise<void>;
+    getJob(jobId: string): Promise<Job>;
+    getJobsByStatus(status: JobStatus, type?: string): Promise<Job[]>;
+    startWorker(handlers: Record<string, JobHandler>): void;
+    stopWorker(): Promise<void>;
+    private processJob;
+}
+export declare const JOB_QUEUE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS jobs (\n  id TEXT PRIMARY KEY,\n  type TEXT NOT NULL,\n  status TEXT NOT NULL DEFAULT 'queued',\n  priority TEXT NOT NULL DEFAULT 'normal',\n  priority_num INTEGER NOT NULL DEFAULT 2,\n  payload JSONB NOT NULL DEFAULT '{}',\n  result JSONB,\n  error TEXT,\n  attempts INTEGER NOT NULL DEFAULT 0,\n  max_retries INTEGER NOT NULL DEFAULT 3,\n  retry_base_ms INTEGER NOT NULL DEFAULT 1000,\n  retry_jitter BOOLEAN NOT NULL DEFAULT true,\n  next_retry_at TIMESTAMPTZ,\n  concurrency_group TEXT,\n  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),\n  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),\n  started_at TIMESTAMPTZ,\n  completed_at TIMESTAMPTZ\n);\n\nCREATE INDEX IF NOT EXISTS idx_jobs_claim\n  ON jobs (priority_num, created_at)\n  WHERE status = 'queued';\nCREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status);\nCREATE INDEX IF NOT EXISTS idx_jobs_type ON jobs(type);\nCREATE INDEX IF NOT EXISTS idx_jobs_concurrency\n  ON jobs (concurrency_group)\n  WHERE status = 'running';\n";
+export {};

package/dist/jobs/index.d.ts

@@ -0,0 +1,12 @@
+export { JobQueue, type Job, type JobStatus, type JobPriority, type JobOptions, type JobQueueConfig } from "./queue.js";
+export { JobWorker, type JobHandler, type JobWorkerConfig } from "./worker.js";
+export { createWorkerPool } from "./worker-pool.js";
+export { createJobRouter } from "./router.js";
+export { LOCAL_JOB_TYPES } from "./types.js";
+export type { JobType } from "./types.js";
+export type { WorkerPool, WorkerPoolOptions } from "./worker-pool.js";
+export type { JobRouter, ToolRoute } from "./router.js";
+export { createJobQueue, createJobWorker, _resetIdCounter } from "./memory-queue.js";
+export type { MemoryJobWorker, MemoryWorkerOptions } from "./memory-queue.js";
+export { createPlannedTaskScheduler, _resetTaskIds } from "./planned-tasks.js";
+export type { PlannedStepStatus, PlannedTaskStatus, PlannedStep, PlannedTask, PlannedStepInput, CreatePlannedTaskInput, SchedulerJobQueue, SchedulerEventType, SchedulerEvent, SchedulerEventListener, PlannedTaskSchedulerConfig, PlannedTaskScheduler, } from "./planned-tasks.js";

package/dist/jobs/memory-queue.d.ts

@@ -0,0 +1,23 @@
+/**
+ * In-memory FIFO job queue — used by Mobile edition.
+ * For the production PostgreSQL-backed queue, use ./queue.ts.
+ */
+import type { JobQueue, JobQueueOptions, JobType, JobHandler } from "./types.js";
+export declare function createJobQueue(opts?: JobQueueOptions): JobQueue;
+/** Reset the auto-increment counter (for testing). */
+export declare function _resetIdCounter(): void;
+/**
+ * Simple single-threaded worker for in-memory queue.
+ */
+export interface MemoryJobWorker {
+    register(type: JobType, handler: JobHandler): void;
+    start(): void;
+    stop(): void;
+    readonly processed: number;
+    readonly isRunning: boolean;
+}
+export interface MemoryWorkerOptions {
+    pollInterval?: number;
+    name?: string;
+}
+export declare function createJobWorker(queue: JobQueue, opts?: MemoryWorkerOptions): MemoryJobWorker;

package/dist/jobs/planned-tasks.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Planned Tasks Scheduler — multi-step datetime queues with
+ * job queue integration.
+ *
+ * A PlannedTask is a named sequence of steps, each with a
+ * scheduled datetime. The scheduler manages progression by
+ * enqueuing the next step as an individual job when the
+ * previous one completes. Steps are fired via setTimeout
+ * at their scheduled time, then enqueued into the job queue
+ * for async processing by workers.
+ *
+ * Features:
+ *  - Multi-step tasks with per-step scheduling
+ *  - Steps enqueued as individual jobs in the job queue
+ *  - Automatic progression: next step enqueues when previous completes
+ *  - Manual step completion callback for worker integration
+ *  - Pause/resume support
+ *  - Cancellation
+ *  - Event system for observability
+ */
+export type PlannedStepStatus = "scheduled" | "waiting" | "enqueued" | "running" | "completed" | "failed" | "cancelled";
+export type PlannedTaskStatus = "pending" | "active" | "paused" | "completed" | "failed" | "cancelled";
+export interface PlannedStep {
+    /** Step index (0-based). */
+    index: number;
+    /** Human-readable label for this step. */
+    label: string;
+    /** When this step should fire. */
+    scheduledAt: Date;
+    /** Job type to enqueue. */
+    jobType: string;
+    /** Payload for the job. */
+    payload: Record<string, unknown>;
+    /** Current status. */
+    status: PlannedStepStatus;
+    /** Job ID once enqueued. */
+    jobId?: string;
+    /** Result from job completion. */
+    result?: unknown;
+    /** Error message if failed. */
+    error?: string;
+    /** When the step actually fired. */
+    firedAt?: Date;
+    /** When the step completed. */
+    completedAt?: Date;
+}
+export interface PlannedTask {
+    id: string;
+    /** Human-readable name. */
+    name: string;
+    /** Steps in execution order. */
+    steps: PlannedStep[];
+    /** Current overall status. */
+    status: PlannedTaskStatus;
+    /** Index of the current step (next to execute). */
+    currentStepIndex: number;
+    /** Chat/conversation to associate jobs with. */
+    chatId?: string;
+    /** Created timestamp. */
+    createdAt: Date;
+    /** When the task last changed state. */
+    updatedAt: Date;
+}
+export interface PlannedStepInput {
+    label: string;
+    scheduledAt: Date;
+    jobType: string;
+    payload?: Record<string, unknown>;
+}
+export interface CreatePlannedTaskInput {
+    name: string;
+    steps: PlannedStepInput[];
+    chatId?: string;
+}
+export interface SchedulerJobQueue {
+    enqueue(type: string, payload: unknown, chatId?: string): {
+        id: string;
+    };
+}
+export type SchedulerEventType = "task_created" | "task_started" | "task_completed" | "task_failed" | "task_cancelled" | "task_paused" | "task_resumed" | "step_scheduled" | "step_enqueued" | "step_completed" | "step_failed";
+export interface SchedulerEvent {
+    type: SchedulerEventType;
+    timestamp: Date;
+    taskId: string;
+    stepIndex?: number;
+    detail: string;
+}
+export type SchedulerEventListener = (event: SchedulerEvent) => void;
+export declare function _resetTaskIds(): void;
+export interface PlannedTaskSchedulerConfig {
+    /** Job queue to enqueue steps into. */
+    queue: SchedulerJobQueue;
+    /** Override Date.now() for testing. */
+    nowFn?: () => number;
+}
+export interface PlannedTaskScheduler {
+    /** Create and start a planned task. Returns the task. */
+    create(input: CreatePlannedTaskInput): PlannedTask;
+    /** Get a task by ID. */
+    get(taskId: string): PlannedTask | undefined;
+    /** List all tasks. */
+    list(): PlannedTask[];
+    /** List tasks by status. */
+    listByStatus(...statuses: PlannedTaskStatus[]): PlannedTask[];
+    /** Mark a step as completed (called by worker when job finishes).
+     *  Triggers the next step if available. */
+    completeStep(taskId: string, stepIndex: number, result?: unknown): boolean;
+    /** Mark a step as failed. */
+    failStep(taskId: string, stepIndex: number, error: string): boolean;
+    /** Pause a task (prevents next step from being scheduled). */
+    pause(taskId: string): boolean;
+    /** Resume a paused task (schedules the next pending step). */
+    resume(taskId: string): boolean;
+    /** Cancel a task and all remaining steps. */
+    cancel(taskId: string): boolean;
+    on(listener: SchedulerEventListener): void;
+    off(listener: SchedulerEventListener): void;
+    /** Clean up all timers. */
+    dispose(): void;
+}
+export declare function createPlannedTaskScheduler(config: PlannedTaskSchedulerConfig): PlannedTaskScheduler;

package/dist/jobs/queue.d.ts

@@ -0,0 +1,79 @@
+/**
+ * JobQueue — PostgreSQL-backed async job queue wrapping the jobs table.
+ *
+ * Methods: enqueue, claim (SELECT FOR UPDATE SKIP LOCKED), complete,
+ * fail, dead. Priority ordering. Concurrency groups.
+ */
+import type { StorageAdapter } from "../storage/interface.js";
+import type { AgentEvent } from "../events/types.js";
+export type JobStatus = "queued" | "running" | "completed" | "failed" | "dead";
+export type JobPriority = "critical" | "high" | "normal" | "low";
+export interface Job<T = unknown> {
+    id: string;
+    type: string;
+    status: JobStatus;
+    priority: JobPriority;
+    payload: T;
+    result: unknown | null;
+    error: string | null;
+    attempts: number;
+    maxRetries: number;
+    retryBaseMs: number;
+    retryJitter: boolean;
+    concurrencyGroup: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface JobOptions {
+    priority?: JobPriority;
+    maxRetries?: number;
+    retryBaseMs?: number;
+    retryJitter?: boolean;
+    concurrencyGroup?: string;
+}
+export interface ConcurrencyGroupConfig {
+    [group: string]: number;
+}
+export interface JobQueueConfig {
+    concurrencyGroups?: ConcurrencyGroupConfig;
+}
+export declare class JobQueue {
+    private storage;
+    private concurrency;
+    constructor(storage: StorageAdapter, config?: JobQueueConfig);
+    /**
+     * Enqueue a new job. Returns the job ID.
+     */
+    enqueue<T>(type: string, payload: T, opts?: JobOptions): Promise<string>;
+    /**
+     * Enqueue and yield a job:enqueued event.
+     */
+    enqueueWithEvents<T>(type: string, payload: T, opts?: JobOptions, sessionId?: string): AsyncGenerator<AgentEvent, string>;
+    /**
+     * Claim the next available job using SELECT FOR UPDATE SKIP LOCKED.
+     * Respects concurrency group limits.
+     */
+    claim(workerTypes?: string[]): Promise<Job | null>;
+    /**
+     * Mark a job as completed with an optional result.
+     */
+    complete(jobId: string, result?: unknown): Promise<void>;
+    /**
+     * Mark a job as failed. If retries remain, re-queues with backoff.
+     */
+    fail(jobId: string, error: string): Promise<{
+        dead: boolean;
+    }>;
+    /**
+     * Force a job to dead state (no more retries).
+     */
+    dead(jobId: string): Promise<void>;
+    /**
+     * Get a single job by ID.
+     */
+    getJob(jobId: string): Promise<Job | null>;
+    /**
+     * List jobs by status and optional type filter.
+     */
+    getJobsByStatus(status: JobStatus, type?: string): Promise<Job[]>;
+}

package/dist/jobs/router.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Job tool router — exposes the job queue as callable "tools"
+ * that the Telegram adapter (or any channel) can present to users.
+ *
+ * Provides a tool-like interface for:
+ *  - Submitting jobs
+ *  - Listing jobs
+ *  - Cancelling jobs
+ *  - Querying job status
+ */
+import type { JobQueue } from "./types.js";
+export interface ToolRoute {
+    name: string;
+    description: string;
+    handler: (args: Record<string, unknown>) => Promise<string>;
+}
+export interface JobRouter {
+    /** All registered tool routes. */
+    readonly routes: ReadonlyArray<ToolRoute>;
+    /** Get a route by name. */
+    get(name: string): ToolRoute | undefined;
+}
+export declare function createJobRouter(queue: JobQueue): JobRouter;

package/dist/jobs/synthesize-memories.d.ts

@@ -0,0 +1,26 @@
+import type { Job } from "../job-queue.js";
+import type { StorageAdapter } from "../storage/interface.js";
+import { type LLMSynthesizeFn } from "../memory/synthesis.js";
+export declare const SYNTHESIZE_JOB_TYPE = "memory.synthesize";
+export interface SynthesizeJobPayload {
+    userId: string;
+}
+export interface SynthesizeJobResult {
+    patternsExtracted: number;
+    diariesProcessed: number;
+}
+/**
+ * Create a job handler for memory synthesis.
+ *
+ * Usage with JobQueue:
+ * ```ts
+ * const handler = createSynthesizeHandler(storage, llmFn);
+ * queue.startWorker({ [SYNTHESIZE_JOB_TYPE]: handler });
+ * ```
+ */
+export declare function createSynthesizeHandler(storage: StorageAdapter, llmSynthesize: LLMSynthesizeFn): (job: Job) => Promise<SynthesizeJobResult>;
+/**
+ * Enqueue a memory synthesis job for a user.
+ * Typically called after task wrapup.
+ */
+export declare function enqueueSynthesisJob(enqueue: (type: string, payload: SynthesizeJobPayload) => Promise<string>, userId: string): Promise<string>;

package/dist/jobs/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Job queue type definitions.
+ */
+export type JobStatus = "pending" | "running" | "done" | "failed";
+export type JobType = "llm.complete" | "web.search" | "web.scrape" | "file.read" | "file.write" | "tool.execute" | "memory.search" | "browser.navigate" | "image.generate" | "audio.transcribe" | "notification.send";
+/** Subset of job types safe for mobile (no heavy network / browser). */
+export declare const LOCAL_JOB_TYPES: ReadonlySet<JobType>;
+export interface Job<T = unknown> {
+    id: string;
+    type: JobType;
+    payload: T;
+    status: JobStatus;
+    result?: unknown;
+    error?: string;
+    createdAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+    /** Which chat/conversation originated this job. */
+    chatId?: string;
+}
+export type JobHandler<T = unknown> = (payload: T) => Promise<unknown>;
+export interface JobQueueOptions {
+    /** Maximum number of queued jobs before rejecting. Default 1000. */
+    maxSize?: number;
+    /** Restrict to only these job types (mobile edition). */
+    allowedTypes?: ReadonlySet<JobType>;
+}
+export interface JobQueue {
+    /** Enqueue a new job.  Returns the job. */
+    enqueue<T>(type: JobType, payload: T, chatId?: string): Job<T>;
+    /** Take the next pending job (FIFO), or undefined if empty. */
+    dequeue(): Job | undefined;
+    /** Mark a job as running. */
+    markRunning(jobId: string): void;
+    /** Mark a job as completed with a result. */
+    markDone(jobId: string, result: unknown): void;
+    /** Mark a job as failed. */
+    markFailed(jobId: string, error: string): void;
+    /** Get a single job by ID. */
+    get(jobId: string): Job | undefined;
+    /** All jobs for a given chat. */
+    listByChatId(chatId: string): Job[];
+    /** All jobs matching a set of statuses. */
+    listByStatus(...statuses: JobStatus[]): Job[];
+    /** Current queue depth (pending jobs). */
+    readonly pendingCount: number;
+}

package/dist/jobs/worker-pool.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Worker pool — runs N workers against a shared job queue.
+ *
+ * Used by Pro and Voices editions (default 3 workers).
+ */
+import type { JobHandler, JobQueue, JobType } from "./types.js";
+export interface WorkerPoolOptions {
+    /** Number of concurrent workers. Default 3. */
+    size?: number;
+    /** Per-worker poll interval in ms. Default 250. */
+    pollInterval?: number;
+}
+export interface WorkerPool {
+    /** Register a handler on all workers. */
+    register(type: JobType, handler: JobHandler): void;
+    /** Start all workers. */
+    start(): void;
+    /** Stop all workers. */
+    stop(): void;
+    /** Total jobs processed across all workers. */
+    readonly totalProcessed: number;
+    readonly size: number;
+    readonly isRunning: boolean;
+}
+export declare function createWorkerPool(queue: JobQueue, opts?: WorkerPoolOptions): WorkerPool;

package/dist/jobs/worker.d.ts

@@ -0,0 +1,40 @@
+/**
+ * JobWorker — poll loop that claims jobs, executes handlers, and
+ * completes or fails them with retry and event emission.
+ *
+ * Features:
+ *   - Configurable poll interval (default 1s)
+ *   - Concurrency group enforcement (via JobQueue.claim)
+ *   - Retry with exponential backoff + jitter (via JobQueue.fail)
+ *   - Yields job lifecycle events (started, completed, failed, dead)
+ */
+import type { AgentEvent } from "../events/types.js";
+import { type Job, type JobQueue } from "./queue.js";
+export type JobHandler = (job: Job) => Promise<unknown>;
+export interface JobWorkerConfig {
+    /** Poll interval in milliseconds. Default 1000. */
+    pollIntervalMs?: number;
+    /** Max concurrent jobs to process. Default 3. */
+    concurrency?: number;
+    /** Worker name for logging. */
+    name?: string;
+}
+export declare class JobWorker {
+    private queue;
+    private handlers;
+    private config;
+    private running;
+    private shutdownRequested;
+    private activeJobs;
+    private events;
+    constructor(queue: JobQueue, config?: JobWorkerConfig);
+    /** Register a handler for a job type. */
+    register(type: string, handler: JobHandler): void;
+    /** Start the worker poll loop. Returns an async generator of lifecycle events. */
+    start(sessionId?: string): AsyncGenerator<AgentEvent, void>;
+    /** Stop the worker loop gracefully. */
+    stop(): void;
+    get isRunning(): boolean;
+    get activeCount(): number;
+    private processJob;
+}

package/dist/loop/autonomous-controller.d.ts

@@ -0,0 +1,91 @@
+import type { EventBus } from "../events/bus.js";
+export type LoopState = "idle" | "running" | "paused" | "circuit-open" | "complete" | "aborted";
+export type CircuitBreakerState = "closed" | "half-open" | "open";
+export interface LoopIteration {
+    index: number;
+    startedAt: Date;
+    completedAt?: Date;
+    exitSignalDetected: boolean;
+    completionIndicators: string[];
+    progressMade: boolean;
+    errorPatterns: string[];
+    outputHash?: string;
+}
+export interface AutonomousLoopConfig {
+    /** Max iterations before forced abort */
+    maxIterations: number;
+    /** Exit signal string to detect in agent output */
+    exitSignal: string;
+    /** Minimum completion indicators required to exit */
+    completionThreshold: number;
+    /** Iterations with no progress before half-open */
+    stagnationThreshold: number;
+    /** Iterations in half-open before circuit opens */
+    halfOpenLimit: number;
+    /** Cooldown ms before auto-retry after circuit open */
+    circuitCooldownMs: number;
+    /** Max API calls per hour (0 = unlimited) */
+    rateLimitPerHour: number;
+    /** Workspace root for .loop/ state files */
+    workspaceDir: string;
+    /** Callback to run one agent iteration */
+    runIteration: (context: IterationContext) => Promise<IterationResult>;
+    /** Optional event bus for lifecycle events */
+    eventBus?: EventBus;
+}
+export interface IterationContext {
+    index: number;
+    sessionId: string | null;
+    previousErrors: string[];
+    backpressurePrefix: string | null;
+}
+export interface IterationResult {
+    output: string;
+    sessionId: string;
+    filesChanged: string[];
+    newCommits: number;
+    testResultsChanged: boolean;
+    completionIndicators: string[];
+}
+export declare class AutonomousLoopController {
+    private config;
+    private state;
+    private circuitState;
+    private iterations;
+    private loopGuard;
+    private sessionId;
+    private noProgressCount;
+    private callTimestamps;
+    private backpressurePrefix;
+    constructor(config: AutonomousLoopConfig);
+    /** Run the autonomous loop to completion or abort. */
+    run(): Promise<AutonomousLoopResult>;
+    /** Inject backpressure failure context for next iteration. */
+    setBackpressure(prefix: string | null): void;
+    /** Signal progress from external sources (e.g. backpressure pass). */
+    signalProgress(): void;
+    /** Abort the loop. */
+    abort(): void;
+    /** Pause the loop (requires external resume). */
+    pause(): void;
+    /** Resume from pause or circuit-open. */
+    resume(sessionId?: string): void;
+    getState(): LoopState;
+    getCircuitState(): CircuitBreakerState;
+    getIterations(): readonly LoopIteration[];
+    private executeIteration;
+    /**
+     * Dual-condition exit: BOTH exit signal AND enough completion indicators.
+     */
+    private shouldExit;
+    private updateCircuitBreaker;
+    private enforceRateLimit;
+    private waitCooldown;
+    private lastErrors;
+    private emit;
+}
+export interface AutonomousLoopResult {
+    state: LoopState;
+    iterations: LoopIteration[];
+    totalIterations: number;
+}