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

package/dist/authority/runtime.d.ts

@@ -0,0 +1,106 @@
+import type { Context } from '@earendil-works/chord/context';
+import { type Harness, type Extension } from '@earendil-works/pi-durable';
+import { type CoreApi, type CoreOptions } from './tools.ts';
+import type { AbortRun } from './interrupt.ts';
+import { type ObservationPortResolver } from './observation.ts';
+import { type StopIntent } from './state.ts';
+export interface StopPlan {
+    id: string;
+    conversations?: string[];
+    tasks?: string[];
+}
+export type StopOutcome = {
+    status: 'settled';
+    tasks: Record<string, string>;
+} | {
+    status: 'failed';
+    tasks: Record<string, string>;
+    error: string;
+};
+export declare const stopPlan: (id: string, intent: StopIntent) => StopPlan;
+export declare function pendingStops(harness: Harness, context: Context): Promise<StopPlan[]>;
+export declare function confirmStop(harness: Harness, id: string, outcome: StopOutcome, context: Context, now?: () => number): Promise<void>;
+/** Called by NodePlugin.closing after its own lead Close intent is stored. */
+export declare function closing(harness: Harness, conversationId: string, context: Context): Promise<StopPlan[]>;
+export interface RuntimeOptions extends Pick<CoreOptions, 'modelRoles' | 'defaultModelRole' | 'catalog' | 'goalMaxLength' | 'resolveModelRole'> {
+    observationPort: ObservationPortResolver;
+    abortRun: AbortRun;
+    stop: (api: CoreApi, plans: StopPlan[], context: Context) => Promise<StopOutcome[]>;
+}
+export declare function createTeamRuntime(options: RuntimeOptions): {
+    core: {
+        lead: {
+            label: string;
+            name: string;
+            description: string;
+            parameters: import("typebox").TSchema;
+            constrainedSampling?: false | import("@earendil-works/pi-ai").ConstrainedSamplingConfig;
+            replay?: "safe" | "unsafe";
+            executionMode?: import("@earendil-works/pi-durable").ToolExecutionMode;
+            prepareArguments?(args: unknown): unknown;
+            structuredOutputSchema?: import("typebox").TSchema;
+            callers?: readonly ("model" | "tools")[];
+            deferred?: true;
+            outputLimits?: {
+                readonly maxBytes?: number;
+                readonly maxLines?: number;
+                readonly retain?: "head" | "tail";
+            };
+            execute(args: unknown, api: import("@earendil-works/pi-durable").ToolExecutionApi<import("@earendil-works/chord").JsonValue>, context: Context): Promise<import("@earendil-works/pi-durable").ToolExecutionResult<import("@earendil-works/chord").JsonValue>>;
+        }[];
+        worker: {
+            label: string;
+            name: string;
+            description: string;
+            parameters: import("typebox").TSchema;
+            constrainedSampling?: false | import("@earendil-works/pi-ai").ConstrainedSamplingConfig;
+            replay?: "safe" | "unsafe";
+            executionMode?: import("@earendil-works/pi-durable").ToolExecutionMode;
+            prepareArguments?(args: unknown): unknown;
+            structuredOutputSchema?: import("typebox").TSchema;
+            callers?: readonly ("model" | "tools")[];
+            deferred?: true;
+            outputLimits?: {
+                readonly maxBytes?: number;
+                readonly maxLines?: number;
+                readonly retain?: "head" | "tail";
+            };
+            execute(args: unknown, api: import("@earendil-works/pi-durable").ToolExecutionApi<import("@earendil-works/chord").JsonValue>, context: Context): Promise<import("@earendil-works/pi-durable").ToolExecutionResult<import("@earendil-works/chord").JsonValue>>;
+        }[];
+        execute: (name: import("./contracts.ts").ToolName, role: import("./contracts.ts").Role, input: unknown, api: CoreApi, context: Context) => Promise<import("./state.ts").Result>;
+        contract: import("./contracts.ts").Contract;
+    };
+    lead: Extension<import("@earendil-works/pi-durable").ToolRegistration<import("typebox").TSchema, import("@earendil-works/chord").JsonValue>>;
+    worker: Extension<import("@earendil-works/pi-durable").ToolRegistration<import("typebox").TSchema, import("@earendil-works/chord").JsonValue>>;
+    mechanics: Extension<import("@earendil-works/pi-durable").ToolRegistration<import("typebox").TSchema, import("@earendil-works/chord").JsonValue>>;
+    observation: Extension<import("@earendil-works/pi-durable").ToolRegistration<import("typebox").TSchema, import("@earendil-works/chord").JsonValue>>;
+    extensions: Extension<import("@earendil-works/pi-durable").ToolRegistration<import("typebox").TSchema, import("@earendil-works/chord").JsonValue>>[];
+    tasks: {
+        WorkerAnchor: import("@earendil-works/pi-durable").Task<null, {
+            phase: "hold";
+        }, null, object>;
+        Deliver: import("@earendil-works/pi-durable").Task<import("./delivery.ts").DeliveryInput, {
+            phase: "interrupt";
+        } | {
+            phase: "submit";
+        } | {
+            phase: "settle";
+            submissionId: import("@earendil-works/pi-durable").SubmissionId;
+        }, null, object>;
+        Notify: import("@earendil-works/pi-durable").Task<{
+            epoch: string;
+        }, {
+            phase: "tick";
+            ordinal: number;
+            due?: number;
+        } | {
+            phase: "submit";
+            pageId: string;
+            ordinal: number;
+        } | {
+            phase: "settle";
+            pageId: string;
+            ordinal: number;
+        }, null, object>;
+    };
+};

package/dist/authority/runtime.js

@@ -0,0 +1,115 @@
+import { configure } from '@earendil-works/pi-durable';
+import { catalogOf, createAuthorityTools } from "./tools.js";
+import { createAnchoredConversation, WorkerAnchor } from "./anchor.js";
+import { createDeliver, scheduleDeliveries } from "./delivery.js";
+import { createNotifier } from "./notifier.js";
+import { openObservations, startObservationEpoch, observationExtension } from "./observation.js";
+import { sync } from "./sync.js";
+import { event } from "./state.js";
+import { openAuthority as open, flushAuthority, allObligations, setObligationState } from "./store.js";
+export const stopPlan = (id, intent) => ({ id, conversations: intent.conversations.map(String), tasks: intent.tasks.map(String) });
+export async function pendingStops(harness, context) {
+    return harness.commit(async (tx) => Object.entries((await open(tx)).team.stops).filter(([, i]) => !i.confirmed).map(([id, i]) => stopPlan(id, i)), context);
+}
+export async function confirmStop(harness, id, outcome, context, now = Date.now) {
+    await harness.commit(async (tx) => {
+        const s = await open(tx), intent = s.team.stops[id];
+        if (!intent || intent.confirmed)
+            return;
+        if (outcome.status !== 'settled') {
+            intent.error = outcome.error;
+            return;
+        }
+        // Confirm the exact persisted targets, including tasks already terminal before mark.
+        for (const target of intent.tasks) {
+            const task = await tx.task(target);
+            if (!task || task.state.status !== 'terminal')
+                throw new Error('PTB stop target is not terminal');
+        }
+        if (s.team.current?.epoch !== intent.epoch)
+            throw new Error('PTB stop epoch changed');
+        const worker = intent.worker ? s.team.current.workers[intent.worker] : undefined;
+        if (intent.binding && (!worker || worker.generation !== intent.generation || worker.anchorId !== intent.binding.anchorId || worker.conversationId !== intent.binding.conversationId))
+            throw new Error('PTB stop binding changed');
+        intent.confirmed = true;
+        delete intent.error;
+        if (worker) {
+            worker.state = 'stopped';
+            await event(tx, s, 'team-lead', 'worker_stopped', { worker: worker.name, at: new Date(now()).toISOString() });
+        }
+        if (s.team.current.shutdownPending && Object.values(s.team.stops).filter(i => i.epoch === intent.epoch).every(i => i.confirmed)) {
+            s.team.current.lifecycle = 'stopped';
+            await event(tx, s, 'team-lead', 'team_stopped', { at: new Date(now()).toISOString() });
+        }
+    }, context);
+}
+async function addMechanicStops(s, shutdown) {
+    const team = s.team.current, obligations = await allObligations(s);
+    for (const intent of Object.values(s.team.stops)) {
+        if (intent.epoch !== team.epoch || intent.confirmed)
+            continue;
+        for (const o of obligations)
+            if (o.epoch === team.epoch && o.recipient === intent.worker && o.deliveryTaskId && !intent.tasks.includes(o.deliveryTaskId))
+                intent.tasks.push(o.deliveryTaskId);
+    }
+    if (!shutdown)
+        return;
+    const key = `${team.epoch}:shutdown-mechanics`;
+    const tasks = obligations.filter(o => o.epoch === team.epoch && o.deliveryTaskId).map(o => o.deliveryTaskId);
+    if (team.notifierId)
+        tasks.push(team.notifierId);
+    s.team.stops[key] ??= { epoch: team.epoch, tasks, conversations: [], confirmed: false };
+    return key;
+}
+/** Called by NodePlugin.closing after its own lead Close intent is stored. */
+export async function closing(harness, conversationId, context) {
+    return harness.commit(async (tx) => {
+        const s = await open(tx), team = s.team.current;
+        if (!team || String(team.lead) !== conversationId || team.lifecycle !== 'active')
+            return [];
+        team.shutdownPending = true;
+        for (const w of Object.values(team.workers))
+            if (w.state !== 'stopped') {
+                const key = `${team.epoch}:stop:${w.name}:g${w.generation}`;
+                w.state = 'stopping';
+                s.team.stops[key] ??= { epoch: team.epoch, worker: w.name, generation: w.generation, binding: { conversationId: w.conversationId, anchorId: w.anchorId }, tasks: [w.anchorId], conversations: [w.conversationId], confirmed: false };
+            }
+        for (const o of await allObligations(s))
+            if (o.epoch === team.epoch)
+                await setObligationState(s, o, 'retired');
+        await addMechanicStops(s, true);
+        flushAuthority(s);
+        return Object.entries(s.team.stops).filter(([, i]) => i.epoch === team.epoch && !i.confirmed).map(([id, i]) => stopPlan(id, i));
+    }, context);
+}
+export function createTeamRuntime(options) {
+    const Notify = createNotifier(catalogOf(options));
+    const Deliver = createDeliver(options.abortRun);
+    let lead, worker;
+    const core = createAuthorityTools({ ...options, sync,
+        createWorker: async (tx, role) => {
+            const s = await open(tx), binding = await createAnchoredConversation(tx, s.team.current.lead);
+            await configure(tx, binding.conversationId, { model: role.model, ...(role.thinking ? { thinkingLevel: role.thinking } : {}), extensions: { remove: [lead], add: [worker] } });
+            return binding;
+        },
+        settleStops: async (stops, context, api) => stops.length ? (await options.stop(api, stops.map(s => stopPlan(s.key, s.intent)), context)).map(o => o.status === 'settled') : [],
+        afterCommand: async (tx, s, name, result) => {
+            const team = s.team.current;
+            if (!team || team.lifecycle !== 'active')
+                return;
+            if (name === 'team_create') {
+                startObservationEpoch(await openObservations(tx), team.epoch);
+            }
+            if (!team.notifierId && !team.shutdownPending)
+                team.notifierId = await tx.createTask(Notify, { epoch: team.epoch }, { conversationId: team.lead, ownership: { kind: 'conversation' }, background: true, abandonOnRestart: false });
+            await scheduleDeliveries(tx, s, Deliver);
+            const extra = name === 'worker_stop' || name === 'team_shutdown' ? await addMechanicStops(s, name === 'team_shutdown') : undefined;
+            if (extra && Array.isArray(result.stops) && !result.stops.includes(extra))
+                result.stops.push(extra);
+        }, });
+    lead = { name: 'ptb.lead', tools: core.lead };
+    worker = { name: 'ptb.worker', tools: core.worker };
+    const mechanics = { name: 'ptb.mechanics', tasks: [WorkerAnchor, Deliver, Notify] };
+    const observation = observationExtension(options.observationPort);
+    return { core, lead, worker, mechanics, observation, extensions: [mechanics, lead, worker, observation], tasks: { WorkerAnchor, Deliver, Notify } };
+}

package/dist/authority/state.d.ts

@@ -0,0 +1,165 @@
+import { type ConversationId, type TaskId, type SubmissionId, type EntryId, type JsonObject, type Tx } from '@earendil-works/pi-durable';
+import type { GraphControlSnapshot } from './graph-control.ts';
+export interface Binding {
+    conversationId: ConversationId;
+    anchorId: TaskId;
+}
+export interface ModelRole {
+    name: string;
+    use: string;
+    model: {
+        provider: string;
+        modelId: string;
+    };
+    thinking?: string;
+}
+/** The roles a lead can select, with the role ensure_worker uses when the call names none. */
+export interface ModelRoleCatalog {
+    modelRoles: ModelRole[];
+    defaultModelRole?: string;
+}
+export interface Worker extends Binding {
+    createdAt?: number;
+    name: string;
+    scope: string;
+    generation: number;
+    state: 'active' | 'stopping' | 'stopped';
+    role: ModelRole;
+}
+export interface Team {
+    createdAt?: number;
+    epoch: string;
+    name: string;
+    purpose: string;
+    lead: ConversationId;
+    lifecycle: 'active' | 'stopped';
+    workers: Record<string, Worker>;
+    shutdownPending?: boolean;
+    notifierId?: TaskId;
+}
+export interface StopIntent {
+    epoch: string;
+    worker?: string;
+    binding?: Binding;
+    generation?: number;
+    tasks: TaskId[];
+    conversations: ConversationId[];
+    confirmed: boolean;
+    error?: string;
+}
+export interface TeamState {
+    current?: Team;
+    history: Team[];
+    stops: Record<string, StopIntent>;
+}
+export interface GraphState {
+    epoch?: string;
+    snapshot?: GraphControlSnapshot;
+    history?: Record<string, GraphControlSnapshot>;
+}
+export interface Alert {
+    interrupt?: true;
+    id: string;
+    from: string;
+    kind: string;
+    text: string;
+    task_id?: string;
+    task_version?: string;
+    receivedAt: string;
+    recipients: {
+        name: string;
+        conversationId: ConversationId;
+        generation: number;
+    }[];
+}
+export interface Obligation {
+    interrupt?: true;
+    interruptRun?: TaskId;
+    interruption?: 'interrupted' | 'ended' | 'failed';
+    acceptedAt?: number;
+    submittedAt?: number;
+    settledAt?: number;
+    key: string;
+    epoch: string;
+    kind: 'task' | 'stop' | 'alert';
+    recipient: string;
+    conversationId: ConversationId;
+    generation: number;
+    taskId?: string;
+    version?: string;
+    alertId?: string;
+    state: 'pending' | 'retired' | 'settled';
+    deliveryTaskId?: TaskId;
+    submissionId?: SubmissionId;
+    outcome?: string;
+}
+export interface OutboxState {
+    alerts: Record<string, Alert>;
+    obligations: Record<string, Obligation>;
+}
+export interface Event {
+    seq: number;
+    epoch: string;
+    actor: string;
+    kind: string;
+    taskId?: string;
+    taskIds?: string[];
+    worker?: string;
+    at?: string;
+    text?: string;
+    entryId?: EntryId;
+}
+export type JournalRef = Event | {
+    seq: number;
+    entryId: EntryId;
+};
+export interface JournalState {
+    seq: number;
+    events: Event[];
+    reservation?: {
+        epoch: string;
+        call: string;
+        through: number;
+    };
+    acknowledged: number;
+}
+export type Result = Record<string, unknown> & {
+    kind: string;
+};
+export interface Receipt {
+    fingerprint: string;
+    result?: Result;
+    stops?: string[];
+    epoch?: string;
+}
+export interface ReceiptState {
+    calls: Record<string, Receipt>;
+}
+export declare const TeamDoc: import("@earendil-works/pi-durable").SessionDocToken<JsonObject>;
+export declare const GraphDoc: import("@earendil-works/pi-durable").SessionDocToken<JsonObject>;
+export declare const JournalDoc: import("@earendil-works/pi-durable").SessionDocToken<JsonObject>;
+export declare const OutboxDoc: import("@earendil-works/pi-durable").SessionDocToken<JsonObject>;
+export declare const ReceiptDoc: import("@earendil-works/pi-durable").SessionDocToken<JsonObject>;
+export declare function hasLegacyFence(value: object): boolean;
+/** Keep the v2 address occupied so an old reader cannot create a v1 incarnation. */
+export declare function fenceLegacyDoc(value: object): void;
+export interface State {
+    team: TeamState;
+    graph: GraphState;
+    journal: JournalState;
+    outbox: OutboxState;
+    receipts: ReceiptState;
+}
+/** Full historical inspection. Runtime commands use openAuthority's indexed state. */
+export declare function open(tx: Tx): Promise<State>;
+export declare const plain: <T>(value: T) => T;
+export declare const JOURNAL_RESIDENT_LIMIT = 100;
+/** History is append-only storage; the document contains a bounded recent projection. */
+export declare function event(tx: Tx, s: {
+    team: TeamState;
+    journal: {
+        seq: number;
+        events: JournalRef[];
+    };
+    flush?: () => void;
+}, actor: string, kind: string, extra?: Pick<Event, 'taskId' | 'taskIds' | 'worker' | 'at' | 'text'>): Promise<void>;

package/dist/authority/state.js

@@ -0,0 +1,28 @@
+import { defineDoc } from '@earendil-works/pi-durable';
+const doc = (kind, initial) => defineDoc({ kind, version: 2, migrate: value => value, scope: 'session', checkpointWhen: () => true, initial });
+export const TeamDoc = doc('ptb.team', () => ({ history: [], stops: {} }));
+export const GraphDoc = doc('ptb.graph', () => ({}));
+export const JournalDoc = doc('ptb.journal', () => ({ seq: 0, events: [], acknowledged: 0 }));
+export const OutboxDoc = doc('ptb.outbox', () => ({ alerts: {}, obligations: {} }));
+export const ReceiptDoc = doc('ptb.receipts', () => ({ calls: {} }));
+const fenceMarker = 'ptb-authority-v2';
+export function hasLegacyFence(value) { return value.fence === fenceMarker; }
+/** Keep the v2 address occupied so an old reader cannot create a v1 incarnation. */
+export function fenceLegacyDoc(value) {
+    for (const key of Object.keys(value))
+        Reflect.deleteProperty(value, key);
+    Object.assign(value, { fence: fenceMarker });
+}
+/** Full historical inspection. Runtime commands use openAuthority's indexed state. */
+export async function open(tx) {
+    return (await import("./store.js")).inspectAuthority(tx);
+}
+export const plain = (value) => JSON.parse(JSON.stringify(value));
+export const JOURNAL_RESIDENT_LIMIT = 100;
+/** History is append-only storage; the document contains a bounded recent projection. */
+export async function event(tx, s, actor, kind, extra = {}) {
+    const value = { seq: ++s.journal.seq, epoch: s.team.current.epoch, actor, kind, ...extra };
+    const entry = await tx.appendEntry(s.team.current.lead, { kind: 'ptb.event', data: value });
+    s.journal.events = [...s.journal.events, { ...value, entryId: entry.id }].slice(-JOURNAL_RESIDENT_LIMIT);
+    s.flush?.();
+}

package/dist/authority/store.d.ts

@@ -0,0 +1,144 @@
+import { type Tx, type JsonObject, type ConversationId, type TaskId } from '@earendil-works/pi-durable';
+import { type GraphControlSnapshot, type GraphApplyInput, type GraphTaskTransitionInput } from './graph-control.ts';
+import { type GraphMaterializedHead, type GraphMaterializedTask } from './incremental-graph-control.ts';
+import type { GraphTaskCard } from './card-types.ts';
+import { type TeamState, type JournalState, type JournalRef, type Event, type Alert, type Obligation, type Receipt, type State } from './state.ts';
+type GraphHead = Omit<GraphMaterializedHead, 'topology' | 'projections'>;
+export interface AuthorityHead {
+    initialized: boolean;
+    legacyFenced?: boolean;
+    epoch?: string;
+    graph?: GraphHead;
+    taskCount: number;
+    log?: ConversationId;
+    journal: Omit<JournalState, 'events'> & {
+        events: string;
+    };
+    pendingBuckets: Record<string, true>;
+    unscheduledBuckets: Record<string, true>;
+    obligationSequence: number;
+    recentObligations: string[];
+    recentAlerts: string[];
+    leadAlerts: string[];
+    leadAlertCount: number;
+    obligationTail?: string;
+    alertTail?: string;
+    callTail?: string;
+    attention: Record<string, 'blocked' | 'failed'>;
+    frontier: Record<string, {
+        id: string;
+        version: string;
+        generation: number;
+    }>;
+    taskObligations: Record<string, string[]>;
+    workerBindings: Record<string, string>;
+    stopRefresh?: boolean;
+}
+export declare const HeadDoc: import("@earendil-works/pi-durable").SessionDocToken<JsonObject>;
+export declare const TaskDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const GraphIndexDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const WorkerIndexDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const OrdinalDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const OperationDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const ObligationDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const EligibilityDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const AlertDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const DirectCallDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const CallDoc: import("@earendil-works/pi-durable").TaskDocToken<JsonObject>;
+export declare const taskAddress: (epoch: string, id: string) => string;
+export interface OperatorTask {
+    key: string;
+    title: string;
+    goal: string;
+    assignee: string;
+    needs: string[];
+    version: string;
+    current_context: string;
+    attempts: {
+        id: string;
+        ordinal: number;
+        startedAt?: number;
+        endedAt?: number;
+        outcome?: string;
+        evidence?: string;
+    }[];
+    derived: string;
+    status: string;
+    derivedReason?: string;
+    evidence?: string;
+}
+export interface TaskRecord {
+    materialized: GraphMaterializedTask;
+    card: GraphTaskCard;
+    operator: OperatorTask;
+}
+interface StoredCall {
+    fingerprint?: string;
+    result?: string;
+    stops?: string[];
+    epoch?: string;
+    previous?: string;
+}
+type CurrentJournal = Omit<JournalState, 'events'> & {
+    events: JournalRef[];
+};
+interface Eligibility {
+    doc: JsonObject;
+    pending: Record<string, number>;
+    unscheduled: Record<string, number>;
+}
+export interface Authority {
+    tx: Tx;
+    team: TeamState;
+    head: AuthorityHead;
+    journal: CurrentJournal;
+    headDoc: JsonObject;
+    deferFlush: boolean;
+    flush: () => void;
+    records: Map<string, TaskRecord | undefined>;
+    obligations: Map<string, Obligation>;
+    eligibility: Map<string, Eligibility>;
+    newObligations: Set<string>;
+    calls: Map<number, {
+        doc: StoredCall;
+        native: boolean;
+    }>;
+    workerIndexes: Map<string, string[]>;
+    migratedHistory?: Map<string, GraphControlSnapshot>;
+}
+export declare function recentEvents(s: Authority, refs?: JournalRef[]): Promise<Event[]>;
+export declare function flushAuthority(s: Authority): void;
+export declare function openAuthority(tx: Tx): Promise<Authority>;
+export declare function startEpoch(s: Authority, epoch: string): Promise<void>;
+export declare function taskIds(s: Authority): Promise<string[]>;
+export declare function taskRecord(s: Authority, id: string): Promise<TaskRecord | undefined>;
+export declare function taskCards(s: Authority, ids?: string[]): Promise<GraphTaskCard[]>;
+export declare function unfinished(s: Authority, worker?: string): Promise<string[]>;
+export declare function obligation(s: Authority, key: string): Promise<Obligation | undefined>;
+export declare function markScheduled(s: Authority, key: string): Promise<void>;
+export declare function unscheduledObligations(s: Authority): Promise<Obligation[]>;
+export declare function addObligation(s: Authority, value: Obligation): Promise<void>;
+export declare function setObligationState(s: Authority, value: Obligation, state: Obligation['state']): Promise<void>;
+export declare function allObligations(s: Authority): Promise<Obligation[]>;
+export declare function pendingObligations(s: Authority): Promise<Obligation[]>;
+export declare function alertRecord(s: Authority, id: string): Promise<Alert | undefined>;
+export declare function addAlert(s: Authority, value: Alert): Promise<void>;
+export declare function callReceipt(s: Authority, id: TaskId, native?: boolean): Promise<StoredCall>;
+export declare function saveCall(s: Authority, id: TaskId, receipt: Receipt): Promise<void>;
+export declare function hasOperation(s: Authority, operationId: string): Promise<boolean>;
+export declare function graphCommand(s: Authority, command: {
+    kind: 'apply';
+    input: GraphApplyInput;
+} | {
+    kind: 'transition';
+    input: GraphTaskTransitionInput;
+}, now: () => number): Promise<(import("./graph-control.ts").GraphApplyResult & {
+    replayed: boolean;
+}) | (import("./graph-control.ts").GraphTransitionResult & {
+    replayed: boolean;
+})>;
+/** History materialization for diagnostics, migration checks, and generation reconciliation. */
+export declare function readGraphHistory(s: Authority, epoch?: string): Promise<GraphControlSnapshot>;
+/** Legacy-shaped, full inspection for diagnostics and existing recovery tests. */
+export declare function inspectAuthority(tx: Tx): Promise<State>;
+export {};