@githolon/runtime 0.113.3 → 0.114.0

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

@@ -714,6 +714,15 @@ 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;
 };
 
 /**
@@ -722,6 +731,42 @@ export declare type OfferAdmitted = Message<"nomos.kernel.v1.OfferAdmitted"> & {
  */
 export declare const OfferAdmittedSchema: GenMessage<OfferAdmitted>;
 
+/**
+ * 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
  */
@@ -1922,6 +1967,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 +1988,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 +2022,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.
@@ -2150,6 +2311,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 +2413,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 +3312,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 +5354,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;
 };
 
 /**
@@ -6145,6 +6371,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 +6417,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 +6455,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;
 };
 
 /**
@@ -6891,6 +7157,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;
 };
 
 /**
@@ -10150,6 +10426,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