@engramx/idl 0.16.0-rc.2 → 0.16.0-rc.21

package/dist/engram.idl.d.ts

@@ -7,15 +7,17 @@ export interface About {
   guardianCount: bigint;
   totalMemoryWrites: bigint;
   lastAgentWriteAtNs: [] | [bigint];
-  distinctReaderPrincipals: bigint;
   lastWriteAtNs: [] | [bigint];
   totalBackupSize: bigint;
   backupCount: bigint;
+  endedAgentCount: [] | [bigint];
   lastAgentReadAtNs: [] | [bigint];
   firstWriteAtNs: [] | [bigint];
   agentCount: bigint;
+  activeAgentCount: [] | [bigint];
   paidMemoryReadEnabled: boolean;
   version: string;
+  timersPausedSinceDayNs: [] | [bigint];
   paymentsFrozen: boolean;
   agentMemoryWrites: bigint;
   agentMemoryReads: bigint;
@@ -24,7 +26,6 @@ export interface About {
   firstAgentWriteAtNs: [] | [bigint];
   lastReadAtNs: [] | [bigint];
   writesPaused: boolean;
-  distinctReaderClients: bigint;
   totalMemoryReads: bigint;
   walletActivatedAtNs: [] | [bigint];
   encryptionEnabled: boolean;
@@ -56,6 +57,15 @@ export interface AgentEnding {
   day: bigint;
   reason: AgentEndReason;
 }
+export interface AgentGrant {
+  key: Principal;
+  permissions: AgentPermissions;
+  name: string;
+  paymentsStoppedBy: [] | [PaymentsStop];
+  paymentsFrozen: [] | [boolean];
+  paymentsNow: [] | [PaymentsNow];
+  paymentLimits: PaymentLimits;
+}
 export interface AgentPaymentSignatures {
   agent: Principal;
   signedToday: bigint;
@@ -86,6 +96,16 @@ export interface AgentRecord {
   keyRotatedAtNs: bigint;
   keyHeldFrom: LogPosition;
 }
+export interface AgentSpendRow {
+  agent: Principal;
+  spentToday: [] | [bigint];
+  root: Principal;
+  maxPerDay: [] | [bigint];
+}
+export interface AgentSpendToday {
+  dayStartNs: bigint;
+  agents: Page_23;
+}
 export type AgentStatus = { Active: null } | { Resigned: null } | { Revoked: null };
 export interface AgentWriteReview {
   cursor: bigint;
@@ -125,10 +145,15 @@ export interface AnchorPushStatus {
   currentTotal: bigint;
   timerTickAtNs: [] | [bigint];
   okTotal: bigint;
+  checkInIntervalSeconds: [] | [bigint];
   carrierArmedAtNs: bigint;
   attemptAtNs: [] | [bigint];
   skipCursor: bigint;
+  timersPauseReason: [] | [string];
   lastError: string;
+  nextCheckInDueAtNs: [] | [bigint];
+  timersPausedAtNs: [] | [bigint];
+  nextAnchorAttemptAtNs: [] | [bigint];
 }
 export interface ApprovalRequest {
   id: string;
@@ -177,6 +202,11 @@ export interface BackupMetadata {
   chunkCount: bigint;
   parentBackupId: [] | [string];
 }
+export interface BackupRetention {
+  maxBackups: bigint;
+  isDefault: boolean;
+  dbType: string;
+}
 export interface BackupRetentionReport {
   maxBackups: bigint;
   dbType: string;
@@ -201,6 +231,30 @@ export interface BearerToken {
   issuedBy: Principal;
 }
 export type BearerTokenStatus = { Active: null } | { Revoked: null } | { Expired: null };
+export interface BirthRecord {
+  bornAtNs: bigint;
+  parentFingerprint: [] | [Uint8Array | number[]];
+  child: Principal;
+  secret: Uint8Array | number[];
+  version: bigint;
+  number: bigint;
+  parent: [] | [Principal];
+}
+export interface BrakePull {
+  by: Principal;
+  atNs: bigint;
+  role: BrakeRole;
+  reason: [] | [string];
+}
+export type BrakeRole = { Guardian: null } | { Owner: null };
+export interface BrakeState {
+  on: boolean;
+  pull: [] | [BrakePull];
+}
+export interface Brakes {
+  payments: BrakeState;
+  writes: BrakeState;
+}
 export interface CallerSignatureCount {
   count: bigint;
   role: Role;
@@ -216,7 +270,7 @@ export interface CertifiedAuditHead {
 }
 export interface CheckpointPage {
   firstAvailableSeq: bigint;
-  page: Page_15;
+  page: Page_18;
   scannedThroughSeq: bigint;
 }
 export interface ChildAllowanceRow {
@@ -282,6 +336,11 @@ export interface Eip3009Authorization {
   nonce: Uint8Array | number[];
   validBefore: bigint;
 }
+export interface Eip712Destination {
+  activeFromNs: bigint;
+  value: string;
+}
+export type Eip712FieldRule = { mustEqual: string } | { atMost: { max: bigint; decimals: bigint } };
 export interface Eip712Registration {
   encodeTypeString: string;
   cooloffEndsAtNs: bigint;
@@ -294,6 +353,25 @@ export interface Eip712SignatureOut {
   rendered: string;
   digest: Uint8Array | number[];
 }
+export interface Eip712TypeView {
+  primaryType: string;
+  encodeTypeString: string;
+  cooloffEndsAtNs: bigint;
+  domainName: string;
+  typeId: Uint8Array | number[];
+  verifyingContract: string;
+  dailySignCap: bigint;
+  fields: Array<[string, string]>;
+  domainSeparator: Uint8Array | number[];
+  destinationFields: Array<string>;
+  authorityClass: AuthorityClass;
+  typeHash: Uint8Array | number[];
+  registeredAtNs: bigint;
+  fieldRules: Array<[string, Eip712FieldRule]>;
+  chainId: bigint;
+  domainVersion: string;
+  ackIrrevocable: boolean;
+}
 export type Eip712Value =
   | { string: string }
   | { bool: boolean }
@@ -335,11 +413,18 @@ export interface Engram {
    * / test/key-replacement.test.mo runs it; this body names no roster gate, because the caller holds
    * / no role here until the move.
    */
-  acceptAgentKeyNomination: ActorMethod<[Principal], Result_70>;
+  acceptAgentKeyNomination: ActorMethod<[Principal], Result_83>;
   /**
    * / Consensus transform for the alert webhook outcall: collapse the response to status-only so
    * / replicas agree regardless of response headers/body (we only care that the POST landed 2xx).
    * /
+   * / ⟨CORRECTED 2026-10-21⟩ No longer a consensus transform: the alert outcall is non-replicated
+   * / (`is_replicated = ?false` in `scanAndPost`), so ONE node sends the POST and runs this on its
+   * / own response — there are no replicas to agree, and "on every replica" below now means "on that
+   * / node". It stays so the response is collapsed to status-only before the engram reads it. The
+   * / PUBLIC reasoning below is unchanged: the outcall protocol still calls it with no caller identity.
+   * / `worldIdTransform` is still a true consensus transform (World ID stays replicated).
+   * /
    * / PUBLIC: not a choice. The management canister invokes a transform on every replica as part of
    * / the HTTP-outcall protocol, and that invocation carries no caller identity to gate on — a gate
    * / here would refuse the only caller there is and break every alert this canister sends. Safe
@@ -349,10 +434,35 @@ export interface Engram {
     [{ context: Uint8Array | number[]; response: HttpRequestResult }],
     HttpRequestResult
   >;
+  /**
+   * / Owner-managed destination allowlist (D7). Additions LOOSEN and wait 24h; removals TIGHTEN
+   * / and apply instantly — the ratified asymmetry, applied to the one mutable policy surface.
+   * /
+   * / ⟨2026-10-14, the owner's ruling 4A⟩ ONE LIST PER REGISTERED ACTION. `addEvmWithdrawDestination`,
+   * / `removeEvmWithdrawDestination` and `listEvmWithdrawDestinations` — one list for every action —
+   * / are REMOVED; these three take the action's `typeId`. Same rules, per action: the owner only; an
+   * / addition activates after 24 hours and is refused while payments are frozen; a removal is instant
+   * / and works while frozen; a value is 1–128 characters (an address, or a venue value such as an
+   * / account name). The action must be registered: a destination list belongs to an action, and a
+   * / list for no action would be a value nothing checks. The caller is the owner's app.
+   */
+  addEip712Destination: ActorMethod<[Uint8Array | number[], string], Result_82>;
   /**
    * / Register a typed-data shape as signable. Owner-only, freeze-gated (a registration is a grant
    * / of FUTURE authority — a frozen engram must not be able to widen what it can sign), and the
    * / shape is IMMUTABLE: any change mints a new typeId.
+   * /
+   * / ⟨2026-10-14, the owner's rulings 3A and 5A⟩ ONE BAR FOR EVERY REGISTRATION — the class the owner
+   * / names is stored as a label and decides nothing. Every registration: records the irrevocability
+   * / acknowledgement (`ackIrrevocable = true`); has no opaque field (`bytes`, `bytes1..32`); names at
+   * / least one destination field OR carries a must-equal rule; passes the watchers — an owner alert
+   * / webhook set, enabled AND with its money class on, and an `#Active` guardian holding
+   * / `canFreezePayments`; and waits `Eip712Policy.COOLOFF_NS` (72 hours). It may carry per-field
+   * / rules (`fieldRules`: "at most N" read as a plain decimal with D places, "must equal X"), which
+   * / are part of the registered shape — inside the typeId, stored in `eip712FieldRules`, enforced in
+   * / `eip712SignFor` before the cap reservation. Before this, a withdrawal registered as `#standard`
+   * / needed no webhook, no guardian and no destination field, waited one hour, and signed to any
+   * / address. Intrinsic checks still come first and the watchers last (the 2026-08-06 re-ordering).
    */
   addEip712Type: ActorMethod<
     [
@@ -365,18 +475,14 @@ export interface Engram {
         fields: Array<[string, string]>;
         destinationFields: Array<string>;
         authorityClass: { standingAuthority: null } | { valueBearing: null } | { standard: null };
+        fieldRules: Array<[string, Eip712FieldRule]>;
         chainId: bigint;
         domainVersion: string;
         ackIrrevocable: boolean;
       },
     ],
-    Result_69
+    Result_81
   >;
-  /**
-   * / Owner-managed destination allowlist (D7). Additions LOOSEN and wait 24h; removals TIGHTEN
-   * / and apply instantly — the ratified asymmetry, applied to the one mutable policy surface.
-   */
-  addEvmWithdrawDestination: ActorMethod<[string], Result_68>;
   /**
    * / ⟨0.16.0, L1⟩ THE ROLE-CONFLICT ARM, and why three refusals here are not the same refusal.
    * /
@@ -387,7 +493,18 @@ export interface Engram {
    * / permitted but this engram's state says no — the principal already holds an incompatible role,
    * / or the roster is full. Only the last is worth an agent's time to resolve.
    */
-  addGuardian: ActorMethod<[Principal, string, GuardianPermissions], Result_1>;
+  addGuardian: ActorMethod<[Principal, string, GuardianPermissions], Result_2>;
+  /**
+   * / ⟨2026-10-21, the owner's round-11 answer b⟩ OWNER-ONLY: put a note on any entry of this
+   * / engram's record — words, nothing else. Appends a chained `record.note` entry
+   * / (`about=<id> note=<words>`) and keeps the note for `listRecordNotes`; answers the new entry's
+   * / id. The entry noted may be any entry ever appended (`about` below the head), including one the
+   * / ring no longer holds in full. An agent, a guardian, a stranger and the anonymous caller are
+   * / refused by `requireOwner`'s own words. Empty words, words over `RecordWords.WORDS_MAX` or
+   * / holding a line break are `#Invalid`; an id past the head is `#NotFound`; nothing is recorded
+   * / on any refusal.
+   */
+  addRecordNote: ActorMethod<[bigint, string], Result_14>;
   /**
    * / Returns the write RECEIPT, not just the version.
    * /
@@ -422,7 +539,7 @@ export interface Engram {
    * / is exactly what a guardian pause exists to hold. No action alert is raised: the operation is
    * / owner-initiated, owner-only, and already chained into the audit log.
    */
-  applyCondense: ActorMethod<[bigint], Result_67>;
+  applyCondense: ActorMethod<[bigint], Result_80>;
   /**
    * / Owner-only: activate a guardian who has registered against an invite.
    * /
@@ -433,7 +550,7 @@ export interface Engram {
    * / `#Conflict("Guardian is already active")` when there is nothing to do — the refusal says the
    * / state the caller asked for is the state that holds, rather than pretending it acted.
    */
-  approveGuardian: ActorMethod<[Principal], Result_1>;
+  approveGuardian: ActorMethod<[Principal], Result_2>;
   /**
    * / Owner-only: approve one pending over-limit request, letting the agent retry the operation
    * / its policy refused.
@@ -456,13 +573,13 @@ export interface Engram {
    * / no longer pending — already approved, denied or expired. The status is in the message because
    * / "not pending" is the one refusal here an owner acts on differently depending on which it is.
    */
-  approveRequest: ActorMethod<[string], Result_1>;
+  approveRequest: ActorMethod<[string], Result_2>;
   /**
    * / Discard a backup started by `backupInit` and never finalized. The way out of a failed upload,
    * / and the reason a stalled one need not occupy space indefinitely. Same gate as the rest of the
    * / write half: owner, or an agent holding `canAppendMemory`.
    */
-  backupAbort: ActorMethod<[string], Result_1>;
+  backupAbort: ActorMethod<[string], Result_2>;
   /**
    * / Close a backup started by `backupInit` and mark it usable.
    * /
@@ -477,7 +594,7 @@ export interface Engram {
    * / It does NOT verify the `sha256` declared at init; see that method for what the digest is and
    * / is not.
    */
-  backupFinalize: ActorMethod<[string], Result_1>;
+  backupFinalize: ActorMethod<[string], Result_2>;
   /**
    * / Begin a chunked backup upload. Returns the `backupId` every later call in the sequence needs.
    * /
@@ -502,7 +619,7 @@ export interface Engram {
    * /
    * / The write half also refuses while writes are PAUSED.
    */
-  backupInit: ActorMethod<[string, BackupType, [] | [string], string, [] | [string]], Result_43>;
+  backupInit: ActorMethod<[string, BackupType, [] | [string], string, [] | [string]], Result_53>;
   /**
    * / Read one chunk of a finalized backup, by index.
    * /
@@ -510,13 +627,13 @@ export interface Engram {
    * / `canAppendMemory`. Holding one says nothing about the other, deliberately: taking a backup and
    * / carrying it away are different authorities.
    */
-  backupPullChunk: ActorMethod<[string, bigint], Result_59>;
-  backupPushChunk: ActorMethod<[string, bigint, Uint8Array | number[]], Result_1>;
+  backupPullChunk: ActorMethod<[string, bigint], Result_69>;
+  backupPushChunk: ActorMethod<[string, bigint, Uint8Array | number[]], Result_2>;
   /**
    * / The OWNER cancels an agent's pending key nomination; the agent keeps its current key. Refused
    * / by name when the agent is unknown or has nothing pending — never a silent success.
    */
-  cancelAgentKeyNomination: ActorMethod<[Principal], Result_1>;
+  cancelAgentKeyNomination: ActorMethod<[Principal], Result_2>;
   /**
    * / Close a session the caller paid for: settle what was consumed, refund the remainder.
    * /
@@ -524,7 +641,7 @@ export interface Engram {
    * / and `forceCloseSession` were on the MARKET, which is withheld, and whose escrow subaccount is
    * / under a different principal entirely, so its close could never have reached these funds.
    */
-  closeSession: ActorMethod<[string], Result_1>;
+  closeSession: ActorMethod<[string], Result_2>;
   /**
    * / Convert the engram's OWN earned ckUSDC/ckUSDT into its OWN cycles, via the cashier — the
    * / engram-self top-up path. Owner-only; per-call cap + cooldown (irreversible); NOT freeze-gated
@@ -548,7 +665,7 @@ export interface Engram {
    * / pair — e6 base units of the token named first. A name only: Candid passes arguments by
    * / position, so nothing on the wire moved.
    */
-  convertEarningsToCycles: ActorMethod<[string, bigint], Result_8>;
+  convertEarningsToCycles: ActorMethod<[string, bigint], Result_14>;
   /**
    * / Owner-only: mint a single-use invite code an agent redeems with `pairAgent`.
    * /
@@ -567,8 +684,18 @@ export interface Engram {
    * /
    * / A principal that is already a GUARDIAN cannot become an agent — a guardian is an
    * / independent check on agents, so one wallet must not hold both.
+   * /
+   * / ⟨2026-10-29, the owner's ruling "a"⟩ `name` MAY BE EMPTY (or only whitespace): the agent is then
+   * / named after its key when it pairs — "agent-" and the key's first five characters, e.g.
+   * / "agent-hsffu" (`People.nameAtPairing` says why five, and the first). ⟨2026-10-29, later, beside "its key"⟩ Its
+   * / PERMANENT key (the root it enrolled with), not the key that pairs, so the name stays right across
+   * / a key replacement and matches the app's "Copy permanent key". A name the owner gives
+   * / always wins. Before this an empty name was refused, so an app that wanted no name had to invent
+   * / one ("agent"), and two agents read alike.
+   * / ⟨2026-10-29, review F7⟩ A name the owner gives meets the rule `renameAgent` applies: a line break
+   * / or another control character is `#Invalid` (`People.nameRefusal`), as a rename to it would be.
    */
-  createAgentInvite: ActorMethod<[string, AgentPermissions], Result_43>;
+  createAgentInvite: ActorMethod<[string, AgentPermissions], Result_53>;
   /**
    * / Owner-only: mint an invite for a GUARDIAN — an independent check on agents, not a
    * / co-owner and not a recovery agent.
@@ -592,7 +719,7 @@ export interface Engram {
    * / So an invite that fails to redeem for that reason is not a bad code. The rule exists because
    * / a check must be independent of the thing it checks.
    */
-  createGuardianInvite: ActorMethod<[string, GuardianPermissions], Result_43>;
+  createGuardianInvite: ActorMethod<[string, GuardianPermissions], Result_53>;
   /**
    * / OWNER-ONLY deletion of a stored backup.
    * /
@@ -605,7 +732,7 @@ export interface Engram {
    * / `backupAbort` is the agent's way out of a failed UPLOAD; it discards something never
    * / finalized. This removes a finished backup, which is a different act on a different object.
    */
-  deleteBackup: ActorMethod<[string], Result_1>;
+  deleteBackup: ActorMethod<[string], Result_2>;
   /**
    * / ⟨0.16.0, census §10 item 16⟩ RETURNS A REAL RECEIPT, not `R<()>`. The receipt was already
    * / being computed and written into the audit line — `receiptSuffix(r)` — and then discarded, so
@@ -625,38 +752,25 @@ export interface Engram {
    * / `#NotFound` for an unknown id and `#Conflict` when the request is no longer pending, and it
    * / does not change the policy — the next request over the same limit will be raised again.
    */
-  denyRequest: ActorMethod<[string, string], Result_1>;
+  denyRequest: ActorMethod<[string, string], Result_2>;
   /**
-   * / Force the tECDSA derivation and return the address.
-   * /
-   * / It exists because the gateway's own derivation fires from a timer that is lazy on some
-   * / replicas, and until it lands the EVM quote advertises the `0x0` fallback and settle fails
-   * / closed — a live money surface quoting an address that cannot receive.
+   * / ⟨2026-10-21, the owner's round-11 answer c⟩ A NEW GUARDIAN POWER, words only: an ACTIVE
+   * / guardian disputes an agent's write. It never moves money, stops anything or changes a grant.
+   * / Appends a chained `record.dispute` entry (`about=<id> reason=<words>`) and keeps the dispute
+   * / for `listGuardianDisputes`; answers the new entry's id. NOT ALERTED, deliberately: a
+   * / `guardian.*` operation would fall in the alerts' #guardian class, and which entries reach a
+   * / phone is the held alerts round's to decide (`ActionAlerts.classify` answers null for
+   * / `record.*`). The owner sees it on the record's Disputes tab.
    * /
-   * / ⟨0.16.0, B-2⟩ Derivation now comes from `EvmIdentity`, and the return type carries the
-   * / outcome: this used to answer `""` on failure, which is a Text a caller can and did paste into
-   * / a payment flow. An empty string is not an address, and saying so is the difference between a
-   * / failed derivation and an address of nothing.
-   * /
-   * / ⚠ TRANSITIONAL: it also primes the ic402 gate, because the gate still settles commerce on this
-   * / canister until those 47 methods move. That second call disappears with them — it is listed in
-   * / the move order in the spec's B-2 addendum, not left for someone to find.
-   * /
-   * / PUBLIC: it inherits `getEvmAddress`'s gate rather than choosing one, and could not usefully be
-   * / narrower — it exists so a caller can make the derivation happen BEFORE a payment flow, and the
-   * / derivation itself is ungated. Idempotent and bounded to the same one-derivation-per-lifetime
-   * / work, so an anonymous caller can cause it once and no more.
-   * / ⟨L7⟩ UPDATE, NOT QUERY, and this one does not merely await — it WRITES. The body awaits
-   * / `EvmIdentity.deriveAddress` (the management canister's `ecdsa_public_key`) and
-   * / `gate.deriveEvmRecipientAt` ⟨renamed 2026-09-22 with the path⟩, then caches the result in `evmAddressCache`. So a query is
-   * / impossible twice over: it could not await the derivation, and it could not keep the answer.
-   * / Named `ensure*` rather than `get*` for that reason — the write is the point, and a read verb
-   * / would have promised a cheapness this cannot deliver.
-   * /
-   * / ⟨Marker added 2026-08-23; the census row said "L7 mark added per review" and no mark was at
-   * / the site.⟩
+   * / WHO: every active guardian — no grant bit (`RecordWords` header says why). The OWNER is refused
+   * / by name (`RecordWords.OWNER_DISPUTES_ELSEWHERE` — the owner's dispute is
+   * / `repudiateMemoryWrite`); an agent and a stranger get "Not a guardian", a pending guardian "Guardian
+   * / is pending approval", the anonymous caller the anonymous refusal.
+   * / WHAT: an entry the owner's review would show (`qualifiesForReview` — an agent's append or
+   * / revision, or a paid session's append) that succeeded, still held in full by the ring.
+   * / One dispute per guardian per write (`#Conflict`, the first stands).
    */
-  ensureEvmReady: ActorMethod<[], Result_43>;
+  disputeAgentWrite: ActorMethod<[bigint, string], Result_14>;
   /**
    * / Record that log entries [fromSeq, toSeq] were served, and return the root that proves it.
    * /
@@ -671,7 +785,7 @@ export interface Engram {
    * / situation rather than a safety measure. It IS gated on requireMemoryAttached: a store that
    * / failed its integrity check must not attest anything it cannot vouch for.
    */
-  exportMemoryRange: ActorMethod<[bigint, bigint, [] | [Principal]], Result_66>;
+  exportMemoryRange: ActorMethod<[bigint, bigint, [] | [Principal]], Result_79>;
   /**
    * / ⟨0.16.0, L2.2 — renamed from `guardianFreezePayments`⟩ The prefix LIED about who may call it.
    * / The gate is `requireOwnerOrGuardian`, and an owner freezing their own payments is the ordinary
@@ -688,6 +802,8 @@ export interface Engram {
    * /     individual method's body finds nothing — the check is one level down.⟩
    * /   · `addEip712Type` and `addEvmWithdrawDestination` — pre-staging for a later payout is the
    * /     thing a brake most needs to stop, so the destination list is frozen along with the signing.
+   * /     ⟨2026-10-14, the owner's ruling 4A⟩ `addEvmWithdrawDestination` is removed; its place is
+   * /     `addEip712Destination` (one list per registered action), freeze-gated the same way.
    * /   · `sessionReadMemory` and `sessionAppendMemory` — the paid-memory rail, money coming IN.
    * /
    * / AND WHAT IT DELIBERATELY DOES NOT, stated so the absence is not read as an oversight:
@@ -703,11 +819,21 @@ export interface Engram {
    * / ⚠ The three exclusions are a reading of intent, not a ruling: no declaration stated the scope
    * / before this one. If any of them is wrong, this comment is where the argument should happen.
    */
-  freezePayments: ActorMethod<[], Result_1>;
+  freezePayments: ActorMethod<[], Result_2>;
+  /**
+   * / ⟨2026-10-21, the owner's round-11 answer d⟩ `freezePayments` with a reason the strip and the
+   * / guardian page show ("Sam froze payments: 'a payment I didn't expect'"). A NEW method, not an
+   * / argument on `freezePayments`: a shipped argument tuple is frozen. Same callers, same grant, same
+   * / brake: the owner, or an active guardian holding `canFreezePayments`; an agent, a stranger, a
+   * / pending guardian and the anonymous caller are refused by `requireOwnerOrGuardian`'s own words.
+   * / An empty reason is no reason; a reason too long or holding a line break is `#Invalid` and the
+   * / brake is NOT pulled — the caller pulls it with `freezePayments`, or shortens the words.
+   */
+  freezePaymentsWithReason: ActorMethod<[string], Result_2>;
   /**
    * / Delivery status + config readback. Owner-only (the URL is a secret).
    */
-  getActionAlertStatus: ActorMethod<[], Result_57>;
+  getActionAlertStatus: ActorMethod<[], Result_67>;
   /**
    * / Agents need to know what they may revise, so they can read it too. Whole-value config, same
    * / carve-out as getProtectedPaths — and kept a SEPARATE method from it deliberately (L2.2): a
@@ -717,7 +843,7 @@ export interface Engram {
    * / Refusal reason preserved from the trap: a grant is a power, and its absence and its
    * / concealment are different facts.
    */
-  getAgentRevisablePaths: ActorMethod<[], Result_53>;
+  getAgentRevisablePaths: ActorMethod<[], Result_63>;
   /**
    * / OWNER-ONLY: every engagement's seat weeks on this engram, with the agent's root — the day it
    * / paired, the days of its first and last payment signature, a 64-week map whose bit 0 is the week
@@ -730,7 +856,7 @@ export interface Engram {
    * / empty page. Paged; `total` is every engagement ever paired here (a reset keeps the rows).
    * / Two rows can name one root: an agent paired again after it left is a second engagement.
    */
-  getAgentSeatWeeks: ActorMethod<[bigint, bigint], Result_64>;
+  getAgentSeatWeeks: ActorMethod<[bigint, bigint], Result_77>;
   /**
    * / Owner: everything written into this engram by someone other than the owner since the last
    * / markAgentWritesReviewed() — agent appends/revisions AND paid-session appends (see
@@ -740,7 +866,7 @@ export interface Engram {
    * / as a total. `earliest` discloses ring eviction — if cursor < earliest, entries between them
    * / aged out of the ring (the CHAIN still proves total count; this view can't show their bodies).
    */
-  getAgentWriteReview: ActorMethod<[], Result_63>;
+  getAgentWriteReview: ActorMethod<[], Result_76>;
   /**
    * / Why anchoring is or is not advancing. PUBLIC: ungated on purpose — detecting a stalled
    * / engram is the point, a gated read would fail-to-empty and hand a third party fabricated zeros,
@@ -763,7 +889,20 @@ export interface Engram {
    * / was signed rather than asserted.
    */
   getAuditHead: ActorMethod<[], AuditHead>;
-  getBackupMetadata: ActorMethod<[string], Result_62>;
+  getBackupMetadata: ActorMethod<[string], Result_75>;
+  /**
+   * / ⟨2026-10-21, the owner's round-11 answer m: a backup-retention getter⟩ How many backups of
+   * / `dbType` each creator keeps, and whether that is the default — the read `setBackupRetention`
+   * / lacked, so "Keeps your newest 3" showed only on the phone that last set it.
+   * /
+   * / WHO: the OWNER, and an active AGENT holding `canAppendMemory` — the permission that lets it
+   * / upload backups, which are exactly the backups this number bounds (`#perm(#append_memory)`).
+   * / Refused, each by the gate's own words: an agent without that permission ("Permission
+   * / denied"), a revoked or resigned agent, a guardian (guardians take no backups), a stranger and
+   * / the anonymous caller. A kind the setter would refuse is `#Invalid` here too
+   * / (`Backup.getRetention`). Records nothing (a query).
+   */
+  getBackupRetention: ActorMethod<[string], Result_74>;
   /**
    * / The cashier this engram recognises as its rent biller — `null` until the registry pushes one.
    * /
@@ -773,6 +912,27 @@ export interface Engram {
    * / too is what lets the two be COMPARED, which is the only way to catch a mismatch.
    */
   getBillerId: ActorMethod<[], [] | [Principal]>;
+  /**
+   * / This engram's BIRTH CHAIN, root first: its own record last, its parent's before it, and so on
+   * / ⟨2026-10-26, the owner's lineage ruling L3A⟩.
+   * /
+   * / OWNER ONLY. The owner decides whom to show it to — the chain names the engrams this one descends
+   * / from, which is the owner's to disclose, not the registry's. The certified half is at the registry
+   * / (`getCertifiedBirth`, public, revealing only whether a fingerprint is present); the client's
+   * / `verifyBirthChain` checks both. Refused to anyone else by the combinator (`#ownerOnly`).
+   */
+  getBirthChain: ActorMethod<[], Result_73>;
+  /**
+   * / ⟨2026-10-21, the owner's round-11 answer d⟩ Each brake: on or off, and while on, who pulled it
+   * / LAST (their key and whether as owner or guardian), since when, and the reason they gave — the
+   * / same person and time as the newest brake entry on the record (`RecordWords.BrakePull`). For the
+   * / owner's status strip and the guardian page. The OWNER and ACTIVE GUARDIANS may read it; an
+   * / agent, a stranger, a pending guardian and the anonymous caller are refused (`#ownerOrGuardian`
+   * / — an agent learns a brake is on from the refusal of what it tried, and needs no more). `pull`
+   * / is null for a brake that is off, and for one carried on across the upgrade that added this
+   * / read (who pulled it was not recorded then) — never a guessed pull.
+   */
+  getBrakes: ActorMethod<[], Result_72>;
   /**
    * / ⟨0.16.0, L9/L10 — census row⟩ `Wire.CertifiedAuditHead`, not an anonymous record. The
    * / registry, market and cashier already served the shared type; the engram — the canister that
@@ -799,13 +959,13 @@ export interface Engram {
    * / recorded nothing while reading as if it did. The refusal is loud in the reply instead. WHAT
    * / WOULD MAKE THIS WRONG: a reason to record who asked — then this becomes an update that says so.
    */
-  getChildAllowance: ActorMethod<[Principal], Result_61>;
+  getChildAllowance: ActorMethod<[Principal], Result_71>;
   /**
    * / Owner-only, Billing-class: what opening an engram costs this engram, the balance below which an
    * / agent's request is refused, the balance now, and every agent's allowance. The console's cost
    * / sentence reads it. Cycles are owner-class information, as on the owner's console read.
    */
-  getChildOpening: ActorMethod<[], Result_60>;
+  getChildOpening: ActorMethod<[], Result_70>;
   /**
    * / Derive the shared memory-encryption key, encrypted under the caller's transport
    * / public key. Gated to owner + read-agents (the same principals allowed to read
@@ -831,7 +991,7 @@ export interface Engram {
    * / cost. Stated here because L7 requires the reason be readable from the interface rather than
    * / inferred by opening the body — which is exactly what had to happen to write this line.
    */
-  getEncryptedMemoryKey: ActorMethod<[[] | [bigint], Uint8Array | number[]], Result_59>;
+  getEncryptedMemoryKey: ActorMethod<[[] | [bigint], Uint8Array | number[]], Result_69>;
   /**
    * / ⟨0.16.0, owner ruling 2026-08-20 — option (a)⟩ `x402Support` REPORTS THE RAIL, not a constant.
    * /
@@ -858,12 +1018,6 @@ export interface Engram {
    * / be discovered, and the ERC-8004 ecosystem it participates in assumes an open read.
    */
   getEngramCard: ActorMethod<[], AgentCard>;
-  /**
-   * / PUBLIC: the engram's permanent spawn ordinal — a provable, non-sensitive fact. It identifies a
-   * / canister, never a person.
-   * / null = spawned before numbering existed; the owner can backfill via syncEngramNumber().
-   */
-  getEngramNumber: ActorMethod<[], [] | [bigint]>;
   /**
    * / Re-pointed at `EvmIdentity` (B-2): custody derivation no longer routes through the ic402
    * / Gateway, which is leaving for the market canister. Behaviour is unchanged for a caller — same
@@ -936,7 +1090,7 @@ export interface Engram {
    * / `#Err`, never a record carrying an empty string (ic402's `getEvmAddress` answers `""` on a
    * / failed derivation — that is fail-to-empty on a money surface, and it stops here).
    */
-  getEvmAddress: ActorMethod<[], Result_58>;
+  getEvmAddress: ActorMethod<[], Result_68>;
   /**
    * / The owner's OWN EVM address, if they registered one — distinct from `getEvmAddress`, which is
    * / the address this canister derives for itself.
@@ -955,7 +1109,7 @@ export interface Engram {
    * / cost — stated here because L7 requires the reason be readable from the interface rather than
    * / inferred by opening the body.
    */
-  getEvmSignerAddress: ActorMethod<[], Result_43>;
+  getEvmSignerAddress: ActorMethod<[], Result_53>;
   /**
    * / PUBLIC: where this chain begins, for the stranger deciding whether to trust it.
    * /
@@ -968,7 +1122,7 @@ export interface Engram {
   /**
    * / A guardian's own channel status (their URL is their secret — each guardian sees only theirs).
    */
-  getGuardianAlertStatus: ActorMethod<[], Result_57>;
+  getGuardianAlertStatus: ActorMethod<[], Result_67>;
   /**
    * / The market this engram will accept signing requests from — `null` until the registry pushes
    * / one at spawn, which is why `requireMarket` refuses fleet-wide today.
@@ -1001,7 +1155,7 @@ export interface Engram {
    * / never renumbered: the next page starts at the last version returned plus one. Defaults
    * / return the whole history of any file a pre-FD engram could have held.
    */
-  getMemoryHistory: ActorMethod<[string, [] | [bigint], [] | [bigint]], Result_56>;
+  getMemoryHistory: ActorMethod<[string, [] | [bigint], [] | [bigint]], Result_66>;
   /**
    * / PUBLIC: the epoch alone, and deliberately nothing else (rotation study D4). A `rotatedAt[]`
    * / history would be a public, fleet-enumerable feed of when each owner terminated a trust
@@ -1050,7 +1204,7 @@ export interface Engram {
    * / forever" — a claim about what this engram will DESTROY — and an empty guard list reads as
    * / "nothing is held back".
    */
-  getMemoryRetentionPolicy: ActorMethod<[], Result_55>;
+  getMemoryRetentionPolicy: ActorMethod<[], Result_65>;
   /**
    * / The metrics reader this engram answers — `null` until the spawning registry names one.
    * /
@@ -1067,7 +1221,7 @@ export interface Engram {
    * / a fact about the caller, told to the caller. There is nothing to leak by omission — which is
    * / the test the #NotFound arm sets.
    */
-  getMyGuardianStatus: ActorMethod<[], Result_15>;
+  getMyGuardianStatus: ActorMethod<[], Result_17>;
   /**
    * / ⟨0.16.0, NEW⟩ The gated half of the status() split.
    * /
@@ -1079,7 +1233,7 @@ export interface Engram {
    * / client (rule 4) and bought a masked answer nobody had asked for — the census could not even
    * / find a consumer that read the masked `0`. Behind a gate there is nobody to mask it from.
    */
-  getOwnerConsole: ActorMethod<[], Result_54>;
+  getOwnerConsole: ActorMethod<[], Result_64>;
   /**
    * / Owner + agents only (agents need it to avoid writing protected paths).
    * /
@@ -1093,7 +1247,7 @@ export interface Engram {
    * / writing one — so a fabricated empty here does not merely misinform, it invites the write the
    * / list exists to prevent.
    */
-  getProtectedPaths: ActorMethod<[], Result_53>;
+  getProtectedPaths: ActorMethod<[], Result_63>;
   /**
    * / Whether the metrics reader's read is answered — `true` from birth.
    * /
@@ -1105,8 +1259,11 @@ export interface Engram {
    * / Owner-only, Billing-class: the signing floor, the balance, one signature's price, and how many
    * / payment signatures the balance carries above the floor before `signX402Payment` is refused by
    * / name. The same numbers the check uses, so Billing can say only what the engram enforces.
+   * / ⟨2026-11-01, "6 fix"⟩ Refused by name (`#Unavailable`) while this engram has not read its own
+   * / freezing setting: there is no floor to serve then, and a 30-day figure would be a made-up one
+   * / (ADR-0002) — the signers refuse in that state too, so the refusal is the truth on Billing.
    */
-  getSigningFloor: ActorMethod<[], Result_52>;
+  getSigningFloor: ActorMethod<[], Result_62>;
   /**
    * / The registry that spawned this engram, if it recorded one.
    * /
@@ -1127,7 +1284,7 @@ export interface Engram {
    * / A refusal names this method (`Gated.gatedResult`) rather than answering null/0 — a ceiling of
    * / "none" and a spend of 0 are both real answers, so a fabricated one would be read as fact.
    */
-  getSpendCeiling: ActorMethod<[], Result_51>;
+  getSpendCeiling: ActorMethod<[], Result_61>;
   /**
    * / Read the caps in force for a caller.
    * /
@@ -1137,8 +1294,8 @@ export interface Engram {
    * / configuration, and publishing them would tell any caller exactly how large a signing request
    * / can be before it needs an approval nobody is watching for.
    */
-  getSpendPolicy: ActorMethod<[[] | [Principal]], Result_50>;
-  getStorageStats: ActorMethod<[], Result_49>;
+  getSpendPolicy: ActorMethod<[[] | [Principal]], Result_60>;
+  getStorageStats: ActorMethod<[], Result_59>;
   /**
    * / Timer arm-state. PUBLIC and deliberately so: these timers are self-arming to save cycles,
    * / and an optimisation nobody can verify is an optimisation nobody should trust. Cheap to read,
@@ -1163,6 +1320,10 @@ export interface Engram {
    * / because a persistent actor re-runs its init body BEFORE postupgrade restores stable sessions,
    * / so a predicate-gated arm would skip exactly the canisters that have live ones. The first tick
    * / disarms it. Still true minutes after an upgrade is a real bug — report it upstream.
+   * / ⟨2026-10-07, beside the paragraph above⟩ The session sweep's interval is 300 seconds now (the
+   * / owner's decision of that day; set in the actor body), so "one interval" is up to five minutes,
+   * / and true five minutes after an upgrade is still expected. True ten minutes after, with no session
+   * / open, is the bug.
    * / NOT the whole timer story. The hourly CYCLE timer — which also carries audit anchoring — is
    * / deliberately absent: it is a `transient let` armed unconditionally at init, so an "armed"
    * / boolean for it would read true forever and tell you nothing, exactly the false-positive the
@@ -1172,6 +1333,18 @@ export interface Engram {
    * / PUBLIC: the same standing as the two liveness reads above. Booleans and timestamps about this
    * / canister's own timers — nothing about content, callers or money — and a liveness signal only
    * / its owner can read cannot tell a third party that the engram is still running.
+   * / ⟨2026-10-28, the owner's ruling "1"⟩ The three ic402 flags read FALSE WHILE THE TIMERS ARE PAUSED.
+   * / The pause's id sweep cancels ic402's sweeps, but ic402 keeps their stale ids, so its own
+   * / "armed" reads would answer true for a timer that no longer exists (a fabricated answer,
+   * / ADR-0002). `alertTimerArmed` needs no guard: the sweep nulls `alertTimerId` itself.
+   * / ⟨2026-10-29, the owner's ruling "A", beside the line above⟩ …the sweep zeroes the arm, and an arm
+   * / past its due time reads stale. `alertTimerArmed` is TRUE ONLY WHILE A DELIVERY IS OWED OR RETRYING
+   * / (the alert drain is a one-shot armed per owed delivery); alerts configured on a quiet engram read
+   * / false, and that is correct — the IDLE STEADY STATE line above now holds with a webhook set too.
+   * / It reads the arm's DUE TIME, not only its id (`ActionAlerts.armLive`): a job that traps before its
+   * / first await rolls back its own `alertTimerId := null`, so a bare id would read armed forever.
+   * / ONE BOUNDED UNTRUTH (the spec's critic, F12): for ARM_STALE_NS (120 s) after the due time of such a
+   * / trapped job, the flag reads true although no timer exists.
    */
   getTimerHealth: ActorMethod<[], TimerHealth>;
   /**
@@ -1207,14 +1380,14 @@ export interface Engram {
    * / UPDATE, marked per L7: it awaits three ICRC-1 ledgers". It was marked in prose and invisible
    * / to any gate; the glyph is what `scripts/check-update-for-read.mjs` matches.
    */
-  getWalletBalances: ActorMethod<[], Result_48>;
+  getWalletBalances: ActorMethod<[], Result_58>;
   /**
    * / Refusal reason preserved, and it is the clearest case of why a masked read is worse than no
    * / read: three empty strings with `configured = false` is a VALID-LOOKING answer meaning "this
    * / engram has no World ID configuration" — handed to a caller who merely lacks a grant. The
    * / fabrication is indistinguishable from the truth by construction.
    */
-  getWorldIdConfig: ActorMethod<[], Result_47>;
+  getWorldIdConfig: ActorMethod<[], Result_57>;
   /**
    * / ⟨L7⟩ UPDATE, NOT QUERY: this awaits THREE system calls — `raw_rand()` for the nonce,
    * / `Call.signWithEcdsa` for the signature, and `worldIdRpPublicKey()` for the derived key. A
@@ -1225,7 +1398,7 @@ export interface Engram {
    * / the World Developer Portal. Short-lived (300s TTL, idkit-server's default) and single-purpose —
    * / it authorizes opening one verification request, nothing else.
    */
-  getWorldIdRpContext: ActorMethod<[], Result_46>;
+  getWorldIdRpContext: ActorMethod<[], Result_56>;
   /**
    * / Owner-only: the EVM address derived from the engram's dedicated World ID RP signing key (the
    * / "worldid-rp" tECDSA path). Register THIS address as the rp_id's signer in the World Developer
@@ -1237,7 +1410,7 @@ export interface Engram {
    * / refusal — a state write, which a query cannot perform. So even if the key were cached this
    * / could not become a query without silently retiring its denial record (ADR-0002's class).
    */
-  getWorldIdRpSignerAddress: ActorMethod<[], Result_43>;
+  getWorldIdRpSignerAddress: ActorMethod<[], Result_53>;
   /**
    * / The verified IDKitResult, verbatim, as World's /api/v4/verify accepted it — the re-checkable
    * / artifact behind verifiedHuman. Role-gated because it carries the NULLIFIER.
@@ -1258,7 +1431,7 @@ export interface Engram {
    * / canister does not serve. The tombstones below and at `about()` are historical and correct as
    * / written; this one was present tense, which is the difference that matters.⟩
    */
-  getWorldIdVerification: ActorMethod<[], Result_45>;
+  getWorldIdVerification: ActorMethod<[], Result_55>;
   /**
    * / ⟨0.16.0, L1⟩ THE EMERGENCY FAMILY. Every refusal below is `#Refused` or `#NotFound`, and the
    * / absence of a `#Conflict` here is the point: these are the calls someone makes while something
@@ -1266,7 +1439,7 @@ export interface Engram {
    * / nothing by that name". A missing PERMISSION is `#Refused` rather than `#Conflict` — the
    * / guardian's standing is what fell short, and no change to engram state would let them through.
    */
-  guardianRevokeAgent: ActorMethod<[Principal], Result_1>;
+  guardianRevokeAgent: ActorMethod<[Principal], Result_2>;
   /**
    * / The HTTP surface: canister-info JSON, OAuth discovery documents, and the MCP route's query
    * / half. See the `http_request_update` twin below for what upgrades and why.
@@ -1342,7 +1515,7 @@ export interface Engram {
    * / Owner-gated because it reports on custody posture, and answered as a Result so that a
    * / wrong-identity caller gets a refusal rather than a bare `false` that reads as "no address yet".
    */
-  isEvmAddressCached: ActorMethod<[], Result_44>;
+  isEvmAddressCached: ActorMethod<[], Result_54>;
   /**
    * / Issue an OAuth authorization code. Called by an OAuth client's sign-in bridge
    * / (an `/auth/connector`-style route) after II authentication. The client then
@@ -1351,7 +1524,7 @@ export interface Engram {
    * /
    * / Owner-only: only the engram owner can authorize a Connector install.
    */
-  issueAuthCode: ActorMethod<[string, string, string, [] | [string]], Result_43>;
+  issueAuthCode: ActorMethod<[string, string, string, [] | [string]], Result_53>;
   /**
    * / ⟨0.16.0⟩ `getCycleSnapshotSource` DELETED — folded into `CycleSnapshot.source`, one label per
    * / ROW. A single label for a whole ring misattributes every row recorded under the other source,
@@ -1367,7 +1540,26 @@ export interface Engram {
    * / DORMANT engram and corrupts retention math — a fabricated empty here does not just misinform a
    * / reader, it feeds a wrong number into a decision about destroying data.
    */
-  listActivitySnapshots: ActorMethod<[bigint, bigint], Result_42>;
+  listActivitySnapshots: ActorMethod<[bigint, bigint], Result_52>;
+  /**
+   * / ⟨2026-10-21, round 11 item l — the owner's answer "round 11: a, b, c, d, e, f, g, h, i, j, k, l,
+   * / m."⟩ OWNER-ONLY: what each agent has spent today, beside the daily limit in force for it, so the
+   * / agent rows can say "$0.50 of $5.00 today" where they said a count of payments. Read from the
+   * / state the payment path already keeps — `outboundSpendToday`, through `SpendCeiling.callerSpentOn`
+   * / (the reader `x402SignFor` uses) — and the limits from `gate.getPolicy(<the agent's key>)`, the
+   * / policy `x402SignFor` checks, on the UTC day it checks (`SpendCeiling.dayIndex`). Amounts are the
+   * / token's minor units, as the record's `amount=` writes them. No new state.
+   * /
+   * / OWNER-ONLY for `getSpendCeiling`'s reason: one agent's spending is the owner's custody
+   * / information, and would tell another agent how much it spent. Everyone else — an agent, a
+   * / guardian, a stranger, the anonymous caller — is refused by name (`#Refused
+   * / listAgentSpendToday: …`), never answered with zeros. Paged like `listAgents`, in its order, one
+   * / row per agent record; a row's `spentToday` is null, not 0, where no daily limit is in force,
+   * / because the payment path keeps no figure then (`SpendCeiling.AgentSpendRow` says why).
+   * / WHAT WOULD MAKE THIS WRONG: `x402SignFor` keeping the per-caller total by something other than
+   * / the calling key, or under another day boundary.
+   */
+  listAgentSpendToday: ActorMethod<[bigint, bigint], Result_51>;
   /**
    * / ⟨0.16.0⟩ THE PAGE EXEMPLAR. Trap → `#Refused`, bare array → `Result<Page<T>>` (L1 + L3).
    * /
@@ -1384,7 +1576,7 @@ export interface Engram {
    * / `withheld` is 0: this roster is owner-only in whole, so there is no partial-visibility case.
    * / A method that filters rows by caller sets it — see L1's row-level honesty rule.
    */
-  listAgents: ActorMethod<[bigint, bigint], Result_41>;
+  listAgents: ActorMethod<[bigint, bigint], Result_50>;
   /**
    * / The GUARDIAN-audience projection of the agent roster — three fields, not the full record.
    * /
@@ -1398,7 +1590,7 @@ export interface Engram {
    * / guardian consults BEFORE REVOKING ONE. A fabricated empty here does not merely misinform —
    * / it tells someone acting under emergency powers that there is nothing to act on.
    */
-  listAgentsForGuardian: ActorMethod<[bigint, bigint], Result_40>;
+  listAgentsForGuardian: ActorMethod<[bigint, bigint], Result_49>;
   /**
    * / Owner-only: rows carry caller, amount, operation and free-text rationale. The SDK omits it.
    * /
@@ -1412,7 +1604,7 @@ export interface Engram {
    * /
    * / Refusal reason preserved: `[]` reads as "nothing is awaiting the owner's decision".
    */
-  listApprovalRequests: ActorMethod<[[] | [ApprovalStatus], bigint, bigint], Result_28>;
+  listApprovalRequests: ActorMethod<[[] | [ApprovalStatus], bigint, bigint], Result_35>;
   /**
    * / ⟨0.16.0⟩ `total` IS THE HEAD COUNTER, and on this method that is the entire point.
    * /
@@ -1433,8 +1625,22 @@ export interface Engram {
    * / For the owner and a guardian `withheld` is 0 and the page is the span. WHAT WOULD MAKE THIS
    * / WRONG: a reader who must see the whole record without being the owner or a guardian — the
    * / public certified head is the answer for integrity, and nothing else is.
-   */
-  listAuditEntries: ActorMethod<[bigint, bigint], Result_23>;
+   * /
+   * / ⟨2026-10-15, the owner's ruling 6B of 2026-10-14⟩ PUBLIC NOW, AND THE COUNT BECAME ROWS. The
+   * / reply is a `Wire.RecordPage`: every entry in the span the reader may not see in full comes back
+   * / as a hash-only row in `sealed` (id, SHA-256 of its body, entry hash) instead of being counted in
+   * / `withheld`, so `items.size() + sealed.size()` is the span examined. Each entry is hashed first,
+   * / then chained (`AuditLog`), so those rows are enough to walk from any entry to the certified
+   * / head — which is what lets a stranger check one entry without the owner. A caller with no role,
+   * / the anonymous caller included, is a stranger (`RecordView.readerFrom`) and gets only sealed
+   * / rows; the owner and guardians still see every entry, an agent its own. Nothing here refuses,
+   * / so the read's former refusal ("Anonymous caller not allowed") is gone from it.
+   * / `ringFloor` says where the ring starts — a `start` below it begins at it — and `hashFirstFrom`
+   * / where this record switched to the hash-first rule. A sealed row costs one SHA-256 of its body
+   * / at read time; nothing new is stored. WHAT WOULD MAKE THIS WRONG: a sealed row carrying any part
+   * / of a body, or a stranger reaching `items` (test/record-view.test.mo pins both).
+   */
+  listAuditEntries: ActorMethod<[bigint, bigint], Result_48>;
   /**
    * / ⟨0.16.0, L1 + L3 — census-ruled⟩ THE TWO-MECHANISM EXCEPTION DISSOLVES.
    * /
@@ -1460,7 +1666,7 @@ export interface Engram {
    * / keeps its optional filter and applies it to the page, so no caller loses the ability to ask
    * / "backups of this database" — it stops being a thing the canister has to page around.
    */
-  listBackups: ActorMethod<[bigint, bigint], Result_39>;
+  listBackups: ActorMethod<[bigint, bigint], Result_47>;
   /**
    * / List all bearer tokens — Active, Revoked, and Expired. Owner uses this in
    * / the dashboard to show installed Connectors (claude.ai, Claude Desktop, etc.).
@@ -1472,7 +1678,7 @@ export interface Engram {
    * / merely stopped being used is reported `#Expired`, not a stale `#Active`), so the page carries
    * / the same honesty the store gained on 2026-08-17.
    */
-  listBearerTokens: ActorMethod<[bigint, bigint], Result_38>;
+  listBearerTokens: ActorMethod<[bigint, bigint], Result_46>;
   /**
    * / The condense checkpoints in the retained log at or above `startSeq`, oldest first.
    * /
@@ -1484,7 +1690,7 @@ export interface Engram {
    * / Owner-only like every other archive surface, and for the same structural reason: these rows
    * / carry the chain positions and roots of entries whose paths were inside the hash preimage.
    */
-  listCondenseCheckpoints: ActorMethod<[bigint, bigint], Result_37>;
+  listCondenseCheckpoints: ActorMethod<[bigint, bigint], Result_45>;
   /**
    * / ⟨0.16.0⟩ `metrics()` DELETED — absorbed by `about()`.
    * /
@@ -1493,22 +1699,13 @@ export interface Engram {
    * / both and know which one owned each field. Every field here survives on `about()`, day-flooring
    * / included.
    */
-  listCycleSnapshots: ActorMethod<[bigint, bigint], Result_36>;
+  listCycleSnapshots: ActorMethod<[bigint, bigint], Result_44>;
   /**
    * / Same `withheld` treatment as listMemoryFiles — the tombstone listing filtered reserved paths
    * / for non-owners just as silently, and a caller could not tell a filtered tombstone list from a
    * / complete one. Counted before slicing, so policy-hidden rows never blur into paging.
    */
-  listDeletedMemoryFiles: ActorMethod<[bigint, bigint], Result_35>;
-  /**
-   * / The registered shapes — E3: encodeTypeString is the display artifact, verbatim.
-   * / Stays on the engram under B1 (hybrid): EIP-712 signing is custody, and custody does not leave.
-   * /
-   * / Refusal reason preserved: `[]` reads as "this engram can sign nothing" — a claim about SIGNING
-   * / AUTHORITY, which is not a thing to hand an unauthorized reader. The public trail of every
-   * / registration remains the audit chain under getCertifiedAuditHead.
-   */
-  listEip712Types: ActorMethod<[bigint, bigint], Result_34>;
+  listDeletedMemoryFiles: ActorMethod<[bigint, bigint], Result_43>;
   /**
    * / Stays on the engram under B1 (hybrid): withdrawal custody does not leave.
    * /
@@ -1518,8 +1715,34 @@ export interface Engram {
    * / Refusal reason preserved, and it has two halves that matter separately: `[]` reads as "this
    * / engram may withdraw nowhere", OR — worse — as "no allowlist is in force", which is the
    * / opposite security posture. It also erases any pending 24h activation from view.
+   * /
+   * / ⟨2026-10-14, 4A⟩ One action's list: `typeId` names the action, and an unregistered one is
+   * / `#NotFound` rather than an empty page (an empty page means "this action may sign to nothing").
+   * / The item's field is `value`, not `address`: a list may hold a venue value that is no address.
+   * / Readable by the owner, an active agent or an active guardian, as the old list was.
    */
-  listEvmWithdrawDestinations: ActorMethod<[bigint, bigint], Result_33>;
+  listEip712Destinations: ActorMethod<[Uint8Array | number[], bigint, bigint], Result_42>;
+  /**
+   * / The registered shapes — E3: encodeTypeString is the display artifact, verbatim.
+   * / Stays on the engram under B1 (hybrid): EIP-712 signing is custody, and custody does not leave.
+   * /
+   * / Refusal reason preserved: `[]` reads as "this engram can sign nothing" — a claim about SIGNING
+   * / AUTHORITY, which is not a thing to hand an unauthorized reader. The public trail of every
+   * / registration remains the audit chain under getCertifiedAuditHead.
+   * /
+   * / ⟨2026-10-14, the owner's ruling 3A⟩ Each row carries its per-field rules (`fieldRules`), joined in
+   * / from `eip712FieldRules` — they are part of what the type authorises, so a reader of the list must
+   * / not have to make a second call to learn them. The row type is `Eip712TypeView`.
+   */
+  listEip712Types: ActorMethod<[bigint, bigint], Result_41>;
+  /**
+   * / ⟨2026-10-21, round 11 c⟩ Guardians' disputes, oldest first. Same visibility as
+   * / `listRepudiations` and `listRecordNotes`: the owner and ACTIVE guardians read the rows; an
+   * / agent gets an empty page whose `withheld` counts them (ruling 16 B holds — a dispute is the
+   * / guardian's entry, not the agent's); a stranger, a pending guardian and the anonymous caller are
+   * / refused.
+   */
+  listGuardianDisputes: ActorMethod<[bigint, bigint], Result_40>;
   /**
    * / Accessible by owner and guardians.
    * /
@@ -1528,7 +1751,7 @@ export interface Engram {
    * / pause writes" — a claim about who can STOP it. A caller who cannot tell that from "you may not
    * / see the roster" has been told the engram is unguarded when it may be fully guarded.
    */
-  listGuardians: ActorMethod<[bigint, bigint], Result_32>;
+  listGuardians: ActorMethod<[bigint, bigint], Result_39>;
   /**
    * / The export receipts in the retained log at or above `startSeq`, oldest first.
    * /
@@ -1546,7 +1769,7 @@ export interface Engram {
    * / Read `MemoryRouter.ReceiptPage` before reading `page.total` as a receipt count. It is not one;
    * / it is the chain's length, and the declaration says why.
    */
-  listMemoryExportReceipts: ActorMethod<[bigint, bigint], Result_31>;
+  listMemoryExportReceipts: ActorMethod<[bigint, bigint], Result_38>;
   /**
    * / ⟨0.16.0⟩ THE `withheld` EXEMPLAR — L1 names this exact method as the defect it fixes.
    * /
@@ -1563,8 +1786,17 @@ export interface Engram {
    * / Note the count is computed from the unfiltered list before slicing, so it reports rows hidden
    * / by POLICY, never rows merely off the end of this page — those are `total`'s job. Conflating
    * / the two would rebuild the ambiguity in a new place.
+   * /
+   * / ⟨2026-10-21, the owner's round-11 answer k: an author on every file row⟩ Each row also
+   * / carries `lastModifiedBy` (`Types.MemoryFileRow`): the key that wrote the file's current
+   * / version, so a phone's file list can say "changed 2 h ago by Recorder" without a read per
+   * / file. It is what `readMemory` already serves to the same callers under the same gate, so it
+   * / tells no caller anything it could not read. Born `opt` (ADR-0018 rule 1). Looked up only for
+   * / the rows of THIS page (`MemoryRouter.info`), after the slice, so the cost is one lookup per
+   * / row served, never one per file stored. A WIDENED REPLY: a reader that decodes the row by
+   * / position rather than by field name breaks — none in this repository does.
    */
-  listMemoryFiles: ActorMethod<[bigint, bigint], Result_30>;
+  listMemoryFiles: ActorMethod<[bigint, bigint], Result_37>;
   /**
    * / One page of the memory log, seq-ordered, optionally narrowed to one author.
    * /
@@ -1591,7 +1823,7 @@ export interface Engram {
    * / with the disclosures that make the page verifiable — the hidden-bound defect the census itself
    * / names on previewCondense's row.
    */
-  listMemoryLog: ActorMethod<[bigint, bigint, [] | [Principal]], Result_29>;
+  listMemoryLog: ActorMethod<[bigint, bigint, [] | [Principal]], Result_36>;
   /**
    * / The caller's OWN spend-approval requests. ⟨0.16.0, L1 + L3 — fixed 2026-08-18⟩
    * /
@@ -1610,7 +1842,7 @@ export interface Engram {
    * / (The unbounded MAP is filed separately — pruning an approval record destroys evidence of what
    * / was asked, which is a retention ruling rather than a shape fix.)
    */
-  listMyApprovalRequests: ActorMethod<[bigint, bigint], Result_28>;
+  listMyApprovalRequests: ActorMethod<[bigint, bigint], Result_35>;
   /**
    * / The payer's own sessions, live ones first. PAYER-SCOPED: a caller sees only their own, which
    * / is why this needs no role — a session id is not a secret from the person who paid for it.
@@ -1621,7 +1853,7 @@ export interface Engram {
    * / client would break on — the market paged its own pending withdrawals before its cut for the
    * / same reason. The order is the order sessions were opened.
    */
-  listMySessions: ActorMethod<[bigint, bigint], Result_27>;
+  listMySessions: ActorMethod<[bigint, bigint], Result_34>;
   /**
    * /
    * / ⟨0.16.0, L3⟩ Paged and enveloped like every other `list*`, and the envelope here is uniformity
@@ -1636,7 +1868,7 @@ export interface Engram {
    * / IT recorded, so this chain is what a caller composes with when currency matters — which it
    * / cannot do if it needs a role here.
    */
-  listOwnershipTransfers: ActorMethod<[bigint, bigint], Result_26>;
+  listOwnershipTransfers: ActorMethod<[bigint, bigint], Result_33>;
   /**
    * / ⟨2026-09-29, the platform's question from the build review⟩ OWNER-ONLY: how many payment
    * / signatures each agent has obtained today, and the daily limit (200, `PaymentSignCap`). The
@@ -1654,7 +1886,7 @@ export interface Engram {
    * / engram enforces for it — beside the agents, never a row among them
    * / (`PaymentSignCap.marketplaceRow`). Null when no marketplace is set.
    */
-  listPaymentSignatureCounts: ActorMethod<[bigint, bigint], Result_25>;
+  listPaymentSignatureCounts: ActorMethod<[bigint, bigint], Result_32>;
   /**
    * / Agent records removed by a reset. Each row is a NAMED record with the fields `principal`,
    * / `name`, `registeredAt` and `purgedAt` — read them BY NAME, never by position.
@@ -1696,7 +1928,7 @@ export interface Engram {
    * / earlier ending, or the reset) — the facts `resyncAgentEdges` re-sends. The stored rows are
    * / served as they are.
    */
-  listPurgedAgents: ActorMethod<[bigint, bigint], Result_24>;
+  listPurgedAgents: ActorMethod<[bigint, bigint], Result_31>;
   /**
    * / ⟨0.16.0⟩ ONE ACCESSOR, folding `readReadLog` and `getDenialLog` — and the fold only became
    * / safe because of a change made earlier in this same leg.
@@ -1759,7 +1991,15 @@ export interface Engram {
    * / on the chained record — the same `RecordView` filter, and `withheld` counts what it removed
    * / together with what `successFilter` removed. WHAT WOULD MAKE THIS WRONG: see `listAuditEntries`.
    */
-  listReadLog: ActorMethod<[[] | [boolean], bigint, bigint], Result_23>;
+  listReadLog: ActorMethod<[[] | [boolean], bigint, bigint], Result_30>;
+  /**
+   * / ⟨2026-10-21, round 11 b⟩ The owner's notes, oldest first. Same visibility as
+   * / `listRepudiations`, for the same reason: the owner and ACTIVE guardians read the rows; an agent
+   * / reads only the entries it caused (follow-up 16 B), and every note is the owner's, so an agent
+   * / gets an empty page whose `withheld` counts the notes in its window — never "there are none". A
+   * / stranger, a pending guardian and the anonymous caller are refused.
+   */
+  listRecordNotes: ActorMethod<[bigint, bigint], Result_29>;
   /**
    * / Same visibility as listAuditEntries: the owner, this engram's agents, and ACTIVE guardians
    * / see disputes. An unauthorized read REFUSES — it does not return an empty list, because an
@@ -1776,7 +2016,18 @@ export interface Engram {
    * / WOULD MAKE THIS WRONG: a ruling that an agent may see the disputes of its own writes; this would
    * / then have to look up each disputed version's writer, which it does not do today.
    */
-  listRepudiations: ActorMethod<[bigint, bigint], Result_22>;
+  listRepudiations: ActorMethod<[bigint, bigint], Result_28>;
+  /**
+   * / ⟨2026-10-21, the owner's round-11 answer f⟩ OWNER-ONLY: the sign-ins, each with the name its app
+   * / registered. The same tokens, in the same order and paged the same way, as `listBearerTokens`,
+   * / each beside `clientName` — the RFC 7591 `client_name` the app registered when the token was
+   * / issued (`People.SignIn` says when it is null, and that it is the app's own claim). A phone
+   * / owner read "localhost" for every app signed in through a local bridge and could not tell two
+   * / apps apart. A NEW method rather than a field on `BearerToken`: that record is stored (M0170)
+   * / and `listBearerTokens`' reply is shipped (never widened). An agent, a guardian, a stranger and
+   * / the anonymous caller are refused, by `listBearerTokens`' own gate and for its reason.
+   */
+  listSignIns: ActorMethod<[bigint, bigint], Result_27>;
   /**
    * / Owner: advance the review cursor — "I have seen everything up to and including uptoAuditId"
    * / (null = everything at the current head). Bounded so the attestation can never cover entries
@@ -1788,7 +2039,27 @@ export interface Engram {
    * / and this never inspects an operation or a role. Widening what the review shows therefore
    * / changes only which ids the console can pass here — it cannot desynchronise the cursor.
    */
-  markAgentWritesReviewed: ActorMethod<[[] | [bigint]], Result_8>;
+  markAgentWritesReviewed: ActorMethod<[[] | [bigint]], Result_14>;
+  /**
+   * / ⟨2026-10-21, the owner's round-11 answer g⟩ AN AGENT READS ITS OWN GRANT — to the calling key
+   * / only (`People.AgentGrant`): what it may read, where it may write, its rate, and the payment
+   * / limits enforced against that key. It reveals nothing a refusal does not already say, and lets
+   * / an agent correct itself before it writes rather than after the owner explains a refusal by
+   * / hand. `getSpendPolicy` and `listAgents` stay owner-only; this answers one row, the caller's.
+   * /
+   * / WHO: an ACTIVE agent (`Gated.authorize(#agentOrOwner)`). Refused, each by its own text: the
+   * / owner by name (`People.OWNER_HAS_NO_GRANT`), a revoked or resigned agent ("Agent is revoked" /
+   * / "Agent has resigned" — an ended agent may do nothing, and its old grant would read as powers),
+   * / a guardian and a stranger ("Not authorized"), the anonymous caller. A query: it writes nothing.
+   * /
+   * / ⟨2026-10-29, the owner's ruling "b: fix"⟩ It also says whether the payments brake is on and what
+   * / the key could pay now (`paymentsFrozen`, `paymentsNow`), read from the values `x402SignFor`
+   * / checks — the brake, the key's policy and stored total, the engram-wide ceiling and total — so
+   * / the caps alone no longer read as money an agent can spend. `People.SpendState` names each one.
+   * / ⟨2026-10-29, review F2⟩ And which whole-key refusal stops every payment now, if one does
+   * / (`paymentsStoppedBy`: the brake, the signing floor, the daily count of payment signatures).
+   */
+  myGrant: ActorMethod<[], Result_26>;
   /**
    * / The AGENT's current key nominates the key that will replace it. Nothing moves yet: the new
    * / key must accept, by its own call, within 24 hours (`acceptAgentKeyNomination`). One pending
@@ -1796,7 +2067,7 @@ export interface Engram {
    * / with nothing changed, for a caller that is not an active agent here and for a key that could
    * / not hold the record (`KeyReplacement.nomineeRefusal`).
    */
-  nominateAgentKey: ActorMethod<[Principal], Result_1>;
+  nominateAgentKey: ActorMethod<[Principal], Result_2>;
   /**
    * / An AGENT paired here asks this engram to open an engram of its own. This engram attaches 1.3 T of
    * / its own cycles to the registry's `sysSpawnChild`; the agent's lasting key owns what is opened, and
@@ -1827,8 +2098,8 @@ export interface Engram {
    * / WHAT WOULD MAKE THIS WRONG: an await added between `ChildAllowance.take` and the registry call; the
    * / registry's `CHILD_MIN_ATTACHED_CYCLES` moving without `CHILD_ATTACH_CYCLES`.
    */
-  openChildEngram: ActorMethod<[], Result_21>;
-  openSession: ActorMethod<[SessionConfig, PaymentSignature], Result_20>;
+  openChildEngram: ActorMethod<[], Result_25>;
+  openSession: ActorMethod<[SessionConfig, PaymentSignature], Result_24>;
   /**
    * / Withdraw tokens to the owner's principal. This is the ONLY way to
    * / move tokens out of the engram to an external address, and the
@@ -1836,7 +2107,7 @@ export interface Engram {
    * / NOT freeze-gated: the owner always controls their own funds.
    * / Guardian freeze only blocks agent/public operations.
    */
-  ownerWithdraw: ActorMethod<[TokenAmount, [] | [ActionAuth]], Result_8>;
+  ownerWithdraw: ActorMethod<[TokenAmount, [] | [ActionAuth]], Result_14>;
   /**
    * / ⟨0.16.0⟩ `payRentFromEarnings` DELETED — ruled TWICE (B1 and B2), and it was the single
    * / clearest violation of the OSS/platform split in this repo.
@@ -1893,12 +2164,17 @@ export interface Engram {
    * / engagement on the agent's track record, and what to do. Before, the reply was `#Ok` with the
    * / record alone even when the registry had refused the start, so the agent was never told.
    */
-  pairAgent: ActorMethod<[{ enrolment: Enrolment; code: string }], Result_19>;
+  pairAgent: ActorMethod<[{ enrolment: Enrolment; code: string }], Result_23>;
   /**
    * / ⟨0.16.0, L2.2 — renamed from `guardianPauseWrites`⟩ Same correction as freezePayments above:
    * / owner-or-guardian, and `resumeWrites` never carried the prefix either.
    */
-  pauseWrites: ActorMethod<[], Result_1>;
+  pauseWrites: ActorMethod<[], Result_2>;
+  /**
+   * / ⟨2026-10-21, the owner's round-11 answer d⟩ `pauseWrites` with a reason; everything said of
+   * / `freezePaymentsWithReason` holds, with `canPauseWrites` as the guardian's grant.
+   */
+  pauseWritesWithReason: ActorMethod<[string], Result_2>;
   /**
    * / What condensing through `toSeq` would do, and whether it is unlocked. COMMITS NOTHING — it is
    * / a query, so it structurally cannot; a preview that wrote would be its own trap.
@@ -1919,7 +2195,7 @@ export interface Engram {
    * / `unlocked` is the export-receipt gate ONLY. It is not a promise the condense will land: the
    * / history-budget delta is checked at commit time and can still refuse a short prefix.
    */
-  previewCondense: ActorMethod<[bigint], Result_18>;
+  previewCondense: ActorMethod<[bigint], Result_22>;
   /**
    * / A quote for a session this caller has not opened and is not committed to — the intent a
    * / buyer signs against. Pure dry run, no state, no funds.
@@ -1949,6 +2225,26 @@ export interface Engram {
    * / `expiryNs`. Same value, same meaning; only the name carries the unit now.
    */
   previewOpenSession: ActorMethod<[], SessionIntent>;
+  /**
+   * / ⟨2026-10-21, the owner's round-11 answer k: a trim preview⟩ What a PROPOSED history policy
+   * / would remove from the store as it stands — "about N old copies in F files would be removed" —
+   * / asked BEFORE the owner saves it. A query: nothing is saved, armed or evicted.
+   * /
+   * / WHO: the OWNER only (`#ownerOnly`). An agent, a guardian, a stranger and the anonymous caller
+   * / are each refused with `requireOwner`'s words; the setter it previews is owner-only too.
+   * /
+   * / HOW: the proposal must pass the setter's own checks (`retentionEntriesRefusal`), so the preview
+   * / never answers for a policy the setter would refuse. The guards a save would arm are computed
+   * / exactly as the setter computes them (`RetentionPolicy.armGuards`), and each file is planned by
+   * / the planner the sweep executes (`MemoryRouter.previewEviction` → `Retention.plan`), as the
+   * / owner (the sweep's `maintainPrincipal`), AT THE INSTANT its guard lets go — so a rule that
+   * / waits 14 days is counted as it will stand then, when the agent floor has released more. Per
+   * / rule: copies, files, bytes and `notBeforeNs`. The count is "about": writes before the rule
+   * / takes effect change it.
+   * / HONEST WHEN CUT SHORT: `complete = false` when the planning budget
+   * / (`MemoryRouter.PREVIEW_MAX_DROPS`) ran out — the totals are then a floor, and say so.
+   */
+  previewRetention: ActorMethod<[Array<[string, RetentionClassSpec]>], Result_21>;
   /**
    * / Read one memory file at its current version.
    * /
@@ -1965,7 +2261,7 @@ export interface Engram {
    * / (`sessionReadContext` and the MCP reads). A caller measuring engram usage from this method
    * / will measure nothing.
    */
-  readMemory: ActorMethod<[string], Result_11>;
+  readMemory: ActorMethod<[string], Result_12>;
   /**
    * / Read many paths in one call. Per-path Results are KEPT — partial success is the point, and
    * / one unreadable path must not fail the other nine.
@@ -1983,7 +2279,7 @@ export interface Engram {
    * / path, each with its own Result — a refused RESERVED path sits beside a readable one, which is
    * / a genuine per-path fact.
    */
-  readMemoryBatch: ActorMethod<[Array<string>], Result_17>;
+  readMemoryBatch: ActorMethod<[Array<string>], Result_20>;
   /**
    * / ⟨0.16.0⟩ `getMemoryRetentionGuards` DELETED — folded into `getMemoryRetentionPolicy` above.
    * / It was the second L2.1 array-returning `get*`, and separating it from the policy it modifies
@@ -1995,7 +2291,7 @@ export interface Engram {
    * / see it cannot know whether it has the whole range, which is how silent truncation gets
    * / reintroduced. Loop while `more` is true, advancing by the bytes actually returned.
    */
-  readMemoryBytes: ActorMethod<[string, bigint, bigint, [] | [bigint]], Result_16>;
+  readMemoryBytes: ActorMethod<[string, bigint, bigint, [] | [bigint]], Result_19>;
   /**
    * / The escrow exit for a session whose settle cannot pay.
    * /
@@ -2051,8 +2347,16 @@ export interface Engram {
    * / the transfer pays its own fee from the escrow. A session still reads `closing` only when its
    * / close trapped after one of its awaits, or an earlier version left it there, and of that one the
    * / line above still holds.
+   * /
+   * / ⟨2026-10-07, the owner's decision of that day⟩ WHAT IT ANSWERS: what came back. `amountE6` is
+   * / the ckUSDC base units transferred to the payer's own account (the amount asked, capped at the
+   * / session's unconsumed deposit; the transfer's fee comes out of the escrow on top), and
+   * / `blockIndex` is the ledger block of that transfer. Until this date it answered a bare `nat` that
+   * / was the block index alone, which read as the amount. If the session's record is removed before
+   * / the amount can be read back — a session closed in the same moment as the recovery and cleaned up
+   * / during its transfer — it answers `#Other` naming the block, never a guessed amount.
    */
-  recoverEscrow: ActorMethod<[string, bigint], Result_8>;
+  recoverEscrow: ActorMethod<[string, bigint], Result_18>;
   /**
    * / ⟨0.16.0, L1⟩ A REDEMPTION PATH, where the arm choice is a disclosure decision.
    * /
@@ -2068,7 +2372,7 @@ export interface Engram {
    * / owner's invite gave them and that they cannot act until approved; before, that took a second
    * / read they had no reason to know to make.
    */
-  registerGuardian: ActorMethod<[string], Result_15>;
+  registerGuardian: ActorMethod<[string], Result_17>;
   /**
    * / Remove a per-caller override so that caller reverts to — and keeps TRACKING — the global caps.
    * /
@@ -2076,7 +2380,12 @@ export interface Engram {
    * / override is to overwrite it with a frozen copy of the global policy, which then stops
    * / following later changes. That makes every override permanent in effect.
    */
-  removeCallerSpendPolicy: ActorMethod<[Principal], Result_1>;
+  removeCallerSpendPolicy: ActorMethod<[Principal], Result_2>;
+  /**
+   * / ⟨2026-10-14, 4A⟩ Remove a destination from one action's list. Instant, and NOT freeze-gated:
+   * / removal TIGHTENS, and a frozen engram must still be able to shrink what it could sign to.
+   */
+  removeEip712Destination: ActorMethod<[Uint8Array | number[], string], Result_2>;
   /**
    * / De-register a type that has NEVER SIGNED. Exists because of a hazard the first external
    * / validation found within hours (consumer report, 2026-08-06): a bare-name #standard registration —
@@ -2087,9 +2396,10 @@ export interface Engram {
    * / removes only authority that was never exercised, which is removing nothing but the mistake.
    * / NOT freeze-gated, same reasoning as removeEvmWithdrawDestination: this is TIGHTENING, and a
    * / frozen engram must still be able to shrink what it could sign.
+   * / ⟨2026-10-14⟩ `removeEvmWithdrawDestination` is now `removeEip712Destination` (ruling 4A); same
+   * / reasoning. Removing a type now also drops its rules and its own destination list.
    */
-  removeEip712Type: ActorMethod<[Uint8Array | number[]], Result_1>;
-  removeEvmWithdrawDestination: ActorMethod<[string], Result_1>;
+  removeEip712Type: ActorMethod<[Uint8Array | number[]], Result_2>;
   /**
    * / Owner-only: remove a guardian from the roster.
    * /
@@ -2100,13 +2410,26 @@ export interface Engram {
    * / `#NotFound` rather than `#Refused` when there is no such guardian: only the owner reaches this
    * / line, so the roster is theirs and its contents are not a secret being withheld from them.
    */
-  removeGuardian: ActorMethod<[Principal], Result_1>;
+  removeGuardian: ActorMethod<[Principal], Result_2>;
+  /**
+   * / ⟨2026-10-21, the owner's round-11 answer a⟩ OWNER-ONLY: give an agent a new name. A name was
+   * / fixed at the invite, and two agents both called "agent" is how the 2026-10-20 session started.
+   * / Only the VALUE of the stored `AgentRecord.name` changes — no new state, no reshaped record —
+   * / and the change is on the record as `agent.rename` (`principal=<key> name=<new name>`, the name
+   * / last). An ended agent may be renamed too (`People.renameTarget` says why).
+   * / Refused: an agent (itself included), a guardian and a stranger by `requireOwner`'s "Not owner",
+   * / the anonymous caller by its own text; a name that is empty, over `MAX_NAME_LENGTH` or holds a
+   * / line break is `#Invalid` (`People.nameRefusal`); an unknown key is `#NotFound`; the agent's
+   * / current name is `#Conflict`. Nothing changes on any refusal. Not alerted: the owner is the one
+   * / renaming (`ActionAlerts.classify` answers null for `agent.rename`).
+   */
+  renameAgent: ActorMethod<[Principal, string], Result_2>;
   /**
    * / Owner disavows a specific memory write, in the open. Marks — never deletes: the content and
    * / the original audit entry stay exactly where they were; this appends a chained
    * / `memory.repudiate` entry and lists the (path, version) so readers can see the dispute.
    */
-  repudiateMemoryWrite: ActorMethod<[string, bigint, string], Result_8>;
+  repudiateMemoryWrite: ActorMethod<[string, bigint, string], Result_14>;
   /**
    * / ⚠ OWNER-ONLY BULK RESET. Destructive, and wider than its name suggests.
    * /
@@ -2136,7 +2459,7 @@ export interface Engram {
    * / long-lived enough for the rent model to apply, the reset entry is not guaranteed to still be
    * / there. `agentPurgeLog` is the evidence that does not age out — which is why it exists.
    */
-  resetEngram: ActorMethod<[], Result_14>;
+  resetEngram: ActorMethod<[], Result_16>;
   /**
    * / ⟨2026-09-28, owner decision: an agent can resign from an engram, and the resignation is
    * / recorded⟩ The AGENT ends its own engagement with this engram.
@@ -2157,13 +2480,13 @@ export interface Engram {
    * / that is down cannot leave the agent half-resigned; a missed notice is logged by
    * / `notifyRegistryAgentEdge`. WHAT WOULD MAKE THIS WRONG: a second path that sets `#Resigned`.
    */
-  resignAgent: ActorMethod<[], Result_1>;
+  resignAgent: ActorMethod<[], Result_2>;
   /**
    * / OWNER-ONLY release of the write pause, with the same one-way shape as `unfreezePayments`: a
    * / guardian holding `canPauseWrites` can stop writes without the owner and cannot restart them,
    * / and the owner can always restart them. A tripwire rather than a lock.
    */
-  resumeWrites: ActorMethod<[], Result_1>;
+  resumeWrites: ActorMethod<[], Result_2>;
   /**
    * / Self-heal: re-send every ACTIVE agent's start to the spawning registry (idempotent — the
    * / registry mints no duplicate for an open engagement), for when a notice was missed. Owner-only.
@@ -2188,13 +2511,13 @@ export interface Engram {
    * / each such engagement under `cannotBeRecorded` (key, root, invite, and how and when it ended),
    * / apart from `notRecorded`, so the owner sees them rather than silence.
    */
-  resyncAgentEdges: ActorMethod<[], Result_13>;
+  resyncAgentEdges: ActorMethod<[], Result_15>;
   /**
    * / Return to managed custody: the engram adds the registry back as a controller ALONGSIDE the
    * / owner — it does not remove the owner. The inverse of `claimSovereignty`, and the reason
    * / sovereignty is not a one-way door.
    */
-  returnToManaged: ActorMethod<[], Result_1>;
+  returnToManaged: ActorMethod<[], Result_2>;
   /**
    * / Replace the whole content of an EXISTING file.
    * /
@@ -2231,7 +2554,7 @@ export interface Engram {
    * /
    * / To narrow what an agent may do rather than end its access, use `setAgentPermissions`.
    */
-  revokeAgent: ActorMethod<[Principal], Result_1>;
+  revokeAgent: ActorMethod<[Principal], Result_2>;
   /**
    * / Owner-only panic button: revoke EVERY active agent at once. Returns how many were revoked.
    * /
@@ -2250,7 +2573,7 @@ export interface Engram {
    * / that fails leaves the agents revoked here regardless — a partial notify is not a partial
    * / revocation, which is the direction that matters for a panic button.
    */
-  revokeAllAgents: ActorMethod<[], Result_8>;
+  revokeAllAgents: ActorMethod<[], Result_14>;
   /**
    * / Owner-only panic button: revoke every connector bearer token at once. Returns how many.
    * /
@@ -2261,7 +2584,7 @@ export interface Engram {
    * /
    * / Tokens are re-issuable: revoking them is not permanent the way revoking an agent is.
    */
-  revokeAllBearerTokens: ActorMethod<[], Result_8>;
+  revokeAllBearerTokens: ActorMethod<[], Result_14>;
   /**
    * / ⟨0.16.0⟩ `removeAllGuardians` DELETED — test-only (L6), and verified NOT part of KILL-SWITCH's
    * / mass-revoke set. The destructive phase-07 suite iterates `removeGuardian` instead, so nothing
@@ -2275,12 +2598,12 @@ export interface Engram {
    * / Unlike revoking an agent, this costs nothing permanently — an invite is a one-time code,
    * / so voiding it and minting a fresh one is the ordinary path.
    */
-  revokeAllInvites: ActorMethod<[], Result_8>;
+  revokeAllInvites: ActorMethod<[], Result_14>;
   /**
    * / Revoke a bearer token by its public tokenId. Idempotent.
    * / Subsequent /mcp requests using this token will be rejected.
    */
-  revokeBearerToken: ActorMethod<[string], Result_1>;
+  revokeBearerToken: ActorMethod<[string], Result_2>;
   /**
    * / ⟨0.16.0, census §10 item 16⟩ RETURNS A REAL RECEIPT, not `R<()>` — same reason as the delete
    * / above, and sharper here: a rollback WRITES A NEW VERSION, so the caller's next question is
@@ -2307,16 +2630,7 @@ export interface Engram {
    * / agent on that record, so its standing is not the problem — the record's state is. An
    * / agent reading `#Refused` would go looking for a permission that was never missing.
    */
-  rotateAgentKeyHash: ActorMethod<[string], Result_1>;
-  /**
-   * / One-time onboarding seed: writes a starter file so the first read-back is non-empty.
-   * /
-   * / Owner-only, and it REFUSES once any memory exists — so it can only ever add the initial
-   * / placeholder and can never overwrite real content. Deliberately NOT counted as a write (no
-   * / `totalMemoryWrites`, no `firstWriteAt`): it is a system seed rather than activity, and
-   * / counting it would corrupt both the write metrics and time-to-first-write for every engram.
-   */
-  seedMemory: ActorMethod<[string, Uint8Array | number[]], Result>;
+  rotateAgentKeyHash: ActorMethod<[string], Result_2>;
   /**
    * / Append to a memory file against a PAID x402 session voucher — the write half of the paid rail,
    * / authorized by the voucher rather than by a role.
@@ -2363,7 +2677,7 @@ export interface Engram {
    * / CIPHERTEXT; the key-holding SDK decrypts it. A caller without the key gets bytes it cannot
    * / read, not an error.
    */
-  sessionReadContext: ActorMethod<[string], Result_12>;
+  sessionReadContext: ActorMethod<[string], Result_13>;
   /**
    * / Read one memory file against a PAID x402 session voucher. No role, no invite — the voucher is
    * / the authorization, which is what makes this the engram's one rail a stranger can pay to use.
@@ -2395,16 +2709,17 @@ export interface Engram {
    * /     cent voucher could read `secrets/*`.
    * /   · Payments are frozen on this engram.
    */
-  sessionReadMemory: ActorMethod<[Voucher, string], Result_11>;
+  sessionReadMemory: ActorMethod<[Voucher, string], Result_12>;
   /**
    * / Configure action alerts: an https webhook that receives new chained-audit entries matching the
    * / enabled event classes (money / approvals / guardian / agentWrites), batched, at most one
-   * / POST per minute. Owner-only. Payloads carry audit METADATA (operation, caller, role, bounded
+   * / POST per minute. ⟨2026-10-29⟩ Delivered within seconds of the action (a 5 s batch window), and
+   * / nothing runs while nothing is owed. Owner-only. Payloads carry audit METADATA (operation, caller, role, bounded
    * / details) — never memory file contents. Setting a URL (re)arms delivery FROM NOW: the cursor
    * / jumps to the current end of the log so history is not replayed. Passing url = null disables.
    * / The URL itself is never written to the audit log (webhook URLs often embed secret tokens).
    */
-  setActionAlertConfig: ActorMethod<[AlertConfig], Result_1>;
+  setActionAlertConfig: ActorMethod<[AlertConfig], Result_2>;
   /**
    * / Owner-only: replace an existing agent's permission set. The way to NARROW what an agent
    * / may do without ending their access — `revokeAgent` is terminal for that principal, this is
@@ -2421,7 +2736,7 @@ export interface Engram {
    * / forward is to grant read to your own agents instead, or to switch to Connected mode first —
    * / both of which the message says.
    */
-  setAgentPermissions: ActorMethod<[Principal, AgentPermissions], Result_1>;
+  setAgentPermissions: ActorMethod<[Principal, AgentPermissions], Result_2>;
   /**
    * / Paths an agent holding a grant may REVISE rather than only append to.
    * /
@@ -2431,7 +2746,7 @@ export interface Engram {
    * / for that. What a bare prefix would do — "MEMORY.md" also matching "MEMORY.md.bak" — is the
    * / kind of accident a permission surface must not have.
    */
-  setAgentRevisablePaths: ActorMethod<[Array<string>], Result_1>;
+  setAgentRevisablePaths: ActorMethod<[Array<string>], Result_2>;
   /**
    * / ⟨0.16.0 — census row⟩ Returns the APPLIED config, which is how this closes the
    * / setter-without-a-getter gap without adding a method: the write is the read.
@@ -2441,12 +2756,18 @@ export interface Engram {
    * / called it an "ops floor: retention enforcement deletes owner backup data silently", mitigated
    * / by a `Debug.print` nobody reads. An owner lowering the cap is destroying their own backups;
    * / they are told how many, in the reply and in the audit line.
+   * /
+   * / ⟨2026-10-21, the owner's round-11 answers h and m⟩ The number now bounds EACH creator's
+   * / backups of the kind (`Backup.enforceRetention`): an agent's finalize prunes only that agent's
+   * / own, and this setter applies the number to every creator's set, so `prunedBackups` counts
+   * / across all of them. "The write is the read" above went stale for a second phone, which never
+   * / made the write: `getBackupRetention` is the read.
    */
-  setBackupRetention: ActorMethod<[string, bigint], Result_10>;
+  setBackupRetention: ActorMethod<[string, bigint], Result_11>;
   /**
    * / Override the caps for ONE caller — an agent this owner trusts more, or less, than the rest.
    */
-  setCallerSpendPolicy: ActorMethod<[Principal, SpendingPolicy], Result_1>;
+  setCallerSpendPolicy: ActorMethod<[Principal, SpendingPolicy], Result_2>;
   /**
    * / Owner-only: set how many engrams `agentPrincipal`'s agent may open of its own through this
    * / engram. Kept by the agent's lasting key, so it carries over a key replacement. Any count is
@@ -2459,7 +2780,7 @@ export interface Engram {
    * / alerts' money class (`ActionAlerts.classify`), so an owner or guardian with an alert channel
    * / hears of it.
    */
-  setChildAllowance: ActorMethod<[Principal, bigint], Result_1>;
+  setChildAllowance: ActorMethod<[Principal, bigint], Result_2>;
   /**
    * / ⟨0.16.0⟩ `getEncryptedMemoryKeyForEpoch` DELETED — folded into `getEncryptedMemoryKey`'s epoch
    * / argument — see that method for the fold and the `null`-means-CURRENT rule.
@@ -2484,7 +2805,7 @@ export interface Engram {
    * / Private mode also closes the paid read rail by construction: a paid session holds no key, so
    * / `sessionReadMemory` refuses on an encrypted engram whatever `setPaidMemoryReadEnabled` says.
    */
-  setEncryptionEnabled: ActorMethod<[boolean], Result_1>;
+  setEncryptionEnabled: ActorMethod<[boolean], Result_2>;
   /**
    * / Register the owner's EVM address for withdrawals.
    * /
@@ -2497,16 +2818,21 @@ export interface Engram {
    * / The guardian doesn't approve the change — the owner is sovereign.
    * / The guardian's existence is the gate, not their active consent.
    */
-  setEvmOwnerAddress: ActorMethod<[string], Result_1>;
+  setEvmOwnerAddress: ActorMethod<[string], Result_2>;
   /**
    * / A guardian arms their OWN webhook over the guarded engram's audit stream (same event
    * / classes and payload as the owner channel — audit metadata, never memory file contents;
    * / the guardian honesty rail: integrity, not content). Active guardians only. Arming starts
    * / from NOW (no history replay); url = null disarms and frees the slot.
    */
-  setGuardianAlertConfig: ActorMethod<[AlertConfig], Result_1>;
+  setGuardianAlertConfig: ActorMethod<[AlertConfig], Result_2>;
   /**
-   * / Per-prefix retention policy. Longest prefix wins; anything unmatched keeps everything.
+   * / Per-prefix retention policy. The longest rule that covers a path wins; anything uncovered
+   * / keeps everything.
+   * /
+   * / ⟨2026-10-21, the owner's round-11 answer i⟩ "Covers" is the folder matcher
+   * / (`AgentPaths.covers`, through `RetentionPolicy.resolve`): a rule ending in "/" governs
+   * / everything beneath it, any other rule exactly one path. It was bare text prefix until that day.
    * /
    * / A CHANGE does not take effect immediately, in EITHER direction: every prefix whose EFFECTIVE
    * / class moves is guarded for the same window as the agent floor, so history cannot be
@@ -2515,7 +2841,7 @@ export interface Engram {
    * / (RetentionPolicy.mo) guards any change it sees. That is the conservative reading, and its
    * / only cost is a delay on keeping MORE, which destroys nothing.
    */
-  setMemoryRetentionPolicy: ActorMethod<[Array<[string, RetentionClassSpec]>], Result_1>;
+  setMemoryRetentionPolicy: ActorMethod<[Array<[string, RetentionClassSpec]>], Result_2>;
   /**
    * / Owner-only: open or close the monetized read rail. When disabled (the default), sessionReadMemory
    * / fails closed for every voucher-bearer — selling the owner's memory is opt-in, not the default.
@@ -2528,7 +2854,7 @@ export interface Engram {
    * / `getEngramCard`'s `x402Support` reports THIS flag, so a buyer can read the rail's state before
    * / paying rather than discovering it in a refusal.
    */
-  setPaidMemoryReadEnabled: ActorMethod<[boolean], Result_1>;
+  setPaidMemoryReadEnabled: ActorMethod<[boolean], Result_2>;
   /**
    * / Open or close the paid-memory WRITE rail (RB4). Owner-only, like its read twin.
    * /
@@ -2537,7 +2863,7 @@ export interface Engram {
    * / the larger permission ride in on the smaller one. Two flags is the shape that lets an owner
    * / say yes to one and no to the other, which is the common case.
    */
-  setPaidMemoryWriteEnabled: ActorMethod<[boolean], Result_1>;
+  setPaidMemoryWriteEnabled: ActorMethod<[boolean], Result_2>;
   /**
    * / ⟨0.16.0, L1⟩ Every validation refusal here is `#Invalid` and the cap is `#Conflict`, and the
    * / split is worth stating once for the whole whole-value-config family below: a malformed path is
@@ -2545,7 +2871,7 @@ export interface Engram {
    * / this engram that no argument gets around. A caller that cannot tell those apart either edits
    * / forever or gives up on a request that was one character from valid.
    */
-  setProtectedPaths: ActorMethod<[Array<string>], Result_1>;
+  setProtectedPaths: ActorMethod<[Array<string>], Result_2>;
   /**
    * / OWNER-ONLY: switch the metrics reader's read of the seat weeks off (`false`) or back on (`true`).
    * / On from birth, by the owner's ruling of 2026-10-02. Off, `sysGetAgentSeatWeeks` refuses the
@@ -2553,7 +2879,7 @@ export interface Engram {
    * / call is a chained record entry (`metrics.setSeatWeeksReadEnabled`, the new and the old value), so
    * / when the read was on or off is part of the record. Anyone else is refused by name.
    */
-  setSeatWeeksReadEnabled: ActorMethod<[boolean], Result_1>;
+  setSeatWeeksReadEnabled: ActorMethod<[boolean], Result_2>;
   /**
    * / Set the most this engram may spend per day ACROSS EVERY CALLER — five agents, the owner and the
    * / marketplace together. `null` removes the ceiling. ⟨2026-09-28⟩
@@ -2564,6 +2890,10 @@ export interface Engram {
    * / bounded instead by each registered type's daily count and destination list; and agent-
    * / registration transactions (`signEngramRegistration`), bounded by three per caller per day and
    * / the 500-gwei gas ceiling. Whether the ceiling should cover them is a separate owner question.⟩
+   * / ⟨2026-10-14, the owner's rulings 3A, 4A and 5A⟩ Typed-data signatures are now bounded by each
+   * / registered type's daily count, its per-field rules ("at most N", "must equal X") and ITS OWN
+   * / destination list, and the signing floor (`SigningFloor`) guards them as it guards x402 payments.
+   * / They are still not counted against this ceiling.
    * /
    * / WHY: the owner decided on 2026-09-28 to add one daily spending ceiling across all callers on an
    * / engram and keep the limit of five agents. Every other spending limit is per caller, so without
@@ -2593,7 +2923,7 @@ export interface Engram {
    * / distinguishable from a tightening afterwards — the reason `spend.setPolicy` records its limits.
    * / Not blocked by a payments freeze, like `setSpendPolicy`: setting a limit moves no money.
    */
-  setSpendCeiling: ActorMethod<[[] | [bigint]], Result_1>;
+  setSpendCeiling: ActorMethod<[[] | [bigint]], Result_2>;
   /**
    * / Set this engram's spending caps.
    * /
@@ -2605,7 +2935,7 @@ export interface Engram {
    * / the escalation an agent starts when it hits a limit, and without it the queue is a place
    * / requests go to expire.
    */
-  setSpendPolicy: ActorMethod<[SpendingPolicy], Result_1>;
+  setSpendPolicy: ActorMethod<[SpendingPolicy], Result_2>;
   /**
    * / Owner-only: set YOUR OWN safety rails on the funding path — a per-top-up ckUSDC ceiling and a
    * / minimum gap between top-ups. Read them back with `getTopUpLimits`.
@@ -2627,14 +2957,14 @@ export interface Engram {
    * / `{ cooldownSeconds; maxCkusdcE6s }`. Setter and getter now share one shape, so read-modify-
    * / write is expressible and neither side can drift from the other without the compiler saying so.
    */
-  setTopUpLimits: ActorMethod<[{ cooldownSeconds: bigint; maxCkusdcE6s: bigint }], Result_1>;
+  setTopUpLimits: ActorMethod<[{ cooldownSeconds: bigint; maxCkusdcE6s: bigint }], Result_2>;
   /**
    * / Owner sets the World ID app_id + action + rp_id from their World Developer Portal (rp_id appears
    * / after "Enable World ID 4.0" on a production app). The action MUST be configured there with
    * / max_verifications = Unlimited (idempotent /verify → survives IC consensus). After setting this,
    * / register getWorldIdRpSignerAddress() as the rp_id's signer address in the Portal.
    */
-  setWorldIdConfig: ActorMethod<[string, string, string], Result_1>;
+  setWorldIdConfig: ActorMethod<[string, string, string], Result_2>;
   /**
    * / Submit a verified-human proof: the IDKitResult from the frontend's World ID flow, forwarded
    * / VERBATIM (compact JSON, as JSON.stringify emits) to World's /api/v4/verify/{rp_id} over an HTTPS
@@ -2645,7 +2975,7 @@ export interface Engram {
    * / (selfie is farmable, passport/mnc are document identity — a different tier). Sets worldIdVerified
    * / and stores the result ONLY on a real verification success — never self-asserted.
    */
-  setWorldIdProof: ActorMethod<[string, string], Result_1>;
+  setWorldIdProof: ActorMethod<[string, string], Result_2>;
   /**
    * / Sign a registered type. ONE call, owner-only, freeze-gated — the delay lives on registration
    * / (D2), never here: an emergency withdrawal must not need two owner round-trips.
@@ -2654,7 +2984,7 @@ export interface Engram {
    * / not lose the ability to sign because a marketplace gained it, and the two share every control
    * / below the caller gate.
    */
-  signEip712: ActorMethod<[Uint8Array | number[], Array<[string, Eip712Value]>], Result_4>;
+  signEip712: ActorMethod<[Uint8Array | number[], Array<[string, Eip712Value]>], Result_5>;
   /**
    * / Sign the engram's own ERC-8004 registration tx for client-side broadcast: the engram signs, the client
    * / broadcasts and keeps the resulting registration id.
@@ -2694,7 +3024,7 @@ export interface Engram {
         maxPriorityFeePerGas: bigint;
       },
     ],
-    Result_9
+    Result_10
   >;
   /**
    * / Sign an EIP-3009 authorization for x402 payment. Agent-accessible.
@@ -2731,39 +3061,30 @@ export interface Engram {
         amount: bigint;
       },
     ],
-    Result_3
+    Result_4
   >;
   /**
-   * / Self-heal: if the registry's spawn-time push was missed, the owner pulls the number from
-   * / the spawning registry. Idempotent; fails closed if the registry has no record.
-   */
-  syncEngramNumber: ActorMethod<[], Result_8>;
-  /**
-   * / Genesis seed — the atomic "spawn only when there's real content" primitive. The spawning
-   * / REGISTRY pushes the owner's first real memory immediately after install, so a canister is
-   * / never spawned holding nothing (see the registry's `provisionEngram` optional genesis).
+   * / ⟨2026-10-21, the owner's round-11 answer e⟩ A GUARDIAN STEPS DOWN: the caller ends their own
+   * / guardianship of this engram. It removes a power from the one who holds it and grants none.
+   * / Before, only the owner could remove a guardian, so one who wanted out could only stop watching
+   * / without anyone knowing — worse than an honest exit on the record.
    * /
-   * / Gated `spawnedBy`-only and ONE-SHOT: it refuses once any file exists, so it can seed and never
-   * / overwrite. Unlike the owner-only `seedMemory` placeholder this is REAL owner content, so it
-   * / IS counted as an owner write (`firstWriteAt`, `totalMemoryWrites`) and is authored by the
-   * / OWNER rather than by the registry principal that called it. It never touches the
-   * / agent metrics.
+   * / WHO: anyone holding a guardian record here, `#Pending` or `#Active`; never refused for the
+   * / record's state. The owner is refused by name (`People.OWNER_IS_NO_GUARDIAN`: their way is
+   * / `removeGuardian`); an agent or a stranger is `#NotFound` (`People.NOT_A_GUARDIAN`, a fact about
+   * / the caller told to the caller, as `resignAgent` does); the anonymous caller is refused.
    * /
-   * / ⚠ THE PAYLOAD IS `Nat` AND MUST STAY `Nat`, which is a constraint on any client of this
-   * / method rather than an internal detail. Its only caller is the registry, over an
-   * / inter-canister boundary, through a hand-declared actor type — and the registry is ROUTINELY a
-   * / different version from the engram template it is seeding: it upgrades before the fleet does,
-   * / and during a transition it can serve a template older than itself. A return-type change here
-   * / breaks genesis provisioning across that skew. That is measured, not predicted: the registry
-   * / trapped with "IDL error: unexpected IDL type when parsing Nat" while seeding an engram built
-   * / at the staging tag. A receipt would buy nothing anyway — the caller does `ignore await`.
+   * / WHAT IT RECORDS: one `guardian.stepDown` entry under `#Guardian`
+   * / (`principal=<key> was=active|pending name=<name>`). Being a `guardian.*` operation it reaches
+   * / the owner's and the other guardians' alerts in the #guardian class, on by default, and the
+   * / guardian who left gets one farewell delivery before their channel goes (the drain's lazy
+   * / cleanup in `drainActionAlerts`, as for a removed guardian).
    * /
-   * / ⚠ ORDERING: upload the engram TEMPLATE first, then upgrade the registry. The reverse leaves a
-   * / window where a spawn seeds an old-shape engram with a new-shape expectation; the reply fails
-   * / to decode and `provisionEngram` dies on a trap its own `try/catch` cannot reach (ADR-0001),
-   * / failing the WHOLE SPAWN rather than just the seed.
+   * / WHAT IT LEAVES: a brake this guardian pulled stays on — lifting one is the owner's; their
+   * / disputes stay on the record. Like `removeGuardian`, it is not terminal: the owner may invite
+   * / the same person again.
    */
-  sysApplyGenesisSeed: ActorMethod<[string, Uint8Array | number[]], Result_8>;
+  stepDownAsGuardian: ActorMethod<[], Result_2>;
   /**
    * / OWNER force-close, for a session the payer abandoned.
    * /
@@ -2785,7 +3106,7 @@ export interface Engram {
    * / and a break after it, and it also moves `packages/client/README.md` and
    * / `docs/AGENT-ONBOARDING.md`, which name it.
    */
-  sysForceCloseSession: ActorMethod<[string], Result_1>;
+  sysForceCloseSession: ActorMethod<[string], Result_2>;
   /**
    * / The metrics reader the registry designated reads every engagement's seat weeks, in one call.
    * /
@@ -2804,12 +3125,15 @@ export interface Engram {
    * / class (`SeatWeeks.readRefusal`), never an empty list: an empty list is a real answer ("no agent
    * / has paired here"), and a fabricated one would be counted as one.
    */
-  sysGetAgentSeatWeeks: ActorMethod<[], Result_7>;
+  sysGetAgentSeatWeeks: ActorMethod<[], Result_9>;
   /**
    * / The metrics reader the registry designated reads this engram's paid-rail health, in one call:
    * / the balance and the line it must stay above, the memory that line is computed from, the sessions
    * / by state, the escrow open sessions hold, the vouchers spent and the refused ones
-   * / (`RailHealth.RailHealth` says what each is, and what is never in it).
+   * / (`RailHealth.RailHealth` says what each is, and what is never in it). ⟨2026-10-08, ic402 2.18.0⟩
+   * / And `refundOwed`: the closed sessions whose refund failed and whose payer has not yet recovered
+   * / it — counted from the close, never read from the ledger; `opt` from birth, and null (an engram
+   * / that does not count) is never 0.
    * /
    * / CALLER: the metrics reader the spawning registry named on this engram (`metricsReaderId`), and
    * / nobody else — the owner reads its balance through `getOwnerConsole`. Answered only while the
@@ -2825,7 +3149,7 @@ export interface Engram {
    * / to freeze. Called by another canister, a query runs replicated and this engram pays for it —
    * / a few million cycles an hour, the cost of being watched.
    */
-  sysGetRailHealth: ActorMethod<[], Result_6>;
+  sysGetRailHealth: ActorMethod<[], Result_8>;
   /**
    * / The cashier reads how many signatures this engram has produced, per caller and in total.
    * / ⟨2026-09-28⟩ The owner's decision of that date: a running counter on the engram, exported to
@@ -2850,7 +3174,20 @@ export interface Engram {
    * / only engrams the registry confirms run published code, and read a lower count than last time as
    * / a reinstall — the reasoning is at `signaturesByCaller`.
    */
-  sysGetSignatureCounts: ActorMethod<[], Result_5>;
+  sysGetSignatureCounts: ActorMethod<[], Result_7>;
+  /**
+   * / Note a restart the registry just made: what this engram owes for it, the floor a repayment may
+   * / not go under, and until when to keep its timers quiet.
+   * /
+   * / CALLER: the registry that spawned this engram, from inside its owner's `restartMyStoppedEngram`,
+   * / and nobody else (ADR-0020) — the same authority as `sysSetBillerId`. The owner's next conversion
+   * / that lands pays the loan back first. The loan is capped at `RestartRepay.LOAN_MAX_CYCLES` and
+   * / the quiet window at 30 minutes, whatever the registry says.
+   */
+  sysNoteRestart: ActorMethod<
+    [{ keepCycles: bigint; loan: bigint; quietUntilNs: bigint }],
+    Result_2
+  >;
   /**
    * / Rent lifecycle notice — how the OWNER (not the agent) learns their subscription lapsed. D6
    * / shipped the handoff but every alarm it added talks to the operating service's watchdog; the
@@ -2863,7 +3200,7 @@ export interface Engram {
    * / OBSERVES the transition, so it is the only thing that can report it. The state whitelist is
    * / closed — this is a lifecycle feed, not a free-text push surface into the owner's audit chain.
    */
-  sysNotifyRentLifecycle: ActorMethod<[string, string], Result_1>;
+  sysNotifyRentLifecycle: ActorMethod<[string, string], Result_2>;
   /**
    * / ⟨0.16.0⟩ `getWalletActivation()` DELETED — folded to `about().walletActivatedAtNs`, with its
    * / custody-posture rationale carried onto the field. "Can this thing hold money" is a question a
@@ -2897,7 +3234,7 @@ export interface Engram {
    * / the origin: only the configured market can pass that value, so the line cannot be produced by
    * / any other caller.
    */
-  sysNotifyWalletActivity: ActorMethod<[string], Result_1>;
+  sysNotifyWalletActivity: ActorMethod<[string], Result_2>;
   /**
    * / The rent RECEIPT seam (B2): the cashier tells this engram that money moved on its behalf, and
    * / the engram appends a `fee.recorded` line to its own audit chain. It computes nothing.
@@ -2937,7 +3274,32 @@ export interface Engram {
         scheduleVersion: [] | [string];
       },
     ],
-    Result_1
+    Result_2
+  >;
+  /**
+   * / Give back what a paid security update advanced this engram and the install did not use.
+   * /
+   * / CALLER: the registry that spawned this engram, right after it installed a security update it
+   * / paid for, and nobody else (ADR-0020). Sends the smallest of: the advance, what this engram holds
+   * / above its balance before the update, and what sits above its 30-day reserve plus send headroom
+   * / (`RestartRepay.giveBack`) — attached to the registry's `sysRepayUpgradeAdvance`, which accepts no
+   * / more than it advanced. The registry writes off what is not returned; nothing is owed after.
+   * / ⟨CORRECTED 2026-10-28, beside "its 30-day reserve" above — the owner's ruling "1"⟩ The reserve is
+   * / this engram's freezing reserve at its own setting (`freezeReservation` = `lineEstimate`), not a
+   * / 30-day figure: about 430B more at a ~305-day setting.
+   * / ⟨2026-10-26, the owner's review choice 1B: "take back only what we added; anything left over goes
+   * / to the 90-day write-off"⟩ The registry now names the ONE advance it is asking for (`advanceId`,
+   * / the one its deposit for this install put on its ledger) and `advance` is that advance's amount
+   * / alone — never the sum of every advance this engram has out. The engram passes the id back to
+   * / `sysRepayUpgradeAdvance` unchanged, and the registry settles that advance only. The engram's own
+   * / caps are unchanged (`RestartRepay.giveBack`). HONEST LIMIT, unchanged by 1B: the engram cannot
+   * / tell its owner's top-up from the unused advance, so when the install used part of the advance and
+   * / the owner added compute meanwhile, up to the part the install used can still come from the
+   * / owner's top-up (the cap is the advance, not its unused part).
+   */
+  sysReturnUpgradeAdvance: ActorMethod<
+    [{ balanceBefore: bigint; advanceId: bigint; advance: bigint }],
+    Result_6
   >;
   /**
    * / Point this engram at the biller that converts its tokens → cycles. Settable, not hardcoded:
@@ -2956,12 +3318,24 @@ export interface Engram {
    * / nobody but the spawning registry can fix it. That refusal therefore names the real remedy
    * / rather than telling an owner to run a call they can no longer make.
    */
-  sysSetBillerId: ActorMethod<[Principal], Result_1>;
+  sysSetBillerId: ActorMethod<[Principal], Result_2>;
   /**
-   * / One-shot assignment of the spawn ordinal — callable ONLY by the spawning registry, ONLY
-   * / while unset. Neither the owner nor any later registry can change an assigned number.
+   * / Give this engram its BIRTH CHAIN: its ancestors' birth records and its own, root first, its own
+   * / last ⟨2026-10-26, the owner's lineage rulings L2C-lite and L3A⟩.
+   * /
+   * / CALLER: the registry that spawned this engram, from its birth push or its sweep's retry, and
+   * / nobody else (ADR-0020) — the same authority as `sysSetBillerId`, through the named gate
+   * / `AccessControl.requireSpawningRegistry`. ⚠ THE REGISTRY'S CLIENT DECLARATION IS HAND-WRITTEN
+   * / (`sysSetBirthChain : ([BirthRecord.BirthRecord]) -> async Wire.Result<()>`, in `mintAndPush`): a
+   * / different reply type here traps inside the registry's callback, and a different name leaves every
+   * / newborn without its record, silently retried. test/lineage-wiring.test.ts holds the two equal.
+   * /
+   * / SET ONCE: the same chain again answers `#Ok` and changes nothing (the registry's sweep may re-send
+   * / a push whose reply was lost); a different one is refused `#Conflict`. THE ENGRAM DOES NOT HASH:
+   * / it checks only that the chain ends with its own record. The fingerprints are the registry's to
+   * / certify and the client's `verifyBirthChain` to check.
    */
-  sysSetEngramNumber: ActorMethod<[bigint], Result_1>;
+  sysSetBirthChain: ActorMethod<[Array<BirthRecord>], Result_2>;
   /**
    * / Point this engram at the commerce satellite allowed to ask it for signatures. ⟨0.16.0, B1⟩
    * /
@@ -2975,7 +3349,7 @@ export interface Engram {
    * / against a null pointer and their refusals name the registry as the remedy rather than telling
    * / an owner to run a call they cannot make.
    */
-  sysSetMarketId: ActorMethod<[Principal], Result_1>;
+  sysSetMarketId: ActorMethod<[Principal], Result_2>;
   /**
    * / Name the metrics reader allowed to read this engram's seat weeks (`sysGetAgentSeatWeeks`).
    * / ⟨2026-10-02, the owner's ruling of that day⟩
@@ -2991,10 +3365,13 @@ export interface Engram {
    * / A CANISTER ONLY: a person's principal, the anonymous principal or the management canister is
    * / refused `#Invalid` and nothing changes — a person named here would be handed this engram's seat
    * / counts. Set or replaced, never cleared: the owner's control is the switch
-   * / (`setSeatWeeksReadEnabled`), not the pointer. The chained record entry
+   * / (`setSeatWeeksReadEnabled`), not the pointer.
+   * / ⟨CORRECTED 2026-10-26, the owner's lineage ruling L6A⟩ "Set or replaced" is no longer true: it is
+   * / SET ONCE. The same reader again answers `#Ok` and changes nothing; another is refused `#Conflict`
+   * / (`AccessControl.setOnce` says why). Still never cleared. The chained record entry
    * / (`metrics.sysSetMetricsReaderId`) is the evidence of when the read was granted, and to whom.
    */
-  sysSetMetricsReaderId: ActorMethod<[Principal], Result_1>;
+  sysSetMetricsReaderId: ActorMethod<[Principal], Result_2>;
   /**
    * / The market asks this engram to sign a registered type — B1's seam, settlement leg. ⟨0.16.0⟩
    * /
@@ -3003,11 +3380,14 @@ export interface Engram {
    * / (the market cannot introduce a shape), its cool-off must have elapsed, its per-type daily cap
    * / still binds, the destination allowlist still fails closed, and a payments freeze still stops
    * / it. What the market supplies is the request; what the engram supplies is the whole policy.
+   * / ⟨2026-10-14⟩ And the type's per-field rules, its own destination list (ruling 4A) and the
+   * / signing floor (ruling 5A) — all in `eip712SignFor`, so they bind the market as they bind the
+   * / owner; a refusal here is on the chained record under the market's caller and role.
    * /
    * / That is what "signatures only" means in code, and it is why this method needs no new authority
    * / model: an unregistered typeId is refused for the market exactly as it is for the owner.
    */
-  sysSignEip712: ActorMethod<[Uint8Array | number[], Array<[string, Eip712Value]>], Result_4>;
+  sysSignEip712: ActorMethod<[Uint8Array | number[], Array<[string, Eip712Value]>], Result_5>;
   /**
    * / The market asks this engram to sign an x402 payment — B1's seam, the paid-request leg. ⟨0.16.0⟩
    * /
@@ -3026,19 +3406,21 @@ export interface Engram {
    */
   sysSignX402Payment: ActorMethod<
     [bigint, string, string, bigint, string, string, [] | [string], [] | [string]],
-    Result_3
+    Result_4
   >;
   /**
    * / Write an `alerts.test` entry into the audit log; the drain timer delivers it to the webhook
-   * / within ~60s. Owner-only; requires a configured URL so the test can actually go somewhere.
+   * / within ~60s. ⟨2026-10-29, beside "within ~60s"⟩ Within seconds (a minute if a delivery was just
+   * / made). Owner-only; requires a configured URL so the test can actually go somewhere.
    */
-  testActionAlert: ActorMethod<[], Result_1>;
+  testActionAlert: ActorMethod<[], Result_2>;
   /**
    * / Guardian test alert — an audited guardian action (`alerts.test`, role Guardian) that every
-   * / armed channel (owner + guardians) receives within ~60s. Requires the caller's own channel
+   * / armed channel (owner + guardians) receives within ~60s (⟨2026-10-29⟩ within seconds; a minute if
+   * / a delivery was just made). Requires the caller's own channel
    * / to be armed so the test has somewhere to land for them.
    */
-  testGuardianAlert: ActorMethod<[], Result_1>;
+  testGuardianAlert: ActorMethod<[], Result_2>;
   /**
    * / RENAMED from `init` (L2.4). This is the OWNERSHIP-TRANSFER method — the most consequential
    * / owner-facing operation on the canister — and it was named for first-time setup, colliding with
@@ -3078,7 +3460,7 @@ export interface Engram {
    * / `listOwnershipTransfers` (until this day it wrote one from the owner to themselves, a hand-on
    * / that did not happen). The record entry says it was a report. `ControlHandover.isReport`.
    */
-  transferOwnership: ActorMethod<[Principal], Result_2>;
+  transferOwnership: ActorMethod<[Principal], Result_3>;
   /**
    * / OWNER-ONLY release of the payment freeze — and the asymmetry with `freezePayments` is the
    * / governance design, not an oversight.
@@ -3092,7 +3474,20 @@ export interface Engram {
    * / So a guardian's freeze is a TRIPWIRE, not a lock — it buys the time it takes the owner to
    * / look, and no more.
    */
-  unfreezePayments: ActorMethod<[], Result_1>;
+  unfreezePayments: ActorMethod<[], Result_2>;
+  /**
+   * / Wake this engram's timers after it paused them to save compute near its freezing line. Owner
+   * / only. Refused, by name, below the room the hourly check-in needs; then nothing is armed.
+   * /
+   * / CALLER: the engram's owner, from the owner's app (its status line and its compute page), and
+   * / nobody else (ADR-0020). ⟨2026-10-28, the owner's ruling "1": "it wakes on the next payment, agent
+   * / request or your Wake"⟩ The automatic doors (the biller's receipt, Convert, an agent's MCP request)
+   * / wake it when compute lands with room; this is the owner's door, for compute that arrived with no
+   * / receipt (a bare top-up). It always reads the engram's own balance (no rate limit, no free filter),
+   * / so a refusal states what the engram measured. Both figures in a refusal are its own READING above
+   * / its line, which runs ~82B below the true figure, so the engram never calls it the gap.
+   */
+  wakeTimers: ActorMethod<[], Result_1>;
   /**
    * / Consensus transform for the World ID /verify outcall. Replicas each call independently, so the raw
    * / response (timestamps, `uses`, request-id headers) is non-deterministic. Collapse it to a single
@@ -3131,6 +3526,10 @@ export interface Engram {
    */
   writeMemory: ActorMethod<[string, Uint8Array | number[]], Result>;
 }
+export interface EngramEscrowRecovery {
+  amountE6: bigint;
+  blockIndex: bigint;
+}
 export interface EngramSessionState {
   id: string;
   status: EngramSessionStatus;
@@ -3183,6 +3582,15 @@ export interface GenesisNote {
   version: string;
   genesisAtNs: bigint;
 }
+export interface GuardianDispute {
+  about: bigint;
+  atNs: bigint;
+  path: [] | [string];
+  auditId: bigint;
+  version: [] | [bigint];
+  guardian: Principal;
+  reason: string;
+}
 export interface GuardianPermissions {
   canFreezePayments: boolean;
   canRevokeAgents: boolean;
@@ -3223,6 +3631,14 @@ export interface HttpResponse {
   upgrade: [] | [boolean];
   status_code: number;
 }
+export interface Ic402Maintenance {
+  revokedGrantsRemoved: bigint;
+  dailySpendRemoved: bigint;
+  more: boolean;
+  runs: bigint;
+  rateLimitRemoved: bigint;
+  lastRunAtNs: bigint;
+}
 export interface KeyNomination {
   key: Principal;
   atNs: bigint;
@@ -3230,7 +3646,7 @@ export interface KeyNomination {
 export interface LogPage {
   firstAvailableSeq: bigint;
   head: Uint8Array | number[];
-  page: Page_7;
+  page: Page_9;
 }
 export interface LogPosition {
   reads: bigint;
@@ -3266,6 +3682,12 @@ export interface MemoryFile {
   lastModifiedBy: Principal;
   lastModifiedAtNs: bigint;
 }
+export interface MemoryFileRow {
+  path: string;
+  version: bigint;
+  lastModifiedBy: [] | [Principal];
+  lastModifiedAtNs: bigint;
+}
 export interface MemoryHistory {
   evictions: Array<MemoryEviction>;
   oldestRetainedVersion: bigint;
@@ -3415,74 +3837,94 @@ export interface OwnershipTransfer {
 export interface Page {
   total: bigint;
   withheld: bigint;
-  items: Array<Repudiation>;
+  items: Array<SignIn>;
 }
 export interface Page_1 {
   total: bigint;
   withheld: bigint;
-  items: Array<AuditEntry>;
+  items: Array<Repudiation>;
 }
 export interface Page_10 {
   total: bigint;
   withheld: bigint;
-  items: Array<GuardianRecord>;
+  items: Array<MemoryFileRow>;
 }
 export interface Page_11 {
   total: bigint;
   withheld: bigint;
-  items: Array<{ activeFromNs: bigint; address: string }>;
+  items: Array<ExportReceiptRow>;
 }
 export interface Page_12 {
   total: bigint;
   withheld: bigint;
-  items: Array<RegisteredType>;
+  items: Array<GuardianRecord>;
 }
 export interface Page_13 {
   total: bigint;
   withheld: bigint;
-  items: Array<string>;
+  items: Array<GuardianDispute>;
 }
 export interface Page_14 {
   total: bigint;
   withheld: bigint;
-  items: Array<CycleSnapshot>;
+  items: Array<Eip712TypeView>;
 }
 export interface Page_15 {
   total: bigint;
   withheld: bigint;
-  items: Array<CondenseCheckpointRow>;
+  items: Array<Eip712Destination>;
 }
 export interface Page_16 {
   total: bigint;
   withheld: bigint;
-  items: Array<BearerToken>;
+  items: Array<string>;
 }
 export interface Page_17 {
   total: bigint;
   withheld: bigint;
-  items: Array<BackupMetadata>;
+  items: Array<CycleSnapshot>;
 }
 export interface Page_18 {
   total: bigint;
   withheld: bigint;
-  items: Array<{ status: AgentStatus; principal: Principal; name: string }>;
+  items: Array<CondenseCheckpointRow>;
 }
 export interface Page_19 {
   total: bigint;
   withheld: bigint;
-  items: Array<AgentRecord>;
+  items: Array<BearerToken>;
 }
 export interface Page_2 {
   total: bigint;
   withheld: bigint;
-  items: Array<PurgedAgent>;
+  items: Array<RecordNote>;
 }
 export interface Page_20 {
   total: bigint;
   withheld: bigint;
-  items: Array<ActivitySnapshot>;
+  items: Array<BackupMetadata>;
 }
 export interface Page_21 {
+  total: bigint;
+  withheld: bigint;
+  items: Array<{ status: AgentStatus; principal: Principal; name: string }>;
+}
+export interface Page_22 {
+  total: bigint;
+  withheld: bigint;
+  items: Array<AgentRecord>;
+}
+export interface Page_23 {
+  total: bigint;
+  withheld: bigint;
+  items: Array<AgentSpendRow>;
+}
+export interface Page_24 {
+  total: bigint;
+  withheld: bigint;
+  items: Array<ActivitySnapshot>;
+}
+export interface Page_25 {
   total: bigint;
   withheld: bigint;
   items: Array<OwnerRow>;
@@ -3490,42 +3932,51 @@ export interface Page_21 {
 export interface Page_3 {
   total: bigint;
   withheld: bigint;
-  items: Array<AgentPaymentSignatures>;
+  items: Array<AuditEntry>;
 }
 export interface Page_4 {
   total: bigint;
   withheld: bigint;
-  items: Array<OwnershipTransfer>;
+  items: Array<PurgedAgent>;
 }
 export interface Page_5 {
   total: bigint;
   withheld: bigint;
-  items: Array<EngramSessionState>;
+  items: Array<AgentPaymentSignatures>;
 }
 export interface Page_6 {
   total: bigint;
   withheld: bigint;
-  items: Array<ApprovalRequest>;
+  items: Array<OwnershipTransfer>;
 }
 export interface Page_7 {
   total: bigint;
   withheld: bigint;
-  items: Array<MemoryLogEvent>;
+  items: Array<EngramSessionState>;
 }
 export interface Page_8 {
   total: bigint;
   withheld: bigint;
-  items: Array<{ path: string; version: bigint; lastModifiedAtNs: bigint }>;
+  items: Array<ApprovalRequest>;
 }
 export interface Page_9 {
   total: bigint;
   withheld: bigint;
-  items: Array<ExportReceiptRow>;
+  items: Array<MemoryLogEvent>;
 }
 export interface Pairing {
   agent: AgentRecord;
   trackRecord: TrackRecordNotice;
 }
+export interface PaymentLimits {
+  maxSessionDeposit: [] | [bigint];
+  maxPerDay: [] | [bigint];
+  maxSessionDuration: [] | [bigint];
+  sessionIdleTimeout: [] | [bigint];
+  rateLimitPerMinute: [] | [bigint];
+  maxPerTransaction: [] | [bigint];
+  maxConcurrentSessions: [] | [bigint];
+}
 export interface PaymentSignature {
   signature: Uint8Array | number[];
   asset: [] | [string];
@@ -3539,9 +3990,15 @@ export interface PaymentSignature {
 export interface PaymentSignatureCounts {
   day: bigint;
   marketplace: [] | [MarketplacePaymentSignatures];
-  agents: Page_3;
+  agents: Page_5;
   limit: bigint;
 }
+export interface PaymentsNow {
+  leftToday: [] | [bigint];
+  largestPayment: [] | [bigint];
+}
+export type PaymentsStop =
+  { paymentsBrake: null } | { dailySignatureLimit: null } | { signingFloor: null };
 export interface PurgedAgent {
   principal: Principal;
   pairedAtNs: bigint;
@@ -3558,6 +4015,7 @@ export interface RailHealth {
   paidVouchersConsumed: bigint;
   escrowOpen: [] | [bigint];
   sessionsOpen: bigint;
+  refundOwed: [] | [bigint];
   sessionsClosing: bigint;
   cycles: bigint;
   sendHeadroom: bigint;
@@ -3567,26 +4025,21 @@ export interface RailHealth {
 }
 export interface ReceiptPage {
   firstAvailableSeq: bigint;
-  page: Page_9;
+  page: Page_11;
   scannedThroughSeq: bigint;
 }
-export interface RegisteredType {
-  primaryType: string;
-  encodeTypeString: string;
-  cooloffEndsAtNs: bigint;
-  domainName: string;
-  typeId: Uint8Array | number[];
-  verifyingContract: string;
-  dailySignCap: bigint;
-  fields: Array<[string, string]>;
-  domainSeparator: Uint8Array | number[];
-  destinationFields: Array<string>;
-  authorityClass: AuthorityClass;
-  typeHash: Uint8Array | number[];
-  registeredAtNs: bigint;
-  chainId: bigint;
-  domainVersion: string;
-  ackIrrevocable: boolean;
+export interface RecordNote {
+  about: bigint;
+  atNs: bigint;
+  note: string;
+  auditId: bigint;
+}
+export interface RecordPage {
+  ringFloor: bigint;
+  total: bigint;
+  sealed: Array<SealedEntry>;
+  items: Array<AuditEntry>;
+  hashFirstFrom: bigint;
 }
 export interface Repudiation {
   atNs: bigint;
@@ -3602,75 +4055,88 @@ export interface ResetReport {
   filesCleared: bigint;
 }
 export type Result = { Ok: WriteReceipt } | { Err: Error };
-export type Result_1 = { Ok: null } | { Err: Error };
-export type Result_10 = { Ok: BackupRetentionReport } | { Err: Error };
-export type Result_11 = { Ok: MemoryFile } | { Err: Error };
-export type Result_12 = { Ok: SessionContext } | { Err: Error };
-export type Result_13 = { Ok: ResyncReport } | { Err: Error };
-export type Result_14 = { Ok: ResetReport } | { Err: Error };
-export type Result_15 = { Ok: GuardianRecord } | { Err: Error };
-export type Result_16 = { Ok: MemoryByteChunk } | { Err: Error };
-export type Result_17 = { Ok: Array<BatchReadItem> } | { Err: Error };
-export type Result_18 = { Ok: CondensePreview } | { Err: Error };
-export type Result_19 = { Ok: Pairing } | { Err: Error };
-export type Result_2 = { Ok: ControlHandover } | { Err: Error };
-export type Result_20 = { Ok: EngramSessionState } | { Err: Error };
-export type Result_21 = { Ok: Principal } | { Err: Error };
-export type Result_22 = { Ok: Page } | { Err: Error };
-export type Result_23 = { Ok: Page_1 } | { Err: Error };
-export type Result_24 = { Ok: Page_2 } | { Err: Error };
-export type Result_25 = { Ok: PaymentSignatureCounts } | { Err: Error };
-export type Result_26 = { Ok: Page_4 } | { Err: Error };
-export type Result_27 = { Ok: Page_5 } | { Err: Error };
-export type Result_28 = { Ok: Page_6 } | { Err: Error };
-export type Result_29 = { Ok: LogPage } | { Err: Error };
-export type Result_3 = { Ok: X402SignOutcome } | { Err: Error };
-export type Result_30 = { Ok: Page_8 } | { Err: Error };
-export type Result_31 = { Ok: ReceiptPage } | { Err: Error };
-export type Result_32 = { Ok: Page_10 } | { Err: Error };
-export type Result_33 = { Ok: Page_11 } | { Err: Error };
-export type Result_34 = { Ok: Page_12 } | { Err: Error };
-export type Result_35 = { Ok: Page_13 } | { Err: Error };
-export type Result_36 = { Ok: Page_14 } | { Err: Error };
-export type Result_37 = { Ok: CheckpointPage } | { Err: Error };
-export type Result_38 = { Ok: Page_16 } | { Err: Error };
-export type Result_39 = { Ok: Page_17 } | { Err: Error };
-export type Result_4 = { Ok: Eip712SignatureOut } | { Err: Error };
-export type Result_40 = { Ok: Page_18 } | { Err: Error };
-export type Result_41 = { Ok: Page_19 } | { Err: Error };
-export type Result_42 = { Ok: Page_20 } | { Err: Error };
-export type Result_43 = { Ok: string } | { Err: Error };
-export type Result_44 = { Ok: boolean } | { Err: Error };
-export type Result_45 = { Ok: [] | [string] } | { Err: Error };
-export type Result_46 = { Ok: WorldIdRpContext } | { Err: Error };
-export type Result_47 = { Ok: WorldIdConfig } | { Err: Error };
-export type Result_48 = { Ok: WalletBalances } | { Err: Error };
-export type Result_49 = { Ok: StorageReport } | { Err: Error };
-export type Result_5 = { Ok: SignatureCounts } | { Err: Error };
-export type Result_50 = { Ok: SpendingPolicy } | { Err: Error };
-export type Result_51 = { Ok: SpendCeiling } | { Err: Error };
-export type Result_52 = { Ok: SigningFloorStatus } | { Err: Error };
-export type Result_53 = { Ok: { paths: Array<string> } } | { Err: Error };
-export type Result_54 = { Ok: OwnerConsole } | { Err: Error };
-export type Result_55 = { Ok: MemoryRetentionPolicy } | { Err: Error };
-export type Result_56 = { Ok: MemoryHistory } | { Err: Error };
-export type Result_57 = { Ok: AlertStatus } | { Err: Error };
-export type Result_58 = { Ok: EvmAddresses } | { Err: Error };
-export type Result_59 = { Ok: Uint8Array | number[] } | { Err: Error };
-export type Result_6 = { Ok: RailHealth } | { Err: Error };
-export type Result_60 = { Ok: ChildOpening } | { Err: Error };
-export type Result_61 = { Ok: ChildAllowanceRow } | { Err: Error };
-export type Result_62 = { Ok: BackupMetadata } | { Err: Error };
-export type Result_63 = { Ok: AgentWriteReview } | { Err: Error };
-export type Result_64 = { Ok: Page_21 } | { Err: Error };
-export type Result_66 = { Ok: MemoryRangeExport } | { Err: Error };
-export type Result_67 = { Ok: CondenseResult } | { Err: Error };
-export type Result_68 = { Ok: { activatesAtNs: bigint } } | { Err: Error };
-export type Result_69 = { Ok: Eip712Registration } | { Err: Error };
-export type Result_7 = { Ok: Array<Seat> } | { Err: Error };
-export type Result_70 = { Ok: AgentRecord } | { Err: Error };
-export type Result_8 = { Ok: bigint } | { Err: Error };
-export type Result_9 = { Ok: SignedTransaction } | { Err: Error };
+export type Result_1 = { Ok: TimersWake } | { Err: Error };
+export type Result_10 = { Ok: SignedTransaction } | { Err: Error };
+export type Result_11 = { Ok: BackupRetentionReport } | { Err: Error };
+export type Result_12 = { Ok: MemoryFile } | { Err: Error };
+export type Result_13 = { Ok: SessionContext } | { Err: Error };
+export type Result_14 = { Ok: bigint } | { Err: Error };
+export type Result_15 = { Ok: ResyncReport } | { Err: Error };
+export type Result_16 = { Ok: ResetReport } | { Err: Error };
+export type Result_17 = { Ok: GuardianRecord } | { Err: Error };
+export type Result_18 = { Ok: EngramEscrowRecovery } | { Err: Error };
+export type Result_19 = { Ok: MemoryByteChunk } | { Err: Error };
+export type Result_2 = { Ok: null } | { Err: Error };
+export type Result_20 = { Ok: Array<BatchReadItem> } | { Err: Error };
+export type Result_21 = { Ok: RetentionPreview } | { Err: Error };
+export type Result_22 = { Ok: CondensePreview } | { Err: Error };
+export type Result_23 = { Ok: Pairing } | { Err: Error };
+export type Result_24 = { Ok: EngramSessionState } | { Err: Error };
+export type Result_25 = { Ok: Principal } | { Err: Error };
+export type Result_26 = { Ok: AgentGrant } | { Err: Error };
+export type Result_27 = { Ok: Page } | { Err: Error };
+export type Result_28 = { Ok: Page_1 } | { Err: Error };
+export type Result_29 = { Ok: Page_2 } | { Err: Error };
+export type Result_3 = { Ok: ControlHandover } | { Err: Error };
+export type Result_30 = { Ok: Page_3 } | { Err: Error };
+export type Result_31 = { Ok: Page_4 } | { Err: Error };
+export type Result_32 = { Ok: PaymentSignatureCounts } | { Err: Error };
+export type Result_33 = { Ok: Page_6 } | { Err: Error };
+export type Result_34 = { Ok: Page_7 } | { Err: Error };
+export type Result_35 = { Ok: Page_8 } | { Err: Error };
+export type Result_36 = { Ok: LogPage } | { Err: Error };
+export type Result_37 = { Ok: Page_10 } | { Err: Error };
+export type Result_38 = { Ok: ReceiptPage } | { Err: Error };
+export type Result_39 = { Ok: Page_12 } | { Err: Error };
+export type Result_4 = { Ok: X402SignOutcome } | { Err: Error };
+export type Result_40 = { Ok: Page_13 } | { Err: Error };
+export type Result_41 = { Ok: Page_14 } | { Err: Error };
+export type Result_42 = { Ok: Page_15 } | { Err: Error };
+export type Result_43 = { Ok: Page_16 } | { Err: Error };
+export type Result_44 = { Ok: Page_17 } | { Err: Error };
+export type Result_45 = { Ok: CheckpointPage } | { Err: Error };
+export type Result_46 = { Ok: Page_19 } | { Err: Error };
+export type Result_47 = { Ok: Page_20 } | { Err: Error };
+export type Result_48 = { Ok: RecordPage } | { Err: Error };
+export type Result_49 = { Ok: Page_21 } | { Err: Error };
+export type Result_5 = { Ok: Eip712SignatureOut } | { Err: Error };
+export type Result_50 = { Ok: Page_22 } | { Err: Error };
+export type Result_51 = { Ok: AgentSpendToday } | { Err: Error };
+export type Result_52 = { Ok: Page_24 } | { Err: Error };
+export type Result_53 = { Ok: string } | { Err: Error };
+export type Result_54 = { Ok: boolean } | { Err: Error };
+export type Result_55 = { Ok: [] | [string] } | { Err: Error };
+export type Result_56 = { Ok: WorldIdRpContext } | { Err: Error };
+export type Result_57 = { Ok: WorldIdConfig } | { Err: Error };
+export type Result_58 = { Ok: WalletBalances } | { Err: Error };
+export type Result_59 = { Ok: StorageReport } | { Err: Error };
+export type Result_6 = { Ok: { returned: bigint } } | { Err: Error };
+export type Result_60 = { Ok: SpendingPolicy } | { Err: Error };
+export type Result_61 = { Ok: SpendCeiling } | { Err: Error };
+export type Result_62 = { Ok: SigningFloorStatus } | { Err: Error };
+export type Result_63 = { Ok: { paths: Array<string> } } | { Err: Error };
+export type Result_64 = { Ok: OwnerConsole } | { Err: Error };
+export type Result_65 = { Ok: MemoryRetentionPolicy } | { Err: Error };
+export type Result_66 = { Ok: MemoryHistory } | { Err: Error };
+export type Result_67 = { Ok: AlertStatus } | { Err: Error };
+export type Result_68 = { Ok: EvmAddresses } | { Err: Error };
+export type Result_69 = { Ok: Uint8Array | number[] } | { Err: Error };
+export type Result_7 = { Ok: SignatureCounts } | { Err: Error };
+export type Result_70 = { Ok: ChildOpening } | { Err: Error };
+export type Result_71 = { Ok: ChildAllowanceRow } | { Err: Error };
+export type Result_72 = { Ok: Brakes } | { Err: Error };
+export type Result_73 = { Ok: Array<BirthRecord> } | { Err: Error };
+export type Result_74 = { Ok: BackupRetention } | { Err: Error };
+export type Result_75 = { Ok: BackupMetadata } | { Err: Error };
+export type Result_76 = { Ok: AgentWriteReview } | { Err: Error };
+export type Result_77 = { Ok: Page_25 } | { Err: Error };
+export type Result_79 = { Ok: MemoryRangeExport } | { Err: Error };
+export type Result_8 = { Ok: RailHealth } | { Err: Error };
+export type Result_80 = { Ok: CondenseResult } | { Err: Error };
+export type Result_81 = { Ok: Eip712Registration } | { Err: Error };
+export type Result_82 = { Ok: { activatesAtNs: bigint } } | { Err: Error };
+export type Result_83 = { Ok: AgentRecord } | { Err: Error };
+export type Result_9 = { Ok: Array<Seat> } | { Err: Error };
 export interface ResyncReport {
   startsAcknowledged: bigint;
   cannotBeRecorded: Array<UnrecordableEngagement>;
@@ -3691,6 +4157,22 @@ export type RetentionClassSpec =
         thinning: { tail: null } | { logSpaced: { denseTail: bigint } };
       };
     };
+export interface RetentionPreview {
+  files: bigint;
+  complete: boolean;
+  planned: bigint;
+  bytes: bigint;
+  copies: bigint;
+  storedFiles: bigint;
+  rules: Array<RetentionPreviewRule>;
+}
+export interface RetentionPreviewRule {
+  files: bigint;
+  notBeforeNs: [] | [bigint];
+  prefix: string;
+  bytes: bigint;
+  copies: bigint;
+}
 export type Role =
   | { Anonymous: null }
   | { Viewer: null }
@@ -3704,6 +4186,11 @@ export type Role =
   | { Agent: null }
   | { Other: null }
   | { Owner: null };
+export interface SealedEntry {
+  id: bigint;
+  entryHash: Uint8Array | number[];
+  digest: Uint8Array | number[];
+}
 export interface Seat {
   pairedDay: bigint;
   lastPaymentDay: [] | [bigint];
@@ -3740,6 +4227,10 @@ export interface SessionIntent {
   expiryNs: bigint;
   suggestedDeposit: bigint;
 }
+export interface SignIn {
+  token: BearerToken;
+  clientName: [] | [string];
+}
 export interface SignatureCounts {
   total: bigint;
   byCaller: Array<CallerSignatureCount>;
@@ -3799,8 +4290,16 @@ export interface StorageReport {
 export interface TimerHealth {
   jobExpiryFastMode: boolean;
   jobExpiryArmed: boolean;
+  ic402Maintenance: [] | [Ic402Maintenance];
   alertTimerArmed: boolean;
+  upkeepRejected: [] | [bigint];
   sessionExpiryArmed: boolean;
+  ic402MaintenanceTimerArmed: [] | [boolean];
+  checkInsUnfinished: [] | [bigint];
+}
+export interface TimersWake {
+  gap: bigint;
+  needed: bigint;
 }
 export type TokenAmount = { Icp: bigint } | { Ckusdc: bigint } | { Ckusdt: bigint };
 export type TrackRecordNotice = { Recorded: null } | { NotRecorded: string };
@@ -3837,8 +4336,14 @@ export interface WorldIdRpContext {
 }
 export interface WriteReceipt {
   seq: bigint;
+  contentRoot: Uint8Array | number[];
+  atNs: bigint;
   head: Uint8Array | number[];
+  prev: Uint8Array | number[];
+  size: bigint;
+  recordPrev: Uint8Array | number[];
   version: bigint;
+  recordId: bigint;
 }
 export type X402SignOutcome =
   { ApprovalPending: ApprovalRequest } | { Signed: SignedAuthorization };