@githolon/runtime 0.113.4 → 0.115.0

package/src/protocol/nomos/kernel/v1/kernel_pb.d.ts

@@ -714,6 +714,25 @@ export declare type OfferAdmitted = Message<"nomos.kernel.v1.OfferAdmitted"> & {
    * @generated from field: bool already_applied = 12;
    */
   alreadyApplied: boolean;
+
+  /**
+   * What this offer changed in the workspace's current state, typed the way reads resolve it, so a
+   * host can tell which declared reads the offer can change (CAP-760). Absent when the kernel cannot
+   * say exactly; a host then treats every read as changed.
+   *
+   * @generated from field: optional nomos.kernel.v1.OfferStateChange state_change = 13;
+   */
+  stateChange?: OfferStateChange | undefined;
+
+  /**
+   * CAP-811: this offer installed, staged or promoted law whose claimed version is equal to or lower
+   * than the claim this workspace already serves for the same law identity (package name). Advice
+   * only: the offer was admitted, and the warning never enters custody. Empty when either side claims
+   * no version (era rule), when the identity was not served, or when the claim moves forward.
+   *
+   * @generated from field: repeated nomos.kernel.v1.LawVersionWarning law_version_warnings = 14;
+   */
+  lawVersionWarnings: LawVersionWarning[];
 };
 
 /**
@@ -722,6 +741,146 @@ export declare type OfferAdmitted = Message<"nomos.kernel.v1.OfferAdmitted"> & {
  */
 export declare const OfferAdmittedSchema: GenMessage<OfferAdmitted>;
 
+/**
+ * A law's identity: its package name (/Nomos/Package nomos:name) (CAP-809, CAP-811).
+ *
+ * @generated from message nomos.kernel.v1.LawIdentity
+ */
+export declare type LawIdentity = Message<"nomos.kernel.v1.LawIdentity"> & {
+  /**
+   * @generated from field: string package_name = 1;
+   */
+  packageName: string;
+};
+
+/**
+ * Describes the message nomos.kernel.v1.LawIdentity.
+ * Use `create(LawIdentitySchema)` to create a new message.
+ */
+export declare const LawIdentitySchema: GenMessage<LawIdentity>;
+
+/**
+ * One version of a law: its closure identity, a canonical lowercase SHA-256 digest (CAP-809).
+ *
+ * @generated from message nomos.kernel.v1.LawVersion
+ */
+export declare type LawVersion = Message<"nomos.kernel.v1.LawVersion"> & {
+  /**
+   * @generated from field: string closure_sha256 = 1;
+   */
+  closureSha256: string;
+};
+
+/**
+ * Describes the message nomos.kernel.v1.LawVersion.
+ * Use `create(LawVersionSchema)` to create a new message.
+ */
+export declare const LawVersionSchema: GenMessage<LawVersion>;
+
+/**
+ * A semver 2.0 claim without build metadata, as authored in nomos.project.ts (CAP-811).
+ *
+ * @generated from message nomos.kernel.v1.LawVersionClaim
+ */
+export declare type LawVersionClaim = Message<"nomos.kernel.v1.LawVersionClaim"> & {
+  /**
+   * @generated from field: string semver = 1;
+   */
+  semver: string;
+};
+
+/**
+ * Describes the message nomos.kernel.v1.LawVersionClaim.
+ * Use `create(LawVersionClaimSchema)` to create a new message.
+ */
+export declare const LawVersionClaimSchema: GenMessage<LawVersionClaim>;
+
+/**
+ * An install that does not move its law's claimed version forward (CAP-811).
+ *
+ * @generated from message nomos.kernel.v1.LawVersionWarning
+ */
+export declare type LawVersionWarning = Message<"nomos.kernel.v1.LawVersionWarning"> & {
+  /**
+   * @generated from field: nomos.kernel.v1.LawIdentity law = 1;
+   */
+  law?: LawIdentity | undefined;
+
+  /**
+   * @generated from field: nomos.kernel.v1.LawVersionOrder order = 2;
+   */
+  order: LawVersionOrder;
+
+  /**
+   * @generated from field: nomos.kernel.v1.LawVersionClaim installed_claim = 3;
+   */
+  installedClaim?: LawVersionClaim | undefined;
+
+  /**
+   * @generated from field: nomos.kernel.v1.LawVersion installed_version = 4;
+   */
+  installedVersion?: LawVersion | undefined;
+
+  /**
+   * @generated from field: nomos.kernel.v1.LawVersionClaim served_claim = 5;
+   */
+  servedClaim?: LawVersionClaim | undefined;
+
+  /**
+   * @generated from field: nomos.kernel.v1.LawVersion served_version = 6;
+   */
+  servedVersion?: LawVersion | undefined;
+
+  /**
+   * Human-readable summary of the same facts.
+   *
+   * @generated from field: string message = 7;
+   */
+  message: string;
+};
+
+/**
+ * Describes the message nomos.kernel.v1.LawVersionWarning.
+ * Use `create(LawVersionWarningSchema)` to create a new message.
+ */
+export declare const LawVersionWarningSchema: GenMessage<LawVersionWarning>;
+
+/**
+ * The aggregates one admitted offer changed, by the type a read resolves for each (its `__type`,
+ * else its id), between the head it was admitted on and the head it produced. Exact or wider,
+ * never narrower: every aggregate whose state differs between the two heads is counted.
+ *
+ * @generated from message nomos.kernel.v1.OfferStateChange
+ */
+export declare type OfferStateChange = Message<"nomos.kernel.v1.OfferStateChange"> & {
+  /**
+   * The head this offer was admitted on; OfferAdmitted.head is its child.
+   *
+   * @generated from field: string parent_head = 1;
+   */
+  parentHead: string;
+
+  /**
+   * Sorted, without duplicates.
+   *
+   * @generated from field: repeated string aggregate_types = 2;
+   */
+  aggregateTypes: string[];
+
+  /**
+   * An aggregate this offer changed may be absent (archived) at the new head.
+   *
+   * @generated from field: bool archives = 3;
+   */
+  archives: boolean;
+};
+
+/**
+ * Describes the message nomos.kernel.v1.OfferStateChange.
+ * Use `create(OfferStateChangeSchema)` to create a new message.
+ */
+export declare const OfferStateChangeSchema: GenMessage<OfferStateChange>;
+
 /**
  * @generated from message nomos.kernel.v1.OfferAggregateRef
  */
@@ -1052,6 +1211,16 @@ export declare type OfferBlockedOnDependency = Message<"nomos.kernel.v1.OfferBlo
    * @generated from field: nomos.kernel.v1.NomosStruct diagnostics = 3;
    */
   diagnostics?: NomosStruct | undefined;
+
+  /**
+   * Present only when the kernel itself found that a read the authored plan made needs a
+   * derivative only background maintenance builds (CAP-824): the exact workspace position owed.
+   * Not a verdict of law. The same offer, made again once maintenance has repaid it, is judged.
+   * Absent for every other blocked dependency; a peer never infers it from `detail`.
+   *
+   * @generated from field: nomos.kernel.v1.ReadIndexPending awaits_maintenance = 4;
+   */
+  awaitsMaintenance?: ReadIndexPending | undefined;
 };
 
 /**
@@ -1922,6 +2091,17 @@ export declare type QueryResponse = Message<"nomos.kernel.v1.QueryResponse"> & {
      */
     value: InstalledLawDeclarationsResponse;
     case: "installedLawDeclarations";
+  } | {
+    /**
+     * Incremental answer to a RowsQuery carrying `since_frontier` (CAP-731). The kernel computed
+     * it from the exact state change set between the two read positions, under the same read
+     * policies, principal and visibility as a full read. Merging it into the result read at
+     * `base_frontier` yields, byte for byte, the full result at `frontier`.
+     *
+     * @generated from field: nomos.kernel.v1.ApplicationResultDelta application_result_delta = 31;
+     */
+    value: ApplicationResultDelta;
+    case: "applicationResultDelta";
   } | { case: undefined; value?: undefined };
 
   /**
@@ -1932,6 +2112,32 @@ export declare type QueryResponse = Message<"nomos.kernel.v1.QueryResponse"> & {
    * @generated from field: nomos.kernel.v1.VerifyChainDiagnostics verify_chain_diagnostics = 20;
    */
   verifyChainDiagnostics?: VerifyChainDiagnostics | undefined;
+
+  /**
+   * The kernel-issued read position of a complete `application_result` for a declared rows
+   * query. Opaque to every caller: only the kernel interprets it, when it comes back as
+   * `RowsQuery.since_frontier`. Absent on every other result.
+   *
+   * @generated from field: optional string result_frontier = 32;
+   */
+  resultFrontier?: string | undefined;
+
+  /**
+   * Why a RowsQuery that asked for a delta (`since_frontier`) was answered in full. Present only
+   * on such answers; a real failure is a Failure, never a reason.
+   *
+   * @generated from field: optional nomos.kernel.v1.FullResultReason full_result_reason = 33;
+   */
+  fullResultReason?: FullResultReason | undefined;
+
+  /**
+   * What can change the answer of a declared rows query at its read position (CAP-760): present
+   * beside `result_frontier` or an `application_result_delta` when the kernel can name it exactly.
+   * Absent means anything may change it.
+   *
+   * @generated from field: optional nomos.kernel.v1.ReadDependencies result_dependencies = 34;
+   */
+  resultDependencies?: ReadDependencies | undefined;
 };
 
 /**
@@ -1940,6 +2146,85 @@ export declare type QueryResponse = Message<"nomos.kernel.v1.QueryResponse"> & {
  */
 export declare const QueryResponseSchema: GenMessage<QueryResponse>;
 
+/**
+ * The state a declared rows result reads, from the installed read law. A state change touching none
+ * of it leaves the next delta from this result's position empty. Exact or wider, never narrower.
+ *
+ * @generated from message nomos.kernel.v1.ReadDependencies
+ */
+export declare type ReadDependencies = Message<"nomos.kernel.v1.ReadDependencies"> & {
+  /**
+   * Aggregate types (as OfferStateChange.aggregate_types names them) whose state the rows, their
+   * membership or the read law come from. Sorted, without duplicates.
+   *
+   * @generated from field: repeated string aggregate_types = 1;
+   */
+  aggregateTypes: string[];
+
+  /**
+   * A combined field reads a related row by reference: an archive of any aggregate may change it.
+   *
+   * @generated from field: bool reads_archives = 2;
+   */
+  readsArchives: boolean;
+
+  /**
+   * The commit whose state this answer shows (as OfferStateChange.parent_head names a head).
+   *
+   * @generated from field: string read_at = 3;
+   */
+  readAt: string;
+};
+
+/**
+ * Describes the message nomos.kernel.v1.ReadDependencies.
+ * Use `create(ReadDependenciesSchema)` to create a new message.
+ */
+export declare const ReadDependenciesSchema: GenMessage<ReadDependencies>;
+
+/**
+ * The rows of one declared query that changed between two kernel-issued read positions.
+ *
+ * @generated from message nomos.kernel.v1.ApplicationResultDelta
+ */
+export declare type ApplicationResultDelta = Message<"nomos.kernel.v1.ApplicationResultDelta"> & {
+  /**
+   * The position the caller's result must be at (the request's `since_frontier`).
+   *
+   * @generated from field: string base_frontier = 1;
+   */
+  baseFrontier: string;
+
+  /**
+   * The position this delta advances it to; the next request's `since_frontier`.
+   *
+   * @generated from field: string frontier = 2;
+   */
+  frontier: string;
+
+  /**
+   * Every added or changed visible row, encoded with the SAME `QueryResult_<identity>` contract as
+   * the full result (rows sorted by id; no page metadata), so generated decoders decode it.
+   *
+   * @generated from field: google.protobuf.Any changed_rows = 3;
+   */
+  changedRows?: Any | undefined;
+
+  /**
+   * Ids that no longer belong to the result. Sorted, disjoint from `changed_rows`; an id the
+   * caller never held is a no-op.
+   *
+   * @generated from field: repeated string removed_ids = 4;
+   */
+  removedIds: string[];
+};
+
+/**
+ * Describes the message nomos.kernel.v1.ApplicationResultDelta.
+ * Use `create(ApplicationResultDeltaSchema)` to create a new message.
+ */
+export declare const ApplicationResultDeltaSchema: GenMessage<ApplicationResultDelta>;
+
 /**
  * OpenAPI is already a JSON document, not a tenant value or a recursive NomosValue tree.
  * Intermediate runtimes forward it without parsing/reconstructing every schema property.
@@ -1967,6 +2252,15 @@ export declare type InterfaceCompatibilityQuery = Message<"nomos.kernel.v1.Inter
    * @generated from field: bytes application_matrix_usda = 1;
    */
   applicationMatrixUsda: Uint8Array;
+
+  /**
+   * RELEASE QUALIFICATION (CAP-789): judge the matrix against the law this workspace would serve once
+   * these carried units were staged and promoted (composed exactly as that STAGE would compose them at
+   * this frontier), instead of the law it serves now. Nothing is written and no verdict is retained.
+   *
+   * @generated from field: repeated nomos.kernel.v1.LawUnit candidate_units = 2;
+   */
+  candidateUnits: LawUnit[];
 };
 
 /**
@@ -2039,6 +2333,13 @@ export declare type InterfaceCompatibilityResponse = Message<"nomos.kernel.v1.In
    * @generated from field: string workspace_frontier = 3;
    */
   workspaceFrontier: string;
+
+  /**
+   * The closure the carried candidate units composed to; empty when the installed law was judged.
+   *
+   * @generated from field: string candidate_hash = 4;
+   */
+  candidateHash: string;
 };
 
 /**
@@ -2150,6 +2451,42 @@ export declare type MaintenanceQuantumQuery = Message<"nomos.kernel.v1.Maintenan
    * @generated from field: bool read_index_only = 6;
    */
   readIndexOnly: boolean;
+
+  /**
+   * The idle pin quantum: pin the live positions the current raw frontier index
+   * does not serve (normally the admitted frontier behind unsynced local
+   * writes), once per position, and prune every other addressed derivative in
+   * bounded batches. No reader waits on it, so the host sends it only after the
+   * workspace has been write-idle for a quiet window, never during a burst.
+   * Exclusive of the other modes; maintenance_pending asks for another quantum.
+   *
+   * @generated from field: bool maintain_addressed_frontiers = 7;
+   */
+  maintainAddressedFrontiers: boolean;
+
+  /**
+   * The durability flush quantum (CAP-746). Under the deferred durability policy a save forces
+   * nothing to stable storage; the kernel owes every file it wrote to one ordered flush (objects,
+   * then refs, then disposable SQLite, then a last-known-good marker per workspace). The host
+   * decides WHEN (after a short write-quiet window, bounded during a long burst); the kernel
+   * decides WHAT, and flushes everything it owes, whichever workspace the quantum names. A no-op
+   * under the synchronous policy. Exclusive of the other modes; maintenance_pending asks for
+   * another quantum.
+   *
+   * @generated from field: bool flush_durability = 8;
+   */
+  flushDurability: boolean;
+
+  /**
+   * The peer's local writes are in a burst (CAP-750). Packing loose custody objects waits for the
+   * person to pause, so the host sends a custody quantum (maintain_git_custody) during a burst
+   * only after the kernel reported loose_custody_pressure. The kernel then packs one small slice of
+   * loose objects and does nothing else in that quantum: no staged-pack promotion, no multi-pack
+   * index or repack step, no command warming.
+   *
+   * @generated from field: bool local_write_burst = 9;
+   */
+  localWriteBurst: boolean;
 };
 
 /**
@@ -2216,6 +2553,15 @@ export declare type MaintenanceQuantumResponse = Message<"nomos.kernel.v1.Mainte
    * @generated from field: optional string prepared_command_selector = 11;
    */
   preparedCommandSelector?: string | undefined;
+
+  /**
+   * The loose objects this kernel instance has written and not yet packed exceed the growth guard
+   * (CAP-750). Reported on every maintenance quantum, so a host holding custody packing back for a
+   * burst learns when an endless burst must pack in small slices after all.
+   *
+   * @generated from field: bool loose_custody_pressure = 12;
+   */
+  looseCustodyPressure: boolean;
 };
 
 /**
@@ -3106,6 +3452,16 @@ export declare type SyncResponse = Message<"nomos.kernel.v1.SyncResponse"> & {
    * @generated from field: repeated string parked_local_refs = 14;
    */
   parkedLocalRefs: string[];
+
+  /**
+   * The replay spent its `replay_offer_budget` before finishing (CAP-757). Nothing was published:
+   * live main is unchanged and `head` is still the live head. The kernel keeps its private
+   * candidate; the same request again continues it from the next offer. Every other field is
+   * empty until the answer that completes the replay.
+   *
+   * @generated from field: bool replay_pending = 15;
+   */
+  replayPending: boolean;
 };
 
 /**
@@ -5138,6 +5494,16 @@ export declare type RowsQuery = Message<"nomos.kernel.v1.RowsQuery"> & {
    * @generated from field: google.protobuf.Any application_arguments = 5;
    */
   applicationArguments?: Any | undefined;
+
+  /**
+   * Opt-in incremental read (CAP-731): the `result_frontier` (or delta `frontier`) of the result
+   * the caller holds for this exact query and arguments. The kernel answers with an
+   * `application_result_delta` from that position, or with the full result and a typed
+   * `full_result_reason`. Only valid with the application Protobuf result format.
+   *
+   * @generated from field: optional string since_frontier = 6;
+   */
+  sinceFrontier?: string | undefined;
 };
 
 /**
@@ -5500,6 +5866,18 @@ export declare type FrontierTransitionRequest = Message<"nomos.kernel.v1.Frontie
    * @generated from field: optional string restore_previous_of = 5;
    */
   restorePreviousOf?: string | undefined;
+
+  /**
+   * RELEASE QUALIFICATION (CAP-789): the candidate carried as law units instead of named as a staged
+   * closure. The kernel admits each unit from its content, places and composes them exactly as a STAGE
+   * carrying them would at this frontier, and judges the same transition. It writes nothing: no stage, no
+   * custody object, no ref. When set, candidate_hash must equal the composed identity (the response names
+   * it either way). The answer is qualification evidence only: promotion still needs the candidate staged
+   * and judged again at the then-current frontier. Not with restore_previous_of.
+   *
+   * @generated from field: repeated nomos.kernel.v1.LawUnit candidate_units = 6;
+   */
+  candidateUnits: LawUnit[];
 };
 
 /**
@@ -6145,6 +6523,17 @@ export declare type SyncRequest = Message<"nomos.kernel.v1.SyncRequest"> & {
    * @generated from field: uint64 parked_at_millis = 5;
    */
   parkedAtMillis: bigint;
+
+  /**
+   * The most offers (incoming and local) this call judges before it answers `replay_pending`
+   * (CAP-757). Receiving a backlog is then bounded steps the host interleaves with foreground
+   * work, never one call that holds the kernel for the whole backlog. Absent or 0 replays
+   * everything in one call, as before. Local writes made between steps are rebased in the same
+   * replay; anything else that moves live main starts it again.
+   *
+   * @generated from field: uint32 replay_offer_budget = 6;
+   */
+  replayOfferBudget: number;
 };
 
 /**
@@ -6180,6 +6569,28 @@ export declare type KernelConfigurationRequest = Message<"nomos.kernel.v1.Kernel
    * @generated from field: optional bool trusts_custodian_history = 2;
    */
   trustsCustodianHistory?: boolean | undefined;
+
+  /**
+   * A peer property, not law (CAP-746): this peer is a personal device whose saves acknowledge
+   * once their writes reach the OS. The kernel forces nothing to stable storage on the hot path
+   * and owes it to an ordered background flush (MaintenanceQuantumQuery.flush_durability); a
+   * reopen after an unclean shutdown returns main to the last flushed head if its newer custody
+   * is unreadable and rebuilds unsynced disposable indexes. Absent or false keeps synchronous
+   * durability (the cloud custodian). Immutable once set.
+   *
+   * @generated from field: optional bool deferred_durability = 3;
+   */
+  deferredDurability?: boolean | undefined;
+
+  /**
+   * Observability only, never law: this host counts the host calls it services into the kernel's
+   * per-offer phase ledger (kernel/src/offer_phases.rs). The kernel answers with the ledger's
+   * address in its own linear memory; the host adds one call and its nanoseconds there for every
+   * host call, and reads the finished offer line back from the same block. Changes no judgment.
+   *
+   * @generated from field: bool host_call_ledger = 4;
+   */
+  hostCallLedger: boolean;
 };
 
 /**
@@ -6196,6 +6607,13 @@ export declare type KernelConfigurationResponse = Message<"nomos.kernel.v1.Kerne
    * @generated from field: nomos.kernel.v1.Acknowledged result = 1;
    */
   result?: Acknowledged | undefined;
+
+  /**
+   * Present when the request asked for `host_call_ledger`: the ledger block's linear-memory address.
+   *
+   * @generated from field: optional uint32 host_call_ledger = 2;
+   */
+  hostCallLedger?: number | undefined;
 };
 
 /**
@@ -6773,6 +7191,31 @@ export declare type PackDeltaRequest = Message<"nomos.kernel.v1.PackDeltaRequest
    * @generated from field: optional string staged_pack_file = 5;
    */
   stagedPackFile?: string | undefined;
+
+  /**
+   * A SHALLOW pack instead of a delta (architecture/peer_catchup.md), with no `base`: the commits
+   * within `depth` generations of `head`, each with its complete tree, objects ordered by id
+   * (deterministic bytes). depth 1 is a checkpoint: the frontier state at `head`.
+   *
+   * @generated from field: optional uint32 depth = 6;
+   */
+  depth?: number | undefined;
+
+  /**
+   * With `depth`: `head` is a shallow boundary the receiver holds. Its commit and tree are omitted
+   * and the `depth` generations below it are packed: one lazy-history slice.
+   *
+   * @generated from field: bool below_head = 7;
+   */
+  belowHead: boolean;
+
+  /**
+   * With `depth` and not `below_head`: more heads packed beside `head` at the same depth (the
+   * settled-letter outcome commits a checkpoint carries).
+   *
+   * @generated from field: repeated string also_heads = 8;
+   */
+  alsoHeads: string[];
 };
 
 /**
@@ -6809,6 +7252,16 @@ export declare type ApplyPackRequest = Message<"nomos.kernel.v1.ApplyPackRequest
      */
     value: string;
     case: "stagedPackFile";
+  } | {
+    /**
+     * Continue the import this repository has pending (CAP-806): the one a request with
+     * `work_budget_bytes` began and answered `import_pending`. It carries no pack, head or
+     * boundary; the import keeps those of the request that began it.
+     *
+     * @generated from field: bool continue_pending = 8;
+     */
+    value: boolean;
+    case: "continuePending";
   } | { case: undefined; value?: undefined };
 
   /**
@@ -6829,6 +7282,18 @@ export declare type ApplyPackRequest = Message<"nomos.kernel.v1.ApplyPackRequest
    * @generated from field: repeated string unshallow = 6;
    */
   unshallow: string[];
+
+  /**
+   * At most about this many bytes of work (hashing, inflating, decoding, rewriting) in this call
+   * (CAP-806). When the pack needs more, the kernel keeps the import's progress, publishes
+   * nothing and answers `import_pending`; `continue_pending` continues it. A host interleaves the
+   * steps with its user's reads and offers, so a large import never holds the kernel for its
+   * whole length. A new pack for the same repository discards a pending import. Absent or 0: the
+   * whole pack in one call, as before.
+   *
+   * @generated from field: uint64 work_budget_bytes = 7;
+   */
+  workBudgetBytes: bigint;
 };
 
 /**
@@ -6891,6 +7356,16 @@ export declare type IntentsAboveRequest = Message<"nomos.kernel.v1.IntentsAboveR
    * @generated from field: bool compact_stored = 7;
    */
   compactStored: boolean;
+
+  /**
+   * With `base` and a nonzero `limit`: the `limit` commits immediately ABOVE base, oldest first,
+   * rather than the newest `limit` below head. A bounded continuation from a boundary the
+   * receiver already holds; only the selected commits' changes are read. Refused when base is
+   * not on head's first-parent chain.
+   *
+   * @generated from field: bool from_base = 8;
+   */
+  fromBase: boolean;
 };
 
 /**
@@ -8623,6 +9098,28 @@ export declare type PackDeltaResponse = Message<"nomos.kernel.v1.PackDeltaRespon
    * @generated from field: uint64 bytes = 2;
    */
   bytes: bigint;
+
+  /**
+   * A shallow pack only: the commits whose parents it omits, and what it holds.
+   *
+   * @generated from field: repeated string shallow = 3;
+   */
+  shallow: string[];
+
+  /**
+   * @generated from field: uint32 commits = 4;
+   */
+  commits: number;
+
+  /**
+   * @generated from field: uint32 trees = 5;
+   */
+  trees: number;
+
+  /**
+   * @generated from field: uint32 blobs = 6;
+   */
+  blobs: number;
 };
 
 /**
@@ -8652,6 +9149,21 @@ export declare type ApplyPackResponse = Message<"nomos.kernel.v1.ApplyPackRespon
    * @generated from field: optional nomos.kernel.v1.PhysicalClosureCheck closure = 3;
    */
   closure?: PhysicalClosureCheck | undefined;
+
+  /**
+   * The import spent its `work_budget_bytes` before finishing (CAP-806). Nothing is published;
+   * every other field is empty until the step that completes it.
+   *
+   * @generated from field: bool import_pending = 4;
+   */
+  importPending: boolean;
+
+  /**
+   * Bytes of work the import has done so far, across its steps.
+   *
+   * @generated from field: uint64 work_done_bytes = 5;
+   */
+  workDoneBytes: bigint;
 };
 
 /**
@@ -9799,6 +10311,33 @@ export declare type HistoryRequired = Message<"nomos.kernel.v1.HistoryRequired">
  */
 export declare const HistoryRequiredSchema: GenMessage<HistoryRequired>;
 
+/**
+ * How an installed claim orders against the claim already served for its identity (CAP-811).
+ *
+ * @generated from enum nomos.kernel.v1.LawVersionOrder
+ */
+export enum LawVersionOrder {
+  /**
+   * @generated from enum value: LAW_VERSION_ORDER_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: LAW_VERSION_ORDER_EQUAL = 1;
+   */
+  EQUAL = 1,
+
+  /**
+   * @generated from enum value: LAW_VERSION_ORDER_LOWER = 2;
+   */
+  LOWER = 2,
+}
+
+/**
+ * Describes the enum nomos.kernel.v1.LawVersionOrder.
+ */
+export declare const LawVersionOrderSchema: GenEnum<LawVersionOrder>;
+
 /**
  * @generated from enum nomos.kernel.v1.BirthOutcomeStatus
  */
@@ -10150,6 +10689,79 @@ export enum KernelRefusalCode {
  */
 export declare const KernelRefusalCodeSchema: GenEnum<KernelRefusalCode>;
 
+/**
+ * Typed premise for answering a delta request with the complete result.
+ *
+ * @generated from enum nomos.kernel.v1.FullResultReason
+ */
+export enum FullResultReason {
+  /**
+   * @generated from enum value: FULL_RESULT_REASON_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * The request named no base position.
+   *
+   * @generated from enum value: FULL_RESULT_REASON_NO_BASE = 1;
+   */
+  NO_BASE = 1,
+
+  /**
+   * The installed law changed between the two positions.
+   *
+   * @generated from enum value: FULL_RESULT_REASON_LAW_CHANGED = 2;
+   */
+  LAW_CHANGED = 2,
+
+  /**
+   * The principal, or the workspace-wide grant the read relied on, changed.
+   *
+   * @generated from enum value: FULL_RESULT_REASON_READ_AUTHORITY_CHANGED = 3;
+   */
+  READ_AUTHORITY_CHANGED = 3,
+
+  /**
+   * The principal reads this type record by record; visibility is not a function of the rows.
+   *
+   * @generated from enum value: FULL_RESULT_REASON_PER_RECORD_REFUSAL = 4;
+   */
+  PER_RECORD_REFUSAL = 4,
+
+  /**
+   * An ordered read is selected by its declared order and limit, not by membership.
+   *
+   * @generated from enum value: FULL_RESULT_REASON_ORDERED_READ = 5;
+   */
+  ORDERED_READ = 5,
+
+  /**
+   * The rows carry clock-derived fields whose value changes without a state change.
+   *
+   * @generated from enum value: FULL_RESULT_REASON_TEMPORAL_FIELDS = 6;
+   */
+  TEMPORAL_FIELDS = 6,
+
+  /**
+   * This replica no longer holds the base position's state.
+   *
+   * @generated from enum value: FULL_RESULT_REASON_BASE_UNAVAILABLE = 7;
+   */
+  BASE_UNAVAILABLE = 7,
+
+  /**
+   * One of the positions predates the state-tree format, which has no exact change set.
+   *
+   * @generated from enum value: FULL_RESULT_REASON_LEGACY_STATE = 8;
+   */
+  LEGACY_STATE = 8,
+}
+
+/**
+ * Describes the enum nomos.kernel.v1.FullResultReason.
+ */
+export declare const FullResultReasonSchema: GenEnum<FullResultReason>;
+
 /**
  * VINTF-inspired compatibility algebra over Nomos's canonical OpenUSD law.
  * The application matrix is USDA; Protobuf carries only the closed request and