import { WorkspaceRepository, CommandStatus, JobStatus, TokenUsageInsert } from "@mcoda/db";
export type JobState = JobStatus;
export type CommandRunStatus = CommandStatus;
export interface CommandRunRecord {
    id: string;
    commandName: string;
    workspaceId: string;
    projectKey?: string;
    jobId?: string;
    agentId?: string;
    taskIds?: string[];
    gitBranch?: string;
    gitBaseBranch?: string;
    startedAt: string;
    completedAt?: string;
    status: CommandRunStatus;
    errorSummary?: string;
    durationSeconds?: number;
    spProcessed?: number | null;
}
export interface JobRecord {
    id: string;
    type: string;
    state: JobState;
    jobState?: JobState;
    jobStateDetail?: string;
    commandRunId?: string;
    commandName?: string;
    workspaceId: string;
    projectKey?: string;
    payload?: Record<string, unknown>;
    agentId?: string;
    agentIds?: string[];
    totalItems?: number;
    processedItems?: number;
    totalUnits?: number;
    completedUnits?: number;
    lastCheckpoint?: string;
    createdAt: string;
    updatedAt: string;
    completedAt?: string;
    errorSummary?: string;
    durationSeconds?: number;
}
export interface TokenUsageRecord extends TokenUsageInsert {
    commandName?: string;
    action?: string;
    invocationKind?: string;
    provider?: string;
    currency?: string;
    promptTokens?: number;
    completionTokens?: number;
    tokensCached?: number;
    tokensCacheRead?: number;
    tokensCacheWrite?: number;
    costUsd?: number;
    durationMs?: number;
    startedAt?: string;
    finishedAt?: string;
    metadata?: Record<string, unknown>;
}
export interface JobCheckpoint {
    stage: string;
    timestamp: string;
    details?: Record<string, unknown>;
}
export interface JobIterationProgress {
    current: number;
    max: number;
    phase?: string;
}
export interface JobProgressUpdate {
    stage: string;
    message: string;
    iteration?: JobIterationProgress;
    details?: Record<string, unknown>;
    totalItems?: number;
    processedItems?: number;
    payload?: Record<string, unknown>;
    heartbeat?: boolean;
}
export interface JobLogRow {
    timestamp: string;
    sequence?: number | null;
    level?: string | null;
    source?: string | null;
    message?: string | null;
    taskId?: string | null;
    taskKey?: string | null;
    phase?: string | null;
    details?: Record<string, unknown> | null;
}
export interface TaskRunSnapshotRow {
    taskId?: string | null;
    taskKey?: string | null;
    status?: string | null;
    startedAt?: string | null;
    finishedAt?: string | null;
    command?: string | null;
}
type JobServiceWorkspace = string | {
    workspaceRoot: string;
    workspaceId?: string;
    mcodaDir?: string;
};
export declare class JobService {
    private workspaceRepo?;
    private static activeJobs;
    private static signalHandlersRegistered;
    private static handlingSignal;
    private checkpointCounters;
    private workspaceRepoInit;
    private telemetryConfig?;
    private telemetryWarningShown;
    private telemetryRemoteWarningShown;
    private perRunTelemetryDisabled;
    private envTelemetryDisabled;
    private requireRepo;
    private workspaceRoot;
    private workspaceId;
    private mcodaDirOverride?;
    private static ensureSignalHandlers;
    private static registerActiveJob;
    private static unregisterActiveJob;
    static cancelActiveJobs(signal: NodeJS.Signals): Promise<void>;
    private static handleProcessSignal;
    constructor(workspace: JobServiceWorkspace, workspaceRepo?: WorkspaceRepository | undefined, options?: {
        noTelemetry?: boolean;
        requireRepo?: boolean;
    });
    private get mcodaDir();
    private get commandRunsPath();
    private get jobsStorePath();
    private get tokenUsagePath();
    private jobDir;
    private manifestPath;
    private checkpointDir;
    private logsDir;
    private ensureMcoda;
    private cancelJobOnSignal;
    private cancelRunningTaskRuns;
    private readJsonArray;
    private writeJsonArray;
    private appendJsonArray;
    listJobs(): Promise<JobRecord[]>;
    getJob(jobId: string): Promise<JobRecord | undefined>;
    readManifest(jobId: string): Promise<Record<string, unknown> | undefined>;
    readCheckpoints(jobId: string): Promise<JobCheckpoint[]>;
    readLog(jobId: string): Promise<string>;
    listJobLogs(jobId: string, options?: {
        since?: string;
        after?: {
            timestamp: string;
            sequence?: number | null;
        };
    }): Promise<JobLogRow[]>;
    summarizeTaskRuns(jobId: string): Promise<TaskRunSnapshotRow[]>;
    startCommandRun(commandName: string, projectKey?: string, options?: {
        gitBranch?: string;
        gitBaseBranch?: string;
        taskIds?: string[];
        jobId?: string;
        agentId?: string;
    }): Promise<CommandRunRecord>;
    finishCommandRun(runId: string, status: CommandRunStatus, errorSummary?: string, spProcessed?: number): Promise<void>;
    startJob(type: string, commandRunId?: string, projectKey?: string, options?: {
        payload?: Record<string, unknown>;
        commandName?: string;
        totalItems?: number;
        processedItems?: number;
        agentId?: string;
        agentIds?: string[];
    }): Promise<JobRecord>;
    private attachCommandRunToJob;
    updateJobStatus(jobId: string, state: JobState, metadata?: {
        payload?: Record<string, unknown>;
        totalItems?: number;
        processedItems?: number;
        totalUnits?: number;
        completedUnits?: number;
        lastCheckpoint?: string;
        errorSummary?: string;
        [key: string]: unknown;
    }): Promise<void>;
    private computeElapsed;
    recordJobProgress(jobId: string, input: JobProgressUpdate): Promise<void>;
    recordIterationProgress(jobId: string, input: {
        current: number;
        max: number;
        phase: string;
        details?: Record<string, unknown>;
    }): Promise<void>;
    writeCheckpoint(jobId: string, checkpoint: JobCheckpoint): Promise<void>;
    appendLog(jobId: string, content: string): Promise<void>;
    private readTelemetryConfig;
    private shouldRecordTokenUsage;
    recordTokenUsage(entry: TokenUsageRecord): Promise<void>;
    writeManifest(job: JobRecord, extras?: Record<string, unknown>): Promise<void>;
    close(): Promise<void>;
}
export {};
//# sourceMappingURL=JobService.d.ts.map