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

package/README.md

@@ -19,10 +19,14 @@ notices.
   Later versions publish from CI with npm provenance.
 - **Protocol value.** The persisted notice value `sender: 'durable-team'` is a
   protocol value from the package's former name. It stays unchanged.
-- **Tests here.** CI runs the unit suites.
+- **Tests here.** CI runs the unit suites and a 100-seed differential oracle run.
+  Run 500 or more seeds by hand before a release.
   The SIGKILL crash suite and `bench/e2e.ts` stay in HyperCarrier (private).
-- **Store format.** This version stores version-1 documents. The next version
-  migrates them to version 2, and a downgrade cannot read a migrated store.
+- **Before deploy.** The first open migrates the store to the indexed format. The
+  migration is one-way: rollback means restoring a backup. Back up the store, and
+  stop every older node process first. 0.1.0-rc.1 stores version-1 documents.
+  This version migrates them to version 2, and a downgrade cannot read a migrated
+  store.
 
 Known issues:
 
@@ -44,14 +48,26 @@ npm install @hypercarrier/pi-team-durable@next
 The package ships compiled JavaScript and type declarations under `dist`.
 Node 22.19 or newer. Install the three pinned peers beside it.
 
+`./testing` exports named internals for a host's own tests. It is unstable test support:
+its names can change in any release. Production code imports `./authority` only.
+
 ## API
 
 `./authority` exports the runtime factory, authority documents, observation
 observer, and structural stop ports. A host adapter registers this runtime.
 
-- `ptb.team`, `ptb.graph`, `ptb.journal`, `ptb.outbox`, and `ptb.receipts` store
-  authority, graph history, recent events, delivery obligations, and replay results.
-  Each accepted command and its mechanics commit together.
+- `ptb.team` owns membership and lifecycle. `ptb.head` holds current graph
+  coordinates, readiness, occupancy, attention, and bounded recent references.
+  Task family members hold current facts, retained Attempts, cards, and operator
+  projections. Immutable graph indexes hold topology. Worker indexes hold
+  nonterminal Task IDs. Each changed document is stored as a base.
+- A controller-only conversation holds graph revision diffs and controller
+  events. Commands restore the incremental engine from current Task records.
+  They commit changed facts, indexes, receipts, obligations, and history together.
+- Operation receipts retain exact result strings per epoch. Native tool-call
+  receipts use task scope and retire with the tool. Direct callers use permanent
+  family members. Obligations retain their identity after settlement; bounded
+  hash partitions index pending and unscheduled keys.
 - Nine lead tools and three Worker tools use the rc.7 contract. Exact conversation
   and generation bindings guard authority. A fork does not acquire an existing
   Team's lead authority.
@@ -75,9 +91,51 @@ observer, and structural stop ports. A host adapter registers this runtime.
   The final request hook records exact page visibility. A later observer requires
   a matching persisted native assistant entry and successful input settlement
   before it advances the cursor. Compaction and failed runs release unseen pages.
-- The journal keeps 100 recent events in its document and immutable `ptb.event`
-  entries in native storage. This bound does not cover graph history, receipts,
-  outbox, observation proofs, or storage history.
+- The head keeps references to 100 recent journal events. Their immutable
+  `ptb.event` entries stay in the lead conversation, so sync page boundaries stay
+  unchanged.
+- Observation indexes, page metadata, immutable page bodies, and open proofs
+  use separate base-checkpointed documents. Requests check active pages from
+  the newest message backward. They do not hash transcript history.
+- The observer retires a proof after its run settles and it processes the
+  evidence. It retires a page body only when the page is acknowledged or
+  replaced and the contiguous cursor covers it. Unsettled proofs and notifier
+  submit/settle checkpoints keep referenced bodies. Unknown notifier ownership
+  keeps the body. Page metadata and the exact replay receipts remain.
+- `observations(tx)` and `observationStats(tx)` are diagnostic readers. The
+  latter reports current-record counts and UTF-8 JSON bytes. Production hooks
+  and the observer read current indexes.
+- `/ptb` reads one acknowledged scan anchor for the current epoch. This anchor
+  differs from the runtime reservation anchor in `scanByEpoch`. Cursor advance
+  folds eligible waiting-page anchors before removing their waiting entries.
+  Body retirement retains the anchor; epoch change removes it.
+- `readTeamPanel` reads current Task projections and recent records.
+  `readTeamSummary` reads head indexes. `state.open()` is a full-history diagnostic
+  adapter; runtime paths do not use it.
+
+The first authority open migrates rc.7 documents in one transaction. It checks
+current facts against the reference controller and writes the new records and
+log. The same transaction raises all six shared PTB document kinds to version 2:
+`ptb.team`, `ptb.graph`, `ptb.journal`, `ptb.outbox`, `ptb.receipts`, and
+`ptb.observation`. `ptb.team` keeps its data. The other five retain only
+`{fence:"ptb-authority-v2"}`. Current commands use the new authority records.
+These occupied addresses prevent old code from creating fresh version-1
+documents. pi-durable rejects old typed reads before mutation. Fresh stores
+receive the same fence. Native pi-durable documents keep their own versions.
+
+A migrated operation receipt receives its original projection check on its
+first replay. Downgrade is not supported.
+
+The fence covers stopped and reopened stores, not an old process that is still
+running. Before the first open with this build, stop every node process that
+runs older code, and back up the whole store directory. To roll back, restore
+that backup and run the older build on it. A rollback discards all Team work
+accepted after the migration.
+
+Known hazard until the next contract change: `team_sync` can replay a stale
+page. This occurred with a direct snapshot call as well as nested calls. Leads
+use `task_read` for any Task state they act on. A direct `team_sync` call does
+not establish current Task state.
 
 The host injects model roles: a static `modelRoles` list, or a `catalog(tx,
 lead)` resolver that gives each lead its own roles and default. The AmPi
@@ -93,11 +151,44 @@ contract pin: it ships the same source files, and a test compares their SHA-256
 values with the recorded ones. The tests regenerate the contract from the
 installed devDependency `@hypercarrier/pi-team-bright@0.25.1`.
 
+Each role's tool labels and descriptions come from Pi Team Bright's own
+registration. `scripts/pi-registration.mjs` captures it per role through an
+inert host. The parity test compares every durable tool with the installed
+`@hypercarrier/pi-team-bright`. Known gap: Pi's Worker `alert_send` requires
+non-empty `text` and `task_id`; the durable schema does not yet.
+
 ```sh
 npm ci
 npm test
 ```
 
+The hardening oracle freezes `src/authority` at
+certified P, the 0.1.0-rc.1 port, in `test/oracle/authority`.
+Do not update that copy when optimizing the runtime. The seeded differential
+harness compares exact tool results or error messages, all public Task cards,
+and created `ptb.deliver` inputs after every command. Each runtime has its own
+MemoryStorage Harness. Both schedulers stay paused. The stop port returns fake
+settlement. A synthetic persisted lead run permits snapshot and update reads.
+Delivery execution and observation acknowledgement have separate tests.
+
+```sh
+# From the repository root: N seeds over K processes (defaults: 500 and 4).
+npm run test:oracle -- --seeds 500 --shards 4
+# Replay one failing seed. Failures print its full command trace.
+npm run test:oracle -- --seed 42 --seeds 1 --shards 1
+# Run only the deterministic boundary cases.
+npm run test:oracle -- --targeted-only
+```
+
+Each seed runs about 70 commands over at most seven Tasks. It combines a fixed
+lifecycle and transition prefix with 30 random commands, then starts a new Team
+epoch. Use `--steps` to change the random command count. A separate deterministic
+sequence covers prerequisite repair, superseded dependents, removed and
+reintroduced keys, stale lineage, blocked Worker capacity, reorder-only
+restatement, and stop notices after Worker reconnection. The normal Vitest suite
+runs these cases and three smoke seeds. This oracle detects behavior drift from the frozen
+runtime; it does not prove that the frozen behavior is correct.
+
 Fast tests use MemoryStorage, a fixed clock, inert timers, and faux responses.
 The SIGKILL crash-recovery suite and `bench/e2e.ts` stay in HyperCarrier (private).
 They use the AmPi node's subprocess carrier. This repository's tests do not

package/dist/authority/contracts.d.ts

@@ -3,10 +3,17 @@ import type { Result } from './state.ts';
 export declare const TOOL_NAMES: readonly ["team_create", "team_sync", "ensure_worker", "task_graph_apply", "task_read", "task_update", "worker_stop", "team_shutdown", "alert_send"];
 export type ToolName = typeof TOOL_NAMES[number];
 export type Role = 'lead' | 'worker';
+/** The label and description Pi Team Bright registers for one role's tool. */
+export interface ToolPresentation {
+    label: string;
+    description: string;
+}
 export interface Contract {
     lead: Record<ToolName, TSchema>;
     worker: Partial<Record<ToolName, TSchema>>;
     results: Record<ToolName, TSchema>;
+    presentation: Record<Role, Partial<Record<ToolName, ToolPresentation>>>;
 }
+export declare function checkSchema(schema: TSchema, value: unknown): boolean;
 export declare function contracts(goalMaxLength?: number): Contract;
 export declare function checkResult(contract: Contract, name: ToolName, value: Result): Result;

package/dist/authority/contracts.js

@@ -1,12 +1,27 @@
 import { readFileSync } from 'node:fs';
-import { Check } from 'typebox/value';
+import { Compile } from 'typebox/compile';
 export const TOOL_NAMES = ['team_create', 'team_sync', 'ensure_worker', 'task_graph_apply', 'task_read', 'task_update', 'worker_stop', 'team_shutdown', 'alert_send'];
 // Generated from the pinned executable rc.7 contract, not the stale agent surface.
-const source = JSON.parse(readFileSync(new URL('./rc7-contract.json', import.meta.url), 'utf8'));
+const source = readFileSync(new URL('./rc7-contract.json', import.meta.url), 'utf8');
+const patchedContracts = new Map();
+const validators = new Map();
+export function checkSchema(schema, value) {
+    const key = JSON.stringify(schema, (_key, value) => value && typeof value === 'object' && !Array.isArray(value)
+        ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : value);
+    let validator = validators.get(key);
+    if (!validator) {
+        validator = Compile(JSON.parse(key));
+        validators.set(key, validator);
+    }
+    return validator.Check(value);
+}
 export function contracts(goalMaxLength = 1600) {
     if (!Number.isSafeInteger(goalMaxLength) || goalMaxLength < 1)
         throw new Error('goalMaxLength must be a positive safe integer');
-    const copy = structuredClone(source);
+    const cached = patchedContracts.get(goalMaxLength);
+    if (cached !== undefined)
+        return JSON.parse(cached);
+    const copy = JSON.parse(source);
     function patch(value) {
         if (!value || typeof value !== 'object')
             return;
@@ -20,10 +35,11 @@ export function contracts(goalMaxLength = 1600) {
             patch(child);
     }
     patch(copy);
+    patchedContracts.set(goalMaxLength, JSON.stringify(copy));
     return copy;
 }
 export function checkResult(contract, name, value) {
-    if (!Check(contract.results[name], value))
+    if (!checkSchema(contract.results[name], value))
         throw new Error(`PTB ${name} produced a result outside the rc.7 contract: ${JSON.stringify(value)}`);
     return value;
 }

package/dist/authority/delivery.d.ts

@@ -1,6 +1,7 @@
 import type { AbortRun, InterruptTarget } from './interrupt.ts';
 import { type SubmissionId, type Tx } from '@earendil-works/pi-durable';
-import { type State, type Obligation } from './state.ts';
+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;
@@ -26,8 +27,8 @@ export type TeamNoticeData = {
     interrupt?: true;
 };
 export declare const SENDER_LIMIT = 64;
-export declare function eligible(s: State, o: Obligation): boolean;
-export declare function deliveryInput(s: State, o: Obligation): DeliveryInput;
+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";

package/dist/authority/delivery.js

@@ -1,10 +1,9 @@
 import { withAbortSignal } from '@earendil-works/chord/context';
 import { defineTask } from '@earendil-works/pi-durable';
-import { GraphTaskController } from "./graph-control.js";
-import { projectGraphTaskCards } from "./graph-card.js";
-import { open, plain, event } from "./state.js";
+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 function eligible(s, o) {
+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;
@@ -15,23 +14,22 @@ export function eligible(s, o) {
         return false;
     if (o.kind !== 'task')
         return true;
-    if (!s.graph.snapshot || s.graph.epoch !== team.epoch)
+    if (!s.head.graph || s.head.epoch !== team.epoch)
         return false;
-    const task = GraphTaskController.recover(plain(s.graph.snapshot)).readTasks().find(t => t.id === o.taskId);
-    return !!task && task.version === o.version && task.assignee === o.recipient && task.state.kind === 'ready';
+    const task = (await taskRecord(s, o.taskId))?.card;
+    return !!task && task.version === o.version && task.assignee === o.recipient && task.status === 'ready';
 }
-export function deliveryInput(s, o) {
+export async function deliveryInput(s, o) {
     let payload;
     if (o.kind === 'alert')
-        payload = { kind: 'alert', alert: plain(s.outbox.alerts[o.alertId]) };
+        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 {
-        const graph = GraphTaskController.recover(plain(s.graph.snapshot));
-        payload = { kind: 'task', task: projectGraphTaskCards(graph).find(t => t.id === o.taskId) };
+        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' ? s.outbox.alerts[o.alertId]?.from : 'team-lead')?.slice(0, SENDER_LIMIT);
+    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. */
@@ -48,12 +46,13 @@ export const Deliver = defineTask({
         submit: async (task, runtime, context) => {
             let valid = false, interruption;
             await runtime.commit(async (tx) => {
-                const s = await open(tx), o = s.outbox.obligations[task.input.key];
-                valid = !!o && eligible(s, o);
+                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)
-                        o.state = 'retired';
+                        await setObligationState(s, o, 'retired');
+                    flushAuthority(s);
                     return { status: 'terminal', outcome: { status: 'completed', result: null } };
                 }
                 return undefined;
@@ -65,7 +64,7 @@ export const Deliver = defineTask({
                 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 = s.outbox.obligations[task.input.key];
+                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;
@@ -80,22 +79,22 @@ export const Deliver = defineTask({
                 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 open(tx)).outbox.obligations[task.input.key]?.interruption; return undefined; }, context);
+            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 = s.outbox.obligations[task.input.key]; obsolete = !o || !eligible(s, o); return undefined; }, context);
+            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 = s.outbox.obligations[task.input.key];
+                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')
-                        o.state = 'settled';
+                        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() });
@@ -104,10 +103,10 @@ export const Deliver = defineTask({
         },
     },
     abort: async (task, runtime, context) => {
-        await runtime.commit(async (tx) => { const o = (await open(tx)).outbox.obligations[task.input.key]; if (o) {
-            o.state = 'retired';
+        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';
-        } return { status: 'terminal', outcome: { status: 'aborted' } }; }, context);
+        } flushAuthority(s); return { status: 'terminal', outcome: { status: 'aborted' } }; }, context);
     },
 });
 /** Keep the shared submit/settle mechanics; only the host-owned interruption needs a port. */
@@ -128,10 +127,11 @@ export function createDeliver(abortRun) {
                     outcome = 'failed';
                 }
                 await runtime.commit(async (tx) => {
-                    const s = await open(tx), o = s.outbox.obligations[task.input.key];
-                    if (!o || !eligible(s, o) || outcome === 'retired') {
+                    const s = await open(tx), o = await obligation(s, task.input.key);
+                    if (!o || !await eligible(s, o) || outcome === 'retired') {
                         if (o)
-                            o.state = 'retired';
+                            await setObligationState(s, o, 'retired');
+                        flushAuthority(s);
                         return { status: 'terminal', outcome: { status: 'completed', result: null } };
                     }
                     o.interruption = outcome;
@@ -144,9 +144,15 @@ export async function scheduleDeliveries(tx, s, delivery) {
     const team = s.team.current;
     if (!team || team.lifecycle !== 'active')
         return;
-    for (const o of Object.values(s.outbox.obligations)) {
-        if (o.deliveryTaskId || !eligible(s, o))
+    for (const o of await unscheduledObligations(s)) {
+        const key = o.key;
+        if (o.deliveryTaskId) {
+            await markScheduled(s, key);
             continue;
-        o.deliveryTaskId = await tx.createTask(delivery, deliveryInput(s, o), { conversationId: team.lead, ownership: { kind: 'conversation' }, background: true, abandonOnRestart: false });
+        }
+        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-control.d.ts

@@ -220,7 +220,7 @@ export type GraphControlResult = GraphApplyResult | GraphTransitionResult;
 export type GraphControlReceipt = GraphControlResult & {
     replayed: boolean;
 };
-interface StoredReceipt {
+export interface StoredReceipt {
     operationId: string;
     fingerprint: string;
     result: GraphControlResult;

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

@@ -0,0 +1,156 @@
+import { type GraphVersionRef, type GraphApplyInput, type GraphTaskTransitionInput, type GraphTaskState, type GraphTaskView, type GraphAttemptView, type GraphRevision, type GraphControlEvent, type GraphApplyResult, type GraphTransitionResult, type GraphControlSnapshot } from "./graph-control.ts";
+type StoredTaskDefinition = GraphRevision["tasks"][number];
+type StoredReceipt = GraphControlSnapshot["receipts"][number];
+type EventOf<K extends GraphControlEvent["kind"]> = Extract<GraphControlEvent, {
+    kind: K;
+}>;
+type AttemptStartedEvent = EventOf<"attempt_started">;
+type AttemptBlockedEvent = EventOf<"attempt_blocked">;
+type AttemptResumedEvent = EventOf<"attempt_resumed">;
+type AttemptCompletedEvent = EventOf<"attempt_completed">;
+type AttemptSupersededEvent = EventOf<"attempt_superseded">;
+type TaskCancelledEvent = EventOf<"task_cancelled">;
+type FailureEdgeExhaustedEvent = EventOf<"failure_edge_exhausted">;
+interface AttemptFold {
+    started: AttemptStartedEvent;
+    blocked?: AttemptBlockedEvent;
+    resumed?: AttemptResumedEvent;
+    completed?: AttemptCompletedEvent;
+    superseded?: AttemptSupersededEvent;
+    cancellation?: TaskCancelledEvent;
+    exhausted?: FailureEdgeExhaustedEvent;
+    endedAt?: string;
+    endedSequence?: number;
+}
+interface DerivedTask {
+    definition: StoredTaskDefinition;
+    state: GraphTaskState;
+    activationKey?: string;
+    inputAttemptIds: Record<string, string>;
+    acceptedAttemptId?: string;
+    attemptsStarted: number;
+}
+declare function digest(value: unknown): string;
+interface TaskNode {
+    definition: StoredTaskDefinition;
+    cancellation?: TaskCancelledEvent;
+    currentContext?: string;
+    demand: number;
+    traversals: number;
+    activations: Map<string, AttemptFold>;
+    derived?: DerivedTask;
+    view?: GraphTaskView;
+}
+/** Current-state representation. History and replay receipts have separate owners. */
+export interface GraphMaterializedHead {
+    sequence: number;
+    revision?: Omit<GraphRevision, "tasks">;
+    topology: Array<{
+        key: string;
+        needs: string[];
+    }>;
+    projections: Record<string, string>;
+    ready: Record<string, string[]>;
+    occupied: Record<string, string[]>;
+}
+export interface GraphMaterializedTask {
+    id: string;
+    attemptsStarted: number;
+    node?: Omit<TaskNode, "activations">;
+    attempts: AttemptFold[];
+}
+export declare class GraphTaskRequired extends Error {
+    readonly ids: string[];
+    constructor(ids: string[]);
+}
+export declare class IncrementalGraphTaskController {
+    private readonly graphRevisions;
+    private readonly events;
+    private readonly receipts;
+    private readonly attempts;
+    private readonly attemptCounts;
+    private readonly activeAttempts;
+    private nodes;
+    private dependents;
+    private ranks;
+    private readonly dirty;
+    private readonly ready;
+    private readonly occupied;
+    private sequence;
+    private projections;
+    private readonly changed;
+    private restoredRevisionCount;
+    private structuralTasks;
+    private commandRecordedAt?;
+    private readonly clock;
+    constructor(clock?: () => Date);
+    /** Migration only. The caller validates the source with the reference controller. */
+    static fromSnapshot(snapshot: GraphControlSnapshot, clock?: () => Date): IncrementalGraphTaskController;
+    static restore(head: GraphMaterializedHead, records: ReadonlyMap<string, GraphMaterializedTask>, clock?: () => Date): IncrementalGraphTaskController;
+    headUpdate(): {
+        sequence: number;
+        projections: {
+            [k: string]: string;
+        };
+        ready: {
+            [k: string]: string[];
+        };
+        occupied: {
+            [k: string]: string[];
+        };
+    };
+    materializedHead(): GraphMaterializedHead;
+    materializedTask(id: string): GraphMaterializedTask;
+    changes(): {
+        taskIds: string[];
+        revisions: GraphRevision[];
+        events: GraphControlEvent[];
+        receipts: import("./graph-control.ts").StoredReceipt[];
+    };
+    restoreReceipt(receipt: StoredReceipt): void;
+    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[];
+    attemptStartedSequence(id: string): number;
+    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 installGraph;
+    private fold;
+    private rebuild;
+    private flush;
+    private indexView;
+    private readyIds;
+    private occupiedTask;
+    private activeAttemptIds;
+    private attemptsToSupersede;
+    private deriveNode;
+    private toView;
+}
+export declare function prerequisiteProjection(task: DerivedTask | undefined): string;
+export { digest as graphControlFingerprint };