import { type FleetConfig } from '../config.js';
import { type CoworkAdapter } from '../rooms-tasks/cowork-adapter.js';
import { provisionMembers } from '../rooms-tasks/provision.js';
import { moveTaskToList } from '../rooms-tasks/task-state.js';
import { type MemberOverrides } from '../rooms-tasks/member-overrides.js';
import { type TaskDeletionSettleResult } from '../rooms-tasks/deletion.js';
import type { RoomLaunchPolicy, RoomOrchestrationRecord, TaskListRecord, TaskOrigin, TaskOutcome, TaskRecord, TaskState, TemplateSnapshot } from '../rooms-tasks/types.js';
import type { TaskDeletionAcceptance } from '../rooms-tasks/task-state.js';
export type TaskRoomActor = {
    kind: 'local_control';
    surface: 'cli' | 'web';
} | {
    kind: 'authenticated_owner';
    surface: 'messenger';
    cid: string;
} | {
    kind: 'internal_worker';
    surface: 'cli';
};
export interface TaskSettlementPlan {
    task: TaskRecord;
    settlementRequired: boolean;
}
export type TaskProvisioningContinuationIssue = {
    code: 'waiting_cowork' | 'waiting_owner_authorization' | 'waiting_owner_invite' | 'owner_cid_mismatch' | 'waiting_seats' | 'provisioning_resumed';
} | {
    code: 'member_failed';
    stepIndex: number;
} | {
    code: 'resume_failed';
    error: string;
};
export interface TaskProvisioningContinuationResult {
    kind: 'provisioning_resumed' | 'provisioning_resume_failed' | 'provisioning_non_resumable' | 'no_op';
    task: TaskRecord;
    room: RoomOrchestrationRecord | undefined;
    issues: TaskProvisioningContinuationIssue[];
    reason?: 'missing_room' | 'missing_durable_template' | 'non_resumable_phase';
}
export interface TaskProvisioningOutcome {
    kind: 'ready' | 'in_progress' | 'failed';
    task: TaskRecord;
    room?: RoomOrchestrationRecord;
    launch: {
        template?: string;
        anonymous: boolean;
        owner_attached: boolean;
    };
    members: {
        expected: number;
        active: number;
        launched: number;
    };
    blocker?: string;
    next_action?: string;
}
/** Repairable terminal observation derived entirely from durable Task/Room state. */
export declare function recordTaskProvisioningOutcome(outcome: TaskProvisioningOutcome): void;
export declare class TaskRoomApplicationError extends Error {
    readonly code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'task_deleting' | 'room_not_found' | 'room_record_not_found';
    readonly fields: Readonly<Record<string, string>>;
    constructor(code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'task_deleting' | 'room_not_found' | 'room_record_not_found', message: string, fields?: Readonly<Record<string, string>>);
}
export interface CreateTaskRequest {
    actor: TaskRoomActor;
    title: string;
    brief?: string;
    briefFile?: string;
    template?: string;
    backlog?: boolean;
    noRoom?: boolean;
    idempotencyKey?: string;
    origin: TaskOrigin;
    list?: string;
    members?: MemberOverrides;
    anonymous?: boolean;
}
export interface CreateRoomRequest {
    actor: TaskRoomActor;
    name: string;
    template?: string;
    goal?: string;
    brief?: string;
    briefFile?: string;
    members?: MemberOverrides;
    anonymous?: boolean;
}
export declare function resolveRoomLaunchPolicy(template: TemplateSnapshot | undefined, override: boolean | undefined): RoomLaunchPolicy;
export interface TaskRoomServiceDeps {
    loadConfiguration?(path?: string): FleetConfig;
    cowork?(config: FleetConfig): CoworkAdapter;
    binPath?(): string;
    provisionMembers?: typeof provisionMembers;
    moveTaskToList?: typeof moveTaskToList;
    launchDeletionWorker?(taskId: string): Promise<void>;
    sleep?(ms: number): Promise<void>;
    now?(): number;
}
/** Exact extraction of the previously CLI-owned task create/start behavior. */
export declare class TaskRoomApplicationService {
    private readonly configurationPath?;
    private readonly deps;
    constructor(configurationPath?: string | undefined, deps?: TaskRoomServiceDeps);
    createTask(request: CreateTaskRequest): Promise<TaskRecord>;
    createRoom(request: CreateRoomRequest): Promise<RoomOrchestrationRecord>;
    startTask(input: {
        actor: TaskRoomActor;
        taskId: string;
        template?: string;
        members?: MemberOverrides;
        anonymous?: boolean;
    }): Promise<TaskRecord>;
    listTasks(filter?: {
        state?: TaskState | TaskState[];
        list?: string;
        includeDeleting?: boolean;
    }): TaskRecord[];
    listTaskLists(): TaskListRecord[];
    groupedTasks(filter?: {
        state?: TaskState | TaskState[];
        list?: string;
        includeDeleting?: boolean;
    }): Array<{
        list: TaskListRecord;
        tasks: TaskRecord[];
    }>;
    createTaskList(input: {
        actor: TaskRoomActor;
        name: string;
    }): Promise<TaskListRecord>;
    renameTaskList(input: {
        actor: TaskRoomActor;
        name: string;
        newName: string;
    }): Promise<TaskListRecord>;
    moveTask(input: {
        actor: TaskRoomActor;
        taskId: string;
        list: string;
    }): Promise<TaskRecord>;
    deleteTaskList(input: {
        actor: TaskRoomActor;
        name: string;
        destination?: string;
    }): Promise<{
        deleted: TaskListRecord;
        moved: number;
        destination?: TaskListRecord;
    }>;
    getTask(taskId: string): {
        task: TaskRecord;
        orchestration: RoomOrchestrationRecord | undefined;
    };
    taskProvisioningOutcome(taskId: string): TaskProvisioningOutcome;
    awaitTaskProvisioning(input: {
        actor: TaskRoomActor;
        taskId: string;
        waitMs?: number;
    }): Promise<TaskProvisioningOutcome>;
    blockTask(input: {
        actor: TaskRoomActor;
        taskId: string;
        reason: string;
    }): TaskRecord;
    unblockTask(input: {
        actor: TaskRoomActor;
        taskId: string;
    }): TaskRecord;
    reviewTask(input: {
        actor: TaskRoomActor;
        taskId: string;
    }): TaskRecord;
    private deletionActor;
    /** Accept a permanent deletion in any lifecycle state; audit at acceptance. */
    requestTaskDeletion(input: {
        actor: TaskRoomActor;
        taskId: string;
    }): Promise<TaskDeletionAcceptance>;
    /** Worker entry: converge an accepted deletion; Cowork is resolved lazily. */
    settleTaskDeletion(input: {
        actor: {
            kind: 'internal_worker';
            surface: 'cli';
        };
        taskId: string;
    }): Promise<TaskDeletionSettleResult>;
    /**
     * Launch the external deletion worker outside the caller's lifecycle and
     * wait boundedly for physical absence. Timeouts and launch failures report
     * a pending, recoverable state — never success. A concurrent worker that
     * already removed the record reads as settled.
     */
    launchTaskDeletionWorker(input: {
        taskId: string;
        waitMs?: number;
    }): Promise<{
        deleted: boolean;
        pending: boolean;
        error?: string;
    }>;
    recordDeletionError(input: {
        actor: TaskRoomActor;
        taskId: string;
        error: string;
        recoveryHint: string;
    }): Promise<TaskRecord>;
    completeTask(input: {
        actor: TaskRoomActor;
        taskId: string;
        outcome?: TaskOutcome;
    }): Promise<TaskSettlementPlan>;
    cancelTask(input: {
        actor: TaskRoomActor;
        taskId: string;
    }): Promise<TaskSettlementPlan>;
    settleTask(input: {
        actor: {
            kind: 'internal_worker';
            surface: 'cli';
        };
        taskId: string;
    }): Promise<TaskRecord>;
    recordSettlementError(input: {
        actor: TaskRoomActor;
        taskId: string;
        error: string;
        recoveryHint: string;
    }): Promise<TaskRecord>;
    continueTaskProvisioning(input: {
        actor: {
            kind: 'internal_worker';
            surface: 'cli';
        };
        taskId: string;
    }): Promise<TaskProvisioningContinuationResult>;
    private setOwnerRoomCommands;
    private reconcileProvisioningOwner;
    private acceptTerminal;
    listTemplates(): import("../rooms-tasks/types.js").TemplateDefinition[];
    getTemplate(name: string): {
        content_hash: string;
        name: string;
        version: number;
        description: string;
        sourceFile?: string;
        room?: import("../rooms-tasks/types.js").TemplateRoomConfig;
        contract?: string;
        members: import("../rooms-tasks/types.js").TemplateMemberSlot[];
    };
    validateTemplates(): {
        template: string;
        issues: string[];
    }[];
    listRooms(filter?: {
        state?: 'active' | 'provisioning';
    }): Promise<{
        orchestration: RoomOrchestrationRecord | null;
        room_id: string;
        identity_name: string;
        identity_cid: string;
        room_name: string;
        state: "provisioning" | "active" | "closing" | "closed";
        anonymous: boolean;
        seats: import("../rooms-tasks/cowork-adapter.js").CoworkSeatInfo[];
        goal?: string;
        briefing?: string;
        role_briefings: Record<string, import("../rooms-tasks/cowork-adapter.js").CoworkRoleBriefingInfo>;
    }[]>;
    getRoomDetail(id: string): Promise<{
        room: import("../rooms-tasks/cowork-adapter.js").CoworkRoomInfo;
        orchestration: RoomOrchestrationRecord | undefined;
    }>;
    getRoomMembers(id: string): Promise<{
        room: import("../rooms-tasks/cowork-adapter.js").CoworkRoomInfo;
        orchestration: RoomOrchestrationRecord | undefined;
        members: import("../rooms-tasks/cowork-adapter.js").CoworkSeatInfo[];
    }>;
    requestRoomDeletion(input: {
        actor: TaskRoomActor;
        roomId: string;
    }): Promise<{
        room: RoomOrchestrationRecord;
        settlementRequired: true;
    }>;
    settleRoomDeletion(input: {
        actor: {
            kind: 'internal_worker';
            surface: 'cli';
        };
        roomId: string;
    }): Promise<import("../rooms-tasks/close.js").ManagedRoomDeleteResult>;
    recordRoomSettlementError(input: {
        actor: TaskRoomActor;
        roomId: string;
        error: string;
        recoveryHint: string;
    }): Promise<RoomOrchestrationRecord>;
    finishTask(input: {
        actor: TaskRoomActor;
        taskId: string;
        outcome?: TaskOutcome;
    }): Promise<TaskSettlementPlan>;
    ensureTaskWork(input: {
        actor: TaskRoomActor;
        taskId: string;
        template?: string;
        members?: MemberOverrides;
        anonymous?: boolean;
    }): Promise<{
        task: TaskRecord;
        status: 'ready' | 'already_active' | 'in_progress';
    }>;
    private createTemplate;
    private existingTemplate;
    private provisionRoom;
}