@tpsdev-ai/agent 0.8.0 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (133) hide show
  1. package/bun.lock +27 -15
  2. package/dist/bin.js +4 -3
  3. package/dist/bin.js.map +1 -1
  4. package/dist/config.d.ts +8 -1
  5. package/dist/config.d.ts.map +1 -1
  6. package/dist/config.js +38 -3
  7. package/dist/config.js.map +1 -1
  8. package/dist/home.d.ts +3 -0
  9. package/dist/home.d.ts.map +1 -0
  10. package/dist/home.js +18 -0
  11. package/dist/home.js.map +1 -0
  12. package/dist/index.d.ts +16 -3
  13. package/dist/index.d.ts.map +1 -1
  14. package/dist/index.js +12 -1
  15. package/dist/index.js.map +1 -1
  16. package/dist/io/flair.d.ts +1 -10
  17. package/dist/io/flair.d.ts.map +1 -1
  18. package/dist/io/flair.js +29 -28
  19. package/dist/io/flair.js.map +1 -1
  20. package/dist/io/mail.d.ts +184 -30
  21. package/dist/io/mail.d.ts.map +1 -1
  22. package/dist/io/mail.js +944 -185
  23. package/dist/io/mail.js.map +1 -1
  24. package/dist/lib/agent-keys.d.ts +106 -0
  25. package/dist/lib/agent-keys.d.ts.map +1 -0
  26. package/dist/lib/agent-keys.js +298 -0
  27. package/dist/lib/agent-keys.js.map +1 -0
  28. package/dist/lib/bridge-identity.d.ts +10 -0
  29. package/dist/lib/bridge-identity.d.ts.map +1 -0
  30. package/dist/lib/bridge-identity.js +56 -0
  31. package/dist/lib/bridge-identity.js.map +1 -0
  32. package/dist/lib/mail-lock-namespace.d.ts +19 -0
  33. package/dist/lib/mail-lock-namespace.d.ts.map +1 -0
  34. package/dist/lib/mail-lock-namespace.js +58 -0
  35. package/dist/lib/mail-lock-namespace.js.map +1 -0
  36. package/dist/lib/mail-lock.d.ts +81 -0
  37. package/dist/lib/mail-lock.d.ts.map +1 -0
  38. package/dist/lib/mail-lock.js +319 -0
  39. package/dist/lib/mail-lock.js.map +1 -0
  40. package/dist/lib/mailbox-filename.d.ts +2 -0
  41. package/dist/lib/mailbox-filename.d.ts.map +1 -0
  42. package/dist/lib/mailbox-filename.js +4 -0
  43. package/dist/lib/mailbox-filename.js.map +1 -0
  44. package/dist/lib/mailbox-policy.d.ts +245 -0
  45. package/dist/lib/mailbox-policy.d.ts.map +1 -0
  46. package/dist/lib/mailbox-policy.js +949 -0
  47. package/dist/lib/mailbox-policy.js.map +1 -0
  48. package/dist/lib/public-key.d.ts +6 -0
  49. package/dist/lib/public-key.d.ts.map +1 -0
  50. package/dist/lib/public-key.js +45 -0
  51. package/dist/lib/public-key.js.map +1 -0
  52. package/dist/lib/registry-key.d.ts +2 -0
  53. package/dist/lib/registry-key.d.ts.map +1 -0
  54. package/dist/lib/registry-key.js +10 -0
  55. package/dist/lib/registry-key.js.map +1 -0
  56. package/dist/lib/relay-lock.d.ts +7 -0
  57. package/dist/lib/relay-lock.d.ts.map +1 -0
  58. package/dist/lib/relay-lock.js +19 -0
  59. package/dist/lib/relay-lock.js.map +1 -0
  60. package/dist/lib/signEnvelope.d.ts +2 -0
  61. package/dist/lib/signEnvelope.d.ts.map +1 -1
  62. package/dist/lib/signEnvelope.js.map +1 -1
  63. package/dist/lib/signing-key.d.ts +2 -0
  64. package/dist/lib/signing-key.d.ts.map +1 -0
  65. package/dist/lib/signing-key.js +9 -0
  66. package/dist/lib/signing-key.js.map +1 -0
  67. package/dist/lib/topic-recipient.d.ts +2 -0
  68. package/dist/lib/topic-recipient.d.ts.map +1 -0
  69. package/dist/lib/topic-recipient.js +2 -0
  70. package/dist/lib/topic-recipient.js.map +1 -0
  71. package/dist/llm/provider.d.ts.map +1 -1
  72. package/dist/llm/provider.js +9 -7
  73. package/dist/llm/provider.js.map +1 -1
  74. package/dist/runtime/agent.d.ts.map +1 -1
  75. package/dist/runtime/agent.js +32 -25
  76. package/dist/runtime/agent.js.map +1 -1
  77. package/dist/runtime/event-loop.d.ts +21 -2
  78. package/dist/runtime/event-loop.d.ts.map +1 -1
  79. package/dist/runtime/event-loop.js +199 -54
  80. package/dist/runtime/event-loop.js.map +1 -1
  81. package/dist/runtime/types.d.ts +11 -0
  82. package/dist/runtime/types.d.ts.map +1 -1
  83. package/dist/runtime/types.js +13 -1
  84. package/dist/runtime/types.js.map +1 -1
  85. package/package.json +2 -3
  86. package/src/bin.ts +4 -3
  87. package/src/config.ts +46 -3
  88. package/src/home.ts +18 -0
  89. package/src/index.ts +33 -2
  90. package/src/io/flair.ts +23 -28
  91. package/src/io/mail.ts +1007 -200
  92. package/src/lib/agent-keys.ts +308 -0
  93. package/src/lib/bridge-identity.ts +49 -0
  94. package/src/lib/mail-lock-namespace.ts +64 -0
  95. package/src/lib/mail-lock.ts +337 -0
  96. package/src/lib/mailbox-filename.ts +3 -0
  97. package/src/lib/mailbox-policy.ts +1085 -0
  98. package/src/lib/public-key.ts +49 -0
  99. package/src/lib/registry-key.ts +8 -0
  100. package/src/lib/relay-lock.ts +20 -0
  101. package/src/lib/signEnvelope.ts +2 -0
  102. package/src/lib/signing-key.ts +8 -0
  103. package/src/lib/topic-recipient.ts +1 -0
  104. package/src/llm/provider.ts +9 -7
  105. package/src/runtime/agent.ts +30 -27
  106. package/src/runtime/event-loop.ts +221 -68
  107. package/src/runtime/types.ts +14 -0
  108. package/test/config.test.ts +85 -2
  109. package/test/core-loop.test.ts +6 -4
  110. package/test/governance.test.ts +4 -1
  111. package/test/helpers/event-loop-child.mjs +50 -0
  112. package/test/helpers/mail-delivery-worker.mjs +16 -0
  113. package/test/helpers/mail-kill-child.mjs +104 -0
  114. package/test/helpers/signed-relay-record.ts +31 -0
  115. package/test/home-per-call.test.ts +72 -0
  116. package/test/io.test.ts +81 -14
  117. package/test/mail-client-lock-namespace.test.ts +155 -0
  118. package/test/mail-client-repoint-root.test.ts +368 -0
  119. package/test/mail-delivery-at-least-once.test.ts +1238 -0
  120. package/test/mail-event-loop-delivery.test.ts +769 -0
  121. package/test/mail-intent-phases.test.ts +304 -0
  122. package/test/mail-interrupted-recovery.test.ts +393 -0
  123. package/test/mail-lock-pid-state.test.ts +238 -0
  124. package/test/mail-lock.test.ts +96 -0
  125. package/test/mail-partial-flair.test.ts +102 -0
  126. package/test/mail-placement-replay.test.ts +116 -0
  127. package/test/mail-promote-guard.test.ts +305 -21
  128. package/test/mail-relay-reservation.test.ts +60 -0
  129. package/test/mailbox-filename.test.ts +16 -0
  130. package/test/public-key.test.ts +108 -0
  131. package/test/runtime-key-encoding.test.ts +105 -0
  132. package/test/runtime-pending-key.test.ts +117 -0
  133. package/test/security/mail-trust.test.ts +406 -109
@@ -0,0 +1,1238 @@
1
+
2
+
3
+ import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
4
+ import * as fs from "node:fs";
5
+ import { spawn } from "node:child_process";
6
+ import { Worker } from "node:worker_threads";
7
+ import { createHash, randomUUID } from "node:crypto";
8
+ import {
9
+ existsSync, linkSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, symlinkSync,
10
+ unlinkSync, writeFileSync,
11
+ } from "node:fs";
12
+ import { tmpdir } from "node:os";
13
+ import { join } from "node:path";
14
+ import { fileURLToPath } from "node:url";
15
+ import * as ed from "@noble/ed25519";
16
+ import { type DeliverNextResult, type MailDelivery, MailClient } from "../src/io/mail.js";
17
+ import { acquireMailLock } from "../src/lib/mail-lock.js";
18
+ import { EventLogger } from "../src/telemetry/events.js";
19
+ import {
20
+ DELIVERY_PRESENTATION_TTL_MS,
21
+ MAX_DELIVERY_PRESENTATIONS,
22
+ hasCommittedMessageId,
23
+ mailboxReplayStore,
24
+ pendingPlacementEntries,
25
+ } from "../src/lib/mailbox-policy.js";
26
+ import { signEnvelope, type FlairClient } from "../src/lib/signEnvelope.js";
27
+
28
+ const AGENT = "agent-a";
29
+ const FROM = "agent-b";
30
+ const OTHER = "agent-c";
31
+ const SEED = Buffer.alloc(32, 0x57);
32
+ const OTHER_SEED = Buffer.alloc(32, 0x58);
33
+ const CHILD = fileURLToPath(new URL("./helpers/mail-kill-child.mjs", import.meta.url));
34
+ const MODULE = new URL("../src/io/mail.ts", import.meta.url).href;
35
+
36
+ let mailDir: string;
37
+ let root: string;
38
+
39
+ const cur = (file: string) => join(root, "cur", file);
40
+ const fresh = (file: string) => join(root, "new", file);
41
+
42
+ /** A verifier that resolves the senders in `known` (default both). */
43
+ function verifier(known: string[] = [FROM, OTHER]): FlairClient {
44
+ return {
45
+ async getAgent(name: string) {
46
+ if (!known.includes(name)) return null;
47
+ return { publicKey: Buffer.from(ed.getPublicKey(name === FROM ? SEED : OTHER_SEED)) };
48
+ },
49
+ };
50
+ }
51
+
52
+ const client = (flair: FlairClient = verifier()) => new MailClient(mailDir, undefined, AGENT, flair);
53
+
54
+ beforeEach(() => {
55
+ mailDir = mkdtempSync(join(tmpdir(), "mail-delivery-"));
56
+ root = join(mailDir, AGENT);
57
+ mkdirSync(join(root, "new"), { recursive: true });
58
+ mkdirSync(join(root, "cur"), { recursive: true });
59
+ });
60
+
61
+ afterEach(() => rmSync(mailDir, { recursive: true, force: true }));
62
+
63
+ /** Write one signed record to `path`. */
64
+ function signedRecord(path: string, messageId: string, from = FROM, body = "delivery-body"): void {
65
+ const timestamp = new Date().toISOString();
66
+ const envelope = signEnvelope(
67
+ {
68
+ v: 1, from, to: AGENT, body, messageId, timestamp,
69
+ delegationChain: [
70
+ { agent: "system", kind: "human", timestamp, rationale: "originates", signature: null },
71
+ { agent: from, kind: "agent", timestamp, rationale: "sends", signature: null },
72
+ ],
73
+ },
74
+ { [from]: from === FROM ? SEED : OTHER_SEED },
75
+ );
76
+ writeFileSync(path, JSON.stringify({ from, body: JSON.stringify(envelope) }));
77
+ }
78
+
79
+ const plant = (file: string, messageId: string, from = FROM) => signedRecord(fresh(file), messageId, from);
80
+
81
+ const jsonFiles = (dir: string) => (existsSync(dir) ? readdirSync(dir).filter((n) => n.endsWith(".json")).sort() : []);
82
+ const newFiles = () => jsonFiles(join(root, "new"));
83
+ const curFiles = () => jsonFiles(join(root, "cur"));
84
+
85
+ const textOf = (path: string) => (existsSync(path) ? readFileSync(path, "utf8") : null);
86
+ const intentPath = (file: string) => join(root, `.placement-${createHash("sha256").update(file).digest("hex")}.json`);
87
+ const intentText = (file: string) => textOf(intentPath(file));
88
+ const intentJson = (file: string) => JSON.parse(readFileSync(intentPath(file), "utf8"));
89
+ const intentPhase = (file: string) => mailboxReplayStore(root).placementPhase(file);
90
+
91
+ /** Rewrite the intent for `file` with `fields` merged in. */
92
+ function setPhase(fields: Record<string, unknown>, file = "m1.json"): Buffer {
93
+ const path = intentPath(file);
94
+ writeFileSync(path, JSON.stringify({ ...JSON.parse(readFileSync(path, "utf8")), ...fields }));
95
+ return readFileSync(path);
96
+ }
97
+
98
+ /** A committed message (linked into cur/, consumed) with the given intent fields. */
99
+ function committed(messageId: string, fields: Record<string, unknown>, file = "m1.json", from = FROM): Buffer {
100
+ signedRecord(fresh(file), messageId, from);
101
+ const replay = mailboxReplayStore(root);
102
+ linkSync(fresh(file), cur(file));
103
+ unlinkSync(fresh(file));
104
+ replay.beginPlacement(messageId, file, cur(file));
105
+ replay.recordConsumed(messageId);
106
+ return setPhase(fields, file);
107
+ }
108
+
109
+ const quarantined = (file: string) => existsSync(`${intentPath(file)}.quarantined`);
110
+
111
+ /** The delivery, asserting the call handed one over. */
112
+ function delivered(result: DeliverNextResult): MailDelivery {
113
+ if (result.status !== "delivered") throw new Error(`expected a delivery, got ${JSON.stringify(result)}`);
114
+ return result.delivery;
115
+ }
116
+ const idOf = (result: DeliverNextResult) => (result.status === "delivered" ? result.delivery.message.verifiedEnvelope?.messageId : undefined);
117
+ const reasonOf = (result: DeliverNextResult) => (result.status === "deferred" ? result.reason : result.status);
118
+
119
+ describe("per-message delivery commits one message at a time", () => {
120
+ test("keeps later mail in new/ while the first presentation is active", async () => {
121
+ plant("m1.json", "id-1");
122
+ plant("m2.json", "id-2");
123
+ plant("m3.json", "id-3");
124
+
125
+ const c = client();
126
+ const first = delivered(await c.deliverNext());
127
+ expect(first.message.verifiedEnvelope?.messageId).toBe("id-1");
128
+ expect(first.presentation).toBe(1);
129
+ expect(first.deliveryKey).toBe(JSON.stringify([realpathSync(root), "id-1"]));
130
+ expect(curFiles()).toEqual(["m1.json"]);
131
+ expect(newFiles()).toEqual(["m2.json", "m3.json"]);
132
+
133
+ const again = await c.deliverNext();
134
+ expect(reasonOf(again)).toBe("active");
135
+ expect(intentJson("m1.json").presentations).toBe(1);
136
+ expect(newFiles()).toEqual(["m2.json", "m3.json"]);
137
+
138
+ expect(c.releaseDelivery(first)).toEqual({ status: "released" });
139
+ const second = delivered(await c.deliverNext());
140
+ expect(second.message.verifiedEnvelope?.messageId).toBe("id-1");
141
+ expect(second.presentation).toBe(2);
142
+ expect(second.deliveryKey).toBe(first.deliveryKey);
143
+ expect(newFiles()).toEqual(["m2.json", "m3.json"]);
144
+
145
+ expect(await c.completeDelivery(second)).toEqual({ status: "completed" });
146
+ expect(intentPhase("m1.json")).toBeNull();
147
+
148
+ const next = delivered(await c.deliverNext());
149
+ expect(next.message.verifiedEnvelope?.messageId).toBe("id-2");
150
+ expect(curFiles()).toEqual(["m1.json", "m2.json"]);
151
+ expect(newFiles()).toEqual(["m3.json"]);
152
+ });
153
+
154
+ test("distinct mailbox roots produce distinct delivery keys for the same agent and message", async () => {
155
+ plant("m1.json", "same-id");
156
+ const otherDir = join(mailDir, "other-root");
157
+ const otherRoot = join(otherDir, AGENT);
158
+ mkdirSync(join(otherRoot, "new"), { recursive: true });
159
+ mkdirSync(join(otherRoot, "cur"), { recursive: true });
160
+ signedRecord(join(otherRoot, "new", "m1.json"), "same-id");
161
+ const a = client();
162
+ const b = new MailClient(otherDir, undefined, AGENT, verifier());
163
+ const first = delivered(await a.deliverNext());
164
+ const second = delivered(await b.deliverNext());
165
+ expect(second.deliveryKey).toBe(JSON.stringify([realpathSync(otherRoot), "same-id"]));
166
+ expect(second.deliveryKey).not.toBe(first.deliveryKey);
167
+ expect(await a.completeDelivery(first)).toEqual({ status: "completed" });
168
+ expect(await b.completeDelivery(second)).toEqual({ status: "completed" });
169
+ });
170
+
171
+ test("completion is idempotent and stops re-presentation", async () => {
172
+ plant("m1.json", "solo");
173
+ const c = client();
174
+ const m = delivered(await c.deliverNext());
175
+ expect(await c.completeDelivery(m)).toEqual({ status: "completed" });
176
+ expect(await c.completeDelivery(m)).toEqual({ status: "already-completed" });
177
+ expect(await c.deliverNext()).toEqual({ status: "idle" });
178
+ });
179
+
180
+ test("a call that listed nothing pending re-checks under the commit lock and does not put a second message in flight", async () => {
181
+ plant("m1.json", "race-1");
182
+ plant("m2.json", "race-2");
183
+ // B lists (nothing pending) and starts verifying m1; A then commits m1 in full.
184
+ let releaseB!: () => void;
185
+ const gate = new Promise<void>((resolve) => { releaseB = resolve; });
186
+ let bCalls = 0;
187
+ const b = client({
188
+ async getAgent(name: string) {
189
+ if (bCalls++ === 0) await gate;
190
+ return verifier().getAgent(name);
191
+ },
192
+ });
193
+ const pendingB = b.deliverNext();
194
+ while (bCalls === 0) await new Promise((r) => setTimeout(r, 5));
195
+ const a = await client().deliverNext();
196
+ expect(idOf(a)).toBe("race-1");
197
+ releaseB();
198
+ const resultB = await pendingB;
199
+ expect(resultB).toMatchObject({ status: "deferred", reason: "new-mail-deferred", file: "m2.json" });
200
+ expect(curFiles()).toEqual(["m1.json"]);
201
+ expect(newFiles()).toEqual(["m2.json"]);
202
+ expect(pendingPlacementEntries(root).map((e) => e.messageId)).toEqual(["race-1"]);
203
+ });
204
+ });
205
+
206
+ describe("persisted delivery release", () => {
207
+ test("another client defers before release, then retries and delivers later mail", async () => {
208
+ plant("m1.json", "released");
209
+ plant("m2.json", "later");
210
+ const a = client();
211
+ const b = client();
212
+ const first = delivered(await a.deliverNext());
213
+ const claim = intentJson("m1.json").claim;
214
+ setPhase({ claim: { ...claim, moduleNonce: randomUUID() } });
215
+ const before = intentJson("m1.json");
216
+ expect(reasonOf(await b.deliverNext())).toBe("active");
217
+ expect(newFiles()).toEqual(["m2.json"]);
218
+ expect(a.releaseDelivery(first)).toEqual({ status: "released" });
219
+ const { claim: _claim, ...unclaimed } = before;
220
+ expect(intentJson("m1.json")).toEqual(unclaimed);
221
+ const retry = delivered(await b.deliverNext());
222
+ expect(retry.message.verifiedEnvelope?.messageId).toBe("released");
223
+ expect(retry.presentation).toBe(2);
224
+ expect(await b.completeDelivery(retry)).toEqual({ status: "completed" });
225
+ expect(idOf(await b.deliverNext())).toBe("later");
226
+ });
227
+
228
+ test("a foreign claim at the presentation limit blocks later mail until released", async () => {
229
+ plant("m1.json", "at-limit");
230
+ plant("m2.json", "later");
231
+ const a = client();
232
+ const first = delivered(await a.deliverNext());
233
+ const claim = intentJson("m1.json").claim;
234
+ setPhase({
235
+ claim: { ...claim, moduleNonce: randomUUID() },
236
+ presentations: MAX_DELIVERY_PRESENTATIONS,
237
+ });
238
+ const b = client();
239
+ expect(reasonOf(await b.deliverNext())).toBe("active");
240
+ expect(a.releaseDelivery(first)).toEqual({ status: "released" });
241
+ expect(idOf(await b.deliverNext())).toBe("later");
242
+ expect(intentPhase("m1.json")).toBe("failed");
243
+ });
244
+
245
+ test("release refuses a replaced token without changing the intent", async () => {
246
+ plant("m1.json", "replaced-token");
247
+ const c = client();
248
+ const first = delivered(await c.deliverNext());
249
+ const claim = intentJson("m1.json").claim;
250
+ setPhase({ claim: { ...claim, token: randomUUID() } });
251
+ const before = intentText("m1.json");
252
+ expect(c.releaseDelivery(first)).toEqual({ status: "refused", reason: "stale" });
253
+ expect(client().releaseDelivery(first)).toEqual({ status: "refused", reason: "foreign" });
254
+ expect(c.releaseDelivery({ ...first })).toEqual({ status: "refused", reason: "foreign" });
255
+ expect(intentText("m1.json")).toBe(before);
256
+ });
257
+
258
+ test("lock contention defers release and permits a retry", async () => {
259
+ plant("m1.json", "release-busy");
260
+ const c = client();
261
+ const first = delivered(await c.deliverNext());
262
+ const before = intentText("m1.json");
263
+ const claimDir = join(root, ".mail-lock.claim");
264
+ mkdirSync(claimDir);
265
+ try {
266
+ expect(c.releaseDelivery(first)).toMatchObject({ status: "deferred", reason: "lock-busy" });
267
+ expect(intentText("m1.json")).toBe(before);
268
+ } finally { rmSync(claimDir, { recursive: true }); }
269
+ expect(reasonOf(await client().deliverNext())).toBe("active");
270
+ expect(c.releaseDelivery(first)).toEqual({ status: "released" });
271
+ expect(c.releaseDelivery(first)).toEqual({ status: "refused", reason: "stale" });
272
+ });
273
+
274
+ test("a phase-write error defers release and retains the claim for retry", async () => {
275
+ plant("m1.json", "release-error");
276
+ const c = client();
277
+ const first = delivered(await c.deliverNext());
278
+ const before = intentText("m1.json");
279
+ const realOpen = fs.openSync;
280
+ const stub = spyOn(fs, "openSync").mockImplementation(((path: fs.PathLike, flags: fs.OpenMode, mode?: fs.Mode) => {
281
+ if (String(path).endsWith(".phase.tmp")) throw new Error("release write failed");
282
+ return realOpen(path, flags, mode);
283
+ }) as typeof fs.openSync);
284
+ try {
285
+ expect(c.releaseDelivery(first)).toMatchObject({ status: "deferred", reason: "storage-error" });
286
+ expect(intentText("m1.json")).toBe(before);
287
+ expect(existsSync(join(root, ".mail-lock"))).toBe(false);
288
+ } finally { stub.mockRestore(); }
289
+ expect(reasonOf(await client().deliverNext())).toBe("active");
290
+ expect(c.releaseDelivery(first)).toEqual({ status: "released" });
291
+ expect(delivered(await client().deliverNext()).presentation).toBe(2);
292
+ });
293
+ });
294
+
295
+ describe("in_progress re-presentation in recovery", () => {
296
+ test("a foreign module nonce in the same process defers re-presentation", async () => {
297
+ plant("m1.json", "foreign-module");
298
+ const c = client();
299
+ const first = delivered(await c.deliverNext());
300
+ const claim = intentJson("m1.json").claim;
301
+ expect(c.releaseDelivery(first)).toEqual({ status: "released" });
302
+ setPhase({ claim: { ...claim, moduleNonce: randomUUID() } });
303
+ const before = intentText("m1.json");
304
+
305
+ for (let i = 0; i < MAX_DELIVERY_PRESENTATIONS * 2; i++) {
306
+ expect(reasonOf(await client().deliverNext())).toBe("active");
307
+ }
308
+ expect(intentText("m1.json")).toBe(before);
309
+ expect(mailboxReplayStore(root).placementState("m1.json")?.claim?.moduleNonce).not.toBe(claim.moduleNonce);
310
+ setPhase({ claim });
311
+ expect(delivered(await client().deliverNext()).presentation).toBe(2);
312
+ });
313
+
314
+ test("a claimed intent without firstPresentedAt is rejected at parse and quarantined", async () => {
315
+ plant("m1.json", "missing-time");
316
+ const c = client();
317
+ const first = delivered(await c.deliverNext());
318
+ const claim = intentJson("m1.json").claim;
319
+ expect(c.releaseDelivery(first)).toEqual({ status: "released" });
320
+ setPhase({ claim: { ...claim, moduleNonce: randomUUID() }, firstPresentedAt: undefined });
321
+ expect(() => mailboxReplayStore(root).placementState("m1.json")).toThrow("malformed placement intent");
322
+ expect(quarantined("m1.json")).toBe(true);
323
+ expect(existsSync(intentPath("m1.json"))).toBe(false);
324
+ expect(await c.deliverNext()).toEqual({ status: "idle" });
325
+ expect(await c.completeDelivery(first)).toMatchObject({
326
+ status: "deferred", reason: "storage-error",
327
+ detail: "quarantined placement intent needs repair before a retry can complete",
328
+ });
329
+ expect(curFiles()).toEqual(["m1.json"]);
330
+ });
331
+
332
+ test("this module's nonce with no local token permits re-presentation", async () => {
333
+ plant("m1.json", "released-module");
334
+ const c = client();
335
+ const first = delivered(await c.deliverNext());
336
+ const claim = intentJson("m1.json").claim;
337
+ expect(c.releaseDelivery(first)).toEqual({ status: "released" });
338
+ setPhase({ claim });
339
+
340
+ const again = delivered(await client().deliverNext());
341
+ expect(again.presentation).toBe(2);
342
+ expect(intentJson("m1.json").claim.moduleNonce).toBe(claim.moduleNonce);
343
+ });
344
+
345
+ test("lease expiry releases a foreign module claim to the delivery deadline", async () => {
346
+ plant("m1.json", "expired-module");
347
+ plant("m2.json", "healthy");
348
+ const c = client();
349
+ const first = delivered(await c.deliverNext());
350
+ const claim = intentJson("m1.json").claim;
351
+ expect(c.releaseDelivery(first)).toEqual({ status: "released" });
352
+ setPhase({
353
+ claim: { ...claim, moduleNonce: randomUUID() },
354
+ firstPresentedAt: new Date(Date.now() - DELIVERY_PRESENTATION_TTL_MS - 1_000).toISOString(),
355
+ });
356
+
357
+ expect(idOf(await client().deliverNext())).toBe("healthy");
358
+ expect(intentPhase("m1.json")).toBe("failed");
359
+ expect(intentJson("m1.json").claim).toBeUndefined();
360
+ expect(curFiles()).toContain("m1.json");
361
+ });
362
+
363
+ test("a real worker's held delivery defers repeated calls from this module copy", async () => {
364
+ plant("probe.json", "own-module");
365
+ const c = client();
366
+ const first = delivered(await c.deliverNext());
367
+ const own = intentJson("probe.json").claim;
368
+ expect(await c.completeDelivery(first)).toEqual({ status: "completed" });
369
+ plant("m1.json", "worker-held");
370
+ plant("m2.json", "waiting");
371
+ const worker = new Worker(new URL("./helpers/mail-delivery-worker.mjs", import.meta.url), {
372
+ workerData: { mailDir, agent: AGENT, from: FROM, seed: SEED.toString("base64"), module: MODULE },
373
+ });
374
+ try {
375
+ const result = await new Promise<DeliverNextResult>((resolve, reject) => {
376
+ worker.once("message", resolve);
377
+ worker.once("error", reject);
378
+ worker.once("exit", (code) => reject(new Error(`worker exited before handoff: ${code}`)));
379
+ });
380
+ expect(delivered(result).presentation).toBe(1);
381
+ const claim = intentJson("m1.json").claim;
382
+ expect(claim.pid).toBe(own.pid);
383
+ expect(claim.start).toBe(own.start);
384
+ expect(claim.moduleNonce).not.toBe(own.moduleNonce);
385
+ const before = intentText("m1.json");
386
+ for (let i = 0; i < MAX_DELIVERY_PRESENTATIONS * 2; i++) {
387
+ expect(reasonOf(await c.deliverNext())).toBe("active");
388
+ }
389
+ expect(intentText("m1.json")).toBe(before);
390
+ expect(newFiles()).toEqual(["m2.json"]);
391
+ const completed = new Promise((resolve, reject) => {
392
+ worker.once("message", resolve);
393
+ worker.once("error", reject);
394
+ });
395
+ worker.postMessage("complete");
396
+ expect(await completed).toEqual({ status: "completed" });
397
+ expect(idOf(await c.deliverNext())).toBe("waiting");
398
+ } finally {
399
+ await worker.terminate();
400
+ }
401
+ });
402
+
403
+ test("another client in the module copy waits for a held token, then presents it again once released", async () => {
404
+ plant("m1.json", "resume-in-progress");
405
+ const a = client();
406
+ const first = delivered(await a.deliverNext());
407
+ expect(intentPhase("m1.json")).toBe("in_progress");
408
+ expect(intentJson("m1.json").presentations).toBe(1);
409
+
410
+ const b = client();
411
+ expect(reasonOf(await b.deliverNext())).toBe("active");
412
+ expect(intentJson("m1.json").presentations).toBe(1);
413
+
414
+ expect(a.releaseDelivery(first)).toEqual({ status: "released" });
415
+ const again = delivered(await b.deliverNext());
416
+ expect(again.message.verifiedEnvelope?.messageId).toBe("resume-in-progress");
417
+ expect(again.presentation).toBe(2);
418
+
419
+ // The stale reader cannot finalize the current presentation.
420
+ const before = intentText("m1.json");
421
+ const stale = await a.completeDelivery(first);
422
+ expect(stale.status).toBe("refused");
423
+ if (stale.status === "refused") expect(stale.reason).toBe("stale");
424
+ expect(intentText("m1.json")).toBe(before);
425
+
426
+ expect(await b.completeDelivery(again)).toEqual({ status: "completed" });
427
+ expect(await client().deliverNext()).toEqual({ status: "idle" });
428
+ });
429
+
430
+ test("recovers a verified placing fixture to in_progress", async () => {
431
+ plant("m1.json", "resume-placing");
432
+ const replay = mailboxReplayStore(root);
433
+ linkSync(fresh("m1.json"), cur("m1.json"));
434
+ replay.beginPlacement("resume-placing", "m1.json", cur("m1.json"));
435
+ // No consumed id and no phase yet: a crash between the link and the phase write.
436
+
437
+ const c = client();
438
+ const m = delivered(await c.deliverNext());
439
+ expect(m.message.verifiedEnvelope?.messageId).toBe("resume-placing");
440
+ expect(intentPhase("m1.json")).toBe("in_progress");
441
+ expect(hasCommittedMessageId(root, "resume-placing")).toBe(true);
442
+
443
+ expect(reasonOf(await c.deliverNext())).toBe("active");
444
+ expect(c.releaseDelivery(m)).toEqual({ status: "released" });
445
+ expect(idOf(await c.deliverNext())).toBe("resume-placing");
446
+ });
447
+
448
+ test("an in_progress intent written without a claim is presented again", async () => {
449
+ committed("unclaimed", { version: 1, phase: "in_progress", presentations: 1, firstPresentedAt: new Date().toISOString() });
450
+ const m = delivered(await client().deliverNext());
451
+ expect(m.presentation).toBe(2);
452
+ expect(intentJson("m1.json").claim.pid).toBe(process.pid);
453
+ });
454
+ });
455
+
456
+ describe("reporting failures", () => {
457
+ function failingEvents(): EventLogger {
458
+ const eventDir = join(mailDir, "events");
459
+ const events = new EventLogger(AGENT, eventDir);
460
+ rmSync(eventDir, { recursive: true });
461
+ writeFileSync(eventDir, "not a directory");
462
+ expect(() => events.emit({ type: "mail.receive", status: "error" })).toThrow();
463
+ return events;
464
+ }
465
+
466
+ test("a failed real event destination preserves a committed delivery", async () => {
467
+ plant("m1.json", "logger-success");
468
+ const events = failingEvents();
469
+ const emit = spyOn(events, "emit");
470
+ const c = new MailClient(mailDir, events, AGENT, verifier());
471
+ try {
472
+ const m = delivered(await c.deliverNext());
473
+ expect(m.message.verifiedEnvelope?.messageId).toBe("logger-success");
474
+ expect(hasCommittedMessageId(root, "logger-success")).toBe(true);
475
+ expect(intentPhase("m1.json")).toBe("in_progress");
476
+ expect(newFiles()).toEqual([]);
477
+ expect(curFiles()).toEqual(["m1.json"]);
478
+ expect(emit).toHaveBeenCalledWith(expect.objectContaining({ status: "ok" }));
479
+ expect(reasonOf(await c.deliverNext())).toBe("active");
480
+ expect(await c.completeDelivery(m)).toEqual({ status: "completed" });
481
+ } finally { emit.mockRestore(); }
482
+ });
483
+
484
+ test("a failed real event destination preserves rejection", async () => {
485
+ writeFileSync(fresh("m1.json"), "{}");
486
+ const events = failingEvents();
487
+ const emit = spyOn(events, "emit");
488
+ try {
489
+ expect(await new MailClient(mailDir, events, AGENT, verifier()).deliverNext()).toEqual({ status: "idle" });
490
+ expect(newFiles()).toEqual([]);
491
+ expect(curFiles()).toEqual([]);
492
+ expect(readFileSync(join(root, "dlq", "m1.json"), "utf8")).toBe("{}");
493
+ expect(readFileSync(join(root, "dlq", "m1.json.reason"), "utf8")).toContain("class: invalid");
494
+ expect(emit).toHaveBeenCalledWith(expect.objectContaining({ status: "rejected" }));
495
+ } finally { emit.mockRestore(); }
496
+ });
497
+
498
+ for (const failSync of [false, true]) {
499
+ test(`quarantine with a failed real event destination and directory sync failure=${failSync}`, async () => {
500
+ writeFileSync(cur("m1.json"), "{}");
501
+ const c = new MailClient(mailDir, failingEvents(), AGENT, verifier());
502
+ mailboxReplayStore(root).beginPlacement("logger-quarantine", "m1.json", cur("m1.json"));
503
+ const fsync = fs.fsyncSync;
504
+ let boundaryReached = false;
505
+ const sync = spyOn(fs, "fsyncSync").mockImplementation((fd) => {
506
+ if (fs.fstatSync(fd).isDirectory() && !existsSync(intentPath("m1.json"))) {
507
+ boundaryReached = true;
508
+ expect(existsSync(cur("m1.json"))).toBe(false);
509
+ expect(readFileSync(join(root, "dlq", "m1.json"), "utf8")).toBe("{}");
510
+ if (failSync) throw new Error("quarantine directory sync failed");
511
+ }
512
+ fsync(fd);
513
+ });
514
+ try {
515
+ const result = await c.deliverNext();
516
+ expect(result).toMatchObject({ status: "deferred", reason: failSync ? "storage-error" : "pending-record-invalid" });
517
+ if (failSync) expect(result).toMatchObject({ detail: "quarantine directory sync failed" });
518
+ expect(boundaryReached).toBe(true);
519
+ expect(existsSync(intentPath("m1.json"))).toBe(false);
520
+ expect(readFileSync(join(root, "dlq", "m1.json.reason"), "utf8")).toContain("pending-record-invalid");
521
+ const lock = await acquireMailLock(realpathSync(root));
522
+ expect(lock).not.toBeNull();
523
+ lock?.release();
524
+ } finally { sync.mockRestore(); }
525
+ });
526
+ }
527
+
528
+ test("a throwing warning preserves the failed-intent transition and later delivery", async () => {
529
+ committed("expired", {
530
+ version: 1, phase: "in_progress", presentations: 1,
531
+ firstPresentedAt: new Date(Date.now() - DELIVERY_PRESENTATION_TTL_MS - 1).toISOString(),
532
+ });
533
+ plant("m2.json", "later");
534
+ const warn = spyOn(console, "warn").mockImplementation(() => { throw new Error("warning failed"); });
535
+ try {
536
+ expect(idOf(await client().deliverNext())).toBe("later");
537
+ expect(intentPhase("m1.json")).toBe("failed");
538
+ expect(warn).toHaveBeenCalled();
539
+ } finally { warn.mockRestore(); }
540
+ });
541
+
542
+ test("a throwing error log preserves a rejection whose DLQ move failed", async () => {
543
+ const c = new MailClient(mailDir, failingEvents(), AGENT, verifier());
544
+ writeFileSync(fresh("m1.json"), "{}");
545
+ mkdirSync(join(root, "dlq", "m1.json"));
546
+ const error = spyOn(console, "error").mockImplementation(() => { throw new Error("error log failed"); });
547
+ try {
548
+ expect(await c.deliverNext()).toEqual({ status: "idle" });
549
+ expect(newFiles()).toEqual(["m1.json"]);
550
+ expect(error).toHaveBeenCalled();
551
+ } finally { error.mockRestore(); }
552
+ });
553
+ });
554
+
555
+ describe("completion is bound to the hand-over", () => {
556
+ test("a failed real event destination cannot reject a placement-error deferral", async () => {
557
+ plant("m1.json", "logger-error");
558
+ const eventDir = join(mailDir, "events");
559
+ const events = new EventLogger(AGENT, eventDir);
560
+ const c = new MailClient(mailDir, events, AGENT, verifier());
561
+ const m = delivered(await c.deliverNext());
562
+ const before = readFileSync(intentPath("m1.json"));
563
+ rmSync(eventDir, { recursive: true });
564
+ writeFileSync(eventDir, "not a directory");
565
+ expect(() => events.emit({ type: "mail.receive", status: "error" })).toThrow();
566
+ unlinkSync(intentPath("m1.json"));
567
+ mkdirSync(intentPath("m1.json"));
568
+ try {
569
+ expect(await c.completeDelivery(m)).toMatchObject({ status: "deferred", reason: "storage-error" });
570
+ const lock = await acquireMailLock(realpathSync(root));
571
+ expect(lock).not.toBeNull();
572
+ lock?.release();
573
+ } finally {
574
+ rmSync(intentPath("m1.json"), { recursive: true });
575
+ writeFileSync(intentPath("m1.json"), before);
576
+ }
577
+ expect(await c.completeDelivery(m)).toEqual({ status: "completed" });
578
+ });
579
+
580
+ test("directory-sync failure after unlink reports uncertain durability", async () => {
581
+ plant("m1.json", "sync-error");
582
+ const c = client();
583
+ const m = delivered(await c.deliverNext());
584
+ const sync = spyOn(fs, "fsyncSync").mockImplementation(() => { throw new Error("sync failed"); });
585
+ try {
586
+ expect(await c.completeDelivery(m)).toEqual({
587
+ status: "deferred", reason: "storage-error",
588
+ detail: "intent unlinked; directory sync failed, durability uncertain",
589
+ });
590
+ expect(existsSync(intentPath("m1.json"))).toBe(false);
591
+ const lock = await acquireMailLock(realpathSync(root));
592
+ expect(lock).not.toBeNull();
593
+ lock?.release();
594
+ } finally {
595
+ sync.mockRestore();
596
+ }
597
+ expect(await c.completeDelivery(m)).toMatchObject({ status: "refused", reason: "stale" });
598
+ });
599
+
600
+ for (const failure of ["unreadable", "malformed"] as const) {
601
+ test(`${failure} intent defers completion with storage-error and retains the token`, async () => {
602
+ plant("m1.json", "intent-error");
603
+ const events = new EventLogger(AGENT, join(mailDir, "events"));
604
+ const emit = spyOn(events, "emit");
605
+ const c = new MailClient(mailDir, events, AGENT, verifier());
606
+ const m = delivered(await c.deliverNext());
607
+ const before = readFileSync(intentPath("m1.json"), "utf8");
608
+ unlinkSync(intentPath("m1.json"));
609
+ if (failure === "unreadable") mkdirSync(intentPath("m1.json"));
610
+ else writeFileSync(intentPath("m1.json"), "{");
611
+ try {
612
+ const result = await c.completeDelivery(m);
613
+ expect(result).toMatchObject({ status: "deferred", reason: "storage-error" });
614
+ if (failure === "malformed") {
615
+ expect(result).toMatchObject({ detail: "quarantined placement intent needs repair before a retry can complete" });
616
+ expect(quarantined("m1.json")).toBe(true);
617
+ expect(existsSync(intentPath("m1.json"))).toBe(false);
618
+ expect(await c.completeDelivery(m)).toEqual(result);
619
+ }
620
+ expect(emit).toHaveBeenLastCalledWith(expect.objectContaining({
621
+ type: "mail.receive", agent: AGENT, status: "error", from: "unknown", durationMs: 0,
622
+ error: expect.any(String),
623
+ }));
624
+ const lock = await acquireMailLock(realpathSync(root));
625
+ expect(lock).not.toBeNull();
626
+ lock?.release();
627
+ } finally {
628
+ emit.mockRestore();
629
+ rmSync(intentPath("m1.json"), { recursive: true, force: true });
630
+ rmSync(`${intentPath("m1.json")}.quarantined`, { force: true });
631
+ writeFileSync(intentPath("m1.json"), before);
632
+ }
633
+ expect(reasonOf(await client().deliverNext())).toBe("active");
634
+ expect(await c.completeDelivery(m)).toEqual({ status: "completed" });
635
+ });
636
+ }
637
+
638
+ test("intent unlink failure defers completion with storage-error and retains the token", async () => {
639
+ plant("m1.json", "unlink-error");
640
+ const events = new EventLogger(AGENT, join(mailDir, "events"));
641
+ const emit = spyOn(events, "emit");
642
+ const c = new MailClient(mailDir, events, AGENT, verifier());
643
+ const m = delivered(await c.deliverNext());
644
+ const before = intentText("m1.json");
645
+ const original = fs.unlinkSync;
646
+ const unlink = spyOn(fs, "unlinkSync").mockImplementation((path) => {
647
+ if (String(path) === intentPath("m1.json")) throw new Error("intent unlink unavailable");
648
+ return original(path);
649
+ });
650
+ try {
651
+ expect(await c.completeDelivery(m)).toMatchObject({ status: "deferred", reason: "storage-error" });
652
+ expect(emit).toHaveBeenLastCalledWith({
653
+ type: "mail.receive", agent: AGENT, status: "error", from: "unknown", durationMs: 0,
654
+ error: "intent unlink unavailable",
655
+ });
656
+ expect(intentText("m1.json")).toBe(before);
657
+ const lock = await acquireMailLock(realpathSync(root));
658
+ expect(lock).not.toBeNull();
659
+ lock?.release();
660
+ } finally {
661
+ unlink.mockRestore();
662
+ emit.mockRestore();
663
+ }
664
+ expect(reasonOf(await client().deliverNext())).toBe("active");
665
+ expect(await c.completeDelivery(m)).toEqual({ status: "completed" });
666
+ });
667
+
668
+ test("a delivery another client issued, or a copied one, is refused as foreign and changes nothing", async () => {
669
+ plant("m1.json", "bound");
670
+ const owner = client();
671
+ const m = delivered(await owner.deliverNext());
672
+ const before = intentText("m1.json");
673
+
674
+ const other = client();
675
+ const foreign = await other.completeDelivery(m);
676
+ expect(foreign).toMatchObject({ status: "refused", reason: "foreign" });
677
+ const copied = await owner.completeDelivery({ ...m });
678
+ expect(copied).toMatchObject({ status: "refused", reason: "foreign" });
679
+ expect(intentText("m1.json")).toBe(before);
680
+
681
+ expect(await owner.completeDelivery(m)).toEqual({ status: "completed" });
682
+ });
683
+
684
+ test("a delivery whose claim was replaced on disk is refused as stale", async () => {
685
+ plant("m1.json", "replaced-claim");
686
+ const c = client();
687
+ const m = delivered(await c.deliverNext());
688
+ const claim = intentJson("m1.json").claim;
689
+ setPhase({ claim: { ...claim, token: randomUUID() } });
690
+ const before = intentText("m1.json");
691
+ expect(await c.completeDelivery(m)).toMatchObject({ status: "refused", reason: "stale" });
692
+ expect(intentText("m1.json")).toBe(before);
693
+ });
694
+
695
+ test("a cur/ copy replaced by another file is refused as identity and keeps the intent", async () => {
696
+ plant("m1.json", "replaced-file");
697
+ const c = client();
698
+ const m = delivered(await c.deliverNext());
699
+ const bytes = readFileSync(cur("m1.json"));
700
+ unlinkSync(cur("m1.json"));
701
+ writeFileSync(cur("m1.json"), Buffer.concat([bytes, Buffer.from(" ")]));
702
+ const before = intentText("m1.json");
703
+ expect(await c.completeDelivery(m)).toMatchObject({ status: "refused", reason: "identity" });
704
+ expect(intentText("m1.json")).toBe(before);
705
+ });
706
+
707
+ for (const field of ["ino", "size"] as const) {
708
+ test(`a cur/ copy with changed ${field} is refused as identity`, async () => {
709
+ plant("m1.json", "changed-identity");
710
+ const c = client();
711
+ const m = delivered(await c.deliverNext());
712
+ const before = intentText("m1.json");
713
+ const stat = fs.lstatSync(cur("m1.json"), { bigint: true });
714
+ expect(intentJson("m1.json").identity).toEqual({
715
+ dev: String(stat.dev), ino: String(stat.ino), size: String(stat.size),
716
+ sha256: createHash("sha256").update(readFileSync(cur("m1.json"))).digest("hex"),
717
+ });
718
+ const realStat = fs.lstatSync;
719
+ const replacement = Object.assign(Object.create(Object.getPrototypeOf(stat)), stat, { [field]: stat[field] + 1n });
720
+ const stub = spyOn(fs, "lstatSync").mockImplementation(((path: fs.PathLike, options: unknown) =>
721
+ path === cur("m1.json") ? replacement : realStat(path, options as { bigint: true })) as typeof fs.lstatSync);
722
+ try {
723
+ expect(mailboxReplayStore(root).ownsPendingPlacement("changed-identity", "m1.json")).toBe(false);
724
+ expect(await c.completeDelivery(m)).toMatchObject({ status: "refused", reason: "identity" });
725
+ expect(intentText("m1.json")).toBe(before);
726
+ expect(c.releaseDelivery(m)).toEqual({ status: "refused", reason: "stale" });
727
+ expect(await c.deliverNext()).toMatchObject({ status: "deferred", reason: "record-changed" });
728
+ expect(intentText("m1.json")).toBe(before);
729
+ } finally { stub.mockRestore(); }
730
+ });
731
+ }
732
+
733
+ test("inode reuse with different same-size bytes is refused as identity", async () => {
734
+ plant("m1.json", "reused-inode");
735
+ const c = client();
736
+ const m = delivered(await c.deliverNext());
737
+ const before = intentText("m1.json");
738
+ const recorded = intentJson("m1.json").identity;
739
+ const bytes = readFileSync(cur("m1.json"), "utf8");
740
+ unlinkSync(cur("m1.json"));
741
+ writeFileSync(cur("m1.json"), bytes.replace("delivery-body", "different-msg"));
742
+ const realStat = fs.lstatSync;
743
+ const stat = realStat(cur("m1.json"), { bigint: true });
744
+ expect(String(stat.size)).toBe(recorded.size);
745
+ const replacement = Object.assign(Object.create(Object.getPrototypeOf(stat)), stat, { ino: BigInt(recorded.ino) });
746
+ const stub = spyOn(fs, "lstatSync").mockImplementation(((path: fs.PathLike, options: unknown) =>
747
+ path === cur("m1.json") ? replacement : realStat(path, options as { bigint: true })) as typeof fs.lstatSync);
748
+ try {
749
+ expect(mailboxReplayStore(root).ownsPendingPlacement("reused-inode", "m1.json")).toBe(false);
750
+ expect(await c.completeDelivery(m)).toMatchObject({ status: "refused", reason: "identity" });
751
+ expect(intentText("m1.json")).toBe(before);
752
+ } finally { stub.mockRestore(); }
753
+ });
754
+
755
+ test("the same inode and bytes remain the same message after link changes and a rewrite", async () => {
756
+ plant("m1.json", "same-message");
757
+ const c = client();
758
+ const m = delivered(await c.deliverNext());
759
+ const bytes = readFileSync(cur("m1.json"));
760
+ linkSync(cur("m1.json"), fresh("linked.json"));
761
+ unlinkSync(fresh("linked.json"));
762
+ writeFileSync(cur("m1.json"), bytes);
763
+ expect(mailboxReplayStore(root).ownsPendingPlacement("same-message", "m1.json")).toBe(true);
764
+ expect(await c.completeDelivery(m)).toEqual({ status: "completed" });
765
+ });
766
+
767
+ test("an identity without a byte hash is refused and keeps the intent", async () => {
768
+ plant("m1.json", "legacy-identity");
769
+ const c = client();
770
+ const m = delivered(await c.deliverNext());
771
+ const { dev, ino, size } = intentJson("m1.json").identity;
772
+ setPhase({ identity: { dev, ino, size, ctimeNs: String(fs.lstatSync(cur("m1.json"), { bigint: true }).ctimeNs) } });
773
+ const before = intentText("m1.json");
774
+ expect(await c.completeDelivery(m)).toMatchObject({ status: "refused", reason: "identity" });
775
+ expect(intentText("m1.json")).toBe(before);
776
+ });
777
+
778
+ test("a held local token defers re-presentation without increasing its count", async () => {
779
+ plant("m1.json", "long-handler");
780
+ plant("m2.json", "waiting");
781
+ const c = client();
782
+ const m = delivered(await c.deliverNext());
783
+ for (let i = 0; i < MAX_DELIVERY_PRESENTATIONS * 2; i++) {
784
+ expect(reasonOf(await c.deliverNext())).toBe("active");
785
+ }
786
+ expect(intentPhase("m1.json")).toBe("in_progress");
787
+ expect(intentJson("m1.json").presentations).toBe(1);
788
+ expect(newFiles()).toEqual(["m2.json"]);
789
+ expect(await c.completeDelivery(m)).toEqual({ status: "completed" });
790
+ });
791
+
792
+ test("completion and delivery resolve the retargeted mail root", async () => {
793
+ const rootA = join(mailDir, "rootA");
794
+ const rootB = join(mailDir, "rootB");
795
+ for (const r of [rootA, rootB]) mkdirSync(join(r, AGENT, "new"), { recursive: true });
796
+ const link = join(mailDir, "mail-link");
797
+ symlinkSync(rootA, link);
798
+ root = join(rootA, AGENT);
799
+ plant("m1.json", "pinned-1");
800
+ plant("m2.json", "pinned-2");
801
+ // rootB holds the same file name for the same message under another claim.
802
+ root = join(rootB, AGENT);
803
+ mkdirSync(join(root, "cur"), { recursive: true });
804
+ committed("pinned-1", {
805
+ version: 1, phase: "in_progress", presentations: 1, firstPresentedAt: new Date().toISOString(),
806
+ claim: { token: randomUUID(), pid: process.pid, start: null, moduleNonce: randomUUID() },
807
+ });
808
+ const rootBIntent = intentText("m1.json");
809
+ plant("m9.json", "other-root");
810
+
811
+ const c = new MailClient(link, undefined, AGENT, verifier());
812
+ root = join(rootA, AGENT);
813
+ const m = delivered(await c.deliverNext());
814
+ expect(m.message.verifiedEnvelope?.messageId).toBe("pinned-1");
815
+
816
+ unlinkSync(link);
817
+ symlinkSync(rootB, link);
818
+ expect(realpathSync(join(link, AGENT))).toBe(realpathSync(join(rootB, AGENT)));
819
+
820
+ const rootAIntent = intentText("m1.json");
821
+ expect(await c.completeDelivery(m)).toMatchObject({ status: "refused", reason: "stale" });
822
+ expect(intentText("m1.json")).toBe(rootAIntent);
823
+ expect(newFiles()).toEqual(["m2.json"]);
824
+
825
+ root = join(rootB, AGENT);
826
+ expect(intentText("m1.json")).toBe(rootBIntent);
827
+ expect(reasonOf(await c.deliverNext())).toBe("active");
828
+ setPhase({ claim: undefined });
829
+ const resumed = delivered(await c.deliverNext());
830
+ expect(resumed.message.verifiedEnvelope?.messageId).toBe("pinned-1");
831
+ expect(resumed.presentation).toBe(2);
832
+ expect(await c.completeDelivery(resumed)).toEqual({ status: "completed" });
833
+ const next = delivered(await c.deliverNext());
834
+ expect(next.message.verifiedEnvelope?.messageId).toBe("other-root");
835
+ expect(newFiles()).toEqual([]);
836
+ });
837
+
838
+ test("completion reports no matching live intent and claim after retargeting to an empty mailbox", async () => {
839
+ const empty = join(mailDir, "empty");
840
+ mkdirSync(join(empty, AGENT, "new"), { recursive: true });
841
+ mkdirSync(join(empty, AGENT, "cur"), { recursive: true });
842
+ const link = join(mailDir, "mail-link");
843
+ symlinkSync(mailDir, link);
844
+ plant("m1.json", "retargeted-empty");
845
+ const c = new MailClient(link, undefined, AGENT, verifier());
846
+ const m = delivered(await c.deliverNext());
847
+ const before = intentText("m1.json");
848
+ expect(intentPhase("m1.json")).toBe("in_progress");
849
+
850
+ unlinkSync(link);
851
+ symlinkSync(empty, link);
852
+ expect(await c.completeDelivery(m)).toEqual({
853
+ status: "refused",
854
+ reason: "stale",
855
+ detail: "message retargeted-empty: no matching live intent and claim in the currently resolved mailbox",
856
+ });
857
+ expect(intentText("m1.json")).toBe(before);
858
+ expect(mailboxReplayStore(join(empty, AGENT)).placementPhase("m1.json")).toBeNull();
859
+ });
860
+
861
+ test("release persists under the issued mailbox lock after a mail-root repoint", async () => {
862
+ const other = join(mailDir, "other");
863
+ mkdirSync(other);
864
+ const link = join(mailDir, "mail-link");
865
+ symlinkSync(mailDir, link);
866
+ plant("m1.json", "released-root");
867
+ const c = new MailClient(link, undefined, AGENT, verifier());
868
+ const first = delivered(await c.deliverNext());
869
+ unlinkSync(link);
870
+ symlinkSync(other, link);
871
+ const before = intentJson("m1.json");
872
+ const originalRoot = root;
873
+ root = join(other, AGENT);
874
+ mkdirSync(join(root, "cur"), { recursive: true });
875
+ mkdirSync(join(root, "new"), { recursive: true });
876
+ committed("released-root", {
877
+ version: 1, phase: "in_progress", presentations: 1,
878
+ firstPresentedAt: before.firstPresentedAt, claim: before.claim,
879
+ });
880
+ const otherIntent = intentText("m1.json");
881
+ const otherIntentPath = intentPath("m1.json");
882
+ root = originalRoot;
883
+ const claimDir = join(root, ".mail-lock.claim");
884
+ mkdirSync(claimDir);
885
+ try {
886
+ expect(c.releaseDelivery(first)).toMatchObject({ status: "deferred", reason: "lock-busy" });
887
+ expect(intentJson("m1.json")).toEqual(before);
888
+ } finally { rmSync(claimDir, { recursive: true }); }
889
+ expect(c.releaseDelivery(first)).toEqual({ status: "released" });
890
+ const { claim: _claim, ...unclaimed } = before;
891
+ expect(intentJson("m1.json")).toEqual(unclaimed);
892
+ expect(readFileSync(otherIntentPath, "utf8")).toBe(otherIntent);
893
+ rmSync(other, { recursive: true });
894
+ mkdirSync(other);
895
+ expect(await c.deliverNext()).toEqual({ status: "idle" });
896
+ unlinkSync(link);
897
+ symlinkSync(mailDir, link);
898
+ const retry = delivered(await c.deliverNext());
899
+ expect(retry.message.verifiedEnvelope?.messageId).toBe("released-root");
900
+ expect(retry.presentation).toBe(2);
901
+ expect(await c.completeDelivery(retry)).toEqual({ status: "completed" });
902
+ });
903
+
904
+ test("unavailable operation roots defer delivery and completion", async () => {
905
+ const link = join(mailDir, "mail-link");
906
+ symlinkSync(mailDir, link);
907
+ plant("m1.json", "unavailable-root");
908
+ const events = new EventLogger(AGENT, join(mailDir, "events"));
909
+ const emit = spyOn(events, "emit");
910
+ const c = new MailClient(link, events, AGENT, verifier());
911
+ const first = delivered(await c.deliverNext());
912
+ const before = intentText("m1.json");
913
+ unlinkSync(link);
914
+ writeFileSync(link, "not a directory");
915
+ try {
916
+ expect(await c.deliverNext()).toMatchObject({ status: "deferred", reason: "storage-error" });
917
+ emit.mockClear();
918
+ expect(await c.completeDelivery(first)).toMatchObject({ status: "deferred", reason: "storage-error" });
919
+ expect(emit).toHaveBeenCalledTimes(1);
920
+ expect(emit).toHaveBeenLastCalledWith(expect.objectContaining({
921
+ type: "mail.receive", agent: AGENT, status: "error", from: "unknown", durationMs: 0,
922
+ error: expect.any(String),
923
+ }));
924
+ expect(intentText("m1.json")).toBe(before);
925
+ } finally {
926
+ emit.mockRestore();
927
+ unlinkSync(link);
928
+ symlinkSync(mailDir, link);
929
+ }
930
+ expect(reasonOf(await client().deliverNext())).toBe("active");
931
+ expect(await c.completeDelivery(first)).toEqual({ status: "completed" });
932
+ });
933
+
934
+ for (const phase of ["new", "placing", "in_progress"] as const) {
935
+ test(`${phase} delivery keeps its operation roots during verification`, async () => {
936
+ const other = join(mailDir, "other");
937
+ mkdirSync(other);
938
+ const link = join(mailDir, "mail-link");
939
+ symlinkSync(mailDir, link);
940
+ mkdirSync(join(mailDir, ".bridge-principals"));
941
+ writeFileSync(join(mailDir, ".bridge-principals", `${FROM}.json`), JSON.stringify({ id: FROM }));
942
+ if (phase === "new") plant("m1.json", "operation-root");
943
+ else committed("operation-root", { phase });
944
+ const c = new MailClient(link, undefined, AGENT, {
945
+ async getAgent(name: string) {
946
+ unlinkSync(link);
947
+ symlinkSync(other, link);
948
+ return verifier().getAgent(name);
949
+ },
950
+ });
951
+ const first = delivered(await c.deliverNext());
952
+ expect(first.message.verifiedEnvelope?.messageId).toBe("operation-root");
953
+ expect(first.message.trustTier).toBe("external");
954
+ expect(intentPhase("m1.json")).toBe("in_progress");
955
+ expect(existsSync(join(other, AGENT, "cur", "m1.json"))).toBe(false);
956
+ unlinkSync(link);
957
+ symlinkSync(mailDir, link);
958
+ expect(await c.completeDelivery(first)).toEqual({ status: "completed" });
959
+ });
960
+ }
961
+ });
962
+
963
+ describe("deliverNext defers pending cur-copy failures before committing new mail", () => {
964
+ test("a failed pending verification defers; a later valid message is not committed", async () => {
965
+ plant("m1.json", "will-not-verify");
966
+ const first = client();
967
+ expect(first.releaseDelivery(delivered(await first.deliverNext()))).toEqual({ status: "released" });
968
+ plant("m2.json", "later-valid", OTHER);
969
+
970
+ // FROM is no longer resolvable: m1's cur/ copy fails re-verification.
971
+ const c = client(verifier([OTHER]));
972
+ for (let i = 0; i < 3; i++) {
973
+ const result = await c.deliverNext();
974
+ expect(reasonOf(result)).toBe("verification-failed");
975
+ if (result.status === "deferred") expect(result.file).toBe("m1.json");
976
+ }
977
+ expect(newFiles()).toEqual(["m2.json"]);
978
+ expect(hasCommittedMessageId(root, "later-valid")).toBe(false);
979
+ expect(intentPhase("m2.json")).toBeNull();
980
+ expect(intentJson("m1.json").presentations).toBe(1); // not presented, not counted
981
+ });
982
+
983
+ test("an unavailable verifier defers the pending message; a later message is not committed", async () => {
984
+ plant("m1.json", "verifier-down");
985
+ const first = client();
986
+ expect(first.releaseDelivery(delivered(await first.deliverNext()))).toEqual({ status: "released" });
987
+ plant("m2.json", "later");
988
+ const down = client({ async getAgent() { throw new Error("flair unreachable"); } });
989
+ expect(reasonOf(await down.deliverNext())).toBe("verification-unavailable");
990
+ expect(newFiles()).toEqual(["m2.json"]);
991
+ expect(hasCommittedMessageId(root, "later")).toBe(false);
992
+ });
993
+
994
+ test("a placing intent naming a CLI-promoted record defers by name and is left untouched", async () => {
995
+ plant("m1.json", "cli-shaped");
996
+ const wrapper = JSON.parse(readFileSync(fresh("m1.json"), "utf8"));
997
+ const envelope = JSON.parse(wrapper.body);
998
+ writeFileSync(fresh("m1.json"), JSON.stringify({
999
+ id: "rec-1", from: FROM, to: AGENT, body: envelope.body, timestamp: envelope.timestamp, read: false,
1000
+ envelopeId: "cli-shaped", envelope, trustTier: "internal", checkedOutAt: new Date().toISOString(),
1001
+ checkedOutBy: AGENT, deliveryAttempts: 1,
1002
+ }));
1003
+ const replay = mailboxReplayStore(root);
1004
+ linkSync(fresh("m1.json"), cur("m1.json"));
1005
+ unlinkSync(fresh("m1.json"));
1006
+ replay.beginPlacement("cli-shaped", "m1.json", cur("m1.json"));
1007
+ replay.recordConsumed("cli-shaped");
1008
+ const intentBefore = intentText("m1.json");
1009
+ const recordBefore = textOf(cur("m1.json"));
1010
+ plant("m2.json", "after-cli");
1011
+
1012
+ const result = await client().deliverNext();
1013
+ expect(result).toMatchObject({ status: "deferred", reason: "cli-record", file: "m1.json" });
1014
+ expect(intentText("m1.json")).toBe(intentBefore);
1015
+ expect(textOf(cur("m1.json"))).toBe(recordBefore);
1016
+ expect(newFiles()).toEqual(["m2.json"]);
1017
+ expect(hasCommittedMessageId(root, "after-cli")).toBe(false);
1018
+ });
1019
+
1020
+ test("a busy mailbox lock defers; nothing is committed", async () => {
1021
+ plant("m1.json", "locked-out");
1022
+ const lock = await acquireMailLock(realpathSync(root));
1023
+ try {
1024
+ expect(reasonOf(await client().deliverNext())).toBe("lock-busy");
1025
+ expect(newFiles()).toEqual(["m1.json"]);
1026
+ } finally {
1027
+ lock?.release();
1028
+ }
1029
+ expect(idOf(await client().deliverNext())).toBe("locked-out");
1030
+ });
1031
+
1032
+ test("new mail that cannot be verified now is deferred, not idle, and stays in new/", async () => {
1033
+ plant("m1.json", "unverifiable-now");
1034
+ const down = client({ async getAgent() { throw new Error("flair unreachable"); } });
1035
+ expect(reasonOf(await down.deliverNext())).toBe("new-mail-deferred");
1036
+ expect(newFiles()).toEqual(["m1.json"]);
1037
+ });
1038
+ });
1039
+
1040
+ describe("liveness-bound transitions for unclaimed in_progress work", () => {
1041
+ const FAILED_AT = `not completed after ${MAX_DELIVERY_PRESENTATIONS} presentation(s)`;
1042
+
1043
+ test("a request for a sixth presentation fails the intent, logs, and leaves other mail flowing", async () => {
1044
+ plant("m1.json", "poison");
1045
+ plant("m2.json", "healthy");
1046
+ const warnings: string[] = [];
1047
+ const warn = spyOn(console, "warn").mockImplementation((...args: unknown[]) => { warnings.push(args.join(" ")); });
1048
+ try {
1049
+ const c = client();
1050
+ for (let i = 1; i <= MAX_DELIVERY_PRESENTATIONS; i++) {
1051
+ const m = delivered(await c.deliverNext());
1052
+ expect(m.message.verifiedEnvelope?.messageId).toBe("poison");
1053
+ expect(m.presentation).toBe(i);
1054
+ expect(c.releaseDelivery(m)).toEqual({ status: "released" });
1055
+ }
1056
+ // The next hand-over would exceed the bound: poison is not presented, its
1057
+ // intent becomes terminal `failed`, and the next message flows.
1058
+ expect(idOf(await c.deliverNext())).toBe("healthy");
1059
+ } finally { warn.mockRestore(); }
1060
+
1061
+ expect(warnings.some((w) => w.includes("poison") && w.includes(FAILED_AT))).toBe(true);
1062
+ expect(intentPhase("m1.json")).toBe("failed");
1063
+ expect(intentJson("m1.json").claim).toBeUndefined();
1064
+ expect(textOf(cur("m1.json"))).not.toBeNull();
1065
+ expect(pendingPlacementEntries(root).map((e) => e.messageId)).toEqual(["healthy"]);
1066
+ expect(mailboxReplayStore(root).hasPendingFile("m1.json")).toBe(false);
1067
+ expect(hasCommittedMessageId(root, "poison")).toBe(true);
1068
+ });
1069
+
1070
+ test("an unclaimed in_progress message past the deadline is quarantined on the next call", async () => {
1071
+ const stale = new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString();
1072
+ committed("stale", { version: 1, phase: "in_progress", presentations: 1, firstPresentedAt: stale });
1073
+ plant("m2.json", "healthy");
1074
+
1075
+ const warnings: string[] = [];
1076
+ const warn = spyOn(console, "warn").mockImplementation((...args: unknown[]) => { warnings.push(args.join(" ")); });
1077
+ let next: DeliverNextResult;
1078
+ try { next = await client().deliverNext(); } finally { warn.mockRestore(); }
1079
+
1080
+ expect(idOf(next)).toBe("healthy");
1081
+ expect(intentPhase("m1.json")).toBe("failed");
1082
+ expect(warnings.some((w) => w.includes("stale") && w.includes("deadline"))).toBe(true);
1083
+ });
1084
+
1085
+ test("the exceeded deadline fails the intent even when the pending copy no longer re-verifies", async () => {
1086
+ const stale = new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString();
1087
+ committed("stale-unverifiable", { version: 1, phase: "in_progress", presentations: 2, firstPresentedAt: stale });
1088
+ plant("m2.json", "healthy", OTHER);
1089
+ const warn = spyOn(console, "warn").mockImplementation(() => {});
1090
+ let next: DeliverNextResult;
1091
+ try { next = await client(verifier([OTHER])).deliverNext(); } finally { warn.mockRestore(); }
1092
+ expect(intentPhase("m1.json")).toBe("failed");
1093
+ expect(idOf(next)).toBe("healthy");
1094
+ });
1095
+
1096
+ test("a held local token blocks another delivery until completion quarantines the overdue claim", async () => {
1097
+ plant("m1.json", "slow-but-live");
1098
+ const c = client();
1099
+ const m = delivered(await c.deliverNext());
1100
+ setPhase({ firstPresentedAt: new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString() });
1101
+ expect(reasonOf(await c.deliverNext())).toBe("active");
1102
+ expect(intentPhase("m1.json")).toBe("in_progress");
1103
+ expect(await c.completeDelivery(m)).toEqual({ status: "quarantined" });
1104
+ expect(intentPhase("m1.json")).toBe("failed");
1105
+ });
1106
+
1107
+ test("the terminal intent keeps its message refused by the replay gate", async () => {
1108
+ committed("poisoned", { version: 1, phase: "failed", presentations: 5, firstPresentedAt: new Date().toISOString() });
1109
+ expect(intentPhase("m1.json")).toBe("failed");
1110
+ // Same signed envelope under the same (free) name: refused at commit as a replay.
1111
+ writeFileSync(fresh("m1.json"), readFileSync(cur("m1.json")));
1112
+ expect(await client().deliverNext()).toEqual({ status: "idle" });
1113
+ expect(textOf(join(root, "dlq", "m1.json.reason")) ?? "").toContain("class: replay");
1114
+ expect(intentJson("m1.json").phase).toBe("failed");
1115
+ });
1116
+ });
1117
+
1118
+ describe("an unknown phase is preserved", () => {
1119
+ test("not presented, not finalized and not quarantined for its value; its file gate stays closed; other mail flows", async () => {
1120
+ const bytes = committed("kept-unknown", { version: 1, phase: "awaiting-review" });
1121
+ plant("m2.json", "flows");
1122
+ expect(idOf(await client().deliverNext())).toBe("flows");
1123
+ expect(intentText("m1.json") ?? "").toBe(bytes.toString("utf8"));
1124
+ expect(quarantined("m1.json")).toBe(false);
1125
+ expect(mailboxReplayStore(root).hasPendingFile("m1.json")).toBe(true);
1126
+ expect(hasCommittedMessageId(root, "kept-unknown")).toBe(true);
1127
+ });
1128
+
1129
+ test("a malformed claim, or a claim on a placing intent, resolves to unknown", async () => {
1130
+ const base = { version: 1, phase: "in_progress", presentations: 1, firstPresentedAt: new Date().toISOString() };
1131
+ committed("bad-claim", { ...base, claim: { token: "not-a-uuid", pid: process.pid, start: null, moduleNonce: randomUUID() } });
1132
+ expect(intentPhase("m1.json")).toBe("unknown");
1133
+ committed("placing-claim", { phase: "placing", claim: { token: randomUUID(), pid: process.pid, start: null, moduleNonce: randomUUID() } }, "m2.json");
1134
+ expect(intentPhase("m2.json")).toBe("unknown");
1135
+ expect(await client().deliverNext()).toEqual({ status: "idle" });
1136
+ });
1137
+ });
1138
+
1139
+ interface KillRun { signal: NodeJS.Signals | null; reached: boolean; stderr: string; }
1140
+
1141
+ /** Run deliverNext() in a child; SIGKILL it once it pauses at `killAt` (or `onPause` resolves). */
1142
+ function runAndKillAt(killAt: string, file: string, after = false, onPause?: () => Promise<void>, timeoutMs = 20_000): Promise<KillRun> {
1143
+ const marker = join(mailDir, `paused.${killAt}`);
1144
+ const child = spawn(process.execPath, [CHILD, mailDir, AGENT], {
1145
+ env: {
1146
+ HOME: mailDir,
1147
+ PATH: process.env.PATH,
1148
+ TPS_MAIL_MODULE: MODULE,
1149
+ TPS_DRIVE: "deliverNext",
1150
+ TPS_KILL_AT: killAt,
1151
+ ...(after ? { TPS_KILL_AFTER: "1" } : {}),
1152
+ TPS_KILL_MARKER: marker,
1153
+ TPS_MAIL_ROOT: root,
1154
+ TPS_SRC: fresh(file),
1155
+ TPS_CUR: cur(file),
1156
+ TPS_FROM: FROM,
1157
+ TPS_SEED: SEED.toString("base64"),
1158
+ },
1159
+ stdio: ["ignore", "pipe", "pipe"],
1160
+ });
1161
+ return new Promise<KillRun>((resolve, reject) => {
1162
+ let stderr = "";
1163
+ let settled = false;
1164
+ child.stderr.on("data", (d) => { stderr += d.toString(); });
1165
+ const poll = setInterval(() => {
1166
+ if (!existsSync(marker)) return;
1167
+ clearInterval(poll);
1168
+ (onPause ? onPause() : Promise.resolve()).finally(() => child.kill("SIGKILL"));
1169
+ }, 15);
1170
+ const deadline = setTimeout(() => {
1171
+ if (settled) return;
1172
+ settled = true; clearInterval(poll); clearTimeout(deadline);
1173
+ child.kill("SIGKILL");
1174
+ reject(new Error(`child never reached ${killAt} (stderr: ${stderr})`));
1175
+ }, timeoutMs);
1176
+ child.once("error", (e) => { if (!settled) { settled = true; clearInterval(poll); clearTimeout(deadline); reject(e); } });
1177
+ child.once("exit", (_code, signal) => {
1178
+ if (settled) return;
1179
+ settled = true; clearInterval(poll); clearTimeout(deadline);
1180
+ resolve({ signal, reached: existsSync(marker), stderr });
1181
+ });
1182
+ });
1183
+ }
1184
+
1185
+ describe("a kill mid-delivery re-presents on the next call", () => {
1186
+ for (const at of ["intent-write", "link-to-cur", "source-removal", "ledger-commit"]) {
1187
+ test(`killed before ${at}: the next call presents the message, later mail waits`, async () => {
1188
+ plant("m1.json", `kill-${at}`);
1189
+ plant("m2.json", "later");
1190
+
1191
+ const run = await runAndKillAt(at, "m1.json");
1192
+ expect(run.reached, `child never reached ${at}; stderr=${run.stderr}`).toBe(true);
1193
+ expect(run.signal).toBe("SIGKILL");
1194
+
1195
+ const c = client();
1196
+ const m = delivered(await c.deliverNext());
1197
+ expect(m.message.verifiedEnvelope?.messageId).toBe(`kill-${at}`);
1198
+ expect(newFiles()).toContain("m2.json");
1199
+
1200
+ expect(await c.completeDelivery(m)).toEqual({ status: "completed" });
1201
+ expect(idOf(await c.deliverNext())).toBe("later");
1202
+ });
1203
+ }
1204
+
1205
+ test("killed after the intent becomes in_progress: the next call presents it again and later mail waits", async () => {
1206
+ plant("m1.json", "after-in-progress");
1207
+ plant("m2.json", "later");
1208
+
1209
+ const run = await runAndKillAt("phase-write", "m1.json", true);
1210
+ expect(run.reached, `child never reached the phase write; stderr=${run.stderr}`).toBe(true);
1211
+ expect(run.signal).toBe("SIGKILL");
1212
+ expect(intentPhase("m1.json")).toBe("in_progress");
1213
+
1214
+ const c = client();
1215
+ const m = delivered(await c.deliverNext());
1216
+ expect(m.message.verifiedEnvelope?.messageId).toBe("after-in-progress");
1217
+ expect(m.presentation).toBe(2);
1218
+ expect(newFiles()).toContain("m2.json");
1219
+ });
1220
+
1221
+ test("a foreign claim defers until its process is killed, then permits re-presentation", async () => {
1222
+ plant("m1.json", "held-by-child");
1223
+ plant("m2.json", "later");
1224
+ let whileAlive: DeliverNextResult | undefined;
1225
+ const run = await runAndKillAt("after-delivery", "m1.json", false, async () => {
1226
+ whileAlive = await client().deliverNext();
1227
+ });
1228
+ expect(run.reached, `child never delivered; stderr=${run.stderr}`).toBe(true);
1229
+ expect(run.signal).toBe("SIGKILL");
1230
+ expect(whileAlive && reasonOf(whileAlive)).toBe("active");
1231
+ expect(intentJson("m1.json").presentations).toBe(1);
1232
+ expect(newFiles()).toEqual(["m2.json"]);
1233
+
1234
+ const m = delivered(await client().deliverNext());
1235
+ expect(m.message.verifiedEnvelope?.messageId).toBe("held-by-child");
1236
+ expect(m.presentation).toBe(2);
1237
+ });
1238
+ });