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

package/dist/engram.did

@@ -180,6 +180,19 @@ type ServiceEntry =
    skills: vec text;
    version: text;
  };
+type SellerView = 
+ record {
+   activatesAtNs: int;
+   addedAtNs: int;
+   addedBy: principal;
+   isPayout: bool;
+   liveNow: bool;
+   payTo: text;
+   pendingActivatesAtNs: opt int;
+   pendingCapE6: opt nat;
+   perDayCapE6: nat;
+   spentTodayE6: nat;
+ };
 type Seat = 
  record {
    firstPaymentDay: opt nat;
@@ -259,25 +272,40 @@ type Result_9 =
    Err: Error;
    Ok: vec Seat;
  };
-type Result_83 = 
+type Result_89 = 
  variant {
    Err: Error;
    Ok: AgentRecord;
  };
+type Result_87 = 
+ variant {
+   Err: Error;
+   Ok: Eip712Registration;
+ };
+type Result_85 = 
+ variant {
+   Err: Error;
+   Ok: CondenseResult;
+ };
+type Result_84 = 
+ variant {
+   Err: Error;
+   Ok: MemoryRangeExport;
+ };
 type Result_82 = 
  variant {
    Err: Error;
-   Ok: record {activatesAtNs: int;};
+   Ok: Page_26;
  };
 type Result_81 = 
  variant {
    Err: Error;
-   Ok: Eip712Registration;
+   Ok: AgentWriteReview;
  };
 type Result_80 = 
  variant {
    Err: Error;
-   Ok: CondenseResult;
+   Ok: BackupMetadata;
  };
 type Result_8 = 
  variant {
@@ -287,47 +315,52 @@ type Result_8 =
 type Result_79 = 
  variant {
    Err: Error;
-   Ok: MemoryRangeExport;
+   Ok: BackupRetention;
+ };
+type Result_78 = 
+ variant {
+   Err: Error;
+   Ok: vec BirthRecord;
  };
 type Result_77 = 
  variant {
    Err: Error;
-   Ok: Page_25;
+   Ok: Brakes;
  };
 type Result_76 = 
  variant {
    Err: Error;
-   Ok: AgentWriteReview;
+   Ok: ChildAllowanceRow;
  };
 type Result_75 = 
  variant {
    Err: Error;
-   Ok: BackupMetadata;
+   Ok: ChildOpening;
  };
 type Result_74 = 
  variant {
    Err: Error;
-   Ok: BackupRetention;
+   Ok: EvmAddresses;
  };
 type Result_73 = 
  variant {
    Err: Error;
-   Ok: vec BirthRecord;
+   Ok: AlertStatus;
  };
 type Result_72 = 
  variant {
    Err: Error;
-   Ok: Brakes;
+   Ok: blob;
  };
 type Result_71 = 
  variant {
    Err: Error;
-   Ok: ChildAllowanceRow;
+   Ok: KeyBackupStatus;
  };
 type Result_70 = 
  variant {
    Err: Error;
-   Ok: ChildOpening;
+   Ok: MemoryHistory;
  };
 type Result_7 = 
  variant {
@@ -337,52 +370,52 @@ type Result_7 =
 type Result_69 = 
  variant {
    Err: Error;
-   Ok: blob;
+   Ok: MemoryRetentionPolicy;
  };
 type Result_68 = 
  variant {
    Err: Error;
-   Ok: EvmAddresses;
+   Ok: OwnerConsole;
  };
 type Result_67 = 
  variant {
    Err: Error;
-   Ok: AlertStatus;
+   Ok: OwnerSignInView;
  };
 type Result_66 = 
  variant {
    Err: Error;
-   Ok: MemoryHistory;
+   Ok: record {paths: vec text;};
  };
 type Result_65 = 
  variant {
    Err: Error;
-   Ok: MemoryRetentionPolicy;
+   Ok: RecipientHistory;
  };
 type Result_64 = 
  variant {
    Err: Error;
-   Ok: OwnerConsole;
+   Ok: SigningFloorStatus;
  };
 type Result_63 = 
  variant {
    Err: Error;
-   Ok: record {paths: vec text;};
+   Ok: SpendCeiling;
  };
 type Result_62 = 
  variant {
    Err: Error;
-   Ok: SigningFloorStatus;
+   Ok: SpendingPolicy;
  };
 type Result_61 = 
  variant {
    Err: Error;
-   Ok: SpendCeiling;
+   Ok: StorageReport;
  };
 type Result_60 = 
  variant {
    Err: Error;
-   Ok: SpendingPolicy;
+   Ok: WalletBalances;
  };
 type Result_6 = 
  variant {
@@ -392,52 +425,52 @@ type Result_6 =
 type Result_59 = 
  variant {
    Err: Error;
-   Ok: StorageReport;
+   Ok: WorldIdConfig;
  };
 type Result_58 = 
  variant {
    Err: Error;
-   Ok: WalletBalances;
+   Ok: WorldIdRpContext;
  };
 type Result_57 = 
  variant {
    Err: Error;
-   Ok: WorldIdConfig;
+   Ok: opt text;
  };
 type Result_56 = 
  variant {
    Err: Error;
-   Ok: WorldIdRpContext;
+   Ok: bool;
  };
 type Result_55 = 
  variant {
    Err: Error;
-   Ok: opt text;
+   Ok: text;
  };
 type Result_54 = 
  variant {
    Err: Error;
-   Ok: bool;
+   Ok: Page_25;
  };
 type Result_53 = 
  variant {
    Err: Error;
-   Ok: text;
+   Ok: AgentSpendToday;
  };
 type Result_52 = 
  variant {
    Err: Error;
-   Ok: Page_24;
+   Ok: Page_23;
  };
 type Result_51 = 
  variant {
    Err: Error;
-   Ok: AgentSpendToday;
+   Ok: Page_22;
  };
 type Result_50 = 
  variant {
    Err: Error;
-   Ok: Page_22;
+   Ok: RecordPage;
  };
 type Result_5 = 
  variant {
@@ -452,47 +485,47 @@ type Result_49 =
 type Result_48 = 
  variant {
    Err: Error;
-   Ok: RecordPage;
+   Ok: Page_20;
  };
 type Result_47 = 
  variant {
    Err: Error;
-   Ok: Page_20;
+   Ok: CheckpointPage;
  };
 type Result_46 = 
  variant {
    Err: Error;
-   Ok: Page_19;
+   Ok: Page_18;
  };
 type Result_45 = 
  variant {
    Err: Error;
-   Ok: CheckpointPage;
+   Ok: Page_17;
  };
 type Result_44 = 
  variant {
    Err: Error;
-   Ok: Page_17;
+   Ok: Page_16;
  };
 type Result_43 = 
  variant {
    Err: Error;
-   Ok: Page_16;
+   Ok: Page_15;
  };
 type Result_42 = 
  variant {
    Err: Error;
-   Ok: Page_15;
+   Ok: Page_14;
  };
 type Result_41 = 
  variant {
    Err: Error;
-   Ok: Page_14;
+   Ok: Page_13;
  };
 type Result_40 = 
  variant {
    Err: Error;
-   Ok: Page_13;
+   Ok: ReceiptPage;
  };
 type Result_4 = 
  variant {
@@ -502,52 +535,52 @@ type Result_4 =
 type Result_39 = 
  variant {
    Err: Error;
-   Ok: Page_12;
+   Ok: Page_11;
  };
 type Result_38 = 
  variant {
    Err: Error;
-   Ok: ReceiptPage;
+   Ok: LogPage;
  };
 type Result_37 = 
  variant {
    Err: Error;
-   Ok: Page_10;
+   Ok: Page_9;
  };
 type Result_36 = 
  variant {
    Err: Error;
-   Ok: LogPage;
+   Ok: Page_8;
  };
 type Result_35 = 
  variant {
    Err: Error;
-   Ok: Page_8;
+   Ok: Page_7;
  };
 type Result_34 = 
  variant {
    Err: Error;
-   Ok: Page_7;
+   Ok: PaymentSignatureCounts;
  };
 type Result_33 = 
  variant {
    Err: Error;
-   Ok: Page_6;
+   Ok: Page_5;
  };
 type Result_32 = 
  variant {
    Err: Error;
-   Ok: PaymentSignatureCounts;
+   Ok: Page_4;
  };
 type Result_31 = 
  variant {
    Err: Error;
-   Ok: Page_4;
+   Ok: Page_3;
  };
 type Result_30 = 
  variant {
    Err: Error;
-   Ok: Page_3;
+   Ok: Page_2;
  };
 type Result_3 = 
  variant {
@@ -557,52 +590,52 @@ type Result_3 =
 type Result_29 = 
  variant {
    Err: Error;
-   Ok: Page_2;
+   Ok: Page_1;
  };
 type Result_28 = 
  variant {
    Err: Error;
-   Ok: Page_1;
+   Ok: Page;
  };
 type Result_27 = 
  variant {
    Err: Error;
-   Ok: Page;
+   Ok: AgentGrant;
  };
 type Result_26 = 
  variant {
    Err: Error;
-   Ok: AgentGrant;
+   Ok: principal;
  };
 type Result_25 = 
  variant {
    Err: Error;
-   Ok: principal;
+   Ok: EngramSessionState;
  };
 type Result_24 = 
  variant {
    Err: Error;
-   Ok: EngramSessionState;
+   Ok: Pairing;
  };
 type Result_23 = 
  variant {
    Err: Error;
-   Ok: Pairing;
+   Ok: CondensePreview;
  };
 type Result_22 = 
  variant {
    Err: Error;
-   Ok: CondensePreview;
+   Ok: RetentionPreview;
  };
 type Result_21 = 
  variant {
    Err: Error;
-   Ok: RetentionPreview;
+   Ok: vec BatchReadItem;
  };
 type Result_20 = 
  variant {
    Err: Error;
-   Ok: vec BatchReadItem;
+   Ok: MemoryByteChunk;
  };
 type Result_2 = 
  variant {
@@ -612,47 +645,47 @@ type Result_2 =
 type Result_19 = 
  variant {
    Err: Error;
-   Ok: MemoryByteChunk;
+   Ok: EngramEscrowRecovery;
  };
 type Result_18 = 
  variant {
    Err: Error;
-   Ok: EngramEscrowRecovery;
+   Ok: GuardianRecord;
  };
 type Result_17 = 
  variant {
    Err: Error;
-   Ok: GuardianRecord;
+   Ok: ResetReport;
  };
 type Result_16 = 
  variant {
    Err: Error;
-   Ok: ResetReport;
+   Ok: ResyncReport;
  };
 type Result_15 = 
  variant {
    Err: Error;
-   Ok: ResyncReport;
+   Ok: nat;
  };
 type Result_14 = 
  variant {
    Err: Error;
-   Ok: nat;
+   Ok: SessionContext;
  };
 type Result_13 = 
  variant {
    Err: Error;
-   Ok: SessionContext;
+   Ok: MemoryFile;
  };
 type Result_12 = 
  variant {
    Err: Error;
-   Ok: MemoryFile;
+   Ok: BackupRetentionReport;
  };
 type Result_11 = 
  variant {
    Err: Error;
-   Ok: BackupRetentionReport;
+   Ok: record {activatesAtNs: int;};
  };
 type Result_10 = 
  variant {
@@ -699,10 +732,21 @@ type RecordNote =
    auditId: nat;
    note: text;
  };
+type RecipientHistory = 
+ record {
+   firstPaidAtNs: opt int;
+   historyFull: bool;
+   largestPaidE6: nat;
+   lastPaidAtNs: opt int;
+   listedSeller: bool;
+   liveNow: bool;
+   paidBefore: bool;
+   timesPaid: nat;
+ };
 type ReceiptPage = 
  record {
    firstAvailableSeq: nat;
-   page: Page_11;
+   page: Page_12;
    scannedThroughSeq: nat;
  };
 type RailHealth = 
@@ -744,7 +788,7 @@ type PaymentsNow =
  };
 type PaymentSignatureCounts = 
  record {
-   agents: Page_5;
+   agents: Page_6;
    day: int;
    limit: nat;
    marketplace: opt MarketplacePaymentSignatures;
@@ -777,71 +821,71 @@ type Pairing =
  };
 type Page_9 = 
  record {
-   items: vec MemoryLogEvent;
+   items: vec ApprovalRequest;
    total: nat;
    withheld: nat;
  };
 type Page_8 = 
  record {
-   items: vec ApprovalRequest;
+   items: vec EngramSessionState;
    total: nat;
    withheld: nat;
  };
 type Page_7 = 
  record {
-   items: vec EngramSessionState;
+   items: vec OwnershipTransfer;
    total: nat;
    withheld: nat;
  };
 type Page_6 = 
  record {
-   items: vec OwnershipTransfer;
+   items: vec AgentPaymentSignatures;
    total: nat;
    withheld: nat;
  };
 type Page_5 = 
  record {
-   items: vec AgentPaymentSignatures;
+   items: vec PurgedAgent;
    total: nat;
    withheld: nat;
  };
 type Page_4 = 
  record {
-   items: vec PurgedAgent;
+   items: vec AuditEntry;
    total: nat;
    withheld: nat;
  };
 type Page_3 = 
  record {
-   items: vec AuditEntry;
+   items: vec RecordNote;
    total: nat;
    withheld: nat;
  };
-type Page_25 = 
+type Page_26 = 
  record {
    items: vec OwnerRow;
    total: nat;
    withheld: nat;
  };
-type Page_24 = 
+type Page_25 = 
  record {
    items: vec ActivitySnapshot;
    total: nat;
    withheld: nat;
  };
-type Page_23 = 
+type Page_24 = 
  record {
    items: vec AgentSpendRow;
    total: nat;
    withheld: nat;
  };
-type Page_22 = 
+type Page_23 = 
  record {
    items: vec AgentRecord;
    total: nat;
    withheld: nat;
  };
-type Page_21 = 
+type Page_22 = 
  record {
    items: vec record {
                 name: text;
@@ -851,81 +895,87 @@ type Page_21 =
    total: nat;
    withheld: nat;
  };
-type Page_20 = 
+type Page_21 = 
  record {
    items: vec BackupMetadata;
    total: nat;
    withheld: nat;
  };
+type Page_20 = 
+ record {
+   items: vec BearerToken;
+   total: nat;
+   withheld: nat;
+ };
 type Page_2 = 
  record {
-   items: vec RecordNote;
+   items: vec Repudiation;
    total: nat;
    withheld: nat;
  };
 type Page_19 = 
  record {
-   items: vec BearerToken;
+   items: vec CondenseCheckpointRow;
    total: nat;
    withheld: nat;
  };
 type Page_18 = 
  record {
-   items: vec CondenseCheckpointRow;
+   items: vec CycleSnapshot;
    total: nat;
    withheld: nat;
  };
 type Page_17 = 
  record {
-   items: vec CycleSnapshot;
+   items: vec text;
    total: nat;
    withheld: nat;
  };
 type Page_16 = 
  record {
-   items: vec text;
+   items: vec Eip712Destination;
    total: nat;
    withheld: nat;
  };
 type Page_15 = 
  record {
-   items: vec Eip712Destination;
+   items: vec Eip712TypeView;
    total: nat;
    withheld: nat;
  };
 type Page_14 = 
  record {
-   items: vec Eip712TypeView;
+   items: vec GuardianDispute;
    total: nat;
    withheld: nat;
  };
 type Page_13 = 
  record {
-   items: vec GuardianDispute;
+   items: vec GuardianRecord;
    total: nat;
    withheld: nat;
  };
 type Page_12 = 
  record {
-   items: vec GuardianRecord;
+   items: vec ExportReceiptRow;
    total: nat;
    withheld: nat;
  };
 type Page_11 = 
  record {
-   items: vec ExportReceiptRow;
+   items: vec MemoryFileRow;
    total: nat;
    withheld: nat;
  };
 type Page_10 = 
  record {
-   items: vec MemoryFileRow;
+   items: vec MemoryLogEvent;
    total: nat;
    withheld: nat;
  };
 type Page_1 = 
  record {
-   items: vec Repudiation;
+   items: vec SellerView;
    total: nat;
    withheld: nat;
  };
@@ -942,6 +992,16 @@ type OwnershipTransfer =
    from: opt principal;
    to: principal;
  };
+type OwnerSignInView = 
+ record {
+   askedAtNs: opt int;
+   callerIsAsked: bool;
+   callerIsSignIn: bool;
+   declinedAtNs: opt int;
+   declinedBy: opt principal;
+   openedFrom: opt principal;
+   ownerSignIn: opt principal;
+ };
 type OwnerRow = 
  record {
    firstPaymentDay: opt nat;
@@ -1157,13 +1217,21 @@ type LogPage =
  record {
    firstAvailableSeq: nat;
    head: blob;
-   page: Page_9;
+   page: Page_10;
  };
 type KeyNomination = 
  record {
    atNs: int;
    key: principal;
  };
+type KeyBackupStatus = 
+ record {
+   copyWaitsWithAsk: bool;
+   matchesSignIn: bool;
+   sealed: bool;
+   sealedAtNs: opt int;
+   sealedFor: opt principal;
+ };
 type Ic402Maintenance = 
  record {
    dailySpendRemoved: nat;
@@ -1342,7 +1410,13 @@ type Engram =
    /// nomination names. That check compares the caller inside the module, where
    /// test/key-replacement.test.mo runs it; this body names no roster gate, because the caller holds
    /// no role here until the move.
-   acceptAgentKeyNomination: (agentKey: principal) -> (Result_83);
+   acceptAgentKeyNomination: (agentKey: 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: () -> (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).
    /// 
@@ -1372,7 +1446,7 @@ type Engram =
    /// 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: (typeId: blob, value: text) -> (Result_82);
+   addEip712Destination: (typeId: blob, value: text) -> (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
    /// shape is IMMUTABLE: any change mints a new typeId.
@@ -1388,6 +1462,14 @@ type 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: (spec:
     record {
       ackIrrevocable: bool;
@@ -1412,7 +1494,7 @@ type Engram =
                   };
       primaryType: text;
       verifyingContract: text;
-    }) -> (Result_81);
+    }) -> (Result_87);
    /// ⟨0.16.0, L1⟩ THE ROLE-CONFLICT ARM, and why three refusals here are not the same refusal.
    /// 
    /// This method had five distinct ways to say no through one `text`, and a caller could only tell
@@ -1431,7 +1513,17 @@ type Engram =
    /// 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: (about: nat, note: text) -> (Result_14);
+   addRecordNote: (about: nat, note: text) -> (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: (payTo: text, perDayCapE6: nat, isPayout: bool) -> (Result_11);
    /// Returns the write RECEIPT, not just the version.
    /// 
    /// The receipt was always computed and then thrown away: MemoryRouter hands back
@@ -1463,7 +1555,7 @@ type Engram =
    /// Gated on requireWritesNotPaused — unlike the export. This one destroys retained entries, which
    /// 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: (toSeq: nat) -> (Result_80);
+   applyCondense: (toSeq: nat) -> (Result_85);
    /// Owner-only: activate a guardian who has registered against an invite.
    /// 
    /// Until this call the guardian is `#Pending` and can do NOTHING — registering is a claim, this
@@ -1494,6 +1586,16 @@ type 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: (requestId: text) -> (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: (sealed: blob) -> (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`.
@@ -1534,13 +1636,13 @@ type Engram =
    /// 
    /// The write half also refuses while writes are PAUSED.
    backupInit: (dbType: text, backupType: BackupType, parentBackupId:
-    opt text, sha256: text, backupLabel: opt text) -> (Result_53);
+    opt text, sha256: text, backupLabel: opt text) -> (Result_55);
    /// Read one chunk of a finalized backup, by index.
    /// 
    /// ⚠ GATED ON `read_backup`, which is NOT the permission the upload half uses — that one is
    /// `canAppendMemory`. Holding one says nothing about the other, deliberately: taking a backup and
    /// carrying it away are different authorities.
-   backupPullChunk: (backupId: text, chunkIndex: nat) -> (Result_69) query;
+   backupPullChunk: (backupId: text, chunkIndex: nat) -> (Result_72) query;
    backupPushChunk: (backupId: text, chunkIndex: nat, data: blob) ->
     (Result_2);
    /// The OWNER cancels an agent's pending key nomination; the agent keeps its current key. Refused
@@ -1573,7 +1675,7 @@ type Engram =
    /// ⟨2026-10-02⟩ The second parameter is NAMED `amountE6` now, as the census row above rules the
    /// pair — e6 base units of the token named first. A name only: Candid passes arguments by
    /// position, so nothing on the wire moved.
-   convertEarningsToCycles: (token: text, amountE6: nat) -> (Result_14);
+   convertEarningsToCycles: (token: text, amountE6: nat) -> (Result_15);
    /// Owner-only: mint a single-use invite code an agent redeems with `pairAgent`.
    /// 
    /// ⚠ READ THIS BEFORE INVITING SOMEONE BACK. Pairing is ONE-SHOT PER PRINCIPAL on
@@ -1602,7 +1704,7 @@ type 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: (name: text, permissions: AgentPermissions) ->
-    (Result_53);
+    (Result_55);
    /// Owner-only: mint an invite for a GUARDIAN — an independent check on agents, not a
    /// co-owner and not a recovery agent.
    /// 
@@ -1625,7 +1727,22 @@ type 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: (name: text, permissions: GuardianPermissions) ->
-    (Result_53);
+    (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: () -> (Result_2);
    /// OWNER-ONLY deletion of a stored backup.
    /// 
    /// ⚠ NOT THE SAME GATE AS THE REST OF THE FAMILY, and the asymmetry is deliberate: `backupInit`,
@@ -1668,7 +1785,7 @@ type Engram =
    /// 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).
-   disputeAgentWrite: (about: nat, reason: text) -> (Result_14);
+   disputeAgentWrite: (about: nat, reason: text) -> (Result_15);
    /// Record that log entries [fromSeq, toSeq] were served, and return the root that proves it.
    /// 
    /// This is the receipt ledgerfs Q2 requires before any of those entries may be condensed away.
@@ -1682,7 +1799,7 @@ type 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: (fromSeq: nat, toSeq: nat, authorFilter:
-    opt principal) -> (Result_79);
+    opt 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
    /// case — the guardian is the exceptional one. A name that says otherwise sends an owner looking
@@ -1724,7 +1841,9 @@ type Engram =
    /// brake is NOT pulled — the caller pulls it with `freezePayments`, or shortens the words.
    freezePaymentsWithReason: (reason: text) -> (Result_2);
    /// Delivery status + config readback. Owner-only (the URL is a secret).
-   getActionAlertStatus: () -> (Result_67) query;
+   /// ⟨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: () -> (Result_73) query;
    /// 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
    /// protected path and a revisable path are opposite grants, and one accessor for both would be a
@@ -1732,7 +1851,7 @@ type Engram =
    /// 
    /// Refusal reason preserved from the trap: a grant is a power, and its absence and its
    /// concealment are different facts.
-   getAgentRevisablePaths: () -> (Result_63) query;
+   getAgentRevisablePaths: () -> (Result_66) query;
    /// 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
    /// of the last one, and how many were produced. Never an amount, a recipient or a nonce.
@@ -1743,7 +1862,9 @@ type 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.
-   getAgentSeatWeeks: (start: nat, limit: nat) -> (Result_77) query;
+   /// ⟨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: (start: nat, limit: nat) -> (Result_82) query;
    /// Owner: everything written into this engram by someone other than the owner since the last
    /// markAgentWritesReviewed() — agent appends/revisions AND paid-session appends (see
    /// qualifiesForReview for why those two families are recognised differently).
@@ -1751,7 +1872,10 @@ type 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).
-   getAgentWriteReview: () -> (Result_76) query;
+   /// ⟨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: () -> (Result_81) query;
    /// 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,
    /// and none of these fields is a secret — `total` is already public via getCertifiedAuditHead.
@@ -1770,7 +1894,7 @@ type Engram =
    /// below serves the same head WITH the subnet certificate for a caller that needs to verify it
    /// was signed rather than asserted.
    getAuditHead: () -> (AuditHead) query;
-   getBackupMetadata: (backupId: text) -> (Result_75) query;
+   getBackupMetadata: (backupId: text) -> (Result_80) query;
    /// ⟨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.
@@ -1781,7 +1905,7 @@ type Engram =
    /// 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: (dbType: text) -> (Result_74) query;
+   getBackupRetention: (dbType: text) -> (Result_79) query;
    /// The cashier this engram recognises as its rent biller — `null` until the registry pushes one.
    /// 
    /// PUBLIC: a payer about to send money needs to know which cashier this engram will accept credit
@@ -1796,7 +1920,9 @@ type 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`).
-   getBirthChain: () -> (Result_73) query;
+   /// ⟨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: () -> (Result_78) query;
    /// ⟨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
@@ -1805,7 +1931,7 @@ type Engram =
    /// — 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: () -> (Result_72) query;
+   getBrakes: () -> (Result_77) query;
    /// ⟨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
    /// IS the evidence product — was the one chain still answering in a shape of its own, missing
@@ -1828,11 +1954,31 @@ type Engram =
    /// query's state writes are discarded when it returns, and the `denied` call first written here
    /// 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: (agentPrincipal: principal) -> (Result_71) query;
+   getChildAllowance: (agentPrincipal: principal) -> (Result_76) query;
    /// 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: () -> (Result_70) query;
+   /// ⟨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: () -> (Result_75) query;
+   /// 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.
+   getEncryptedKeyBackupKey: (transportPublicKey: blob) -> (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
    /// memory). The client decrypts it locally with its transport secret key.
@@ -1857,7 +2003,7 @@ type 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: (epoch: opt nat, transportPublicKey: blob) ->
-    (Result_69);
+    (Result_72);
    /// ⟨0.16.0, owner ruling 2026-08-20 — option (a)⟩ `x402Support` REPORTS THE RAIL, not a constant.
    /// 
    /// The card's config hardcodes `x402Support = true`, answering a buyer's question with a fact
@@ -1952,7 +2098,7 @@ type Engram =
    /// It refuses rather than half-answers: if either address cannot be derived the reply is
    /// `#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: () -> (Result_68);
+   getEvmAddress: () -> (Result_74);
    /// The owner's OWN EVM address, if they registered one — distinct from `getEvmAddress`, which is
    /// the address this canister derives for itself.
    /// 
@@ -1967,7 +2113,10 @@ type 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.
-   getEvmSignerAddress: () -> (Result_53);
+   /// ⟨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: () -> (Result_55);
    /// PUBLIC: where this chain begins, for the stranger deciding whether to trust it.
    /// 
    /// The fourth of the four evidence methods (`getAuditHead`, `getCertifiedAuditHead`,
@@ -1976,7 +2125,40 @@ type Engram =
    /// cannot verify it, and nothing here identifies anybody.
    getGenesisNote: () -> (GenesisNote) query;
    /// A guardian's own channel status (their URL is their secret — each guardian sees only theirs).
-   getGuardianAlertStatus: () -> (Result_67) query;
+   getGuardianAlertStatus: () -> (Result_73) query;
+   /// 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: () -> (Result_72) query;
+   /// 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: () -> (Result_71) query;
+   /// 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: () -> (blob);
    /// 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.
    /// 
@@ -2006,7 +2188,7 @@ type 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: (path: text, start: opt nat, max: opt nat) ->
-    (Result_66) query;
+    (Result_70) query;
    /// 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
    /// relationship — readable by, among others, the party just terminated.
@@ -2047,7 +2229,7 @@ type Engram =
    /// Refusal reasons of both merge: an empty policy reads as "nothing is capped, every version kept
    /// forever" — a claim about what this engram will DESTROY — and an empty guard list reads as
    /// "nothing is held back".
-   getMemoryRetentionPolicy: () -> (Result_65) query;
+   getMemoryRetentionPolicy: () -> (Result_69) query;
    /// The metrics reader this engram answers — `null` until the spawning registry names one.
    /// 
    /// PUBLIC: an owner deciding whether to switch the read off needs to know who it is, and anyone
@@ -2060,7 +2242,7 @@ type Engram =
    /// see: the only row it can ever return is the caller's own, so "you are not a guardian here" is
    /// 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: () -> (Result_17) query;
+   getMyGuardianStatus: () -> (Result_18) query;
    /// ⟨0.16.0, NEW⟩ The gated half of the status() split.
    /// 
    /// Every field is bare — no masking, no `authorized` discriminator — because reaching this record
@@ -2070,7 +2252,16 @@ type Engram =
    /// was `nat`, then widened to `opt nat` so a refusal could be `null`, which broke every published
    /// 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: () -> (Result_64) query;
+   getOwnerConsole: () -> (Result_68) query;
+   /// 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: () -> (Result_67) query;
    /// Owner + agents only (agents need it to avoid writing protected paths).
    /// 
    /// A NAMED RECORD, not a Page: the setter replaces this list wholesale, so there is no window to
@@ -2082,7 +2273,18 @@ type Engram =
    /// path on this engram is protected", and an agent consults this list precisely to avoid
    /// writing one — so a fabricated empty here does not merely misinform, it invites the write the
    /// list exists to prevent.
-   getProtectedPaths: () -> (Result_63) query;
+   getProtectedPaths: () -> (Result_66) query;
+   /// 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: (payTo: text) -> (Result_65) query;
    /// Whether the metrics reader's read is answered — `true` from birth.
    /// 
    /// PUBLIC: the promise that an owner can switch this read off can be checked only if the switch
@@ -2094,7 +2296,9 @@ type Engram =
    /// ⟨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: () -> (Result_62) query;
+   /// ⟨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: () -> (Result_64) query;
    /// The registry that spawned this engram, if it recorded one.
    /// 
    /// PUBLIC: it is the provenance claim. An engram asserting it is part of a fleet, under that
@@ -2111,7 +2315,9 @@ type 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.
-   getSpendCeiling: () -> (Result_61) query;
+   /// ⟨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: () -> (Result_63) query;
    /// Read the caps in force for a caller.
    /// 
    /// OWNER-ONLY, and this is where it diverges from the market's inbound twin, which is public.
@@ -2119,8 +2325,17 @@ type 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.
-   getSpendPolicy: (caller: opt principal) -> (Result_60) query;
-   getStorageStats: () -> (Result_59) query;
+   /// 
+   /// ⟨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: (caller: opt principal) -> (Result_62) query;
+   getStorageStats: () -> (Result_61) query;
    /// 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,
    /// leaks nothing (booleans about our own scheduling).
@@ -2203,12 +2418,12 @@ type Engram =
    /// ⟨L7⟩ MARKER ADDED 2026-08-23, reasoning above UNCHANGED — this block already said "Stays an
    /// 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: () -> (Result_58);
+   getWalletBalances: () -> (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: () -> (Result_57) query;
+   getWorldIdConfig: () -> (Result_59) query;
    /// ⟨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
    /// query can do none of them.
@@ -2217,7 +2432,7 @@ type Engram =
    /// Valid iff the derived signer address (getWorldIdRpSignerAddress) is registered for this rp_id in
    /// the World Developer Portal. Short-lived (300s TTL, idkit-server's default) and single-purpose —
    /// it authorizes opening one verification request, nothing else.
-   getWorldIdRpContext: () -> (Result_56);
+   getWorldIdRpContext: () -> (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
    /// Portal — the engram never holds or exports a private key (only threshold shares exist, on the
@@ -2227,7 +2442,10 @@ type 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).
-   getWorldIdRpSignerAddress: () -> (Result_53);
+   /// ⟨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: () -> (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.
    /// `Result<opt Text>` — and the double wrapper is the entire point, not redundancy.
@@ -2246,7 +2464,7 @@ type Engram =
    /// `///`, so the dead name was PUBLISHED in engram.did and pointed every client at a method the
    /// 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: () -> (Result_55) query;
+   getWorldIdVerification: () -> (Result_57) query;
    /// ⟨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
    /// is going wrong, and the only two answers that help are "you may not do this" and "there is
@@ -2321,7 +2539,10 @@ type 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: () -> (Result_54) query;
+   /// ⟨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: () -> (Result_56) query;
    /// 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
    /// redirects the user's browser to `redirectUri` with `?code=<this>` so the
@@ -2329,7 +2550,7 @@ type Engram =
    /// 
    /// Owner-only: only the engram owner can authorize a Connector install.
    issueAuthCode: (redirectUri: text, scope: text, codeChallenge: text,
-    clientId: opt text) -> (Result_53);
+    clientId: opt text) -> (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,
    /// and the source flips by design (self-call first, balance on fallback). Its documentation of
@@ -2343,7 +2564,7 @@ type Engram =
    /// Refusal reason preserved, and it is the sharpest of this family: a masked `[]` reads as a
    /// 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: (start: nat, limit: nat) -> (Result_52) query;
+   listActivitySnapshots: (start: nat, limit: nat) -> (Result_54) query;
    /// ⟨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
@@ -2360,7 +2581,9 @@ type 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.
-   listAgentSpendToday: (start: nat, limit: nat) -> (Result_51) query;
+   /// ⟨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: (start: nat, limit: nat) -> (Result_53) query;
    /// ⟨0.16.0⟩ THE PAGE EXEMPLAR. Trap → `#Refused`, bare array → `Result<Page<T>>` (L1 + L3).
    /// 
    /// The refusal prose that used to be `gatedTrap`'s `whyNotEmpty` argument is not lost — it is why
@@ -2375,7 +2598,9 @@ type 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: (start: nat, limit: nat) -> (Result_50) query;
+   /// ⟨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: (start: nat, limit: nat) -> (Result_52) query;
    /// The GUARDIAN-audience projection of the agent roster — three fields, not the full record.
    /// 
    /// Two audiences, two methods (L1/L8), rather than one method masking fields by caller: a
@@ -2387,7 +2612,7 @@ type Engram =
    /// Refusal reason preserved: `[]` reads as "this engram has no agents", and this is the list a
    /// 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: (start: nat, limit: nat) -> (Result_49) query;
+   listAgentsForGuardian: (start: nat, limit: nat) -> (Result_51) query;
    /// Owner-only: rows carry caller, amount, operation and free-text rationale. The SDK omits it.
    /// 
    /// The optional leading filter SURVIVES the L3 reshape — ratified (census tier-2 #8) rather than
@@ -2400,7 +2625,7 @@ type Engram =
    /// 
    /// Refusal reason preserved: `[]` reads as "nothing is awaiting the owner's decision".
    listApprovalRequests: (statusFilter: opt ApprovalStatus, start: nat,
-    limit: nat) -> (Result_35) query;
+    limit: nat) -> (Result_37) query;
    /// ⟨0.16.0⟩ `total` IS THE HEAD COUNTER, and on this method that is the entire point.
    /// 
    /// The audit log is a bounded RING: it trims its tail, so "rows you can read" and "entries that
@@ -2434,7 +2659,7 @@ type Engram =
    /// 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: (start: nat, limit: nat) -> (Result_48) query;
+   listAuditEntries: (start: nat, limit: nat) -> (Result_50) query;
    /// ⟨0.16.0, L1 + L3 — census-ruled⟩ THE TWO-MECHANISM EXCEPTION DISSOLVES.
    /// 
    /// This method used to answer THREE ways to one question: a list, an `#Err` text, and a trap,
@@ -2458,7 +2683,7 @@ type Engram =
    /// `dbTypeFilter` DIES on the wire (census). The capability does not: `EngramClient.listBackups`
    /// 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: (start: nat, limit: nat) -> (Result_47) query;
+   listBackups: (start: nat, limit: nat) -> (Result_49) query;
    /// List all bearer tokens — Active, Revoked, and Expired. Owner uses this in
    /// the dashboard to show installed Connectors (claude.ai, Claude Desktop, etc.).
    /// Refusal reason preserved from the trap: `[]` reads as "no connector is installed on this
@@ -2468,7 +2693,9 @@ type 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.
-   listBearerTokens: (start: nat, limit: nat) -> (Result_46) query;
+   /// ⟨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: (start: nat, limit: nat) -> (Result_48) query;
    /// The condense checkpoints in the retained log at or above `startSeq`, oldest first.
    /// 
    /// ⟨0.16.0, NEW⟩ The other half of the split above. A checkpoint is the only surviving record of a
@@ -2478,18 +2705,18 @@ type 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: (startSeq: nat, max: nat) -> (Result_45) query;
+   listCondenseCheckpoints: (startSeq: nat, max: nat) -> (Result_47) query;
    /// ⟨0.16.0⟩ `metrics()` DELETED — absorbed by `about()`.
    /// 
    /// Two public projections of one canister (L2.2): `metrics()` and `status()` both answered "what
    /// is this engram like" and disagreed on which counters they carried, so a consumer had to fetch
    /// both and know which one owned each field. Every field here survives on `about()`, day-flooring
    /// included.
-   listCycleSnapshots: (start: nat, limit: nat) -> (Result_44) query;
+   listCycleSnapshots: (start: nat, limit: nat) -> (Result_46) query;
    /// 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: (start: nat, limit: nat) -> (Result_43) query;
+   listDeletedMemoryFiles: (start: nat, limit: nat) -> (Result_45) query;
    /// Stays on the engram under B1 (hybrid): withdrawal custody does not leave.
    /// 
    /// NAMED item, not a `(Text, Int)` tuple. The Int is an activation time, and a bare Int beside a
@@ -2504,7 +2731,7 @@ type 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: (typeId: blob, start: nat, limit: nat) ->
-    (Result_42) query;
+    (Result_44) query;
    /// 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.
    /// 
@@ -2515,20 +2742,20 @@ type Engram =
    /// ⟨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: (start: nat, limit: nat) -> (Result_41) query;
+   listEip712Types: (start: nat, limit: nat) -> (Result_43) query;
    /// ⟨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: (start: nat, limit: nat) -> (Result_40) query;
+   listGuardianDisputes: (start: nat, limit: nat) -> (Result_42) query;
    /// Accessible by owner and guardians.
    /// 
    /// Refusal reason carried over from the trap, because it is the sharpest example of why this
    /// surface may not fail soft: `[]` reads as "this engram has nobody who can freeze payments or
    /// 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: (start: nat, limit: nat) -> (Result_39) query;
+   listGuardians: (start: nat, limit: nat) -> (Result_41) query;
    /// The export receipts in the retained log at or above `startSeq`, oldest first.
    /// 
    /// ⟨0.16.0, L3⟩ ONE LIST, ONE QUESTION. This method used to return receipts AND checkpoints
@@ -2544,7 +2771,7 @@ type 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: (startSeq: nat, max: nat) -> (Result_38) query;
+   listMemoryExportReceipts: (startSeq: nat, max: nat) -> (Result_40) query;
    /// ⟨0.16.0⟩ THE `withheld` EXEMPLAR — L1 names this exact method as the defect it fixes.
    /// 
    /// A non-owner's answer silently dropped every `config/` and `secrets/` row. Not "refused the
@@ -2569,7 +2796,7 @@ type Engram =
    /// 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: (start: nat, limit: nat) -> (Result_37) query;
+   listMemoryFiles: (start: nat, limit: nat) -> (Result_39) query;
    /// One page of the memory log, seq-ordered, optionally narrowed to one author.
    /// 
    /// THE WINDOW IS THE CURSOR, and the page now states it. The window is
@@ -2595,7 +2822,7 @@ type Engram =
    /// with the disclosures that make the page verifiable — the hidden-bound defect the census itself
    /// names on previewCondense's row.
    listMemoryLog: (startSeq: nat, max: nat, authorFilter: opt principal) ->
-    (Result_36) query;
+    (Result_38) query;
    /// The caller's OWN spend-approval requests. ⟨0.16.0, L1 + L3 — fixed 2026-08-18⟩
    /// 
    /// Two defects in seven lines, and the first is the one this release exists to remove:
@@ -2612,7 +2839,7 @@ type Engram =
    /// to see, so `total` over their own rows is the honest count and nothing is hidden FROM them.
    /// (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: (start: nat, limit: nat) -> (Result_35) query;
+   listMyApprovalRequests: (start: nat, limit: nat) -> (Result_37) query;
    /// 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.
    /// 
@@ -2621,7 +2848,7 @@ type Engram =
    /// It took no arguments, and a cursor added after the freeze is an argument-list change every
    /// 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: (start: nat, limit: nat) -> (Result_34) query;
+   listMySessions: (start: nat, limit: nat) -> (Result_36) query;
    /// 
    /// ⟨0.16.0, L3⟩ Paged and enveloped like every other `list*`, and the envelope here is uniformity
    /// rather than gating: this method cannot refuse anybody, so `#Err` is unreachable on it. That is
@@ -2634,7 +2861,7 @@ type Engram =
    /// asked by strangers. `verifyEngramActiveOwner` on the registry answers only about the owner
    /// 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: (start: nat, limit: nat) -> (Result_33) query;
+   listOwnershipTransfers: (start: nat, limit: nat) -> (Result_35) query;
    /// ⟨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
    /// owner's console stated the rule and showed no number, because nothing served one; a number it
@@ -2650,7 +2877,9 @@ type 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.
-   listPaymentSignatureCounts: (start: nat, limit: nat) -> (Result_32) query;
+   /// ⟨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: (start: nat, limit: nat) -> (Result_34) query;
    /// 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.
    /// ⟨2026-09-29, the vocabulary ruling: pairing is the one verb that admits an agent⟩ The field
@@ -2690,7 +2919,9 @@ type 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.
-   listPurgedAgents: (start: nat, limit: nat) -> (Result_31) query;
+   /// ⟨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: (start: nat, limit: nat) -> (Result_33) query;
    /// ⟨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.
    /// 
@@ -2752,13 +2983,13 @@ type 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: (successFilter: opt bool, start: nat, limit: nat) ->
-    (Result_30) query;
+    (Result_32) query;
    /// ⟨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: (start: nat, limit: nat) -> (Result_29) query;
+   listRecordNotes: (start: nat, limit: nat) -> (Result_31) query;
    /// 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
    /// empty list reads as "no disputes have been filed", which is a claim, not an absence of one.
@@ -2773,7 +3004,14 @@ type Engram =
    /// window — which says disputes exist without showing them, never "none have been filed". WHAT
    /// 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: (start: nat, limit: nat) -> (Result_28) query;
+   listRepudiations: (start: nat, limit: nat) -> (Result_30) query;
+   /// 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: (start: nat, limit: nat) -> (Result_29) query;
    /// ⟨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
@@ -2782,7 +3020,9 @@ type 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.
-   listSignIns: (start: nat, limit: nat) -> (Result_27) query;
+   /// ⟨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: (start: nat, limit: nat) -> (Result_28) query;
    /// 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
    /// the console did not render; clamped monotonic (the cursor never moves backward) and to the
@@ -2792,7 +3032,7 @@ type Engram =
    /// (every family qualifiesForReview admits is written to auditLogger, so they share that space),
    /// 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: (uptoAuditId: opt nat) -> (Result_14);
+   markAgentWritesReviewed: (uptoAuditId: opt nat) -> (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
    /// limits enforced against that key. It reveals nothing a refusal does not already say, and lets
@@ -2810,7 +3050,7 @@ type Engram =
    /// 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: () -> (Result_26) query;
+   myGrant: () -> (Result_27) query;
    /// 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
    /// nomination per agent — a new one replaces the earlier one, and the record says which. Refused,
@@ -2818,7 +3058,7 @@ type Engram =
    /// not hold the record (`KeyReplacement.nomineeRefusal`).
    nominateAgentKey: (newKey: 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
@@ -2845,15 +3085,36 @@ type 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: () -> (Result_25);
-   openSession: (config: SessionConfig, sig: 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: (req: record {signIn: opt principal;}) -> (Result_26);
+   openSession: (config: SessionConfig, sig: 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
    /// destination is always hardcoded to the owner.
    /// NOT freeze-gated: the owner always controls their own funds.
    /// Guardian freeze only blocks agent/public operations.
    ownerWithdraw: (amount: TokenAmount, ownerAuth: opt ActionAuth) ->
-    (Result_14);
+    (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.
    /// 
@@ -2911,7 +3172,7 @@ type Engram =
    pairAgent: (arg: record {
                       code: text;
                       enrolment: Enrolment;
-                    }) -> (Result_23);
+                    }) -> (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.
    pauseWrites: () -> (Result_2);
@@ -2936,7 +3197,7 @@ type 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: (toSeq: nat) -> (Result_22) query;
+   previewCondense: (toSeq: nat) -> (Result_23) query;
    /// 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.
    /// 
@@ -2981,10 +3242,12 @@ type 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: (entries: vec record {
                                      text;
                                      RetentionClassSpec;
-                                   }) -> (Result_21) query;
+                                   }) -> (Result_22) query;
    /// Read one memory file at its current version.
    /// 
    /// Gated on the `read_memory` permission, so an agent holding that grant reaches it — unlike
@@ -2999,7 +3262,7 @@ type Engram =
    /// counter here could never persist; read counting lives on the update path
    /// (`sessionReadContext` and the MCP reads). A caller measuring engram usage from this method
    /// will measure nothing.
-   readMemory: (path: text) -> (Result_12) query;
+   readMemory: (path: text) -> (Result_13) query;
    /// 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.
    /// 
@@ -3015,7 +3278,7 @@ type Engram =
    /// Both are now what they are: a single `#Err` for the whole call. `#Ok` still carries a row per
    /// path, each with its own Result — a refused RESERVED path sits beside a readable one, which is
    /// a genuine per-path fact.
-   readMemoryBatch: (paths: vec text) -> (Result_20) query;
+   readMemoryBatch: (paths: vec text) -> (Result_21) query;
    /// ⟨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
    /// was the defect described there. Its own docs are preserved at the fold site.
@@ -3026,7 +3289,7 @@ type 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: (path: text, offset: nat, len: nat, version: opt nat) ->
-    (Result_19) query;
+    (Result_20) query;
    /// The escrow exit for a session whose settle cannot pay.
    /// 
    /// PAYER-ONLY, enforced inside the gateway, and deliberately not owner-triggered: the payer's own
@@ -3089,7 +3352,7 @@ type Engram =
    /// 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: (sessionId: text, amountE6: nat) -> (Result_18);
+   recoverEscrow: (sessionId: text, amountE6: nat) -> (Result_19);
    /// ⟨0.16.0, L1⟩ A REDEMPTION PATH, where the arm choice is a disclosure decision.
    /// 
    /// Four of these refusals are about the CODE and one is about the caller. The code arms restate
@@ -3103,7 +3366,7 @@ type Engram =
    /// rather than `()`. The new guardian learns, in the same reply, the name and permissions the
    /// 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: (code: text) -> (Result_17);
+   registerGuardian: (code: text) -> (Result_18);
    /// Remove a per-caller override so that caller reverts to — and keeps TRACKING — the global caps.
    /// 
    /// It travels with its pair and is never dropped alone: without it the only way "back" from an
@@ -3134,6 +3397,13 @@ type 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: (guardianPrincipal: 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: (payTo: text) -> (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 —
@@ -3149,7 +3419,7 @@ type 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: (path: text, version: nat, reason: text) ->
-    (Result_14);
+    (Result_15);
    /// ⚠ OWNER-ONLY BULK RESET. Destructive, and wider than its name suggests.
    /// 
    /// It severs EVERY grant surface that can outlive a role — agents, guardians, invites and
@@ -3168,6 +3438,10 @@ type 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.
    /// 
@@ -3177,7 +3451,7 @@ type Engram =
    /// NOT unbounded. It caps at MAX_ENTRIES and trims its oldest tenth on overflow, so on any 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: () -> (Result_16);
+   resetEngram: () -> (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.
    /// 
@@ -3223,7 +3497,7 @@ type Engram =
    /// all that is left to send is the ending, and the registry has nothing to end. The report lists
    /// 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: () -> (Result_15);
+   resyncAgentEdges: () -> (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
    /// sovereignty is not a one-way door.
@@ -3277,7 +3551,7 @@ type Engram =
    /// written, and only then does it await one notification per revoked agent. So a notification
    /// 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: () -> (Result_14);
+   revokeAllAgents: () -> (Result_15);
    /// Owner-only panic button: revoke every connector bearer token at once. Returns how many.
    /// 
    /// The THIRD independent surface — hosted connectors authenticate with bearer tokens, not with
@@ -3286,7 +3560,7 @@ type Engram =
    /// holding a live session.
    /// 
    /// Tokens are re-issuable: revoking them is not permanent the way revoking an agent is.
-   revokeAllBearerTokens: () -> (Result_14);
+   revokeAllBearerTokens: () -> (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
    /// loses a capability: what dies is a bulk spelling no runbook ever invoked.
@@ -3298,7 +3572,7 @@ type 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: () -> (Result_14);
+   revokeAllInvites: () -> (Result_15);
    /// Revoke a bearer token by its public tokenId. Idempotent.
    /// Subsequent /mcp requests using this token will be rejected.
    revokeBearerToken: (tokenId: text) -> (Result_2);
@@ -3325,6 +3599,32 @@ type 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: (newPublicKeyHash: text) -> (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: (amount: 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.
    /// ⟨2026-09-30, ic402 2.17.0⟩ Authorized by the payer's own call with the voucher: only the
@@ -3368,7 +3668,7 @@ type Engram =
    /// ⚠ RAW STORED BYTES, like `readMemoryBatch`. On a Private (encrypted) engram the content is
    /// CIPHERTEXT; the key-holding SDK decrypts it. A caller without the key gets bytes it cannot
    /// read, not an error.
-   sessionReadContext: (clientLabel: text) -> (Result_13);
+   sessionReadContext: (clientLabel: text) -> (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.
    /// 
@@ -3398,7 +3698,7 @@ type Engram =
    ///     session must not be the side door: without this guard a stranger holding a fraction-of-a-
    ///     cent voucher could read `secrets/*`.
    ///   · Payments are frozen on this engram.
-   sessionReadMemory: (voucher: Voucher, path: text) -> (Result_12);
+   sessionReadMemory: (voucher: Voucher, path: text) -> (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
    /// POST per minute. ⟨2026-10-29⟩ Delivered within seconds of the action (a 5 s batch window), and
@@ -3445,7 +3745,7 @@ type Engram =
    /// 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: (dbType: text, maxBackups: nat) -> (Result_11);
+   setBackupRetention: (dbType: text, maxBackups: nat) -> (Result_12);
    /// Override the caps for ONE caller — an agent this owner trusts more, or less, than the rest.
    setCallerSpendPolicy: (caller: principal, policy: SpendingPolicy) ->
     (Result_2);
@@ -3517,6 +3817,16 @@ type Engram =
           text;
           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: (next: principal, resealedBackup: opt blob) -> (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.
    /// 
@@ -3547,6 +3857,13 @@ type 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: (enabled: bool) -> (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: (payTo: text, perDayCapE6: nat) -> (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⟩
    /// ⟨CORRECTED 2026-09-29, review finding X-8: "spend" was too wide. The ceiling covers the x402
@@ -3643,6 +3960,14 @@ type 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: (typeId: blob, values: vec record {
                                             text;
                                             Eip712Value;
@@ -3733,6 +4058,15 @@ type Engram =
    /// disputes stay on the record. Like `removeGuardian`, it is not terminal: the owner may invite
    /// the same person again.
    stepDownAsGuardian: () -> (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: (ciphertext: blob) -> (Result_2);
    /// OWNER force-close, for a session the payer abandoned.
    /// 
    /// ⟨R1b, ruled 2026-08-26: owner-gated, NO guardian.⟩ It moves someone else's money, and only ever
@@ -4007,6 +4341,10 @@ type 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: (typeId: blob, values: vec record {
                                                text;
                                                Eip712Value;
@@ -4283,7 +4621,7 @@ type ChildAllowanceRow =
 type CheckpointPage = 
  record {
    firstAvailableSeq: nat;
-   page: Page_18;
+   page: Page_19;
    scannedThroughSeq: nat;
  };
 type CertifiedAuditHead = 
@@ -4508,7 +4846,7 @@ type AgentStatus =
  };
 type AgentSpendToday = 
  record {
-   agents: Page_23;
+   agents: Page_24;
    dayStartNs: int;
  };
 type AgentSpendRow = 
@@ -4626,5 +4964,7 @@ type About =
 service : (initArgs: opt
                       record {
                         owner: opt principal;
+                        ownerSignIn: opt principal;
+                        parent: opt principal;
                         registry: opt principal;
                       }) -> Engram