import { type BackgroundTaskStatus } from "./background-command-store.js";
export type { BackgroundTaskRecord, BackgroundTaskStatus } from "./background-command-store.js";

export interface BackgroundCommandResult {
    taskId: string;
    exitCode: number | null;
    signal: string | null;
    timedOut: boolean;
    
    inactivityTimedOut?: boolean;
    
    outputFilePath: string;
    
    outputLineCount: number;
    
    outputSpilled: boolean;
    
    commandFilePath?: string;
    commandLineCount: number;
    timeoutMs: number;
    inactivityTimeoutMs: number;
    stdout: string;
    stderr: string;
    durationMs: number;
}

export interface AwaitBgCommandResult {
    taskId: string;
    
    status: BackgroundTaskStatus;
    exitCode: number | null;
    signal: string | null;
    timedOut: boolean;
    
    aborted: boolean;
    durationMs: number;
    
    outputFilePath?: string;
}

export interface StartCommandInput {
    commandText: string;
    agentId: string;
    workspaceRoot: string;
    cwd: string;
    
    description?: string;
    timeoutMs?: number;
    
    inactivityTimeoutMs?: number;
    onOutput?: (event: {
        stream: "stdout" | "stderr";
        text: string;
    }) => void;
    
    onCompleted?: (event: BackgroundCompletedEvent) => void;
}
export interface BackgroundCompletedEvent {
    taskId: string;
    agentId: string;
    status: BackgroundTaskStatus;
    exitCode: number | null;
    signal: string | null;
    commandPreview: string;
    outputLineCount: number;
    outputBytes: number;
    outputPath: string;
    finishedAt: number;
    killedReason?: string | null;
}
export interface TaskSummary {
    taskId: string;
    status: BackgroundTaskStatus;
    command: string;
    commandPreview: string;
    
    description?: string;
    cwd: string;
    startedAt: number;
    finishedAt: number | null;
    exitCode: number | null;
    signal: string | null;
    outputLineCount: number;
    outputBytes: number;
}

export interface TaskOutputSubscriber {
    
    onLine: (event: {
        stream: "stdout" | "stderr";
        text: string;
        seq: number;
    }) => void;
    
    onDone: (event: {
        status: BackgroundTaskStatus;
        exitCode: number | null;
        signal: string | null;
    }) => void;
}

export interface TaskOutputSnapshot {
    taskId: string;
    status: BackgroundTaskStatus;
    exitCode: number | null;
    signal: string | null;
    startedAt: number;
    finishedAt: number | null;
    command: string;
    
    lines: string[];
    
    nextSeq: number;
    
    totalLines: number;
    totalBytes: number;
    truncated: boolean;
}
export interface ReadOutputArgs {
    task_id: string;
    mode?: "lines" | "grep" | "tail";
    
    line_size?: number;
    
    start_line?: number;
    pattern?: string;
    context_before?: number;
    context_after?: number;
    include_metadata?: boolean;
}

export interface ReadOutputLine {
    line: number;
    text: string;
}
export interface ReadOutputResult {
    taskId: string;
    status: BackgroundTaskStatus;
    mode: string;
    lines: ReadOutputLine[];
    lineCount: number;
    metadata?: {
        
        totalLines: number;
        totalBytes: number;
        returnedBytes: number;
        
        truncated: boolean;
        
        outputTruncated: boolean;
        hasMore: boolean;
        
        nextStartLine: number | null;
        outputFile: string;
    };
}
export interface KillResult {
    taskId: string;
    status: BackgroundTaskStatus;
    signal?: string;
    exitCode?: number | null;
    error?: string;
    reason?: string;
}
export declare class BackgroundCommandManager {
    private tasksByAgent;
    private store;
    
    private globalCount;
    
    startCommand(input: StartCommandInput): {
        taskId: string;
        completion: Promise<BackgroundCommandResult>;
    };
    private spawnAndAttach;
    
    disableInactivityTimeout(agentId: string, taskId: string): boolean;
    
    markBackgrounded(agentId: string, taskId: string): Promise<boolean>;
    private onOutput;
    
    private scheduleInactivity;
    private appendToFile;
    private finalizeTask;
    
    private evictTask;
    listTasks(agentId: string, statusFilter?: string): TaskSummary[];
    private toSummary;
    
    getTaskOutputSnapshot(agentId: string, taskId: string, tailLines?: number): TaskOutputSnapshot | null;
    
    subscribeTaskOutput(agentId: string, taskId: string, subscriber: TaskOutputSubscriber): (() => void) | null;
    
    readOutput(agentId: string, args: ReadOutputArgs): Promise<ReadOutputResult>;
    
    private _emptyResult;
    
    private readFromFile;
    
    awaitCompletion(agentId: string, taskIds: string[], timeoutMs?: number): Promise<Array<AwaitBgCommandResult | null>>;
    private awaitOne;
    private taskToAwaitResult;
    
    interruptAwaits(agentId: string, taskIds: Iterable<string>): void;
    killTask(agentId: string, taskId: string): Promise<KillResult>;
    
    private killProcessGroup;
    
    disposeAgent(agentId: string): Promise<void>;
    
    disposeAll(): Promise<void>;
    
    reconcileDiskRunning(agentId: string): Promise<number>;
    
    listTasksWithReconcile(agentId: string, statusFilter?: string): Promise<TaskSummary[]>;
    
    reconcileAllAgents(): Promise<number>;
    
    reconcileOrphans(agentId: string): Promise<void>;
    
    readSessionState(agentId: string): Promise<import("./background-command-store.js").BackgroundSessionState | null>;
    
    markNotified(agentId: string, taskIds: string[]): Promise<void>;
    private getOrCreateBucket;
    private getTask;
    private generateTaskId;
    private persistTask;
    
    private persistTaskSafe;
}

export declare class BackgroundTaskError extends Error {
    readonly code: string;
    constructor(code: string, message: string);
}

export declare const backgroundCommandManager: BackgroundCommandManager;