@fro.bot/systematic 3.2.8 → 3.3.1

package/dist/lib/config-schema.d.ts

@@ -14,6 +14,14 @@
  *   but is not reflected in the type declarations for this Zod 4 minor.
  */
 import { z } from 'zod';
+export declare const WorkflowGuardSchema: z.ZodDefault<z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        observe: "observe";
+        protected: "protected";
+        disabled: "disabled";
+    }>>;
+    debug: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>>;
 export declare const AgentOverlaySchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     variant: z.ZodOptional<z.ZodString>;

package/dist/lib/config.d.ts

@@ -2,6 +2,11 @@ export interface BootstrapConfig {
     enabled: boolean;
     file?: string;
 }
+export type WorkflowGuardMode = 'observe' | 'protected' | 'disabled';
+export interface WorkflowGuardConfig {
+    mode: WorkflowGuardMode;
+    debug: boolean;
+}
 export type OverlayConfig = Record<string, unknown>;
 export type OverlayConfigMap = Record<string, OverlayConfig>;
 export interface SourcedOverlayConfig {
@@ -22,6 +27,7 @@ export interface SystematicConfig {
     disabled_agents: string[];
     disabled_commands: string[];
     bootstrap: BootstrapConfig;
+    workflow_guard: WorkflowGuardConfig;
     agents?: OverlayConfigMap;
     categories?: OverlayConfigMap;
     skills_as_commands: boolean;

package/dist/lib/opencode-operation-observer.d.ts

@@ -0,0 +1,79 @@
+export type OperationObserverReasonCode = 'target-unavailable' | 'command-failed' | 'command-timeout' | 'command-output-limit' | 'file-limit' | 'file-output-limit' | 'file-read-failed' | 'remote-command-failed' | 'remote-command-output-limit' | 'remote-invalid-json' | 'remote-missing-field' | 'remote-item-limit' | 'remote-not-advanced' | 'commit-not-closed';
+export type RemoteOperation = 'push' | 'pr-creation' | 'check-readback' | 'review-readback';
+export type RemoteReadbackPhase = 'before' | 'after';
+export interface OperationObserverSnapshot {
+    readonly targetDigest: string;
+    readonly repositoryRevisionDigest: string;
+    readonly worktreeRevisionDigest: string;
+    readonly commitClosure?: boolean;
+}
+export type OperationObserverResult = {
+    readonly status: 'available';
+    readonly snapshot: OperationObserverSnapshot;
+} | {
+    readonly status: 'unavailable';
+    readonly reasonCode: OperationObserverReasonCode;
+};
+export interface OperationObserverCommandResult {
+    readonly status: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly timedOut?: boolean;
+}
+export interface OperationObserverRemoteCommandResult {
+    readonly status: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly timedOut?: boolean;
+}
+export type OperationObserverCommandRunner = (args: readonly string[], cwd: string, maxOutputBytes: number, timeoutMs: number) => OperationObserverCommandResult;
+export type OperationObserverRemoteCommandRunner = (executable: 'git' | 'gh', args: readonly string[], cwd: string, maxOutputBytes: number, timeoutMs: number) => OperationObserverRemoteCommandResult;
+export interface OperationObserverRemoteSnapshot {
+    readonly resourceIdentity: string;
+    readonly resourceRevisionIdentity: string;
+    readonly pullRequest?: {
+        readonly identity: string;
+        readonly state: 'open' | 'closed' | 'merged';
+    };
+    readonly checkState?: 'completed-success' | 'completed-failure' | 'pending';
+    readonly reviewDecision?: 'approved' | 'changes-requested' | 'commented' | 'pending';
+}
+export type OperationObserverRemoteResult = {
+    readonly status: 'available';
+    readonly snapshot: OperationObserverRemoteSnapshot;
+} | {
+    readonly status: 'missing-resource';
+} | {
+    readonly status: 'unavailable';
+    readonly reasonCode: OperationObserverReasonCode;
+};
+export interface OperationObserverLimits {
+    readonly maxCommandOutputBytes?: number;
+    readonly maxCommandTimeoutMs?: number;
+    readonly maxFiles?: number;
+    readonly maxTotalFileBytes?: number;
+    readonly maxPathBytes?: number;
+}
+export interface OperationObserverFileStat {
+    readonly isFile: boolean;
+    readonly isSymbolicLink: boolean;
+    readonly isDirectory: boolean;
+    readonly mode: number;
+    readonly size: number;
+}
+export interface OpencodeOperationObserverOptions {
+    readonly targetDirectory: string;
+    readonly commandRunner?: OperationObserverCommandRunner;
+    readonly remoteCommandRunner?: OperationObserverRemoteCommandRunner;
+    readonly fileReader?: (filePath: string) => Uint8Array;
+    readonly symlinkReader?: (filePath: string) => string;
+    readonly statReader?: (filePath: string) => OperationObserverFileStat;
+    readonly realPath?: (filePath: string) => string;
+    readonly limits?: OperationObserverLimits;
+}
+export interface OpencodeOperationObserver {
+    readonly targetDigest: string;
+    snapshot(): Promise<OperationObserverResult>;
+    remoteSnapshot?(operation: RemoteOperation, phase: RemoteReadbackPhase): Promise<OperationObserverRemoteResult>;
+}
+export declare function createOpencodeOperationObserver(options: OpencodeOperationObserverOptions): OpencodeOperationObserver;

package/dist/lib/opencode-workflow-guard.d.ts

@@ -0,0 +1,54 @@
+import type { ToolDefinition } from '@opencode-ai/plugin';
+import type { OpencodeOperationObserver } from './opencode-operation-observer.js';
+import type { ReceiptClassifier } from './receipt-classifier.js';
+import { type ReceiptLedger, type ReceiptOperation } from './receipt-ledger.js';
+import { type EvidenceObservationResult, type RuntimeUnitPolicy, type TransitionPrepareResult, type WorkflowReasonCode, type WorkflowStatus } from './workflow-guard.js';
+export declare const SYSTEMATIC_WORKFLOW_RECEIPT_METADATA_KEY = "systematic_workflow_receipt";
+export interface OpencodeWorkflowGuardConfig {
+    mode: 'observe' | 'protected' | 'disabled';
+    debug: boolean;
+}
+declare const WORKFLOW_GUARD_BLOCKED_ERROR_CODE = "workflow-guard-blocked";
+export type WorkflowGuardBlockedError = Error & {
+    readonly code: typeof WORKFLOW_GUARD_BLOCKED_ERROR_CODE;
+    readonly reasonCode: WorkflowReasonCode;
+};
+export declare function createWorkflowGuardBlockedError(reasonCode: WorkflowReasonCode): WorkflowGuardBlockedError;
+export declare function isWorkflowGuardBlockedError(value: unknown): value is WorkflowGuardBlockedError;
+export interface OpencodeWorkflowGuardOptions {
+    config: OpencodeWorkflowGuardConfig;
+    workspaceIdentity: string;
+    repositoryIdentity?: string;
+    worktreeIdentity?: string;
+    observer?: OpencodeOperationObserver;
+    classifier?: ReceiptClassifier;
+    runtimeRequiredOperations?: readonly ReceiptOperation[];
+    hostReadback?: OpencodeWorkflowHostReadback;
+    readonly registrationIdentity?: string;
+    readonly sessionSalt?: Uint8Array;
+}
+export interface OpencodeWorkflowChildSession {
+    readonly sessionId: string;
+    readonly parentID?: string;
+}
+export interface OpencodeWorkflowHostReadback {
+    readSessionParts(sessionID: string): Promise<ReadonlyArray<unknown>>;
+    listChildren(sessionID: string): Promise<ReadonlyArray<OpencodeWorkflowChildSession>>;
+}
+export interface OpencodeWorkflowGuardHooks {
+    'tool.execute.before': (input: unknown, output: unknown) => Promise<void>;
+    'tool.execute.after': (input: unknown, output: unknown) => Promise<void>;
+    event: (input: unknown) => Promise<void>;
+    'experimental.chat.system.transform': (input: unknown, output: unknown) => Promise<void>;
+}
+export interface OpencodeWorkflowGuard {
+    readonly tools: Readonly<Record<string, ToolDefinition>>;
+    readonly hooks: OpencodeWorkflowGuardHooks;
+    status(sessionID: unknown): WorkflowStatus;
+    ledger(sessionID: unknown): ReceiptLedger | undefined;
+    observeReceipt(sessionID: unknown, input: unknown): EvidenceObservationResult;
+    prepareTransition(sessionID: unknown, input: unknown): TransitionPrepareResult;
+    startUnit(sessionID: unknown, input: unknown, policy?: RuntimeUnitPolicy): unknown;
+}
+export declare function createOpencodeWorkflowGuard(options: OpencodeWorkflowGuardOptions): OpencodeWorkflowGuard;
+export {};

package/dist/lib/question-attestation.d.ts

@@ -0,0 +1,94 @@
+export declare const CANONICAL_QUESTION_WORDING: "Confirm the requested guarded transition.";
+export type QuestionPurpose = 'transition' | 'session-disablement';
+export type QuestionAnswerClassification = 'affirmative' | 'non-affirmative';
+export type QuestionAttestationReasonCode = 'already-bound' | 'already-consumed' | 'already-disabled' | 'call-session-mismatch' | 'challenge-expired' | 'challenge-consumed' | 'invalid-input' | 'no-attestation' | 'non-affirmative' | 'rejected' | 'replay' | 'scope-mismatch' | 'substitution' | 'unknown-challenge' | 'unknown-request';
+export interface QuestionAttestationOptions {
+    clock?: () => number;
+    maxChallengeAgeMs?: number;
+}
+export interface QuestionChallengeRecord {
+    readonly challengeId: string;
+    readonly sessionId: string;
+    readonly resourceDigest: string;
+    readonly transitionKey: string;
+    readonly purpose: QuestionPurpose;
+    readonly createdAt: number;
+    readonly question: {
+        readonly wording: typeof CANONICAL_QUESTION_WORDING;
+        readonly args: {
+            readonly challengeId: string;
+            readonly purpose: QuestionPurpose;
+            readonly resourceDigest: string;
+            readonly transitionKey: string;
+        };
+    };
+}
+export interface QuestionAttestation {
+    readonly purpose: QuestionPurpose;
+    readonly sessionId: string;
+    readonly resourceDigest: string;
+    readonly transitionKey: string;
+    readonly requestId: string;
+    readonly answer: 'affirmed';
+    readonly timestamp: number;
+    readonly consumption: 'available' | 'consumed';
+}
+export type ChallengeResult = {
+    readonly status: 'pending';
+    readonly challenge: QuestionChallengeRecord;
+} | RejectedResult;
+export type BindAskedResult = {
+    readonly status: 'bound';
+    readonly challengeId: string;
+    readonly requestId: string;
+} | RejectedResult;
+export type ObserveReplyResult = {
+    readonly status: 'accepted';
+    readonly attestation: QuestionAttestation;
+} | RejectedResult;
+export type ObserveRejectResult = {
+    readonly status: 'rejected';
+    readonly reasonCode: 'rejected';
+} | RejectedResult;
+export type ConsumeAttestationResult = {
+    readonly status: 'consumed';
+    readonly projection: 'attested' | 'disabled';
+    readonly attestation: QuestionAttestation;
+} | RejectedResult;
+export type QuestionAttestationProjection = KnownQuestionAttestationProjection | {
+    readonly status: 'unknown';
+    readonly reasonCode: QuestionAttestationReasonCode;
+};
+interface KnownQuestionAttestationProjection {
+    readonly status: 'pending' | 'bound' | 'attested' | 'denied' | 'disabled';
+    readonly challengeId: string;
+    readonly purpose: QuestionPurpose;
+    readonly sessionId: string;
+    readonly resourceDigest: string;
+    readonly transitionKey: string;
+    readonly requestId?: string;
+    readonly consumption?: 'available' | 'consumed';
+}
+export type SessionDisablementProjection = {
+    readonly status: 'enabled' | 'pending' | 'bound' | 'disabled';
+    readonly sessionId: string;
+} | {
+    readonly status: 'unknown';
+    readonly reasonCode: QuestionAttestationReasonCode;
+};
+export interface QuestionAttestationMachine {
+    challenge(input: unknown): ChallengeResult;
+    bindAsked(input: unknown): BindAskedResult;
+    observeReply(input: unknown): ObserveReplyResult;
+    observeReject(input: unknown): ObserveRejectResult;
+    consumeAttestation(input: unknown): ConsumeAttestationResult;
+    status(input: unknown): QuestionAttestationProjection;
+    sessionStatus(input: unknown): SessionDisablementProjection;
+}
+interface RejectedResult {
+    readonly status: 'rejected';
+    readonly reasonCode: QuestionAttestationReasonCode;
+}
+export declare function classifyQuestionAnswer(answer: unknown): QuestionAnswerClassification;
+export declare function createQuestionAttestation(options?: QuestionAttestationOptions): QuestionAttestationMachine;
+export {};

package/dist/lib/receipt-classifier.d.ts

@@ -0,0 +1,44 @@
+import type { ReceiptClassification, ReceiptContext, ReceiptObservationAfter, ReceiptOperation, TerminalObservation } from './receipt-ledger.js';
+export interface ReceiptClassificationInput {
+    command: string;
+    terminal: TerminalObservation;
+}
+export interface ReceiptClassifierOptions {
+    treeSitterWasmPath?: string;
+    bashWasmPath?: string;
+}
+export interface ReceiptClassifier {
+    classify(input: unknown): Promise<ReceiptClassification>;
+    classifyOperation?(input: unknown): Promise<ReceiptClassification>;
+    close(): Promise<void>;
+}
+export type ReceiptOperationTool = 'edit' | 'write' | 'apply-patch' | 'apply_patch' | 'bash' | 'git' | 'gh' | 'bun' | 'npm';
+export type PullRequestObservationState = 'open' | 'closed' | 'merged';
+export type CheckObservationState = 'completed-success' | 'completed-failure' | 'pending';
+export type ReviewObservationDecision = 'approved' | 'changes-requested' | 'commented' | 'pending';
+export interface ReceiptOperationContext extends ReceiptContext {
+    resourceRevisionIdentity?: string;
+}
+export interface ReceiptOperationAfter extends ReceiptObservationAfter {
+    commitClosure?: boolean;
+    pullRequest?: {
+        identity: string;
+        state: PullRequestObservationState;
+    };
+    resourceRevisionIdentity?: string;
+    checkState?: CheckObservationState;
+    reviewDecision?: ReviewObservationDecision;
+}
+export interface ReceiptOperationObservation {
+    callId: string;
+    operation: ReceiptOperation;
+    tool: ReceiptOperationTool;
+    command?: string;
+    context: ReceiptOperationContext;
+    after?: ReceiptOperationAfter;
+    terminal: TerminalObservation;
+}
+export declare function parseReceiptOperationAfter(input: unknown): ReceiptOperationAfter | undefined;
+export declare function parseReceiptOperationObservation(input: unknown): ReceiptOperationObservation | undefined;
+export declare function createReceiptClassifier(options?: ReceiptClassifierOptions): ReceiptClassifier;
+export type { ReceiptOperation };

package/dist/lib/receipt-ledger.d.ts

@@ -0,0 +1,139 @@
+import type { ReceiptDigestDomain, ReceiptReadbackFailureCategory, ReceiptReadbackProgression } from './receipt-readback.js';
+export declare const RECEIPT_SCHEMA_VERSION: 1;
+export declare const RECEIPT_PROTOCOL_VERSION: 1;
+export type ReceiptOperation = 'implementation' | 'verification' | 'commit' | 'push' | 'pr-creation' | 'check-readback' | 'review-readback';
+export type ReceiptClassificationOutcome = 'accepted' | 'rejected' | 'unavailable';
+export type ReceiptAttribution = 'runtime-verified' | 'unattributed';
+export type ReceiptResult = 'success' | 'failure' | 'unknown';
+export type ReceiptSideEffect = 'required' | 'not-required';
+export type TerminalStatus = 'success' | 'failure' | 'cancelled' | 'running' | 'unknown';
+export type TerminalOutput = 'empty' | 'non-empty' | 'unknown';
+export type DigestDomain = ReceiptDigestDomain;
+export type ReceiptReasonCode = 'already-consumed' | 'abandoned-observation' | 'ambiguous-attribution' | 'classification-rejected' | 'classification-unavailable' | 'call-context-conflict' | 'classifier-closed' | 'cross-registration-disputed' | 'capability-mismatch' | 'duplicate-finalization' | 'empty-result' | 'epoch-mismatch' | 'forbidden-field' | 'grammar-incompatible' | 'incomplete-envelope' | 'invalid-observation' | 'invalid-receipt' | 'invalid-terminal-result' | 'no-op-resource' | 'parser-asset-unavailable' | 'parser-failure' | 'prohibited-shell-shape' | 'successful-no-op' | 'terminal-failure' | 'terminal-cancelled' | 'terminal-running' | 'terminal-unknown' | 'unknown-envelope' | 'unknown-receipt' | 'unit-mismatch' | 'unchanged-worktree' | 'unchanged-worktree' | 'unsupported-command' | 'workspace-mismatch' | 'recognized-command';
+export interface ReceiptClassification {
+    outcome: ReceiptClassificationOutcome;
+    category: ReceiptOperation | null;
+    attribution: ReceiptAttribution;
+    result: ReceiptResult;
+    sideEffect: ReceiptSideEffect;
+    reasonCode: ReceiptReasonCode;
+}
+export interface ReceiptContext {
+    epochId: string;
+    unitId: string;
+    workspaceIdentity: string;
+    repositoryIdentity?: string;
+    worktreeIdentity?: string;
+    resourceIdentity?: string;
+}
+export interface ReceiptObservationAfter {
+    workspaceIdentity: string;
+    repositoryIdentity?: string;
+    worktreeIdentity?: string;
+    resourceIdentity?: string;
+}
+export interface TerminalObservation {
+    status: TerminalStatus;
+    output: TerminalOutput;
+    noOp: boolean;
+}
+export interface ReceiptLedgerOptions {
+    registrationIdentity?: string;
+    capabilityFlags?: readonly string[];
+    sessionSalt?: Uint8Array;
+}
+export interface ReceiptLedgerMetadata {
+    schemaVersion: typeof RECEIPT_SCHEMA_VERSION;
+    protocolVersion: typeof RECEIPT_PROTOCOL_VERSION;
+    registrationDigest: string;
+    capabilityFlags: readonly string[];
+}
+export interface CanonicalReceiptFields {
+    receiptId: string;
+    registrationDigest: string;
+    callDigest: string;
+    epochDigest: string;
+    unitDigest: string;
+    workspaceDigest: string;
+    repositoryDigest?: string;
+    worktreeDigest?: string;
+    resourceDigest?: string;
+    operation: ReceiptOperation;
+    result: 'success';
+    source: 'runtime-verified';
+    consumption: 'available' | 'consumed';
+    timestamp: number;
+}
+export interface ReceiptEnvelope {
+    schemaVersion: typeof RECEIPT_SCHEMA_VERSION;
+    protocolVersion: typeof RECEIPT_PROTOCOL_VERSION;
+    registrationDigest: string;
+    capabilityFlags: readonly string[];
+    compatibility: 'compatible';
+    canonical: CanonicalReceiptFields;
+}
+export type PrepareObservationResult = {
+    status: 'prepared';
+    preparationId: string;
+} | {
+    status: 'duplicate' | 'rejected';
+    reasonCode: ReceiptReasonCode;
+};
+export type FinalizeObservationResult = {
+    status: 'finalized';
+    receipt: ReceiptEnvelope;
+} | {
+    status: 'rejected';
+    reasonCode: ReceiptReasonCode;
+};
+export type AbandonObservationResult = {
+    status: 'abandoned';
+} | {
+    status: 'rejected';
+    reasonCode: ReceiptReasonCode;
+};
+export type ConsumeReceiptResult = {
+    status: 'consumed';
+    receipt: ReceiptEnvelope;
+} | {
+    status: 'rejected';
+    reasonCode: ReceiptReasonCode;
+};
+export type RecoverReceiptResult = {
+    status: 'recovered' | 'duplicate';
+    receipt: ReceiptEnvelope;
+} | {
+    status: 'rejected';
+    category: ReceiptReadbackFailureCategory;
+};
+export type RecoverReadbackResult = {
+    status: 'recovered' | 'duplicate';
+    receipts: readonly ReceiptEnvelope[];
+    progression: ReceiptReadbackProgression;
+} | {
+    status: 'rejected';
+    category: ReceiptReadbackFailureCategory;
+};
+export type EnvelopeValidationResult = {
+    compatibility: 'compatible';
+    envelope: ReceiptEnvelope;
+} | {
+    compatibility: 'unavailable' | 'rejected';
+    reasonCode: ReceiptReasonCode;
+};
+export interface ReceiptLedger {
+    readonly metadata: ReceiptLedgerMetadata;
+    digestIdentity(domain: DigestDomain, identity: string): string;
+    prepareObservation(input: unknown): PrepareObservationResult;
+    finalizeObservation(input: unknown): FinalizeObservationResult;
+    abandonObservation(input: unknown): AbandonObservationResult;
+    consumeReceipt(receiptId: unknown, context: unknown): ConsumeReceiptResult;
+    recoverReceipt(input: unknown): RecoverReceiptResult;
+    recoverReadback(input: readonly unknown[]): RecoverReadbackResult;
+    getProgressionState(): ReceiptReadbackProgression;
+    validateEnvelope(input: unknown): EnvelopeValidationResult;
+    getEnvelope(receiptId: unknown): ReceiptEnvelope | undefined;
+    listReceipts(): readonly ReceiptEnvelope[];
+    getSessionSalt(): Uint8Array;
+}
+export declare function createReceiptLedger(options?: ReceiptLedgerOptions): ReceiptLedger;

package/dist/lib/receipt-readback.d.ts

@@ -0,0 +1,164 @@
+import type { ReceiptEnvelope, ReceiptLedgerMetadata, ReceiptOperation } from './receipt-ledger.js';
+export declare const RECEIPT_READBACK_SCHEMA_VERSION: 1;
+export declare const RECEIPT_READBACK_PROTOCOL_VERSION: 1;
+export type ReceiptDigestDomain = 'repository' | 'worktree' | 'resource' | 'workspace' | 'epoch' | 'unit' | 'call' | 'registration';
+export type ReceiptProgressionStateName = 'started' | 'completed';
+export type ReceiptEpochFamily = 'work' | 'shipping';
+export interface ReceiptResourceScope {
+    readonly operation: ReceiptOperation;
+    readonly resourceIdentity: string;
+}
+export type ReceiptReadbackFailureCategory = 'malformed' | 'forbidden-field' | 'unknown-kind' | 'unknown-schema' | 'unknown-protocol' | 'unknown-capability' | 'integrity-mismatch' | 'missing-mint' | 'control-before-mint' | 'conflicting-marker' | 'out-of-order' | 'cross-registration' | 'capability-mismatch' | 'salt-mismatch' | 'receipt-mismatch' | 'progression-mismatch' | 'inconsistent-evidence' | 'missing-internal-id' | 'identity-digest-mismatch' | 'conflicting-seed' | 'missing-seed';
+export interface ReceiptMintMarker {
+    readonly kind: 'mint';
+    readonly schemaVersion: typeof RECEIPT_READBACK_SCHEMA_VERSION;
+    readonly protocolVersion: typeof RECEIPT_READBACK_PROTOCOL_VERSION;
+    readonly envelope: ReceiptEnvelope;
+    readonly sessionSalt: string;
+    readonly integrity: string;
+}
+export interface ReceiptConsumeMarker {
+    readonly kind: 'control';
+    readonly schemaVersion: typeof RECEIPT_READBACK_SCHEMA_VERSION;
+    readonly protocolVersion: typeof RECEIPT_READBACK_PROTOCOL_VERSION;
+    readonly registrationDigest: string;
+    readonly capabilityFlags: readonly string[];
+    readonly control: 'consume';
+    readonly receiptId: string;
+    readonly transitionDigest: string;
+    readonly timestamp: number;
+    readonly integrity: string;
+}
+export interface ReceiptEpochProgressionMarker {
+    readonly kind: 'control';
+    readonly schemaVersion: typeof RECEIPT_READBACK_SCHEMA_VERSION;
+    readonly protocolVersion: typeof RECEIPT_READBACK_PROTOCOL_VERSION;
+    readonly registrationDigest: string;
+    readonly capabilityFlags: readonly string[];
+    readonly control: 'progression';
+    readonly target: 'epoch';
+    readonly epochId: string;
+    readonly epochDigest: string;
+    readonly family: ReceiptEpochFamily;
+    readonly state: ReceiptProgressionStateName;
+    readonly transitionDigest: string;
+    readonly timestamp: number;
+    readonly sessionSalt: string;
+    readonly integrity: string;
+}
+export interface ReceiptUnitProgressionMarker {
+    readonly kind: 'control';
+    readonly schemaVersion: typeof RECEIPT_READBACK_SCHEMA_VERSION;
+    readonly protocolVersion: typeof RECEIPT_READBACK_PROTOCOL_VERSION;
+    readonly registrationDigest: string;
+    readonly capabilityFlags: readonly string[];
+    readonly control: 'progression';
+    readonly target: 'unit';
+    readonly epochId: string;
+    readonly epochDigest: string;
+    readonly unitId: string;
+    readonly unitDigest: string;
+    readonly family: ReceiptEpochFamily;
+    readonly requiredOperations: readonly ReceiptOperation[];
+    readonly resourceScopes: readonly ReceiptResourceScope[];
+    readonly state: ReceiptProgressionStateName;
+    readonly transitionDigest: string;
+    readonly timestamp: number;
+    readonly sessionSalt: string;
+    readonly integrity: string;
+}
+export type ReceiptProgressionMarker = ReceiptEpochProgressionMarker | ReceiptUnitProgressionMarker;
+export type ReceiptControlMarker = ReceiptConsumeMarker | ReceiptProgressionMarker;
+export type ReceiptMarker = ReceiptMintMarker | ReceiptControlMarker;
+export type ReceiptProgressionMarkerInput = {
+    readonly target: 'epoch';
+    readonly state: ReceiptProgressionStateName;
+    readonly epochId: string;
+    readonly family: ReceiptEpochFamily;
+    readonly transitionDigest: string;
+    readonly timestamp?: number;
+} | {
+    readonly target: 'unit';
+    readonly state: ReceiptProgressionStateName;
+    readonly epochId: string;
+    readonly unitId: string;
+    readonly family: ReceiptEpochFamily;
+    readonly requiredOperations: readonly ReceiptOperation[];
+    readonly resourceScopes: readonly ReceiptResourceScope[];
+    readonly transitionDigest: string;
+    readonly timestamp?: number;
+};
+export interface ReceiptProgressionProjectionSource {
+    readonly metadata: ReceiptLedgerMetadata | (() => ReceiptLedgerMetadata);
+    readonly getSessionSalt: () => Uint8Array;
+    readonly digestIdentity: (domain: ReceiptDigestDomain, identity: string) => string;
+}
+export interface ReceiptReadbackExpectation {
+    readonly registrationDigest: string;
+    readonly capabilityFlags: readonly string[];
+    readonly sessionSalt: Uint8Array;
+    readonly source?: 'runtime-verified';
+}
+export type ReceiptEpochProgressionSnapshot = {
+    readonly target: 'epoch';
+    readonly state: ReceiptProgressionStateName;
+    readonly epochId: string;
+    readonly epochDigest: string;
+    readonly family: ReceiptEpochFamily;
+    readonly transitionDigest: string;
+};
+export type ReceiptUnitProgressionSnapshot = {
+    readonly target: 'unit';
+    readonly state: ReceiptProgressionStateName;
+    readonly epochId: string;
+    readonly epochDigest: string;
+    readonly unitId: string;
+    readonly unitDigest: string;
+    readonly family: ReceiptEpochFamily;
+    readonly requiredOperations: readonly ReceiptOperation[];
+    readonly resourceScopes: readonly ReceiptResourceScope[];
+    readonly transitionDigest: string;
+};
+export type ReceiptProgressionSnapshot = ReceiptEpochProgressionSnapshot | ReceiptUnitProgressionSnapshot;
+export interface ReceiptReadbackProgression {
+    readonly epoch: ReceiptEpochProgressionSnapshot | null;
+    readonly unit: ReceiptUnitProgressionSnapshot | null;
+}
+export interface ReceiptReadbackState {
+    readonly registrationDigest: string;
+    readonly receipts: readonly ReceiptEnvelope[];
+    readonly progression: ReceiptReadbackProgression;
+}
+export type ReceiptMarkerValidation = {
+    readonly status: 'valid';
+    readonly marker: ReceiptMarker;
+} | {
+    readonly status: 'rejected';
+    readonly category: ReceiptReadbackFailureCategory;
+};
+export type ReceiptReadbackResult = {
+    readonly status: 'reconstructed';
+    readonly state: ReceiptReadbackState;
+} | {
+    readonly status: 'rejected';
+    readonly category: ReceiptReadbackFailureCategory;
+};
+export type ReceiptReadbackSeedResult = {
+    readonly status: 'empty';
+} | {
+    readonly status: 'ready';
+    readonly sessionSalt: Uint8Array;
+    readonly registrationDigest: string;
+    readonly capabilityFlags: readonly string[];
+} | {
+    readonly status: 'repair-required';
+    readonly category: ReceiptReadbackFailureCategory;
+};
+export declare function digestReceiptIdentity(domain: ReceiptDigestDomain, identity: string, sessionSalt: Uint8Array): string;
+export declare function validateReceiptMarker(input: unknown): ReceiptMarkerValidation;
+export declare function extractReceiptReadbackSeed(inputs: readonly unknown[]): ReceiptReadbackSeedResult;
+export declare function projectReceiptMintMarker(receipt: unknown, sessionSalt: Uint8Array): ReceiptMintMarker | undefined;
+export declare function projectReceiptConsumptionMarker(receipt: unknown, transitionDigest: string, timestamp?: number): ReceiptConsumeMarker | undefined;
+export declare function projectReceiptProgressionMarker(source: ReceiptProgressionProjectionSource, input: ReceiptProgressionMarkerInput): ReceiptProgressionMarker | undefined;
+export declare function foldReceiptReadback(inputs: readonly unknown[], expectation: ReceiptReadbackExpectation): ReceiptReadbackResult;
+export declare function receiptReadbackExpectationFromMetadata(metadata: ReceiptLedgerMetadata, sessionSalt: Uint8Array): ReceiptReadbackExpectation;