feat(daemon): Persist messages over across restarts (including promise/resolver formulas) (#3074)

Refs: #2074

## Description

This PR makes mailbox requests and their resolutions durable across
restarts. This required introducing promise/resolver formulas and
persisting request resolution state. This necessitates allowing petnames
to include numbers, since messages are indexed by sequence of arrival.

```console
❯ endo purge -f
❯ endo start
❯ endo send SELF 'Hello, World!'
❯ endo inbox
0. you sent yourself "Hello, World!" at "2026-02-05T11:52:26.171Z"
❯ endo restart
❯ endo inbox
0. you sent yourself "Hello, World!" at "2026-02-05T11:52:26.171Z"
```

### Security Considerations

- Promise resolution is captured once in durable storage; resolvers
ignore subsequent writes.

### Scaling Considerations

- Each request now creates two formulas (promise + resolver) and writes
a status record on resolve/reject.
- Mailbox persistence includes two additional IDs per request,
increasing mailbox storage and I/O.
- Promise status tracking adds extra pet-store updates and listener
activity proportional to outstanding requests.

### Documentation Considerations

None

### Testing Considerations

- Added restart durability tests for mailbox persistence and rehydrated
request resolution.

### Compatibility Considerations

Existing daemon databases must be purged. This is the current norm.

### Upgrade Considerations

None

Author: kriskowal

packages/cli/src/commands/adopt.js

@@ -3,7 +3,7 @@ import os from 'os';
 import { E } from '@endo/far';
 import { withEndoAgent } from '../context.js';
 import { parsePetNamePath } from '../pet-name.js';
-import { parseNumber } from '../number-parse.js';
+import { parseBigint } from '../number-parse.js';
 
 export const adoptCommand = async ({
   messageNumberText,
@@ -13,7 +13,7 @@ export const adoptCommand = async ({
 }) =>
   withEndoAgent(agentNames, { os, process }, async ({ agent }) => {
     await E(agent).adopt(
-      parseNumber(messageNumberText),
+      parseBigint(messageNumberText),
       edgeName,
       parsePetNamePath(name),
     );

packages/cli/src/commands/dismiss.js

@@ -2,10 +2,9 @@
 import os from 'os';
 import { E } from '@endo/far';
 import { withEndoAgent } from '../context.js';
+import { parseBigint } from '../number-parse.js';
 
 export const dismissCommand = async ({ messageNumberText, agentNames }) =>
   withEndoAgent(agentNames, { os, process }, async ({ agent }) => {
-    // TODO less bad number parsing.
-    const messageNumber = Number(messageNumberText);
-    await E(agent).dismiss(messageNumber);
+    await E(agent).dismiss(parseBigint(messageNumberText));
   });

packages/cli/src/commands/reject.js

@@ -2,13 +2,13 @@
 import os from 'os';
 import { E } from '@endo/far';
 import { withEndoAgent } from '../context.js';
-import { parseNumber } from '../number-parse.js';
+import { parseBigint } from '../number-parse.js';
 
 export const rejectCommand = async ({
   requestNumberText,
   message,
   agentNames,
 }) =>
   withEndoAgent(agentNames, { os, process }, async ({ agent }) => {
-    await E(agent).reject(parseNumber(requestNumberText), message);
+    await E(agent).reject(parseBigint(requestNumberText), message);
   });

packages/cli/src/commands/resolve.js

@@ -2,13 +2,13 @@
 import os from 'os';
 import { E } from '@endo/far';
 import { withEndoAgent } from '../context.js';
-import { parseNumber } from '../number-parse.js';
+import { parseBigint } from '../number-parse.js';
 
 export const resolveCommand = async ({
   requestNumberText,
   resolutionName,
   agentNames,
 }) =>
   withEndoAgent(agentNames, { os, process }, async ({ agent }) => {
-    await E(agent).resolve(parseNumber(requestNumberText), resolutionName);
+    await E(agent).resolve(parseBigint(requestNumberText), resolutionName);
   });

packages/cli/src/number-parse.js

@@ -1,15 +1,13 @@
 /**
- * Parses the input and returns it as a number if it's valid, otherwise throws error.
+ * Parses the input and returns it as a bigint if it's a valid integer.
  *
  * @param {string} input
- * @returns {number}
+ * @returns {bigint}
  */
-export const parseNumber = input => {
-  const result = /[0-9]/.test(input || '') ? Number(input) : NaN;
-
-  if (Number.isNaN(result)) {
+export const parseBigint = (input = '') => {
+  const trimmed = input.trim();
+  if (!/^(0|[1-9][0-9]*)$/.test(trimmed)) {
     throw new Error(`Invalid number: ${input}`);
   }
-
-  return result;
+  return BigInt(trimmed);
 };

packages/cli/test/number-parse.test.js

@@ -1,27 +1,24 @@
 import test from 'ava';
-import { parseNumber } from '../src/number-parse.js';
+import { parseBigint } from '../src/number-parse.js';
 
-test('returns the number when input is a valid numeric string', t => {
-  t.is(parseNumber('42'), 42);
-  t.is(parseNumber('-40.0'), -40.0);
-  t.is(parseNumber('.5'), 0.5);
-  t.is(parseNumber('1.337e3'), 1337);
-  t.is(parseNumber(' +1 '), 1);
-  t.is(parseNumber('0B111'), 7);
-  t.is(parseNumber('0o040'), 32);
-  t.is(parseNumber('0xf00'), 3840);
-  t.is(parseNumber('0xF00'), 3840);
-  t.is(parseNumber('   -40.0   '), -40.0);
-  // Test for binary, octal and hexadecimal
-  t.is(parseNumber('0B111'), 7);
-  t.is(parseNumber('0o040'), 32);
-  t.is(parseNumber('0xf00'), 3840);
+test('returns a bigint when input is a valid integer string', t => {
+  t.is(parseBigint('42'), 42n);
+  t.is(parseBigint('0'), 0n);
+  t.is(parseBigint('   9007199254740993   '), 9007199254740993n);
+  t.is(
+    parseBigint('123456789012345678901234567890'),
+    123456789012345678901234567890n,
+  );
 });
 
-test('throws an error when input is not a valid numeric string', t => {
+test('throws an error when input is not a valid integer string', t => {
   const badStrings = [
     'f00',
     'F00',
+    '+1',
+    '-1',
+    '1.0',
+    '01',
     'NaN',
     'Infinity',
     '-Infinity',
@@ -31,6 +28,6 @@ test('throws an error when input is not a valid numeric string', t => {
     '   ',
   ];
   for (const bad of badStrings) {
-    t.throws(() => parseNumber(bad), { message: `Invalid number: ${bad}` });
+    t.throws(() => parseBigint(bad), { message: `Invalid number: ${bad}` });
   }
 });