@sema-agent/core 7.48.0 → 7.49.1

package/dist/core/checkpoint-requirements.d.ts

@@ -0,0 +1,892 @@
+import type { AssertAllKeysHandled } from "./ask-origin.js";
+import { type StoreFidelity, type Checkpoint, type CheckpointFeature, type CheckpointGate, type PendingAction } from "./checkpoint-store.js";
+/**
+ * The closed set of reader-requirement words this engine knows. The first seven are the feature table's keys
+ * (the features that raised the row format before it froze); then the row digest's scheme; then the members a feature
+ * had carried beside the one its word now names, and the members added after the table, each a capability a reader
+ * must have. Downstream reads them for display only (`CheckpointError.detail.requires`).
+ */
+export declare const REQUIREMENT_WORDS: readonly ["resource", "binding", "token", "orgAdmission", "f012", "realApproval", "face", "requirements_digest", "org_admission_inherited", "org_write_grant", "org_governed", "delegation_provenance", "skill_grants", "skill_card_binding", "hands_coordinates", "hands_home", "path_rule_anchors", "path_rule_installations", "permission_mode", "plan_mode_restore", "persisted_rule_mandate", "deployment_authored", "call_names", "write_face", "denial_limit_fallback", "leg_scope", "tool_ceiling", "tool_lists_judged"];
+export type RequirementWord = (typeof REQUIREMENT_WORDS)[number];
+/** Runtime twin of {@link RequirementWord}. */
+export declare function isRequirementWord(word: unknown): word is RequirementWord;
+/** Every feature that raised the format is a word (the baseline is the floor, `requirements` the frame). */
+export type FeatureWordsAreRequirementWords = AssertAllKeysHandled<Exclude<Exclude<CheckpointFeature, "baseline" | "requirements">, RequirementWord>>;
+/** What one persisted member owes the reader. The row digest covers every member a decision reads — a word member
+ *  (a capability the reader must have) or a `digest` member (one every admitted reader already reads); a `mutable`
+ *  member is rewritten after the mint by the store's own transitions, so the static digest cannot hold it; an
+ *  `ignorable` member is shown and never decided. */
+export type RequirementClass = {
+    readonly word: RequirementWord;
+} | {
+    readonly digest: "decision-read";
+} | {
+    readonly mutable: string;
+} | {
+    readonly ignorable: string;
+} | {
+    readonly members: RequirementTable;
+} | {
+    readonly variants: {
+        readonly [kind: string]: RequirementTable;
+    };
+};
+export type RequirementTable = {
+    readonly [key: string]: RequirementClass;
+};
+/** A table over EVERY key of record `T` — a member left out is a compile error at the table. */
+export type RequirementTableFor<T> = {
+    readonly [K in keyof T]-?: RequirementClass;
+};
+/** One table per variant of the discriminated union `U` — a new kind, or a new member of any variant, is a compile
+ *  error. Each variant's `kind` entry classifies the kind itself. */
+export type RequirementVariantsFor<U extends {
+    kind: string;
+}> = {
+    readonly [K in U["kind"]]: RequirementTableFor<Extract<U, {
+        kind: K;
+    }>>;
+};
+/** The words a table's entries carry, read off its literal type (nested records and variants walked). */
+type WordsIn<C> = C extends {
+    readonly word: infer W;
+} ? W : C extends {
+    readonly members: infer M;
+} ? WordsOfTable<M> : C extends {
+    readonly variants: infer V;
+} ? WordsOfTable<V[keyof V]> : never;
+type WordsOfTable<T> = T extends unknown ? {
+    [K in keyof T]: WordsIn<T[K]>;
+}[keyof T] : never;
+export declare const INHERITED_GATE_REQUIREMENTS: {
+    readonly ancestorRules: {
+        readonly digest: "decision-read";
+    };
+    readonly shellGate: {
+        readonly digest: "decision-read";
+    };
+    readonly permissionMode: {
+        readonly word: "permission_mode";
+    };
+    readonly prePlanMode: {
+        readonly word: "plan_mode_restore";
+    };
+    readonly admittedOrgScopes: {
+        readonly word: "org_admission_inherited";
+    };
+    readonly ownAdmittedOrgScopes: {
+        readonly word: "orgAdmission";
+    };
+    readonly ownAdmittedOrgWriteScope: {
+        readonly word: "org_write_grant";
+    };
+    readonly orgAdmissionGoverned: {
+        readonly word: "org_governed";
+    };
+    readonly pathRuleAnchors: {
+        readonly word: "path_rule_anchors";
+    };
+    readonly pathRuleInstallations: {
+        readonly word: "path_rule_installations";
+    };
+    readonly requiresParentConstraint: {
+        readonly digest: "decision-read";
+    };
+    readonly parentConstraintCount: {
+        readonly digest: "decision-read";
+    };
+    readonly constraintChain: {
+        readonly word: "f012";
+    };
+    readonly constraintDigest: {
+        readonly word: "f012";
+    };
+};
+export declare const CHECKPOINT_STATE_REQUIREMENTS: {
+    readonly activeTools: {
+        readonly digest: "decision-read";
+    };
+    readonly outputRef: {
+        readonly digest: "decision-read";
+    };
+    readonly nestedStats: {
+        readonly digest: "decision-read";
+    };
+    readonly readFileState: {
+        readonly digest: "decision-read";
+    };
+    readonly readFace: {
+        readonly word: "face";
+    };
+    readonly writeFace: {
+        readonly word: "write_face";
+    };
+    readonly skillGrants: {
+        readonly word: "skill_grants";
+    };
+    readonly reminderMark: {
+        readonly digest: "decision-read";
+    };
+    readonly repairBundle: {
+        readonly digest: "decision-read";
+    };
+    readonly workspaceHandle: {
+        readonly digest: "decision-read";
+    };
+    readonly pendingSteerQueue: {
+        readonly mutable: "store state-machine member; integrity = CAS contract + kit, see #1580";
+    };
+    readonly runningBackgroundTasks: {
+        readonly digest: "decision-read";
+    };
+    readonly handsCwd: {
+        readonly digest: "decision-read";
+    };
+    readonly handsRoot: {
+        readonly word: "hands_coordinates";
+    };
+    readonly handsHome: {
+        readonly word: "hands_home";
+    };
+    readonly activeWorktree: {
+        readonly digest: "decision-read";
+    };
+    readonly inheritedGate: {
+        readonly members: {
+            readonly ancestorRules: {
+                readonly digest: "decision-read";
+            };
+            readonly shellGate: {
+                readonly digest: "decision-read";
+            };
+            readonly permissionMode: {
+                readonly word: "permission_mode";
+            };
+            readonly prePlanMode: {
+                readonly word: "plan_mode_restore";
+            };
+            readonly admittedOrgScopes: {
+                readonly word: "org_admission_inherited";
+            };
+            readonly ownAdmittedOrgScopes: {
+                readonly word: "orgAdmission";
+            };
+            readonly ownAdmittedOrgWriteScope: {
+                readonly word: "org_write_grant";
+            };
+            readonly orgAdmissionGoverned: {
+                readonly word: "org_governed";
+            };
+            readonly pathRuleAnchors: {
+                readonly word: "path_rule_anchors";
+            };
+            readonly pathRuleInstallations: {
+                readonly word: "path_rule_installations";
+            };
+            readonly requiresParentConstraint: {
+                readonly digest: "decision-read";
+            };
+            readonly parentConstraintCount: {
+                readonly digest: "decision-read";
+            };
+            readonly constraintChain: {
+                readonly word: "f012";
+            };
+            readonly constraintDigest: {
+                readonly word: "f012";
+            };
+        };
+    };
+    readonly announcedListings: {
+        readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+    };
+    readonly gitAnnouncement: {
+        readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+    };
+    readonly delegationProvenance: {
+        readonly word: "delegation_provenance";
+    };
+    readonly isDelegatedChild: {
+        readonly digest: "decision-read";
+    };
+    readonly placementRootSessionId: {
+        readonly digest: "decision-read";
+    };
+    readonly externalContentTarget: {
+        readonly digest: "decision-read";
+    };
+    readonly legScope: {
+        readonly word: "leg_scope";
+    };
+    readonly toolCeiling: {
+        readonly word: "tool_ceiling";
+    };
+    readonly toolListsJudged: {
+        readonly word: "tool_lists_judged";
+    };
+};
+export declare const PENDING_ACTION_REQUIREMENTS: {
+    readonly tool_approval: {
+        readonly kind: {
+            readonly word: "binding";
+        };
+        readonly toolCallId: {
+            readonly digest: "decision-read";
+        };
+        readonly toolName: {
+            readonly digest: "decision-read";
+        };
+        readonly args: {
+            readonly digest: "decision-read";
+        };
+        readonly preview: {
+            readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+        };
+        readonly previewWithheld: {
+            readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+        };
+        readonly ruleOffers: {
+            readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+        };
+        readonly ruleOffersAbsence: {
+            readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+        };
+        readonly execCwd: {
+            readonly digest: "decision-read";
+        };
+        readonly requiresRealApproval: {
+            readonly digest: "decision-read";
+        };
+        readonly mandated: {
+            readonly word: "persisted_rule_mandate";
+        };
+        readonly authoredBy: {
+            readonly word: "deployment_authored";
+        };
+        readonly mandate: {
+            readonly digest: "decision-read";
+        };
+        readonly denialLimitFallback: {
+            readonly word: "denial_limit_fallback";
+        };
+        readonly classifierNoRuling: {
+            readonly digest: "decision-read";
+        };
+        readonly origin: {
+            readonly digest: "decision-read";
+        };
+        readonly askClass: {
+            readonly digest: "decision-read";
+        };
+        readonly classes: {
+            readonly digest: "decision-read";
+        };
+        readonly boundInputHash: {
+            readonly digest: "decision-read";
+        };
+        readonly boundGrantDigest: {
+            readonly word: "skill_card_binding";
+        };
+        readonly boundGrants: {
+            readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+        };
+        readonly capabilityId: {
+            readonly digest: "decision-read";
+        };
+        readonly contractId: {
+            readonly digest: "decision-read";
+        };
+        readonly shapeDigest: {
+            readonly digest: "decision-read";
+        };
+        readonly implementationRevision: {
+            readonly digest: "decision-read";
+        };
+        readonly rosterDigest: {
+            readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+        };
+        readonly family: {
+            readonly digest: "decision-read";
+        };
+        readonly pathTarget: {
+            readonly digest: "decision-read";
+        };
+        readonly names: {
+            readonly word: "call_names";
+        };
+        readonly hasBidiControls: {
+            readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+        };
+        readonly batchToolCallIds: {
+            readonly digest: "decision-read";
+        };
+        readonly completedCallIds: {
+            readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+        };
+    };
+    readonly resource_limit: {
+        readonly kind: {
+            readonly digest: "decision-read";
+        };
+        readonly reason: {
+            readonly digest: "decision-read";
+        };
+    };
+    readonly review: {
+        readonly kind: {
+            readonly digest: "decision-read";
+        };
+    };
+    readonly plan_review: {
+        readonly kind: {
+            readonly word: "binding";
+        };
+    };
+    readonly task_done: {
+        readonly kind: {
+            readonly digest: "decision-read";
+        };
+    };
+};
+export type PendingRequirementsCoverEveryKind = AssertAllKeysHandled<Exclude<PendingAction["kind"], keyof typeof PENDING_ACTION_REQUIREMENTS>>;
+export declare const CHECKPOINT_GATE_REQUIREMENTS: {
+    readonly human: {
+        readonly kind: {
+            readonly digest: "decision-read";
+        };
+        readonly reason: {
+            readonly digest: "decision-read";
+        };
+        readonly toolName: {
+            readonly digest: "decision-read";
+        };
+        readonly approvalCard: {
+            readonly digest: "decision-read";
+        };
+        readonly riskDescriptor: {
+            readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+        };
+    };
+    readonly irreversible_ask: {
+        readonly kind: {
+            readonly digest: "decision-read";
+        };
+        readonly reason: {
+            readonly digest: "decision-read";
+        };
+        readonly toolName: {
+            readonly digest: "decision-read";
+        };
+        readonly approvalCard: {
+            readonly digest: "decision-read";
+        };
+        readonly safetyAxis: {
+            readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+        };
+        readonly realApproval: {
+            readonly word: "realApproval";
+        };
+        readonly riskDescriptor: {
+            readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+        };
+    };
+    readonly resource_limit: {
+        readonly kind: {
+            readonly word: "resource";
+        };
+        readonly reason: {
+            readonly digest: "decision-read";
+        };
+        readonly resumeAfterMs: {
+            readonly digest: "decision-read";
+        };
+    };
+    readonly needs_review: {
+        readonly kind: {
+            readonly digest: "decision-read";
+        };
+        readonly reason: {
+            readonly digest: "decision-read";
+        };
+    };
+    readonly plan_review: {
+        readonly kind: {
+            readonly digest: "decision-read";
+        };
+        readonly reason: {
+            readonly digest: "decision-read";
+        };
+    };
+    readonly task_done: {
+        readonly kind: {
+            readonly digest: "decision-read";
+        };
+    };
+};
+export type GateRequirementsCoverEveryKind = AssertAllKeysHandled<Exclude<CheckpointGate["kind"], keyof typeof CHECKPOINT_GATE_REQUIREMENTS>>;
+/** The row itself: its frame, its two records and its pause pair. */
+export declare const CHECKPOINT_REQUIREMENTS: {
+    readonly token: {
+        readonly digest: "decision-read";
+    };
+    readonly checkpointId: {
+        readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+    };
+    readonly version: {
+        readonly ignorable: "the format stamp itself";
+    };
+    readonly requires: {
+        readonly ignorable: "the format stamp itself";
+    };
+    readonly requirementsDigest: {
+        readonly word: "requirements_digest";
+    };
+    readonly scope: {
+        readonly digest: "decision-read";
+    };
+    readonly sessionId: {
+        readonly digest: "decision-read";
+    };
+    readonly leafId: {
+        readonly digest: "decision-read";
+    };
+    readonly state: {
+        readonly members: {
+            readonly activeTools: {
+                readonly digest: "decision-read";
+            };
+            readonly outputRef: {
+                readonly digest: "decision-read";
+            };
+            readonly nestedStats: {
+                readonly digest: "decision-read";
+            };
+            readonly readFileState: {
+                readonly digest: "decision-read";
+            };
+            readonly readFace: {
+                readonly word: "face";
+            };
+            readonly writeFace: {
+                readonly word: "write_face";
+            };
+            readonly skillGrants: {
+                readonly word: "skill_grants";
+            };
+            readonly reminderMark: {
+                readonly digest: "decision-read";
+            };
+            readonly repairBundle: {
+                readonly digest: "decision-read";
+            };
+            readonly workspaceHandle: {
+                readonly digest: "decision-read";
+            };
+            readonly pendingSteerQueue: {
+                readonly mutable: "store state-machine member; integrity = CAS contract + kit, see #1580";
+            };
+            readonly runningBackgroundTasks: {
+                readonly digest: "decision-read";
+            };
+            readonly handsCwd: {
+                readonly digest: "decision-read";
+            };
+            readonly handsRoot: {
+                readonly word: "hands_coordinates";
+            };
+            readonly handsHome: {
+                readonly word: "hands_home";
+            };
+            readonly activeWorktree: {
+                readonly digest: "decision-read";
+            };
+            readonly inheritedGate: {
+                readonly members: {
+                    readonly ancestorRules: {
+                        readonly digest: "decision-read";
+                    };
+                    readonly shellGate: {
+                        readonly digest: "decision-read";
+                    };
+                    readonly permissionMode: {
+                        readonly word: "permission_mode";
+                    };
+                    readonly prePlanMode: {
+                        readonly word: "plan_mode_restore";
+                    };
+                    readonly admittedOrgScopes: {
+                        readonly word: "org_admission_inherited";
+                    };
+                    readonly ownAdmittedOrgScopes: {
+                        readonly word: "orgAdmission";
+                    };
+                    readonly ownAdmittedOrgWriteScope: {
+                        readonly word: "org_write_grant";
+                    };
+                    readonly orgAdmissionGoverned: {
+                        readonly word: "org_governed";
+                    };
+                    readonly pathRuleAnchors: {
+                        readonly word: "path_rule_anchors";
+                    };
+                    readonly pathRuleInstallations: {
+                        readonly word: "path_rule_installations";
+                    };
+                    readonly requiresParentConstraint: {
+                        readonly digest: "decision-read";
+                    };
+                    readonly parentConstraintCount: {
+                        readonly digest: "decision-read";
+                    };
+                    readonly constraintChain: {
+                        readonly word: "f012";
+                    };
+                    readonly constraintDigest: {
+                        readonly word: "f012";
+                    };
+                };
+            };
+            readonly announcedListings: {
+                readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+            };
+            readonly gitAnnouncement: {
+                readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+            };
+            readonly delegationProvenance: {
+                readonly word: "delegation_provenance";
+            };
+            readonly isDelegatedChild: {
+                readonly digest: "decision-read";
+            };
+            readonly placementRootSessionId: {
+                readonly digest: "decision-read";
+            };
+            readonly externalContentTarget: {
+                readonly digest: "decision-read";
+            };
+            readonly legScope: {
+                readonly word: "leg_scope";
+            };
+            readonly toolCeiling: {
+                readonly word: "tool_ceiling";
+            };
+            readonly toolListsJudged: {
+                readonly word: "tool_lists_judged";
+            };
+        };
+    };
+    readonly resourceLedger: {
+        readonly members: {
+            readonly totalBudgetMicroUsd: {
+                readonly digest: "decision-read";
+            };
+            readonly totalTokens: {
+                readonly word: "token";
+            };
+            readonly spentMicroUsd: {
+                readonly digest: "decision-read";
+            };
+            readonly spentTokens: {
+                readonly digest: "decision-read";
+            };
+            readonly spentTurns: {
+                readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+            };
+            readonly spentWalltimeMs: {
+                readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+            };
+            readonly sliceCount: {
+                readonly digest: "decision-read";
+            };
+        };
+    };
+    readonly deadline: {
+        readonly digest: "decision-read";
+    };
+    readonly status: {
+        readonly mutable: "store state-machine member; integrity = CAS contract + kit, see #1580";
+    };
+    readonly createdAt: {
+        readonly digest: "decision-read";
+    };
+    readonly suspendCount: {
+        readonly digest: "decision-read";
+    };
+    readonly suspendedAt: {
+        readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+    };
+    readonly humanReview: {
+        readonly digest: "decision-read";
+    };
+    readonly resolvedOutcome: {
+        readonly mutable: "store state-machine member; integrity = CAS contract + kit, see #1580";
+    };
+    readonly reopenReason: {
+        readonly mutable: "store state-machine member; integrity = CAS contract + kit, see #1580";
+    };
+    readonly rev: {
+        readonly mutable: "store state-machine member; integrity = CAS contract + kit, see #1580";
+    };
+    readonly sourceTaskId: {
+        readonly digest: "decision-read";
+    };
+    readonly principal: {
+        readonly digest: "decision-read";
+    };
+    readonly durableApproval: {
+        readonly digest: "decision-read";
+    };
+    readonly executionOutcome: {
+        readonly mutable: "store state-machine member; integrity = CAS contract + kit, see #1580";
+    };
+    readonly executionAtMs: {
+        readonly mutable: "the store's time stamp on the execution record: it changes after the mint and decides nothing";
+    };
+    readonly gate: {
+        readonly variants: {
+            readonly human: {
+                readonly kind: {
+                    readonly digest: "decision-read";
+                };
+                readonly reason: {
+                    readonly digest: "decision-read";
+                };
+                readonly toolName: {
+                    readonly digest: "decision-read";
+                };
+                readonly approvalCard: {
+                    readonly digest: "decision-read";
+                };
+                readonly riskDescriptor: {
+                    readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+                };
+            };
+            readonly irreversible_ask: {
+                readonly kind: {
+                    readonly digest: "decision-read";
+                };
+                readonly reason: {
+                    readonly digest: "decision-read";
+                };
+                readonly toolName: {
+                    readonly digest: "decision-read";
+                };
+                readonly approvalCard: {
+                    readonly digest: "decision-read";
+                };
+                readonly safetyAxis: {
+                    readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+                };
+                readonly realApproval: {
+                    readonly word: "realApproval";
+                };
+                readonly riskDescriptor: {
+                    readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+                };
+            };
+            readonly resource_limit: {
+                readonly kind: {
+                    readonly word: "resource";
+                };
+                readonly reason: {
+                    readonly digest: "decision-read";
+                };
+                readonly resumeAfterMs: {
+                    readonly digest: "decision-read";
+                };
+            };
+            readonly needs_review: {
+                readonly kind: {
+                    readonly digest: "decision-read";
+                };
+                readonly reason: {
+                    readonly digest: "decision-read";
+                };
+            };
+            readonly plan_review: {
+                readonly kind: {
+                    readonly digest: "decision-read";
+                };
+                readonly reason: {
+                    readonly digest: "decision-read";
+                };
+            };
+            readonly task_done: {
+                readonly kind: {
+                    readonly digest: "decision-read";
+                };
+            };
+        };
+    };
+    readonly pendingAction: {
+        readonly variants: {
+            readonly tool_approval: {
+                readonly kind: {
+                    readonly word: "binding";
+                };
+                readonly toolCallId: {
+                    readonly digest: "decision-read";
+                };
+                readonly toolName: {
+                    readonly digest: "decision-read";
+                };
+                readonly args: {
+                    readonly digest: "decision-read";
+                };
+                readonly preview: {
+                    readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+                };
+                readonly previewWithheld: {
+                    readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+                };
+                readonly ruleOffers: {
+                    readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+                };
+                readonly ruleOffersAbsence: {
+                    readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+                };
+                readonly execCwd: {
+                    readonly digest: "decision-read";
+                };
+                readonly requiresRealApproval: {
+                    readonly digest: "decision-read";
+                };
+                readonly mandated: {
+                    readonly word: "persisted_rule_mandate";
+                };
+                readonly authoredBy: {
+                    readonly word: "deployment_authored";
+                };
+                readonly mandate: {
+                    readonly digest: "decision-read";
+                };
+                readonly denialLimitFallback: {
+                    readonly word: "denial_limit_fallback";
+                };
+                readonly classifierNoRuling: {
+                    readonly digest: "decision-read";
+                };
+                readonly origin: {
+                    readonly digest: "decision-read";
+                };
+                readonly askClass: {
+                    readonly digest: "decision-read";
+                };
+                readonly classes: {
+                    readonly digest: "decision-read";
+                };
+                readonly boundInputHash: {
+                    readonly digest: "decision-read";
+                };
+                readonly boundGrantDigest: {
+                    readonly word: "skill_card_binding";
+                };
+                readonly boundGrants: {
+                    readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+                };
+                readonly capabilityId: {
+                    readonly digest: "decision-read";
+                };
+                readonly contractId: {
+                    readonly digest: "decision-read";
+                };
+                readonly shapeDigest: {
+                    readonly digest: "decision-read";
+                };
+                readonly implementationRevision: {
+                    readonly digest: "decision-read";
+                };
+                readonly rosterDigest: {
+                    readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+                };
+                readonly family: {
+                    readonly digest: "decision-read";
+                };
+                readonly pathTarget: {
+                    readonly digest: "decision-read";
+                };
+                readonly names: {
+                    readonly word: "call_names";
+                };
+                readonly hasBidiControls: {
+                    readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+                };
+                readonly batchToolCallIds: {
+                    readonly digest: "decision-read";
+                };
+                readonly completedCallIds: {
+                    readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+                };
+            };
+            readonly resource_limit: {
+                readonly kind: {
+                    readonly digest: "decision-read";
+                };
+                readonly reason: {
+                    readonly digest: "decision-read";
+                };
+            };
+            readonly review: {
+                readonly kind: {
+                    readonly digest: "decision-read";
+                };
+            };
+            readonly plan_review: {
+                readonly kind: {
+                    readonly word: "binding";
+                };
+            };
+            readonly task_done: {
+                readonly kind: {
+                    readonly digest: "decision-read";
+                };
+            };
+        };
+    };
+};
+/** ONE word list: the closed set is exactly the words the tables carry — every table word is a member (each entry is
+ *  typed against the set) and every member is carried by some entry (this fence), both at compile time. */
+export type RequirementWordsAreTheTablesWords = AssertAllKeysHandled<Exclude<RequirementWord, WordsOfTable<typeof CHECKPOINT_REQUIREMENTS>>>;
+/** The words a row's content carries — a word for every word member present on it — sorted, without repeats.
+ *  The ONE derivation: the mint writes it, the resume screen recomputes it. Total (a non-record reads as none). */
+export declare function checkpointRequirementsFor(cp: Checkpoint): RequirementWord[];
+/** A member a decision reads whose value the digest cannot encode: where it sits, and what it holds. */
+export interface UnencodableMember {
+    readonly path: string;
+    readonly kind: "cycle" | "depth" | "function" | "symbol" | "unreadable" | "codec";
+}
+/** Where a value holds something the row digest cannot encode, or `undefined` — the park mint asks this of the
+ *  arguments before any side effect, so such a call is refused before anything is paused. */
+export declare function unencodableIn(value: unknown, path: string): UnencodableMember | undefined;
+/** The row digest: sha256 (hex) over the binding serializer's canonical form ({@link canonicalize}: type-tagged,
+ *  sorted keys) of every member a decision reads but the digest itself, keyed by path, each read through
+ *  {@link digestProjection}. Never a constant: a value it cannot encode throws {@link RowNotEncodable}. */
+export declare function requirementsDigestOf(cp: Checkpoint): string;
+/** The one stamp: the row AS THE STORE AT `fidelity` HANDS IT BACK (the commit stamps with its store's declared
+ *  fidelity, and writes exactly the row returned here), with the frozen version, the row digest of that reading and
+ *  the words derived from it (the digest's word among them) — so a reader digests exactly what it read. A row that
+ *  store's codec or the digest cannot encode is returned WITHOUT a digest, so it fails its own judge — which the
+ *  commit asks before the write. */
+export declare function stampCheckpointRequirements(row: Checkpoint, fidelity: StoreFidelity): Checkpoint;
+/** The row as the store at `fidelity` hands it back, judged — the commit's question before the write. */
+export declare function judgeAsStored(cp: Checkpoint, fidelity: StoreFidelity): CheckpointRequirementsVerdict;
+/** The resume screen's reading of a row's requirement list. */
+export type CheckpointRequirementsVerdict = {
+    readonly kind: "ok";
+} | {
+    readonly kind: "lacking";
+    readonly words: readonly string[];
+} | {
+    readonly kind: "damaged";
+    readonly why: string;
+};
+/**
+ * Judge a row's requirement list and digest against this engine and against the row's content, before the claim.
+ *  - below v10: neither the list nor the digest may be present (no release of those versions wrote one);
+ *  - v10: the list must be an array of strings; a word this engine lacks ⇒ `lacking` (a newer row); the digest's word
+ *    must be declared (every v10 mint writes it); the words this engine knows must EQUAL the recomputed words; the
+ *    digest must EQUAL the recomputed digest — a lost member, a lost element, a changed value is damage.
+ * Rows above v10 never reach it (the version ceiling refuses them first). Reads `requires` and the digest once each.
+ */
+export declare function judgeCheckpointRequirements(cp: Checkpoint): CheckpointRequirementsVerdict;
+export {};