@engramx/idl 0.16.0-rc.20 → 0.16.0-rc.22

package/dist/engram.idl.d.ts

@@ -104,7 +104,7 @@ export interface AgentSpendRow {
 }
 export interface AgentSpendToday {
   dayStartNs: bigint;
-  agents: Page_23;
+  agents: Page_24;
 }
 export type AgentStatus = { Active: null } | { Resigned: null } | { Revoked: null };
 export interface AgentWriteReview {
@@ -270,7 +270,7 @@ export interface CertifiedAuditHead {
 }
 export interface CheckpointPage {
   firstAvailableSeq: bigint;
-  page: Page_18;
+  page: Page_19;
   scannedThroughSeq: bigint;
 }
 export interface ChildAllowanceRow {
@@ -413,7 +413,15 @@ 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_83>;
+  acceptAgentKeyNomination: ActorMethod<[Principal], Result_89>;
+  /**
+   * / The person the owner asked again ACCEPTS: they become this engram's sign-in, and the sealed copy
+   * / that came with the ask becomes the engram's (sealed for them). Until this call they have no power
+   * / at all. Callable only by that person while the ask waits; refused (as at birth) if they are now
+   * / an agent or a guardian here.
+   * / Named caller: an owner console — "accept" on a waiting ask, signed in as the person asked.
+   */
+  acceptSignIn: ActorMethod<[], Result_2>;
   /**
    * / 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).
@@ -446,7 +454,7 @@ export interface Engram {
    * / 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>;
+  addEip712Destination: ActorMethod<[Uint8Array | number[], string], Result_11>;
   /**
    * / 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
@@ -463,6 +471,14 @@ export interface Engram {
    * / `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).
+   * /
+   * / ⟨2026-11-02, the child build's stage 5⟩ In an engram opened through another, after the spec's own
+   * / checks: the venue actions that move money or control to another account are refused by name
+   * / (`HyperliquidTransaction:` `UsdSend`, `SpotSend`, `SendAsset`, `SendToEvmWithData`,
+   * / `ConvertToMultiSigUser`, `ApproveBuilderFee`, `TokenDelegate` — `#Refused`), and
+   * / `HyperliquidTransaction:Withdraw` registers only with a must-equal rule on `destination` naming this
+   * / engram's own pay address (`#Refused` otherwise; `#Conflict` while the pay address has not been
+   * / derived — call `getEvmAddress` first). A first engram is unchanged.
    */
   addEip712Type: ActorMethod<
     [
@@ -481,7 +497,7 @@ export interface Engram {
         ackIrrevocable: boolean;
       },
     ],
-    Result_81
+    Result_87
   >;
   /**
    * / ⟨0.16.0, L1⟩ THE ROLE-CONFLICT ARM, and why three refusals here are not the same refusal.
@@ -504,7 +520,19 @@ export interface Engram {
    * / 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>;
+  addRecordNote: ActorMethod<[bigint, string], Result_15>;
+  /**
+   * / List a seller: from 24 hours after this call, x402 may pay `payTo` up to `perDayCapE6` a UTC day
+   * / (minor units of a six-decimal stablecoin — 1_000_000 is $1.00) without an approval, and a payment
+   * / to it no longer counts against the engram-wide ceiling or the paying agent's own limits. Above the
+   * / cap a payment goes to the approval queue like any other. `isPayout` marks it as where this engram
+   * / pays out (the same row, its own cap). The sign-in only, in an engram opened through another; the
+   * / owner in a first engram. Refused while payments are frozen, for a malformed or already-listed
+   * / address, a cap of 0, and past `Sellers.MAX_SELLERS` rows. Answers when the row starts to count.
+   * / Named callers: an owner console's seller list for an engram (signed in as its sign-in, for one
+   * / opened through another), and the owner kit.
+   */
+  addSeller: ActorMethod<[string, bigint, boolean], Result_11>;
   /**
    * / Returns the write RECEIPT, not just the version.
    * /
@@ -539,7 +567,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_80>;
+  applyCondense: ActorMethod<[bigint], Result_85>;
   /**
    * / Owner-only: activate a guardian who has registered against an invite.
    * /
@@ -574,6 +602,18 @@ export interface Engram {
    * / "not pending" is the one refusal here an owner acts on differently depending on which it is.
    */
   approveRequest: ActorMethod<[string], Result_2>;
+  /**
+   * / The OWNER asks the person who last declined to be this engram's sign-in again. No principal
+   * / argument: the ask goes to `signInDeclinedBy` alone, so the key file can never seat a sign-in of
+   * / its choosing — re-asking the person who already said no gives a thief nothing. `sealed` is the
+   * / owner's key sealed by the kit for that person; it is stored with the ask, inert, and becomes the
+   * / engram's sealed copy only if they accept. Refused in a first engram, while a sign-in is in place,
+   * / when nobody ever declined (an engram opened without a sign-in has nobody to ask, for life), while
+   * / an ask already waits, within 7 days of the last decline (`OwnerSignIn.askRefusal`), and when the
+   * / person has since become an agent or a guardian here. The sign-in and the person asked are refused.
+   * / Named caller: the owner kit, signed by the agent's lasting key (it seals the key for that person).
+   */
+  askSignInAgain: ActorMethod<[Uint8Array | number[]], 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
@@ -619,7 +659,7 @@ export interface Engram {
    * /
    * / The write half also refuses while writes are PAUSED.
    */
-  backupInit: ActorMethod<[string, BackupType, [] | [string], string, [] | [string]], Result_53>;
+  backupInit: ActorMethod<[string, BackupType, [] | [string], string, [] | [string]], Result_55>;
   /**
    * / Read one chunk of a finalized backup, by index.
    * /
@@ -627,7 +667,7 @@ 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_69>;
+  backupPullChunk: ActorMethod<[string, bigint], Result_72>;
   backupPushChunk: ActorMethod<[string, bigint, Uint8Array | number[]], Result_2>;
   /**
    * / The OWNER cancels an agent's pending key nomination; the agent keeps its current key. Refused
@@ -665,7 +705,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_14>;
+  convertEarningsToCycles: ActorMethod<[string, bigint], Result_15>;
   /**
    * / Owner-only: mint a single-use invite code an agent redeems with `pairAgent`.
    * /
@@ -695,7 +735,7 @@ export interface Engram {
    * / ⟨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_53>;
+  createAgentInvite: ActorMethod<[string, AgentPermissions], Result_55>;
   /**
    * / Owner-only: mint an invite for a GUARDIAN — an independent check on agents, not a
    * / co-owner and not a recovery agent.
@@ -719,7 +759,24 @@ 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_53>;
+  createGuardianInvite: ActorMethod<[string, GuardianPermissions], Result_55>;
+  /**
+   * / The sign-in GIVES ITSELF UP, or the person the owner asked again says no. ⟨the owner's ruling "1
+   * / yes, but the child can ask again" — the child build's Challenge C3.1: whoever the kit names cannot
+   * / otherwise refuse a seat they never agreed to⟩
+   * /   · as the sign-in: the slot empties, the sealed copy of the owner's key is deleted (nobody may
+   * /     hold a copy for a seat that is gone), and the caller is recorded as the one who declined, with
+   * /     the time. The engram keeps its small limits; the owner may ask this person again in 7 days.
+   * /     Listed sellers stop counting at once (a raise waiting in them too): the rows are kept, and
+   * /     count again only if this person accepts a re-ask (`Sellers.inForce`).
+   * /   · as the person a waiting ask goes to: the ask and the copy that came with it are dropped, and
+   * /     the decline's time moves to now (the next ask waits another 7 days).
+   * / The key file is refused: it cannot empty the slot (a thief would, to strand the honest owner's
+   * / approvals). A first engram has nothing to decline.
+   * / Named caller: an owner console — the sign-in's "decline", and the person asked's "decline" on a
+   * / waiting ask.
+   */
+  declineSignIn: ActorMethod<[], Result_2>;
   /**
    * / OWNER-ONLY deletion of a stored backup.
    * /
@@ -770,7 +827,7 @@ export interface Engram {
    * / 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).
    */
-  disputeAgentWrite: ActorMethod<[bigint, string], Result_14>;
+  disputeAgentWrite: ActorMethod<[bigint, string], Result_15>;
   /**
    * / Record that log entries [fromSeq, toSeq] were served, and return the root that proves it.
    * /
@@ -785,7 +842,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_79>;
+  exportMemoryRange: ActorMethod<[bigint, bigint, [] | [Principal]], Result_84>;
   /**
    * / ⟨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
@@ -832,8 +889,10 @@ export interface Engram {
   freezePaymentsWithReason: ActorMethod<[string], Result_2>;
   /**
    * / Delivery status + config readback. Owner-only (the URL is a secret).
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
    */
-  getActionAlertStatus: ActorMethod<[], Result_67>;
+  getActionAlertStatus: ActorMethod<[], Result_73>;
   /**
    * / 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
@@ -843,7 +902,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_63>;
+  getAgentRevisablePaths: ActorMethod<[], Result_66>;
   /**
    * / 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
@@ -855,8 +914,10 @@ export interface Engram {
    * / order. Anyone else is refused by name (`#Refused getAgentSeatWeeks: …`), never answered with an
    * / 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.
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
    */
-  getAgentSeatWeeks: ActorMethod<[bigint, bigint], Result_77>;
+  getAgentSeatWeeks: ActorMethod<[bigint, bigint], Result_82>;
   /**
    * / Owner: everything written into this engram by someone other than the owner since the last
    * / markAgentWritesReviewed() — agent appends/revisions AND paid-session appends (see
@@ -865,8 +926,11 @@ export interface Engram {
    * / them — the UI must page (markAgentWritesReviewed(?lastShownId)) and must NOT present 200
    * / 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).
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`AccessControl.requireOwnerOrSignIn`); a first
+   * / engram is unchanged.
    */
-  getAgentWriteReview: ActorMethod<[], Result_76>;
+  getAgentWriteReview: ActorMethod<[], Result_81>;
   /**
    * / 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,
@@ -889,7 +953,7 @@ export interface Engram {
    * / was signed rather than asserted.
    */
   getAuditHead: ActorMethod<[], AuditHead>;
-  getBackupMetadata: ActorMethod<[string], Result_75>;
+  getBackupMetadata: ActorMethod<[string], Result_80>;
   /**
    * / ⟨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`
@@ -902,7 +966,7 @@ export interface Engram {
    * / the anonymous caller. A kind the setter would refuse is `#Invalid` here too
    * / (`Backup.getRetention`). Records nothing (a query).
    */
-  getBackupRetention: ActorMethod<[string], Result_74>;
+  getBackupRetention: ActorMethod<[string], Result_79>;
   /**
    * / The cashier this engram recognises as its rent biller — `null` until the registry pushes one.
    * /
@@ -920,8 +984,10 @@ export interface Engram {
    * / 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`).
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
    */
-  getBirthChain: ActorMethod<[], Result_73>;
+  getBirthChain: ActorMethod<[], Result_78>;
   /**
    * / ⟨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
@@ -932,7 +998,7 @@ export interface Engram {
    * / 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>;
+  getBrakes: ActorMethod<[], Result_77>;
   /**
    * / ⟨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
@@ -959,13 +1025,35 @@ 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_71>;
+  getChildAllowance: ActorMethod<[Principal], Result_76>;
   /**
    * / 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.
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
+   */
+  getChildOpening: ActorMethod<[], Result_75>;
+  /**
+   * / Derive the key that opens the sealed copy, encrypted under the caller's transport public key —
+   * / for the SIGN-IN alone (the combinator's `#ownerSignIn`; the key file is refused by name: only the
+   * / sign-in opens the backup, and the key file holds the plaintext anyway). The derivation input is the
+   * / sign-in's own principal, the same identity the kit sealed the copy to, so a former sign-in's key
+   * / never opens a copy re-sealed for its successor. Refused in a first engram, with no sign-in, and
+   * / with no copy, all before the call. The opening is recorded (`keyBackup.opened`), so the owner's
+   * / alert fires: the one act a thief holding the sign-in cannot hide. Not blocked by a freeze: a
+   * / freeze must never lock the owner out of its own key.
+   * / ⟨CORRECTED 2026-11-03, the stage-6 review's m1, beside the sentence above⟩ "cannot hide" overstates
+   * / it: in an engram opened through another the sign-in sets the alert address, so a thief holding the
+   * / sign-in can re-point it first. Each opening is recorded in the engram's record (which the key file
+   * / reads) and alerted to whatever address the sign-in has set.
+   * /
+   * / ⟨L7⟩ UPDATE, NOT QUERY, and this is the system call that forces it: the body awaits
+   * / `VetKeys.ManagementCanister.vetKdDeriveKey`. A query cannot await.
+   * / Named callers: an owner console signed in as the sign-in (the browser's recovery), and the owner
+   * / kit's `--recover-key` signed by a key-file sign-in.
    */
-  getChildOpening: ActorMethod<[], Result_70>;
+  getEncryptedKeyBackupKey: ActorMethod<[Uint8Array | number[]], Result_72>;
   /**
    * / 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
@@ -991,7 +1079,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_69>;
+  getEncryptedMemoryKey: ActorMethod<[[] | [bigint], Uint8Array | number[]], Result_72>;
   /**
    * / ⟨0.16.0, owner ruling 2026-08-20 — option (a)⟩ `x402Support` REPORTS THE RAIL, not a constant.
    * /
@@ -1090,7 +1178,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_68>;
+  getEvmAddress: ActorMethod<[], Result_74>;
   /**
    * / The owner's OWN EVM address, if they registered one — distinct from `getEvmAddress`, which is
    * / the address this canister derives for itself.
@@ -1108,8 +1196,11 @@ export interface Engram {
    * / the management canister's `ecdsa_public_key`. A query cannot await, so the round-trip is the
    * / cost — stated here because L7 requires the reason be readable from the interface rather than
    * / inferred by opening the body.
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`AccessControl.requireOwnerOrSignIn`); a first
+   * / engram is unchanged.
    */
-  getEvmSignerAddress: ActorMethod<[], Result_53>;
+  getEvmSignerAddress: ActorMethod<[], Result_55>;
   /**
    * / PUBLIC: where this chain begins, for the stranger deciding whether to trust it.
    * /
@@ -1122,7 +1213,46 @@ export interface Engram {
   /**
    * / A guardian's own channel status (their URL is their secret — each guardian sees only theirs).
    */
-  getGuardianAlertStatus: ActorMethod<[], Result_67>;
+  getGuardianAlertStatus: ActorMethod<[], Result_73>;
+  /**
+   * / The sealed copy itself — opaque bytes only the sign-in can open. Readable by the sign-in (it
+   * / opens them with the key `getEncryptedKeyBackupKey` derives for it) and by the key file, which
+   * / holds the plaintext already and so learns nothing — it reads them to compare with the copy the kit
+   * / made (the Challenge's C2.11: a copy someone else stored first reads as "not this key", not as
+   * / "sealed"). Refused in a first engram, and `#NotFound` when no copy is held. The copy that waits
+   * / with an ask is never served here: it is inert until accepted.
+   * / A QUERY: the refusal is in the reply, not the denial log (a query's writes are discarded).
+   * / Named callers: the owner kit (`--recover-key`, and its check after sealing), and an owner console
+   * / signed in as the sign-in (the browser's recovery).
+   */
+  getKeyBackupCiphertext: ActorMethod<[], Result_72>;
+  /**
+   * / Whether this engram holds a sealed copy of its owner's key, for whom, since when, whether it is
+   * / sealed for the sign-in seated now, and whether a copy waits with an ask (`Types.KeyBackupStatus`).
+   * / Readable by the key file and the sign-in (`#ownerOrSignIn`); refused loudly to anyone else
+   * / (ADR-0002). A first engram refuses by name rather than answer "not sealed": it never holds one,
+   * / and an empty answer there would read as a child whose seal failed.
+   * / A QUERY: the refusal is in the reply, not the denial log (a query's writes are discarded).
+   * / Named callers: the owner kit after it opens an engram (it prints whether the copy is stored), and
+   * / an owner console showing an engram opened through another (whether recovery can work).
+   */
+  getKeyBackupStatus: ActorMethod<[], Result_71>;
+  /**
+   * / BLS verification key under which the owner kit seals the backup (`IbeCiphertext.encrypt` to the
+   * / sign-in's principal) and the opener verifies the derived key. Served on-canister so the kit never
+   * / has to know which master key this network uses (the spec's Q-K3: a wrong guess would seal a copy
+   * / nobody can open). Static per (context, key id, canister) — cacheable.
+   * /
+   * / PUBLIC: intentionally unauthenticated — a vetKD public key reveals nothing secret and cannot
+   * / decrypt anything — the sensitive derivation is getEncryptedKeyBackupKey below, which IS gated
+   * / (the sign-in alone) and returns key material encrypted to the caller's transport key. The same
+   * / reasoning as getMemoryKeyVerificationKey, for the backup's own context.
+   * / ⟨L7⟩ UPDATE, NOT QUERY, and this is the system call that forces it: the body awaits
+   * / `VetKeys.ManagementCanister.vetKdPublicKey`. A query cannot await.
+   * / Named callers: the owner kit, when it seals the copy at birth or for an ask; an owner console,
+   * / to verify the derived key during recovery.
+   */
+  getKeyBackupVerificationKey: ActorMethod<[], Uint8Array | number[]>;
   /**
    * / 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.
@@ -1155,7 +1285,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_66>;
+  getMemoryHistory: ActorMethod<[string, [] | [bigint], [] | [bigint]], Result_70>;
   /**
    * / 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
@@ -1204,7 +1334,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_65>;
+  getMemoryRetentionPolicy: ActorMethod<[], Result_69>;
   /**
    * / The metrics reader this engram answers — `null` until the spawning registry names one.
    * /
@@ -1221,7 +1351,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_17>;
+  getMyGuardianStatus: ActorMethod<[], Result_18>;
   /**
    * / ⟨0.16.0, NEW⟩ The gated half of the status() split.
    * /
@@ -1233,7 +1363,18 @@ 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_64>;
+  getOwnerConsole: ActorMethod<[], Result_68>;
+  /**
+   * / The engram's sign-in, as `Types.OwnerSignInView` describes it: whether this engram was opened
+   * / through another, who its sign-in is, whether the caller is it, and any decline or waiting ask.
+   * / Readable by the owner's key, the sign-in, and the person a waiting ask goes to (they need to see
+   * / the ask to answer it); refused loudly to anyone else (ADR-0002) — never an empty view, which would
+   * / read as "no sign-in". A first engram answers its owner with every field null or false.
+   * / A QUERY: the refusal is in the reply, not the denial log (a query's writes are discarded).
+   * / Named callers: an owner console showing an engram opened through another (who signs in, and a
+   * / waiting ask with Accept and Decline), and the owner kit after it opens one.
+   */
+  getOwnerSignIn: ActorMethod<[], Result_67>;
   /**
    * / Owner + agents only (agents need it to avoid writing protected paths).
    * /
@@ -1247,7 +1388,20 @@ 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_63>;
+  getProtectedPaths: ActorMethod<[], Result_66>;
+  /**
+   * / What an approval card shows beside a payment to `payTo` (`Types.RecipientHistory`): whether an x402
+   * / signature from this engram has paid it before and since when, whether it is a listed seller and
+   * / counts now, and whether the history is full (then "not paid before" may be one it forgot). Read
+   * / beside the request, because the stored request is never reshaped. For the key file and the sign-in
+   * / (the owner in a first engram); refused loudly to anyone else. A malformed address is `#Invalid`.
+   * / ⟨2026-11-02, the child build's stage 5⟩ Also how many times x402 has paid it and the largest of
+   * / those payments (`timesPaid`, `largestPaidE6`, six-decimal minor units), so a card can say "paid 3
+   * / times, largest $12"; the history forgets the address paid longest ago when full.
+   * / ⟨2026-11-03, the pre-gate fixes⟩ And when it was LAST paid (`lastPaidAtNs`; null when never).
+   * / Named callers: an owner console's approval card for a payment request.
+   */
+  getRecipientHistory: ActorMethod<[string], Result_65>;
   /**
    * / Whether the metrics reader's read is answered — `true` from birth.
    * /
@@ -1259,8 +1413,13 @@ 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.
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
    */
-  getSigningFloor: ActorMethod<[], Result_62>;
+  getSigningFloor: ActorMethod<[], Result_64>;
   /**
    * / The registry that spawned this engram, if it recorded one.
    * /
@@ -1280,8 +1439,10 @@ export interface Engram {
    * / configuration, and the engram-wide total would also tell one agent how much the others spent.
    * / 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.
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
    */
-  getSpendCeiling: ActorMethod<[], Result_61>;
+  getSpendCeiling: ActorMethod<[], Result_63>;
   /**
    * / Read the caps in force for a caller.
    * /
@@ -1290,9 +1451,18 @@ export interface Engram {
    * / Here the engram serves no 402s at all: these caps are the owner's private custody
    * / 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.
+   * /
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner, through the combinator's `#ownerOrSignIn` (a first
+   * / engram is unchanged: the owner only). The inline owner comparison that stood here is gone with it —
+   * / one fewer unnamed caller guard. Its refusal sentence is kept as the reason it never fails soft:
+   * / "Spending caps are the owner's custody configuration. Refusing rather than answering with
+   * / defaults — a default-looking answer would understate the real limits to anyone probing them." The
+   * / refusal itself is now the combinator's (`#Refused getSpendPolicy: …`, `requireOwner`'s words), and
+   * / an engram with no owner yet is refused the same way rather than answered `#Conflict`.
    */
-  getSpendPolicy: ActorMethod<[[] | [Principal]], Result_60>;
-  getStorageStats: ActorMethod<[], Result_59>;
+  getSpendPolicy: ActorMethod<[[] | [Principal]], Result_62>;
+  getStorageStats: ActorMethod<[], Result_61>;
   /**
    * / 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,
@@ -1377,14 +1547,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_58>;
+  getWalletBalances: ActorMethod<[], Result_60>;
   /**
    * / 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_57>;
+  getWorldIdConfig: ActorMethod<[], Result_59>;
   /**
    * / ⟨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
@@ -1395,7 +1565,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_56>;
+  getWorldIdRpContext: ActorMethod<[], Result_58>;
   /**
    * / 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
@@ -1406,8 +1576,11 @@ export interface Engram {
    * / awaits `worldIdRpPublicKey()` (management `ecdsa_public_key`), and it calls `denied()` on
    * / 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).
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`AccessControl.requireOwnerOrSignIn`); a first
+   * / engram is unchanged.
    */
-  getWorldIdRpSignerAddress: ActorMethod<[], Result_53>;
+  getWorldIdRpSignerAddress: ActorMethod<[], Result_55>;
   /**
    * / 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.
@@ -1428,7 +1601,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_55>;
+  getWorldIdVerification: ActorMethod<[], Result_57>;
   /**
    * / ⟨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
@@ -1511,8 +1684,11 @@ 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".
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`AccessControl.requireOwnerOrSignIn`); a first
+   * / engram is unchanged.
    */
-  isEvmAddressCached: ActorMethod<[], Result_54>;
+  isEvmAddressCached: ActorMethod<[], Result_56>;
   /**
    * / 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
@@ -1521,7 +1697,7 @@ export interface Engram {
    * /
    * / Owner-only: only the engram owner can authorize a Connector install.
    */
-  issueAuthCode: ActorMethod<[string, string, string, [] | [string]], Result_53>;
+  issueAuthCode: ActorMethod<[string, string, string, [] | [string]], Result_55>;
   /**
    * / ⟨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,
@@ -1537,7 +1713,7 @@ 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_52>;
+  listActivitySnapshots: ActorMethod<[bigint, bigint], Result_54>;
   /**
    * / ⟨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
@@ -1555,8 +1731,10 @@ export interface Engram {
    * / 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.
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
    */
-  listAgentSpendToday: ActorMethod<[bigint, bigint], Result_51>;
+  listAgentSpendToday: ActorMethod<[bigint, bigint], Result_53>;
   /**
    * / ⟨0.16.0⟩ THE PAGE EXEMPLAR. Trap → `#Refused`, bare array → `Result<Page<T>>` (L1 + L3).
    * /
@@ -1572,8 +1750,10 @@ 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.
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
    */
-  listAgents: ActorMethod<[bigint, bigint], Result_50>;
+  listAgents: ActorMethod<[bigint, bigint], Result_52>;
   /**
    * / The GUARDIAN-audience projection of the agent roster — three fields, not the full record.
    * /
@@ -1587,7 +1767,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_49>;
+  listAgentsForGuardian: ActorMethod<[bigint, bigint], Result_51>;
   /**
    * / Owner-only: rows carry caller, amount, operation and free-text rationale. The SDK omits it.
    * /
@@ -1601,7 +1781,7 @@ export interface Engram {
    * /
    * / Refusal reason preserved: `[]` reads as "nothing is awaiting the owner's decision".
    */
-  listApprovalRequests: ActorMethod<[[] | [ApprovalStatus], bigint, bigint], Result_35>;
+  listApprovalRequests: ActorMethod<[[] | [ApprovalStatus], bigint, bigint], Result_37>;
   /**
    * / ⟨0.16.0⟩ `total` IS THE HEAD COUNTER, and on this method that is the entire point.
    * /
@@ -1637,7 +1817,7 @@ export interface Engram {
    * / 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>;
+  listAuditEntries: ActorMethod<[bigint, bigint], Result_50>;
   /**
    * / ⟨0.16.0, L1 + L3 — census-ruled⟩ THE TWO-MECHANISM EXCEPTION DISSOLVES.
    * /
@@ -1663,7 +1843,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_47>;
+  listBackups: ActorMethod<[bigint, bigint], Result_49>;
   /**
    * / List all bearer tokens — Active, Revoked, and Expired. Owner uses this in
    * / the dashboard to show installed Connectors (claude.ai, Claude Desktop, etc.).
@@ -1674,8 +1854,10 @@ export interface Engram {
    * / `bearerTokenStore.list()` already resolves each token's status at read time (a token that
    * / 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.
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
    */
-  listBearerTokens: ActorMethod<[bigint, bigint], Result_46>;
+  listBearerTokens: ActorMethod<[bigint, bigint], Result_48>;
   /**
    * / The condense checkpoints in the retained log at or above `startSeq`, oldest first.
    * /
@@ -1687,7 +1869,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_45>;
+  listCondenseCheckpoints: ActorMethod<[bigint, bigint], Result_47>;
   /**
    * / ⟨0.16.0⟩ `metrics()` DELETED — absorbed by `about()`.
    * /
@@ -1696,13 +1878,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_44>;
+  listCycleSnapshots: ActorMethod<[bigint, bigint], Result_46>;
   /**
    * / 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_43>;
+  listDeletedMemoryFiles: ActorMethod<[bigint, bigint], Result_45>;
   /**
    * / Stays on the engram under B1 (hybrid): withdrawal custody does not leave.
    * /
@@ -1718,7 +1900,7 @@ export interface Engram {
    * / 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.
    */
-  listEip712Destinations: ActorMethod<[Uint8Array | number[], bigint, bigint], Result_42>;
+  listEip712Destinations: ActorMethod<[Uint8Array | number[], bigint, bigint], Result_44>;
   /**
    * / 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.
@@ -1731,7 +1913,7 @@ export interface Engram {
    * / 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>;
+  listEip712Types: ActorMethod<[bigint, bigint], Result_43>;
   /**
    * / ⟨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
@@ -1739,7 +1921,7 @@ export interface Engram {
    * / guardian's entry, not the agent's); a stranger, a pending guardian and the anonymous caller are
    * / refused.
    */
-  listGuardianDisputes: ActorMethod<[bigint, bigint], Result_40>;
+  listGuardianDisputes: ActorMethod<[bigint, bigint], Result_42>;
   /**
    * / Accessible by owner and guardians.
    * /
@@ -1748,7 +1930,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_39>;
+  listGuardians: ActorMethod<[bigint, bigint], Result_41>;
   /**
    * / The export receipts in the retained log at or above `startSeq`, oldest first.
    * /
@@ -1766,7 +1948,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_38>;
+  listMemoryExportReceipts: ActorMethod<[bigint, bigint], Result_40>;
   /**
    * / ⟨0.16.0⟩ THE `withheld` EXEMPLAR — L1 names this exact method as the defect it fixes.
    * /
@@ -1793,7 +1975,7 @@ export interface Engram {
    * / 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_37>;
+  listMemoryFiles: ActorMethod<[bigint, bigint], Result_39>;
   /**
    * / One page of the memory log, seq-ordered, optionally narrowed to one author.
    * /
@@ -1820,7 +2002,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_36>;
+  listMemoryLog: ActorMethod<[bigint, bigint, [] | [Principal]], Result_38>;
   /**
    * / The caller's OWN spend-approval requests. ⟨0.16.0, L1 + L3 — fixed 2026-08-18⟩
    * /
@@ -1839,7 +2021,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_35>;
+  listMyApprovalRequests: ActorMethod<[bigint, bigint], Result_37>;
   /**
    * / 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.
@@ -1850,7 +2032,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_34>;
+  listMySessions: ActorMethod<[bigint, bigint], Result_36>;
   /**
    * /
    * / ⟨0.16.0, L3⟩ Paged and enveloped like every other `list*`, and the envelope here is uniformity
@@ -1865,7 +2047,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_33>;
+  listOwnershipTransfers: ActorMethod<[bigint, bigint], Result_35>;
   /**
    * / ⟨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
@@ -1882,8 +2064,10 @@ export interface Engram {
    * / marketplace's one shared count today is in the reply's `marketplace` field, with the limit this
    * / engram enforces for it — beside the agents, never a row among them
    * / (`PaymentSignCap.marketplaceRow`). Null when no marketplace is set.
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
    */
-  listPaymentSignatureCounts: ActorMethod<[bigint, bigint], Result_32>;
+  listPaymentSignatureCounts: ActorMethod<[bigint, bigint], Result_34>;
   /**
    * / 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.
@@ -1924,8 +2108,10 @@ export interface Engram {
    * / `invite` its enrolment named, and `ended` — why and on what day its engagement ended (its own
    * / earlier ending, or the reset) — the facts `resyncAgentEdges` re-sends. The stored rows are
    * / served as they are.
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
    */
-  listPurgedAgents: ActorMethod<[bigint, bigint], Result_31>;
+  listPurgedAgents: ActorMethod<[bigint, bigint], Result_33>;
   /**
    * / ⟨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.
@@ -1988,7 +2174,7 @@ 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_30>;
+  listReadLog: ActorMethod<[[] | [boolean], bigint, bigint], Result_32>;
   /**
    * / ⟨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
@@ -1996,7 +2182,7 @@ export interface Engram {
    * / 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>;
+  listRecordNotes: ActorMethod<[bigint, bigint], Result_31>;
   /**
    * / 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
@@ -2013,7 +2199,16 @@ 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_28>;
+  listRepudiations: ActorMethod<[bigint, bigint], Result_30>;
+  /**
+   * / The seller list, a page at a time, as `Types.SellerView` (a raise whose wait is over shown applied;
+   * / `liveNow` — false for every row while an engram opened through another has no sign-in seated; what
+   * / x402 reserved for each today). For the key file and the sign-in in an engram opened
+   * / through another, the owner in a first engram; refused loudly to anyone else — never an empty page,
+   * / which would read as "no sellers". A QUERY: the refusal is in the reply, not the denial log.
+   * / Named callers: an owner console's seller list.
+   */
+  listSellers: ActorMethod<[bigint, bigint], Result_29>;
   /**
    * / ⟨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`,
@@ -2023,8 +2218,10 @@ export interface Engram {
    * / 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.
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
    */
-  listSignIns: ActorMethod<[bigint, bigint], Result_27>;
+  listSignIns: ActorMethod<[bigint, bigint], Result_28>;
   /**
    * / 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
@@ -2036,7 +2233,7 @@ 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_14>;
+  markAgentWritesReviewed: ActorMethod<[[] | [bigint]], Result_15>;
   /**
    * / ⟨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
@@ -2056,7 +2253,7 @@ export interface Engram {
    * / ⟨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>;
+  myGrant: ActorMethod<[], Result_27>;
   /**
    * / 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
@@ -2067,7 +2264,7 @@ export interface Engram {
   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
+   * / its own cycles to the registry's `sysOpenChild`; the agent's lasting key owns what is opened, and
    * / the engram is recorded as opened through this one. Answers the new engram's canister id.
    * /
    * / APPROVING IS GIVING: the owner allowed this with `setChildAllowance`, and what is attached is the
@@ -2094,9 +2291,30 @@ 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_25>;
-  openSession: ActorMethod<[SessionConfig, PaymentSignature], Result_24>;
+   * /
+   * / ⟨2026-11-02, the owner's ruling "1-4 all as you recommended" (the child build's stage 2)⟩ THE
+   * / SIGN-IN. `signIn` names the opened engram's sign-in — the person running the agent, on a second
+   * / credential; null opens it with none, and it then keeps small limits for life. It goes to the
+   * / registry's door and from there into the opened engram's init record, so that engram never runs a
+   * / message without it. Refused here first, with no await and before the allowance is taken, by the
+   * / door's own three rules (`OwnerSignIn.candidateRefusal`): the agent's lasting key itself, the
+   * / anonymous principal, a canister — so the agent sees the refusal before any cycles move. The
+   * / record entry says `signIn=set` or `signIn=none`, never the principal.
+   * / ⟨2026-11-02, the stage-2 review M3, beside the above⟩ And a fourth, the door's own: the key this
+   * / call is signed by — the agent's session key — is refused as the sign-in too
+   * / (`OwnerSignIn.agentKeyRefusal`), at the same place.
+   * /
+   * / ⟨2026-11-02, the child build's stage 2 — RENAMED from `openChildEngram`, beside the paragraphs
+   * / above, which describe the same door⟩ It was `openChildEngram()`, with no argument. A second
+   * / positional argument would grow its argument tuple, and a shipped tuple is frozen (evolution
+   * / happens inside records), so the door takes ONE record whose later fields are optional, under a
+   * / new name — the shape the registry's own door took the same day (`sysSpawnChild` →
+   * / `sysOpenChild`). An rc.21 kit calling the old name is rejected
+   * / (IC0536) with nothing spent; it can never open an engram without a sign-in by accident.
+   * / Named caller: the owner kit's `open-engram` command, signed by the agent's session key.
+   */
+  openChild: ActorMethod<[{ signIn: [] | [Principal] }], Result_26>;
+  openSession: ActorMethod<[SessionConfig, PaymentSignature], Result_25>;
   /**
    * / 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
@@ -2104,7 +2322,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_14>;
+  ownerWithdraw: ActorMethod<[TokenAmount, [] | [ActionAuth]], Result_15>;
   /**
    * / ⟨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.
@@ -2161,7 +2379,7 @@ 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_23>;
+  pairAgent: ActorMethod<[{ enrolment: Enrolment; code: string }], Result_24>;
   /**
    * / ⟨0.16.0, L2.2 — renamed from `guardianPauseWrites`⟩ Same correction as freezePayments above:
    * / owner-or-guardian, and `resumeWrites` never carried the prefix either.
@@ -2192,7 +2410,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_22>;
+  previewCondense: ActorMethod<[bigint], Result_23>;
   /**
    * / 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.
@@ -2240,8 +2458,10 @@ export interface Engram {
    * / 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.
+   * / ⟨2026-11-03, the pre-gate fixes — spec §7, "child: sign-in — reads yes"⟩ Also the seated sign-in of
+   * / an engram opened through another, as the owner (`#ownerOrSignIn`); a first engram is unchanged.
    */
-  previewRetention: ActorMethod<[Array<[string, RetentionClassSpec]>], Result_21>;
+  previewRetention: ActorMethod<[Array<[string, RetentionClassSpec]>], Result_22>;
   /**
    * / Read one memory file at its current version.
    * /
@@ -2258,7 +2478,7 @@ export interface Engram {
    * / (`sessionReadContext` and the MCP reads). A caller measuring engram usage from this method
    * / will measure nothing.
    */
-  readMemory: ActorMethod<[string], Result_12>;
+  readMemory: ActorMethod<[string], Result_13>;
   /**
    * / 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.
@@ -2276,7 +2496,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_20>;
+  readMemoryBatch: ActorMethod<[Array<string>], Result_21>;
   /**
    * / ⟨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
@@ -2288,7 +2508,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_19>;
+  readMemoryBytes: ActorMethod<[string, bigint, bigint, [] | [bigint]], Result_20>;
   /**
    * / The escrow exit for a session whose settle cannot pay.
    * /
@@ -2353,7 +2573,7 @@ export interface Engram {
    * / 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_18>;
+  recoverEscrow: ActorMethod<[string, bigint], Result_19>;
   /**
    * / ⟨0.16.0, L1⟩ A REDEMPTION PATH, where the arm choice is a disclosure decision.
    * /
@@ -2369,7 +2589,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_17>;
+  registerGuardian: ActorMethod<[string], Result_18>;
   /**
    * / Remove a per-caller override so that caller reverts to — and keeps TRACKING — the global caps.
    * /
@@ -2408,6 +2628,15 @@ export interface Engram {
    * / line, so the roster is theirs and its contents are not a secret being withheld from them.
    */
   removeGuardian: ActorMethod<[Principal], Result_2>;
+  /**
+   * / Remove a listed seller, at once: from now a payment to it meets the engram-wide ceiling and the
+   * / paying agent's own limits again, and adding it back waits 24 hours. Removing TIGHTENS, so the key
+   * / file may do it as well as the sign-in, and it works while payments are frozen. Its "paid before"
+   * / history is kept (that is about the address, not the row). Unknown address `#NotFound`.
+   * / Named callers: an owner console's seller list, and the owner kit (the key file's way to stop a
+   * / seller).
+   */
+  removeSeller: ActorMethod<[string], 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.
@@ -2426,7 +2655,7 @@ export interface Engram {
    * / 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_14>;
+  repudiateMemoryWrite: ActorMethod<[string, bigint, string], Result_15>;
   /**
    * / ⚠ OWNER-ONLY BULK RESET. Destructive, and wider than its name suggests.
    * /
@@ -2446,6 +2675,10 @@ export interface Engram {
    * /   · ⟨2026-10-02⟩ the seat weeks of every engagement (`agentSeatWeeks`), with the signature count
    * /     they sit beside, and the owner's switch over the metrics reader's read and the reader it
    * /     names — a reset severs access, it does not change who may read what was kept.
+   * /   · ⟨2026-11-02, the child build — decided "unless you object", recorded at stage 5⟩ the seller
+   * /     list and the paid history (`listSellers`, `getRecipientHistory`), as the typed-data
+   * /     destinations are kept: a reset severs access, it does not forget which counterparties the
+   * /     owner approved or which addresses this engram has paid.
    * /
    * / ⟨2026-10-02⟩ It tells the spawning registry that it happened (`sysNoteReset`), on every reset.
    * /
@@ -2456,7 +2689,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_16>;
+  resetEngram: ActorMethod<[], Result_17>;
   /**
    * / ⟨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.
@@ -2508,7 +2741,7 @@ 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_15>;
+  resyncAgentEdges: ActorMethod<[], Result_16>;
   /**
    * / 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
@@ -2570,7 +2803,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_14>;
+  revokeAllAgents: ActorMethod<[], Result_15>;
   /**
    * / Owner-only panic button: revoke every connector bearer token at once. Returns how many.
    * /
@@ -2581,7 +2814,7 @@ export interface Engram {
    * /
    * / Tokens are re-issuable: revoking them is not permanent the way revoking an agent is.
    */
-  revokeAllBearerTokens: ActorMethod<[], Result_14>;
+  revokeAllBearerTokens: ActorMethod<[], Result_15>;
   /**
    * / ⟨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
@@ -2595,7 +2828,7 @@ 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_14>;
+  revokeAllInvites: ActorMethod<[], Result_15>;
   /**
    * / Revoke a bearer token by its public tokenId. Idempotent.
    * / Subsequent /mcp requests using this token will be rejected.
@@ -2628,6 +2861,34 @@ export interface Engram {
    * / agent reading `#Refused` would go looking for a permission that was never missing.
    */
   rotateAgentKeyHash: ActorMethod<[string], Result_2>;
+  /**
+   * / Send money from this engram's wallet to the engram it was opened through — "up", and only up:
+   * / the destination is always the parent engram's own default account, never an address the caller
+   * / names. ANY amount (the owner's ruling "B"); the answer is the ledger's block index.
+   * /
+   * / WHO: the owner's key file or the sign-in, in an engram opened through another (the build's
+   * / resolution L14: both may send — the key file's honest sweep needs it, and the sign-in may sweep
+   * / too); refused to anyone else. In a first engram there is nothing above it, and it refuses with
+   * / `#Conflict`. NOT freeze-gated: up is not out, so a payments freeze does not stop it.
+   * /
+   * / ORDER: the caller, then the parent from this engram's own birth record (`openedFrom`, no await),
+   * / then ONE call to the registry — refused unless the registry shows the parent registered, active
+   * / and not abandoned (`#Refused`; the registry unreachable is `#Unavailable`; nothing sent either
+   * / way) — then ONE ledger transfer, the same per-token ledger as `ownerWithdraw`. Both calls are
+   * / counted (ADR-0025), so near its freezing line this engram may be unable to send the registry
+   * / call at all; it then answers `#Unavailable` and nothing moves.
+   * /
+   * / NO RE-CHECK between the two calls, deliberately: the parent can be abandoned in between, and the
+   * / money then sits in an existing canister whose owner can still withdraw it. Guarding that window
+   * / would need a third call and buys nothing the owner of the parent does not already have.
+   * /
+   * / NOT INCOME. The parent's track record is engagements, standing, seat-weeks and counts of use, and
+   * / signature counts count signatures; nothing reads a ledger balance, and this method calls none of
+   * / those writers (test/child-sign-in-wiring.test.ts rule 13). Written to the record as
+   * / `wallet.sendToParent` (money class), with the amount, the token, the parent and the block.
+   * / Named callers: the owner kit, signed by the key file; an owner console, signed in as the sign-in.
+   */
+  sendToParent: ActorMethod<[TokenAmount], Result_15>;
   /**
    * / 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.
@@ -2674,7 +2935,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_13>;
+  sessionReadContext: ActorMethod<[string], Result_14>;
   /**
    * / 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.
@@ -2706,7 +2967,7 @@ export interface Engram {
    * /     cent voucher could read `secrets/*`.
    * /   · Payments are frozen on this engram.
    */
-  sessionReadMemory: ActorMethod<[Voucher, string], Result_12>;
+  sessionReadMemory: ActorMethod<[Voucher, string], Result_13>;
   /**
    * / 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
@@ -2760,7 +3021,7 @@ export interface Engram {
    * / 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_11>;
+  setBackupRetention: ActorMethod<[string, bigint], Result_12>;
   /**
    * / Override the caps for ONE caller — an agent this owner trusts more, or less, than the rest.
    */
@@ -2839,6 +3100,18 @@ export interface Engram {
    * / only cost is a delay on keeping MORE, which destroys nothing.
    */
   setMemoryRetentionPolicy: ActorMethod<[Array<[string, RetentionClassSpec]>], Result_2>;
+  /**
+   * / The SIGN-IN changes itself to `next` — "changeable only by itself". Immediate (a delay would need
+   * / a third credential to cut it short). The key file is refused by name: it never names a sign-in,
+   * / or a thief holding a copy would name themselves. A first engram refuses: its owner is its own
+   * / sign-in. `next` must pass the door's rules and not be an agent or a guardian here. When this
+   * / engram holds a sealed copy of the owner's key, `resealedBackup` is that copy re-sealed for `next`
+   * / (the sign-in opens it and re-seals it client-side) and is stored in the same message, so the copy
+   * / never names a sign-in that is not this engram's; with no copy held, none may be passed. Not
+   * / blocked by a freeze: a freeze must not lock the sign-in out of itself.
+   * / Named caller: an owner console, signed in as the sign-in ("change your sign-in").
+   */
+  setOwnerSignIn: ActorMethod<[Principal, [] | [Uint8Array | number[]]], 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.
@@ -2877,6 +3150,15 @@ export interface Engram {
    * / when the read was on or off is part of the record. Anyone else is refused by name.
    */
   setSeatWeeksReadEnabled: ActorMethod<[boolean], Result_2>;
+  /**
+   * / Change a listed seller's daily cap. A LOWER (or equal) cap applies at once and cancels a raise that
+   * / was waiting; a HIGHER cap waits 24 hours, as a new seller does (the cap in force until then is the
+   * / old one, and a second raise restarts the wait). Answers when the new cap applies. The sign-in only,
+   * / in an engram opened through another; the owner in a first engram. A raise is refused while payments
+   * / are frozen; a lowering is not. Unknown address `#NotFound`; a cap of 0 `#Invalid` (remove instead).
+   * / Named callers: an owner console's seller list, as `addSeller`.
+   */
+  setSellerCap: ActorMethod<[string, bigint], Result_11>;
   /**
    * / 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⟩
@@ -2980,6 +3262,14 @@ export interface Engram {
    * / ⟨0.16.0⟩ PERSISTS beside the market's `sysSignEip712` (census row 177, ruled). The owner does
    * / not lose the ability to sign because a marketplace gained it, and the two share every control
    * / below the caller gate.
+   * /
+   * / ⟨2026-11-02, the owner's ruling "1-4 all as you recommended" (the sign-in "approves trading keys")
+   * / — the child build's stage 5⟩ In an engram opened through another, a type named
+   * / `HyperliquidTransaction:ApproveAgent` (`Eip712Policy.childSignInOnlyToSign`) is signed by the
+   * / sign-in alone: the key file is refused it by name, and the sign-in may sign it (as the owner, on
+   * / the record). Every other type is the key file's to sign, as before. An access check beside the
+   * / owner gate, keyed by the registered NAME, before any of `eip712SignFor`'s eight checks; a first
+   * / engram is untouched (its owner is its own sign-in).
    */
   signEip712: ActorMethod<[Uint8Array | number[], Array<[string, Eip712Value]>], Result_5>;
   /**
@@ -3082,6 +3372,17 @@ export interface Engram {
    * / the same person again.
    */
   stepDownAsGuardian: ActorMethod<[], Result_2>;
+  /**
+   * / The key file stores the sealed copy of its own key — once, right after the engram is opened,
+   * / sealed by the owner kit for the sign-in named at birth. Refused in a first engram, when no
+   * / sign-in is seated (nobody could open it), when a copy is already held (set-once: a thief holding
+   * / the same file cannot overwrite the honest copy; a later sign-in's copy arrives through
+   * / `setOwnerSignIn`'s re-seal or `acceptSignIn`), and for an empty or oversized blob
+   * / (`OwnerSignIn.storeRefusal`). The engram stamps whom the copy is for from its own sign-in — the
+   * / caller never names it. Not blocked by a freeze: storing a recovery path loosens nothing.
+   * / Named caller: the owner kit, signed by the agent's lasting key, right after it opens the engram.
+   */
+  storeKeyBackup: ActorMethod<[Uint8Array | number[]], Result_2>;
   /**
    * / OWNER force-close, for a session the payer abandoned.
    * /
@@ -3383,6 +3684,10 @@ export interface Engram {
    * /
    * / 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.
+   * /
+   * / ⟨2026-11-02, the child build's stage 5⟩ In an engram opened through another, approving a trading
+   * / key (`HyperliquidTransaction:ApproveAgent`) is refused to the market (`#Refused`): it is signed by
+   * / that engram's sign-in alone, through `signEip712`.
    */
   sysSignEip712: ActorMethod<[Uint8Array | number[], Array<[string, Eip712Value]>], Result_5>;
   /**
@@ -3636,6 +3941,13 @@ export interface Ic402Maintenance {
   rateLimitRemoved: bigint;
   lastRunAtNs: bigint;
 }
+export interface KeyBackupStatus {
+  matchesSignIn: boolean;
+  copyWaitsWithAsk: boolean;
+  sealed: boolean;
+  sealedFor: [] | [Principal];
+  sealedAtNs: [] | [bigint];
+}
 export interface KeyNomination {
   key: Principal;
   atNs: bigint;
@@ -3643,7 +3955,7 @@ export interface KeyNomination {
 export interface LogPage {
   firstAvailableSeq: bigint;
   head: Uint8Array | number[];
-  page: Page_9;
+  page: Page_10;
 }
 export interface LogPosition {
   reads: bigint;
@@ -3825,6 +4137,15 @@ export interface OwnerRow {
   produced: bigint;
   firstPaymentDay: [] | [bigint];
 }
+export interface OwnerSignInView {
+  askedAtNs: [] | [bigint];
+  openedFrom: [] | [Principal];
+  declinedAtNs: [] | [bigint];
+  callerIsSignIn: boolean;
+  declinedBy: [] | [Principal];
+  callerIsAsked: boolean;
+  ownerSignIn: [] | [Principal];
+}
 export interface OwnershipTransfer {
   to: Principal;
   atNs: bigint;
@@ -3839,89 +4160,94 @@ export interface Page {
 export interface Page_1 {
   total: bigint;
   withheld: bigint;
-  items: Array<Repudiation>;
+  items: Array<SellerView>;
 }
 export interface Page_10 {
   total: bigint;
   withheld: bigint;
-  items: Array<MemoryFileRow>;
+  items: Array<MemoryLogEvent>;
 }
 export interface Page_11 {
   total: bigint;
   withheld: bigint;
-  items: Array<ExportReceiptRow>;
+  items: Array<MemoryFileRow>;
 }
 export interface Page_12 {
   total: bigint;
   withheld: bigint;
-  items: Array<GuardianRecord>;
+  items: Array<ExportReceiptRow>;
 }
 export interface Page_13 {
   total: bigint;
   withheld: bigint;
-  items: Array<GuardianDispute>;
+  items: Array<GuardianRecord>;
 }
 export interface Page_14 {
   total: bigint;
   withheld: bigint;
-  items: Array<Eip712TypeView>;
+  items: Array<GuardianDispute>;
 }
 export interface Page_15 {
   total: bigint;
   withheld: bigint;
-  items: Array<Eip712Destination>;
+  items: Array<Eip712TypeView>;
 }
 export interface Page_16 {
   total: bigint;
   withheld: bigint;
-  items: Array<string>;
+  items: Array<Eip712Destination>;
 }
 export interface Page_17 {
   total: bigint;
   withheld: bigint;
-  items: Array<CycleSnapshot>;
+  items: Array<string>;
 }
 export interface Page_18 {
   total: bigint;
   withheld: bigint;
-  items: Array<CondenseCheckpointRow>;
+  items: Array<CycleSnapshot>;
 }
 export interface Page_19 {
   total: bigint;
   withheld: bigint;
-  items: Array<BearerToken>;
+  items: Array<CondenseCheckpointRow>;
 }
 export interface Page_2 {
   total: bigint;
   withheld: bigint;
-  items: Array<RecordNote>;
+  items: Array<Repudiation>;
 }
 export interface Page_20 {
   total: bigint;
   withheld: bigint;
-  items: Array<BackupMetadata>;
+  items: Array<BearerToken>;
 }
 export interface Page_21 {
   total: bigint;
   withheld: bigint;
-  items: Array<{ status: AgentStatus; principal: Principal; name: string }>;
+  items: Array<BackupMetadata>;
 }
 export interface Page_22 {
   total: bigint;
   withheld: bigint;
-  items: Array<AgentRecord>;
+  items: Array<{ status: AgentStatus; principal: Principal; name: string }>;
 }
 export interface Page_23 {
   total: bigint;
   withheld: bigint;
-  items: Array<AgentSpendRow>;
+  items: Array<AgentRecord>;
 }
 export interface Page_24 {
   total: bigint;
   withheld: bigint;
-  items: Array<ActivitySnapshot>;
+  items: Array<AgentSpendRow>;
 }
 export interface Page_25 {
+  total: bigint;
+  withheld: bigint;
+  items: Array<ActivitySnapshot>;
+}
+export interface Page_26 {
   total: bigint;
   withheld: bigint;
   items: Array<OwnerRow>;
@@ -3929,37 +4255,37 @@ export interface Page_25 {
 export interface Page_3 {
   total: bigint;
   withheld: bigint;
-  items: Array<AuditEntry>;
+  items: Array<RecordNote>;
 }
 export interface Page_4 {
   total: bigint;
   withheld: bigint;
-  items: Array<PurgedAgent>;
+  items: Array<AuditEntry>;
 }
 export interface Page_5 {
   total: bigint;
   withheld: bigint;
-  items: Array<AgentPaymentSignatures>;
+  items: Array<PurgedAgent>;
 }
 export interface Page_6 {
   total: bigint;
   withheld: bigint;
-  items: Array<OwnershipTransfer>;
+  items: Array<AgentPaymentSignatures>;
 }
 export interface Page_7 {
   total: bigint;
   withheld: bigint;
-  items: Array<EngramSessionState>;
+  items: Array<OwnershipTransfer>;
 }
 export interface Page_8 {
   total: bigint;
   withheld: bigint;
-  items: Array<ApprovalRequest>;
+  items: Array<EngramSessionState>;
 }
 export interface Page_9 {
   total: bigint;
   withheld: bigint;
-  items: Array<MemoryLogEvent>;
+  items: Array<ApprovalRequest>;
 }
 export interface Pairing {
   agent: AgentRecord;
@@ -3987,7 +4313,7 @@ export interface PaymentSignature {
 export interface PaymentSignatureCounts {
   day: bigint;
   marketplace: [] | [MarketplacePaymentSignatures];
-  agents: Page_5;
+  agents: Page_6;
   limit: bigint;
 }
 export interface PaymentsNow {
@@ -4022,9 +4348,19 @@ export interface RailHealth {
 }
 export interface ReceiptPage {
   firstAvailableSeq: bigint;
-  page: Page_11;
+  page: Page_12;
   scannedThroughSeq: bigint;
 }
+export interface RecipientHistory {
+  historyFull: boolean;
+  firstPaidAtNs: [] | [bigint];
+  timesPaid: bigint;
+  paidBefore: boolean;
+  liveNow: boolean;
+  lastPaidAtNs: [] | [bigint];
+  largestPaidE6: bigint;
+  listedSeller: boolean;
+}
 export interface RecordNote {
   about: bigint;
   atNs: bigint;
@@ -4054,85 +4390,89 @@ export interface ResetReport {
 export type Result = { Ok: WriteReceipt } | { 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_11 = { Ok: { activatesAtNs: bigint } } | { Err: Error };
+export type Result_12 = { Ok: BackupRetentionReport } | { Err: Error };
+export type Result_13 = { Ok: MemoryFile } | { Err: Error };
+export type Result_14 = { Ok: SessionContext } | { Err: Error };
+export type Result_15 = { Ok: bigint } | { Err: Error };
+export type Result_16 = { Ok: ResyncReport } | { Err: Error };
+export type Result_17 = { Ok: ResetReport } | { Err: Error };
+export type Result_18 = { Ok: GuardianRecord } | { Err: Error };
+export type Result_19 = { Ok: EngramEscrowRecovery } | { 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_20 = { Ok: MemoryByteChunk } | { Err: Error };
+export type Result_21 = { Ok: Array<BatchReadItem> } | { Err: Error };
+export type Result_22 = { Ok: RetentionPreview } | { Err: Error };
+export type Result_23 = { Ok: CondensePreview } | { Err: Error };
+export type Result_24 = { Ok: Pairing } | { Err: Error };
+export type Result_25 = { Ok: EngramSessionState } | { Err: Error };
+export type Result_26 = { Ok: Principal } | { Err: Error };
+export type Result_27 = { Ok: AgentGrant } | { Err: Error };
+export type Result_28 = { Ok: Page } | { Err: Error };
+export type Result_29 = { Ok: Page_1 } | { 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_30 = { Ok: Page_2 } | { Err: Error };
+export type Result_31 = { Ok: Page_3 } | { Err: Error };
+export type Result_32 = { Ok: Page_4 } | { Err: Error };
+export type Result_33 = { Ok: Page_5 } | { Err: Error };
+export type Result_34 = { Ok: PaymentSignatureCounts } | { Err: Error };
+export type Result_35 = { Ok: Page_7 } | { Err: Error };
+export type Result_36 = { Ok: Page_8 } | { Err: Error };
+export type Result_37 = { Ok: Page_9 } | { Err: Error };
+export type Result_38 = { Ok: LogPage } | { Err: Error };
+export type Result_39 = { Ok: Page_11 } | { 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_40 = { Ok: ReceiptPage } | { Err: Error };
+export type Result_41 = { Ok: Page_13 } | { Err: Error };
+export type Result_42 = { Ok: Page_14 } | { Err: Error };
+export type Result_43 = { Ok: Page_15 } | { Err: Error };
+export type Result_44 = { Ok: Page_16 } | { Err: Error };
+export type Result_45 = { Ok: Page_17 } | { Err: Error };
+export type Result_46 = { Ok: Page_18 } | { Err: Error };
+export type Result_47 = { Ok: CheckpointPage } | { Err: Error };
+export type Result_48 = { Ok: Page_20 } | { 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_50 = { Ok: RecordPage } | { Err: Error };
+export type Result_51 = { Ok: Page_22 } | { Err: Error };
+export type Result_52 = { Ok: Page_23 } | { Err: Error };
+export type Result_53 = { Ok: AgentSpendToday } | { Err: Error };
+export type Result_54 = { Ok: Page_25 } | { Err: Error };
+export type Result_55 = { Ok: string } | { Err: Error };
+export type Result_56 = { Ok: boolean } | { Err: Error };
+export type Result_57 = { Ok: [] | [string] } | { Err: Error };
+export type Result_58 = { Ok: WorldIdRpContext } | { Err: Error };
+export type Result_59 = { Ok: WorldIdConfig } | { 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_60 = { Ok: WalletBalances } | { Err: Error };
+export type Result_61 = { Ok: StorageReport } | { Err: Error };
+export type Result_62 = { Ok: SpendingPolicy } | { Err: Error };
+export type Result_63 = { Ok: SpendCeiling } | { Err: Error };
+export type Result_64 = { Ok: SigningFloorStatus } | { Err: Error };
+export type Result_65 = { Ok: RecipientHistory } | { Err: Error };
+export type Result_66 = { Ok: { paths: Array<string> } } | { Err: Error };
+export type Result_67 = { Ok: OwnerSignInView } | { Err: Error };
+export type Result_68 = { Ok: OwnerConsole } | { Err: Error };
+export type Result_69 = { Ok: MemoryRetentionPolicy } | { 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_70 = { Ok: MemoryHistory } | { Err: Error };
+export type Result_71 = { Ok: KeyBackupStatus } | { Err: Error };
+export type Result_72 = { Ok: Uint8Array | number[] } | { Err: Error };
+export type Result_73 = { Ok: AlertStatus } | { Err: Error };
+export type Result_74 = { Ok: EvmAddresses } | { Err: Error };
+export type Result_75 = { Ok: ChildOpening } | { Err: Error };
+export type Result_76 = { Ok: ChildAllowanceRow } | { Err: Error };
+export type Result_77 = { Ok: Brakes } | { Err: Error };
+export type Result_78 = { Ok: Array<BirthRecord> } | { Err: Error };
+export type Result_79 = { Ok: BackupRetention } | { 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_80 = { Ok: BackupMetadata } | { Err: Error };
+export type Result_81 = { Ok: AgentWriteReview } | { Err: Error };
+export type Result_82 = { Ok: Page_26 } | { Err: Error };
+export type Result_84 = { Ok: MemoryRangeExport } | { Err: Error };
+export type Result_85 = { Ok: CondenseResult } | { Err: Error };
+export type Result_87 = { Ok: Eip712Registration } | { Err: Error };
+export type Result_89 = { Ok: AgentRecord } | { Err: Error };
 export type Result_9 = { Ok: Array<Seat> } | { Err: Error };
 export interface ResyncReport {
   startsAcknowledged: bigint;
@@ -4195,6 +4535,18 @@ export interface Seat {
   produced: bigint;
   firstPaymentDay: [] | [bigint];
 }
+export interface SellerView {
+  spentTodayE6: bigint;
+  isPayout: boolean;
+  perDayCapE6: bigint;
+  addedBy: Principal;
+  activatesAtNs: bigint;
+  addedAtNs: bigint;
+  liveNow: boolean;
+  payTo: string;
+  pendingActivatesAtNs: [] | [bigint];
+  pendingCapE6: [] | [bigint];
+}
 export interface ServiceEntry {
   endpoint: string;
   name: string;