@hypercarrier/pi-team-durable 0.0.0-stage → 0.1.0-rc.2

package/dist/authority/delivery.d.ts

@@ -0,0 +1,60 @@
+import type { AbortRun, InterruptTarget } from './interrupt.ts';
+import { type SubmissionId, type Tx } from '@earendil-works/pi-durable';
+import { type Obligation } from './state.ts';
+import { type Authority as State } from './store.ts';
+/** `kind` and `sender` name the delivery in its queue entry; inputs persisted before they existed lack them. */
+export interface DeliveryInput extends InterruptTarget {
+    interrupt?: true;
+    epoch: string;
+    content: string;
+    whenBusy: 'steer' | 'followUp';
+    kind?: Obligation['kind'];
+    sender?: string;
+}
+/**
+ * The structured data of a Team input's `team.notice` entry. A reader names the input from these fields, never from
+ * its text: `delivery` is the kind (`update` for a notifier page), `sender` the author, at most SENDER_LIMIT characters.
+ * `interrupt` marks an Alert sent to interrupt the recipient's run; the interruption outcome stays in the model-facing content.
+ * Entries written before `delivery` existed carry only `source` and `deliveryId` or `pageId`.
+ */
+export type TeamNoticeData = {
+    source: 'team';
+    epoch: string;
+    deliveryId?: string;
+    pageId?: string;
+    delivery?: Obligation['kind'] | 'update';
+    sender?: string;
+    interrupt?: true;
+};
+export declare const SENDER_LIMIT = 64;
+export declare function eligible(s: State, o: Obligation): Promise<boolean>;
+export declare function deliveryInput(s: State, o: Obligation): Promise<DeliveryInput>;
+/** The input a delivery submits. The request ID names the Obligation, so a retry reacquires the same admission. */
+export declare function deliveryDraft(input: DeliveryInput, interruption?: Obligation['interruption']): {
+    type: "input";
+    content: string;
+    whenBusy: "steer" | "followUp";
+    requestId: string;
+    entry: {
+        kind: string;
+        data: TeamNoticeData;
+    };
+};
+export declare const Deliver: import("@earendil-works/pi-durable").Task<DeliveryInput, {
+    phase: "interrupt";
+} | {
+    phase: "submit";
+} | {
+    phase: "settle";
+    submissionId: SubmissionId;
+}, null, object>;
+/** Keep the shared submit/settle mechanics; only the host-owned interruption needs a port. */
+export declare function createDeliver(abortRun: AbortRun): import("@earendil-works/pi-durable").Task<DeliveryInput, {
+    phase: "interrupt";
+} | {
+    phase: "submit";
+} | {
+    phase: "settle";
+    submissionId: SubmissionId;
+}, null, object>;
+export declare function scheduleDeliveries(tx: Tx, s: State, delivery: typeof Deliver): Promise<void>;

package/dist/authority/delivery.js

@@ -0,0 +1,158 @@
+import { withAbortSignal } from '@earendil-works/chord/context';
+import { defineTask } from '@earendil-works/pi-durable';
+import { plain, event } from "./state.js";
+import { openAuthority as open, flushAuthority, markScheduled, unscheduledObligations, taskRecord, alertRecord, obligation, setObligationState } from "./store.js";
+export const SENDER_LIMIT = 64;
+export async function eligible(s, o) {
+    const team = s.team.current;
+    if (!team || team.epoch !== o.epoch || team.lifecycle !== 'active' || team.shutdownPending || o.state !== 'pending')
+        return false;
+    if (o.recipient === 'team-lead')
+        return team.lead === o.conversationId;
+    const worker = Object.hasOwn(team.workers, o.recipient) ? team.workers[o.recipient] : undefined;
+    if (!worker || worker.state !== 'active' || worker.generation !== o.generation || worker.conversationId !== o.conversationId)
+        return false;
+    if (o.kind !== 'task')
+        return true;
+    if (!s.head.graph || s.head.epoch !== team.epoch)
+        return false;
+    const task = (await taskRecord(s, o.taskId))?.card;
+    return !!task && task.version === o.version && task.assignee === o.recipient && task.status === 'ready';
+}
+export async function deliveryInput(s, o) {
+    let payload;
+    if (o.kind === 'alert')
+        payload = { kind: 'alert', alert: plain(await alertRecord(s, o.alertId)) };
+    else if (o.kind === 'stop')
+        payload = { kind: 'task_changed', task_id: o.taskId, message: 'The previous Attempt was superseded or cancelled. Read current Task authority before continuing.' };
+    else {
+        payload = { kind: 'task', task: plain((await taskRecord(s, o.taskId))?.card) };
+    }
+    // An Alert names its author; durable-team sends Tasks and stops on the Team authority's behalf, as team-lead.
+    const sender = (o.kind === 'alert' ? (await alertRecord(s, o.alertId))?.from : 'team-lead')?.slice(0, SENDER_LIMIT);
+    return { key: o.key, epoch: o.epoch, conversationId: o.conversationId, ...(o.interrupt ? { interrupt: true, ...(o.interruptRun !== undefined ? { expectedRunTaskId: o.interruptRun } : {}) } : {}), content: JSON.stringify(payload), whenBusy: o.kind === 'task' ? 'followUp' : 'steer', kind: o.kind, ...(sender ? { sender } : {}) };
+}
+/** The input a delivery submits. The request ID names the Obligation, so a retry reacquires the same admission. */
+export function deliveryDraft(input, interruption) {
+    const data = { source: 'team', deliveryId: input.key, epoch: input.epoch, ...(input.kind ? { delivery: input.kind } : {}), ...(input.sender ? { sender: input.sender } : {}), ...(input.interrupt && input.kind === 'alert' ? { interrupt: true } : {}) };
+    const content = interruption ? JSON.stringify({ ...JSON.parse(input.content), interruption: { outcome: interruption, message: interruption === 'interrupted' ? 'The captured run was interrupted.' : interruption === 'ended' ? 'The captured run already ended or changed.' : 'Interruption was not proved; this Alert uses normal delivery.' } }) : input.content;
+    return { type: 'input', content, whenBusy: input.whenBusy, requestId: `ptb:${input.key}`, entry: { kind: 'team.notice', data } };
+}
+const draft = deliveryDraft;
+export const Deliver = defineTask({
+    name: 'ptb.deliver', version: 1, initial: input => ({ phase: input.interrupt ? 'interrupt' : 'submit' }),
+    phases: {
+        interrupt: async () => { throw new Error('The host must supply the run-only interrupt port'); },
+        submit: async (task, runtime, context) => {
+            let valid = false, interruption;
+            await runtime.commit(async (tx) => {
+                const s = await open(tx), o = await obligation(s, task.input.key);
+                valid = !!o && await eligible(s, o);
+                interruption = o?.interruption;
+                if (!valid) {
+                    if (o)
+                        await setObligationState(s, o, 'retired');
+                    flushAuthority(s);
+                    return { status: 'terminal', outcome: { status: 'completed', result: null } };
+                }
+                return undefined;
+            }, context);
+            if (!valid)
+                return;
+            const target = await runtime.conversation(task.input.conversationId, context);
+            if (!target)
+                throw new Error('PTB delivery recipient is missing');
+            const submission = await target.submit(draft(task.input, interruption), context);
+            await runtime.commit(async (tx) => {
+                const s = await open(tx), o = await obligation(s, task.input.key);
+                if (!o)
+                    throw new Error('PTB delivery obligation is missing');
+                o.submissionId = submission.id;
+                o.submittedAt ??= runtime.now();
+                return { status: 'running', checkpoint: { phase: 'settle', submissionId: submission.id } };
+            }, context);
+            // The settle phase rechecks revisions that raced with admission.
+        },
+        settle: async (task, runtime, context) => {
+            const target = await runtime.conversation(task.input.conversationId, context);
+            if (!target)
+                throw new Error('PTB admitted recipient is missing');
+            // Same request ID reacquires the durable admission after a process interruption.
+            let interruption;
+            await runtime.commit(async (tx) => { interruption = (await obligation(await open(tx), task.input.key))?.interruption; return undefined; }, context);
+            const submission = await target.submit(draft(task.input, interruption), context);
+            if (submission.id !== task.state.checkpoint.submissionId)
+                throw new Error('PTB admission identity changed');
+            let obsolete = false;
+            await runtime.commit(async (tx) => { const s = await open(tx), o = await obligation(s, task.input.key); obsolete = !o || !await eligible(s, o); return undefined; }, context);
+            if (obsolete)
+                await submission.abort(context);
+            const settled = await submission.wait(context);
+            await runtime.commit(async (tx) => {
+                const s = await open(tx), o = await obligation(s, task.input.key);
+                if (o) {
+                    o.settledAt = runtime.now();
+                    o.outcome = settled.status === 'done' ? 'answered' : `unanswered:${settled.reason}`;
+                    if (o.state === 'pending')
+                        await setObligationState(s, o, 'settled');
+                }
+                if (s.team.current?.epoch === task.input.epoch)
+                    await event(tx, s, 'authority', 'delivery_settled', { at: new Date(runtime.now()).toISOString() });
+                return { status: 'terminal', outcome: { status: 'completed', result: null } };
+            }, context);
+        },
+    },
+    abort: async (task, runtime, context) => {
+        await runtime.commit(async (tx) => { const s = await open(tx), o = await obligation(s, task.input.key); if (o) {
+            await setObligationState(s, o, 'retired');
+            o.outcome = 'stopped';
+        } flushAuthority(s); return { status: 'terminal', outcome: { status: 'aborted' } }; }, context);
+    },
+});
+/** Keep the shared submit/settle mechanics; only the host-owned interruption needs a port. */
+export function createDeliver(abortRun) {
+    return defineTask({ ...Deliver.definition, phases: {
+            ...Deliver.definition.phases,
+            submit: (task, runtime, context) => Deliver.definition.phases.submit(task, runtime, context),
+            interrupt: async (task, runtime, context) => {
+                const bound = withAbortSignal(runtime.signal, context);
+                let outcome;
+                try {
+                    outcome = await abortRun(runtime, task.input, bound);
+                }
+                catch (error) {
+                    if (runtime.signal.aborted)
+                        throw error;
+                    runtime.report(error);
+                    outcome = 'failed';
+                }
+                await runtime.commit(async (tx) => {
+                    const s = await open(tx), o = await obligation(s, task.input.key);
+                    if (!o || !await eligible(s, o) || outcome === 'retired') {
+                        if (o)
+                            await setObligationState(s, o, 'retired');
+                        flushAuthority(s);
+                        return { status: 'terminal', outcome: { status: 'completed', result: null } };
+                    }
+                    o.interruption = outcome;
+                    return { status: 'running', checkpoint: { phase: 'submit' } };
+                }, bound);
+            },
+        } });
+}
+export async function scheduleDeliveries(tx, s, delivery) {
+    const team = s.team.current;
+    if (!team || team.lifecycle !== 'active')
+        return;
+    for (const o of await unscheduledObligations(s)) {
+        const key = o.key;
+        if (o.deliveryTaskId) {
+            await markScheduled(s, key);
+            continue;
+        }
+        if (!await eligible(s, o))
+            continue;
+        o.deliveryTaskId = await tx.createTask(delivery, await deliveryInput(s, o), { conversationId: team.lead, ownership: { kind: 'conversation' }, background: true, abandonOnRestart: false });
+        await markScheduled(s, key);
+    }
+}

package/dist/authority/graph-card.d.ts

@@ -0,0 +1,4 @@
+import type { GraphTaskReadState } from "./graph-control.ts";
+import type { GraphTaskCard } from "./card-types.ts";
+/** Project controller state into the public Task card. */
+export declare function projectGraphTaskCards(controller: GraphTaskReadState): GraphTaskCard[];

package/dist/authority/graph-card.js

@@ -0,0 +1,39 @@
+/** Project controller state into the public Task card. */
+export function projectGraphTaskCards(controller) {
+    const attempts = controller.readAttempts();
+    return controller.readTasks().map(task => {
+        const currentAttempt = attempts.find(attempt => attempt.taskId === task.id && attempt.current);
+        const prerequisiteIds = task.state.kind === "dependency_waiting"
+            ? task.state.prerequisiteTaskIds
+            : task.state.kind === "goal_failed" && "prerequisiteTaskIds" in task.state ? task.state.prerequisiteTaskIds : [];
+        const terminal = ["goal_achieved", "goal_failed", "cancelled"].includes(task.state.kind);
+        const state = task.state.kind === "dependency_waiting"
+            ? { kind: "dependency_waiting", prerequisite_task_ids: [...task.state.prerequisiteTaskIds] }
+            : task.state.kind === "in_progress" ? { kind: "in_progress", attempt_id: task.state.attemptId }
+                : task.state.kind === "blocked" ? { kind: "blocked", attempt_id: task.state.attemptId, evidence: task.state.evidence }
+                    : task.state.kind === "goal_achieved" ? { kind: "goal_achieved", attempt_id: task.state.attemptId }
+                        : task.state.kind === "goal_failed" && task.state.reason === "criterion_failed"
+                            ? { kind: "goal_failed", reason: "criterion_failed", attempt_id: task.state.attemptId }
+                            : task.state.kind === "goal_failed" && task.state.reason === "failure_edge_exhausted"
+                                ? { kind: "goal_failed", reason: "failure_edge_exhausted", attempt_id: task.state.attemptId,
+                                    target_task_id: task.state.targetTaskId, traversals: task.state.traversals, exhaustion_reason: task.state.exhaustionReason }
+                                : task.state.kind === "goal_failed"
+                                    ? { kind: "goal_failed", reason: task.state.reason, prerequisite_task_ids: [...task.state.prerequisiteTaskIds] }
+                                    : task.state.kind === "cancelled" ? { kind: "cancelled", reason: task.state.reason }
+                                        : { kind: "ready" };
+        return {
+            id: task.id, title: task.title, goal: task.goal, assignee: task.assignee, needs: [...task.needs],
+            ...(task.onGoalFailed ? { on_goal_failed: { target: task.onGoalFailed.target, max_traversals: task.onGoalFailed.maxTraversals } } : {}),
+            status: task.state.kind, state, current_context: task.currentContext, version: task.version,
+            ...(task.activationKey ? { activation_key: task.activationKey } : {}),
+            ...(task.acceptedAttemptId ? { accepted_attempt_id: task.acceptedAttemptId } : {}),
+            ...(currentAttempt ? { current_attempt: { id: currentAttempt.id, ordinal: currentAttempt.ordinal, input_attempt_ids: { ...currentAttempt.inputAttemptIds } } } : {}),
+            attempts_started: task.attemptsStarted,
+            relations: task.needs.map(target_task_id => ({ relation: "blocked_by", target_task_id })),
+            dependency_state: terminal || task.state.kind === "blocked"
+                ? { kind: "terminal", active_blocker_ids: prerequisiteIds }
+                : prerequisiteIds.length ? { kind: "waiting", active_blocker_ids: prerequisiteIds }
+                    : { kind: "ready", active_blocker_ids: [] },
+        };
+    });
+}

package/dist/authority/graph-control.d.ts

@@ -0,0 +1,299 @@
+import { type TaskVersionRef } from "./task-version-ref.ts";
+/**
+ * Executable first contract for graph-native Task control.
+ *
+ * The upstream transition design lives in Pi Team Bright's
+ * docs/projects/dag-native/graph-control-transition-spec.json.
+ * This module has no Beads, Pi, delivery, or presentation dependency.
+ */
+export declare const GRAPH_CONTROL_MAX_FAILURE_TRAVERSALS = 8;
+export declare const GRAPH_CONTROL_TASK_STATES: readonly ["dependency_waiting", "ready", "in_progress", "blocked", "goal_failed", "goal_achieved", "cancelled"];
+export type GraphVersionRef = `g_${string}`;
+export type GraphTaskOutcome = "goal_achieved" | "goal_failed";
+export type GraphTaskTransition = "claim" | "block" | "resume" | "goal_achieved" | "goal_failed" | "cancel";
+export interface GraphFailureEdge {
+    target: string;
+    maxTraversals: number;
+}
+export interface GraphTaskDefinitionInput {
+    key: string;
+    title: string;
+    goal: string;
+    assignee: string;
+    needs?: string[];
+    onGoalFailed?: GraphFailureEdge;
+}
+export interface GraphApplyInput {
+    operationId: string;
+    expectedGraphVersion?: GraphVersionRef;
+    tasks: GraphTaskDefinitionInput[];
+}
+export interface GraphTaskTransitionInput {
+    taskId: string;
+    operationId: string;
+    expectedVersion: TaskVersionRef;
+    transition?: GraphTaskTransition;
+    worker?: string;
+    currentContext?: string;
+    evidence?: string;
+}
+export type GraphGoalFailure = {
+    reason: "criterion_failed";
+    attemptId: string;
+} | {
+    reason: "failure_edge_exhausted";
+    attemptId: string;
+    targetTaskId: string;
+    traversals: number;
+    exhaustionReason: "limit_reached" | "target_cancelled";
+} | {
+    reason: "dependency_failed";
+    prerequisiteTaskIds: string[];
+} | {
+    reason: "dependency_cancelled";
+    prerequisiteTaskIds: string[];
+};
+export type GraphTaskState = {
+    kind: "dependency_waiting";
+    prerequisiteTaskIds: string[];
+} | {
+    kind: "ready";
+} | {
+    kind: "in_progress";
+    attemptId: string;
+} | {
+    kind: "blocked";
+    attemptId: string;
+    evidence: string;
+} | ({
+    kind: "goal_failed";
+} & GraphGoalFailure) | {
+    kind: "goal_achieved";
+    attemptId: string;
+} | {
+    kind: "cancelled";
+    reason: string;
+};
+export interface GraphTaskView {
+    id: string;
+    title: string;
+    goal: string;
+    assignee: string;
+    needs: string[];
+    onGoalFailed?: GraphFailureEdge;
+    state: GraphTaskState;
+    currentContext: string;
+    version: TaskVersionRef;
+    activationKey?: string;
+    acceptedAttemptId?: string;
+    attemptsStarted: number;
+}
+export interface GraphAttemptView {
+    id: string;
+    taskId: string;
+    ordinal: number;
+    graphVersion: GraphVersionRef;
+    taskLineage: string;
+    activationKey: string;
+    inputAttemptIds: Record<string, string>;
+    assignee: string;
+    state: "in_progress" | "blocked" | "completed" | "superseded" | "cancelled";
+    current: boolean;
+    outcome?: GraphTaskOutcome;
+    evidence?: string;
+}
+interface StoredTaskDefinition extends Omit<GraphTaskDefinitionInput, "needs" | "onGoalFailed"> {
+    needs: string[];
+    onGoalFailed?: GraphFailureEdge;
+    lineage: string;
+}
+export interface GraphRevision {
+    sequence: number;
+    version: GraphVersionRef;
+    tasks: StoredTaskDefinition[];
+    recorded_at?: string;
+}
+interface RecordedEvent {
+    recorded_at?: string;
+}
+interface AttemptStartedEvent extends RecordedEvent {
+    kind: "attempt_started";
+    sequence: number;
+    operationId: string;
+    attemptId: string;
+    taskId: string;
+    ordinal: number;
+    graphVersion: GraphVersionRef;
+    taskLineage: string;
+    activationKey: string;
+    inputAttemptIds: Record<string, string>;
+    assignee: string;
+}
+interface AttemptBlockedEvent extends RecordedEvent {
+    kind: "attempt_blocked";
+    sequence: number;
+    operationId: string;
+    attemptId: string;
+    evidence: string;
+}
+interface AttemptResumedEvent extends RecordedEvent {
+    kind: "attempt_resumed";
+    sequence: number;
+    operationId: string;
+    attemptId: string;
+}
+interface AttemptCompletedEvent extends RecordedEvent {
+    kind: "attempt_completed";
+    sequence: number;
+    operationId: string;
+    attemptId: string;
+    outcome: GraphTaskOutcome;
+    evidence: string;
+}
+interface AttemptSupersededEvent extends RecordedEvent {
+    kind: "attempt_superseded";
+    sequence: number;
+    operationId: string;
+    attemptId: string;
+    reason: "graph_revised" | "repair_requested" | "dependency_cancelled";
+}
+interface TaskCancelledEvent extends RecordedEvent {
+    kind: "task_cancelled";
+    sequence: number;
+    operationId: string;
+    taskId: string;
+    taskLineage: string;
+    attemptId?: string;
+    reason: string;
+}
+interface TaskContextUpdatedEvent extends RecordedEvent {
+    kind: "task_context_updated";
+    sequence: number;
+    operationId: string;
+    taskId: string;
+    taskLineage: string;
+    currentContext: string;
+}
+interface FailureEdgeTraversedEvent extends RecordedEvent {
+    kind: "failure_edge_traversed";
+    sequence: number;
+    operationId: string;
+    sourceTaskId: string;
+    sourceTaskLineage: string;
+    sourceAttemptId: string;
+    targetTaskId: string;
+    targetTaskLineage: string;
+    traversal: number;
+}
+interface FailureEdgeExhaustedEvent extends RecordedEvent {
+    kind: "failure_edge_exhausted";
+    sequence: number;
+    operationId: string;
+    sourceTaskId: string;
+    sourceTaskLineage: string;
+    sourceAttemptId: string;
+    targetTaskId: string;
+    traversals: number;
+    reason: "limit_reached" | "target_cancelled";
+}
+export type GraphControlEvent = AttemptStartedEvent | AttemptBlockedEvent | AttemptResumedEvent | AttemptCompletedEvent | AttemptSupersededEvent | TaskCancelledEvent | TaskContextUpdatedEvent | FailureEdgeTraversedEvent | FailureEdgeExhaustedEvent;
+export interface GraphApplyResult {
+    kind: "graph_applied";
+    operationId: string;
+    graphVersion: GraphVersionRef;
+    tasks: GraphTaskView[];
+    readyTaskIds: string[];
+}
+export interface GraphTransitionResult {
+    kind: "task_transitioned";
+    operationId: string;
+    transition: GraphTaskTransition | "context_updated";
+    task: GraphTaskView;
+    readyTaskIds: string[];
+    failureTraversal?: {
+        sourceTaskId: string;
+        targetTaskId: string;
+        traversal: number;
+    };
+}
+export type GraphControlResult = GraphApplyResult | GraphTransitionResult;
+export type GraphControlReceipt = GraphControlResult & {
+    replayed: boolean;
+};
+export interface StoredReceipt {
+    operationId: string;
+    fingerprint: string;
+    result: GraphControlResult;
+}
+export interface GraphControlSnapshot {
+    schema: "pi-team-bright-graph-control/1";
+    graphRevisions: GraphRevision[];
+    events: GraphControlEvent[];
+    receipts: StoredReceipt[];
+}
+export type GraphControlRefusalCode = "invalid_graph" | "graph_version_conflict" | "task_not_found" | "task_version_conflict" | "operation_conflict" | "invalid_transition" | "worker_mismatch" | "worker_occupied" | "evidence_required";
+export declare class GraphControlRefusal extends Error {
+    readonly code: GraphControlRefusalCode;
+    constructor(code: GraphControlRefusalCode, message: string);
+}
+/**
+ * Small event-backed reference authority for deterministic Task graph control.
+ * External work is a transition command; all graph movement runs synchronously
+ * before that command returns.
+ */
+export declare class GraphTaskController {
+    private readonly graphRevisions;
+    private readonly events;
+    private readonly receipts;
+    private commandRecordedAt?;
+    private derivedCache?;
+    private readonly clock;
+    constructor(snapshot?: GraphControlSnapshot, clock?: () => Date);
+    static recover(snapshot: GraphControlSnapshot, clock?: () => Date): GraphTaskController;
+    snapshot(): GraphControlSnapshot;
+    currentGraphVersion(): GraphVersionRef | undefined;
+    hasOperationReceipt(operationId: string): boolean;
+    applyGraph(input: GraphApplyInput): GraphApplyResult & {
+        replayed: boolean;
+    };
+    transition(input: GraphTaskTransitionInput): GraphTransitionResult & {
+        replayed: boolean;
+    };
+    readTask(taskId: string): GraphTaskView;
+    readTasks(): GraphTaskView[];
+    readAttempts(taskId?: string): GraphAttemptView[];
+    selectReadyFrontier(): GraphTaskView[];
+    trace(): {
+        graphRevisions: GraphRevision[];
+        tasks: GraphTaskView[];
+        attempts: GraphAttemptView[];
+        events: GraphControlEvent[];
+    };
+    private claim;
+    private block;
+    private resume;
+    private complete;
+    private cancel;
+    private assertWorker;
+    private invalid;
+    private command;
+    private append;
+    private nextSequence;
+    private currentRevision;
+    private definition;
+    private attemptFolds;
+    private derivedGraph;
+    private derive;
+    private toView;
+}
+export type GraphTaskReadState = Pick<GraphTaskController, "readTasks" | "readAttempts" | "selectReadyFrontier">;
+/** Read-only recovery owns revision reuse. Commit recovery always validates fully.
+ * Retain fingerprints only; changed prefixes and failures require full validation.
+ */
+export declare class GraphObservationRecovery {
+    private accepted?;
+    recover(snapshot: GraphControlSnapshot): GraphTaskReadState;
+    private revisionFingerprint;
+    private validateRevision;
+}
+export {};