import { type RoomCloseDeps } from './close.js';
import { type CoworkAdapter } from './cowork-adapter.js';
import { type TaskDeletionAcceptance } from './task-state.js';
import type { TaskDeletionActor, TaskRecord } from './types.js';
export { DELETION_MEMBER_ABSENT_VERIFIED } from './task-state.js';
type DeletionCowork = Pick<CoworkAdapter, 'closeRoom' | 'deleteRoom'>;
export interface TaskDeletionSettleDeps {
    roomClose?: RoomCloseDeps;
    /** Test seam for the temp-state existence proof. */
    hasTempState?(name: string): boolean;
    /** Test seam for the CID-wide daemon identity scan. */
    identityCidPresent?(cid: string): Promise<boolean>;
}
export interface TaskDeletionSettleResult {
    task_id: string;
    deleted: boolean;
    /** Lifecycle state observed before unlink, for completion audit. */
    previous_state?: TaskRecord['state'];
    /** Title observed before unlink, for completion audit. */
    title?: string;
}
/**
 * Accept a permanent task deletion under the common task-operation lock so it
 * serializes against terminal settlement, recovery, and the room-publication
 * window. Acceptance is durable before any side effect and never requires
 * Cowork availability; settlement runs separately and converges through
 * retries.
 */
export declare function acceptTaskDeletion(taskId: string, actor: TaskDeletionActor): Promise<TaskDeletionAcceptance>;
/** Persist a settlement failure under the same task-operation lock. */
export declare function recordTaskDeletionError(taskId: string, error: string, recoveryHint: string): Promise<TaskRecord>;
/**
 * Converge an accepted deletion to physical absence in two lock-ordered
 * stages. Cleanup stage (task-operation lock): per surviving room record,
 * register late seats → close saga (retires members) → durable evidence
 * checkpoint → tolerant remote delete → local record delete; then
 * cursor-based retirement for members with no room record and tolerant remote
 * close+delete of a recorded room whose local record is gone. Finalization
 * stage (launch-snapshot lock → task-operation lock, matching the global
 * provisioning order): re-verify quiescence, delete the owned launch snapshot
 * while excluding only this deleting task from the reference scan, and unlink
 * the task record LAST — every crash seam leaves the hidden intent
 * recoverable. Failures are recorded on the intent; the task stays hidden and
 * recoverable, never falsely settled.
 */
export declare function settleTaskDeletion(input: {
    taskId: string;
    /** Lazy: resolved only when room work exists, so no-room tasks settle without Cowork config. */
    cowork: () => DeletionCowork;
    deps?: TaskDeletionSettleDeps;
}): Promise<TaskDeletionSettleResult>;