export type OrgTaskStatus = 'pending' | 'ready' | 'running' | 'blocked' | 'done' | 'failed' | 'split' | 'merged' | 'cancelled';
export interface OrgTask {
    id: string;
    title: string;
    assignee: string;
    deps: string[];
    status: OrgTaskStatus;
    result?: string;
    createdAt: number;
    startedAt?: number;
    completedAt?: number;
    splitFrom?: string;
    mergedInto?: string;
    /** Set when status is 'blocked': the task can't proceed until this real-world
     *  time (e.g. waiting on a scheduled external process — a CI run, a soak
     *  test, a human-set deadline). Distinct from a dependency block (deps not
     *  yet done): this is an explicit "nothing to do until <time>" signal a role
     *  gives when genuinely no other task is dispatchable. The idle watchdog
     *  treats an active block the same as a pending decision gate — legitimate
     *  waiting, not silence to nudge about. */
    blockedUntil?: number;
    blockedReason?: string;
}
export interface SplitChild {
    title: string;
    assignee: string;
}
export declare class TaskDag {
    private tasks;
    private counter;
    add(title: string, assignee: string, deps?: string[]): OrgTask;
    complete(id: string, result?: string): OrgTask[];
    fail(id: string, reason?: string): void;
    markRunning(id: string): void;
    /** Mark a task as waiting on a real-world time, not on other tasks. Only
     *  valid from 'running' (a role already working it discovers it can't
     *  proceed further right now) — a 'ready'/'pending' task should just stay
     *  that way until its deps clear. */
    block(id: string, untilMs: number, reason?: string): OrgTask;
    /** Transition every task whose block has expired back to 'running', so its
     *  assignee gets nudged that it's time to resume. Called by the idle
     *  watchdog on every tick — cheap no-op when nothing has expired. */
    unblockExpired(now: number): OrgTask[];
    /** True if there is genuinely nothing else dispatchable right now — every
     *  non-terminal task is blocked on a real-world time still in the future.
     *  This is the watchdog's signal to skip nudging (same treatment as a
     *  pending gate). Scoped to the whole DAG rather than a single task on
     *  purpose: if ANY task is pending/ready/running, or blocked with a time
     *  that's already passed (should have auto-resumed), there is real
     *  outstanding work and nudging is still meaningful — a single long-lived
     *  block on one task (e.g. a feature deferred for weeks) must not silence
     *  the watchdog for the entire org while other roles sit genuinely idle. */
    hasActiveBlock(now: number): boolean;
    split(parentId: string, children: SplitChild[]): OrgTask[];
    merge(sourceId: string, targetId: string): OrgTask;
    cancel(id: string, reason?: string): OrgTask[];
    ready(): OrgTask[];
    get(id: string): OrgTask | undefined;
    all(): OrgTask[];
    toJSON(): OrgTask[];
    static fromJSON(data: OrgTask[]): TaskDag;
    private promoteReady;
    private hasCycle;
}
//# sourceMappingURL=task-dag.d.ts.map