@sleep2agi/commhub-server 0.9.0-preview.274 → 0.9.0-preview.276

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 (51) hide show
  1. package/build-info.json +2 -2
  2. package/package.json +1 -1
  3. package/src/agent-access-batch.test.ts +7 -2
  4. package/src/agent-acl-slice3-http.test.ts +4 -1
  5. package/src/agent-groups-perf.test.ts +6 -1
  6. package/src/anet-variant-real-daemon-http.test.ts +184 -0
  7. package/src/build-commit-report-http.test.ts +90 -0
  8. package/src/config-apply-sec1.test.ts +37 -0
  9. package/src/config-apply-validate.ts +7 -3
  10. package/src/contracts/session-project-create.ts +14 -0
  11. package/src/contracts/session-source-delivery.ts +16 -0
  12. package/src/contracts/session-source-directory.ts +54 -0
  13. package/src/contracts/session-source-evidence.ts +72 -0
  14. package/src/contracts/session-source-execution.ts +24 -0
  15. package/src/contracts/session-source-transport.ts +18 -0
  16. package/src/create-node-tool-schema.test.ts +10 -0
  17. package/src/db.ts +35 -0
  18. package/src/node-permissions.ts +1 -1
  19. package/src/node-session-control-http.test.ts +90 -2
  20. package/src/node-session-control.ts +89 -31
  21. package/src/opencode-v2-catalog.test.ts +14 -0
  22. package/src/opencode-v2-catalog.ts +1 -0
  23. package/src/package-self-contained.test.ts +32 -0
  24. package/src/report-status-host-schema.test.ts +37 -0
  25. package/src/rules-file-transport.test.ts +9 -0
  26. package/src/server.ts +47 -4
  27. package/src/session-fork-store.test.ts +43 -0
  28. package/src/session-fork-store.ts +51 -0
  29. package/src/session-project-attach-migration.test.ts +22 -0
  30. package/src/session-project-attach-native.test.ts +121 -0
  31. package/src/session-project-create-http.test.ts +407 -0
  32. package/src/session-project-create-native.test.ts +290 -0
  33. package/src/session-project-create.ts +159 -0
  34. package/src/session-source-admission-store.ts +58 -0
  35. package/src/session-source-create.test.ts +155 -0
  36. package/src/session-source-create.ts +97 -0
  37. package/src/session-source-delivery.ts +109 -0
  38. package/src/session-source-directory-http.test.ts +192 -0
  39. package/src/session-source-evidence.test.ts +890 -0
  40. package/src/session-source-evidence.ts +191 -0
  41. package/src/session-source-execution.ts +87 -0
  42. package/src/session-source-grant.test.ts +117 -0
  43. package/src/session-source-grant.ts +78 -0
  44. package/src/session-source-issuer.test.ts +247 -0
  45. package/src/session-source-issuer.ts +158 -0
  46. package/src/session-source-transport.ts +368 -0
  47. package/src/task-not-found-error-domain.test.ts +4 -1
  48. package/src/token-usage-http.test.ts +10 -0
  49. package/src/tool-audience-http.test.ts +18 -0
  50. package/src/tool-audience.ts +1 -1
  51. package/src/tools.ts +154 -51
@@ -0,0 +1,890 @@
1
+ import { afterAll, beforeAll, beforeEach, expect, test } from "bun:test";
2
+ import { mkdtempSync, mkdirSync, readFileSync, statSync, writeFileSync, chmodSync, chownSync, rmSync, symlinkSync } from "node:fs";
3
+ import { tmpdir } from "node:os";
4
+ import { join } from "node:path";
5
+ import { db } from "./db";
6
+ import { register, createNetworkTokenForNode, resolveToken } from "./auth";
7
+ import { createSessionSourceEvidenceQueue } from "./session-source-evidence";
8
+ import type { SourceSelection } from "./session-source-issuer";
9
+ import { createSessionSourceEvidenceReader, handleSessionSourceEvidenceRead, handleSessionSourceLeaseRecheck } from "../../agent-node/src/runtime/session-source-evidence";
10
+ import { recordChildWorkdir, forgetChildWorkdir } from "../../agent-node/src/runtime/child-workdir";
11
+ import { writeOpenCodeV2CatalogEndpoint } from "../../agent-node/src/runtime/opencode-v2-catalog-endpoint";
12
+ import { publishSharedLaunchHealth } from "../../agent-node/src/runtime/opencode-copresence/launcher-health";
13
+ import { isSourceReadEvidence } from "../../contracts/session-source-evidence";
14
+ import { createSessionSourceExecutionQueue } from "./session-source-execution";
15
+ import { createSessionSourceExecutor, handleSessionSourceExecution } from "../../agent-node/src/runtime/session-source-execution";
16
+ import { createSessionSourceDeliveryQueue } from "./session-source-delivery";
17
+ import { createSessionSourceProfileWorker } from "../../agent-node/src/runtime/session-source-delivery";
18
+ import { SOURCE_DELIVERY_CAPABILITY, isSourceNodeDelivery } from "../../contracts/session-source-delivery";
19
+ import { stopBackgroundTimersForTest } from "./create-node";
20
+ import { createSessionSourceTransport } from "./session-source-transport";
21
+ import { createSessionSourceTransportWorker } from "../../agent-node/src/runtime/session-source-transport";
22
+ import { createSessionControlPin } from "../../agent-node/src/runtime/session-control-bridge";
23
+ import { SOURCE_FORK_ROOT, SOURCE_FORK_CAPABILITY } from "../../contracts/session-source-transport";
24
+
25
+ let human: ReturnType<typeof register>, daemon: ReturnType<typeof createNetworkTokenForNode>;
26
+ let source: ReturnType<typeof createNetworkTokenForNode>, selection: SourceSelection;
27
+ const req = (token?: string) => new Request("http://isolated.invalid", { headers: token ? { authorization: `Bearer ${token}` } : {} });
28
+ const root = mkdtempSync(join(tmpdir(), "source-read-")), project = join(root, "project"), daemonDir = join(root, "daemon");
29
+ const nodeDir = join(project, ".anet", "nodes", "source");
30
+ let version = "2.0.22", sessionDirectory = project, sessionId = "ses_Selected", authGate = true, redirect = false, large = false;
31
+ let forkPosts = 0, loseForkResponse = false, busy = false, busyDelivery = "";
32
+ // The native Server persists for the whole suite, as do per-child tombstones.
33
+ // A fresh fork must NEVER reuse a previous Session ID when per-test counts reset.
34
+ let nativeSessionSerial = 0;
35
+ let omitSessionModel = false, omitDefaultModel = false;
36
+ const calls: string[] = [];
37
+ let sourceTransport = createSessionSourceTransport({ enabled: true });
38
+ const server = Bun.serve({ hostname: "127.0.0.1", port: 0, async fetch(r) {
39
+ const u = new URL(r.url); calls.push(`${r.method} ${u.pathname}`);
40
+ const transport = await sourceTransport(r, u); if (transport) return transport;
41
+ if (u.pathname === "/fixture-register") {
42
+ const token = r.headers.get("authorization")?.replace(/^Bearer /, ""), a = resolveToken(token ?? "");
43
+ if (!a) return new Response("", { status: 401 });
44
+ const body: any = await r.json();
45
+ await registerFromPrivateProfile({ token, network_id: selection.network_id, alias: body.alias,
46
+ node_id: body.node_id, sessionId: body.session_id });
47
+ return Response.json({ ok: true });
48
+ }
49
+ if (u.pathname === "/mcp" && r.method === "POST") {
50
+ const token = r.headers.get("authorization")?.replace(/^Bearer /, ""), a = resolveToken(token ?? "");
51
+ if (!a) return new Response("", { status: 401 });
52
+ const body: any = await r.json();
53
+ if (body.params?.name === "report_status") {
54
+ const b = body.params.arguments;
55
+ await registerFromPrivateProfile({ token, network_id: selection.network_id, alias: b.alias, node_id: b.node_id, sessionId: b.session_id });
56
+ }
57
+ return Response.json({ jsonrpc: "2.0", id: body.id, result: { content: [{ type: "text", text: JSON.stringify({ ok: true, sessions: [] }) }] } });
58
+ }
59
+ if (authGate && r.headers.get("authorization") !== "Basic b3BlbmNvZGU6Zml4dHVyZQ==") return new Response("", { status: 401 });
60
+ if (redirect) return new Response("", { status: 302, headers: { location: "http://untrusted.invalid" } });
61
+ if (large) return new Response("x".repeat(40000));
62
+ if (u.pathname === "/api/info") return Response.json({ version, pid: process.pid });
63
+ if (u.pathname === "/api/session/active") return Response.json({ data: busy ? { ses_Selected: { type: "running" } } : busyDelivery ? { [busyDelivery]: { type: "running" } } : {} });
64
+ if (u.pathname === "/api/provider") return Response.json({ location: { directory: project }, data: [{ id: "stub", activation: "enabled" }] });
65
+ if (u.pathname === "/api/model") return Response.json({ location: { directory: project }, data: [{ providerID: "stub", id: "stub-model" }] });
66
+ if (u.pathname === "/api/model/default") return Response.json({ location: { directory: project }, data: omitDefaultModel ? null : { providerID: "stub", id: "stub-model" } });
67
+ if (r.method === "POST" && u.pathname === "/api/session/ses_Selected/fork") {
68
+ forkPosts++;
69
+ const id = `ses_Child${++nativeSessionSerial}`;
70
+ return loseForkResponse ? new Response("") : Response.json({ data: { id } });
71
+ }
72
+ return Response.json({ data: { id: u.pathname.includes("ses_Child") ? u.pathname.split("/").at(-1) : sessionId, location: { directory: sessionDirectory }, ...(omitSessionModel ? {} : { model: { providerID: "stub", id: "stub-model" } }) } });
73
+ } });
74
+ const local = () => ({ networkId: selection.network_id, daemonId: "n_daemon", daemonWorkDir: daemonDir, home: join(root, "home") });
75
+ const queue = () => createSessionSourceEvidenceQueue({ enabled: true });
76
+ const enqueue = (q: ReturnType<typeof queue>) => q.queue(req(human.token), selection, "ses_Selected")!;
77
+ const endpoint = () => writeOpenCodeV2CatalogEndpoint(nodeDir, { url: `http://127.0.0.1:${server.port}`, authorization: "Basic b3BlbmNvZGU6Zml4dHVyZQ==", directory: project });
78
+ beforeAll(() => {
79
+ register("evidence_bootstrap", "Fixture-Strong-4150!");
80
+ human = register("evidence_owner", "Fixture-Strong-4150!");
81
+ const net = human.network_id!, uid = human.user!.user_id;
82
+ source = createNetworkTokenForNode(uid, net, "source", "n_source");
83
+ daemon = createNetworkTokenForNode(uid, net, "daemon", "n_daemon");
84
+ expect(source.ok && daemon.ok).toBe(true);
85
+ selection = { network_id: net, source_node_id: "n_source", daemon_node_id: "n_daemon", mode: "attach_existing" };
86
+ db.run("UPDATE nodes SET runtime='opencode-cli',config_snapshot=?1 WHERE node_id='n_source'", [JSON.stringify({ flags: { opencodeGeneration: "v2", opencodeMode: "copresence" } })]);
87
+ db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id='n_daemon'", [JSON.stringify({ role: "host_supervisor" })]);
88
+ db.run(`INSERT INTO sessions (resume_id,alias,node_id,network_id,last_seen_at) VALUES
89
+ ('ev_source','source','n_source',?1,datetime('now')),('ev_daemon','daemon','n_daemon',?1,datetime('now'))`, [net]);
90
+ db.run(`INSERT INTO node_create_requests (request_id,daemon_node_id,child_name,network_id,runtime,flags_json,env_keys,status,child_node_id,created_at,created_by_token)
91
+ VALUES ('cr_evidence','n_daemon','source',?1,'opencode-cli','{}','[]','succeeded','n_source',1000,?2)`, [net, human.token_id!]);
92
+ mkdirSync(daemonDir, { mode: 0o700 });
93
+ mkdirSync(nodeDir, { recursive: true, mode: 0o700 });
94
+ });
95
+ beforeEach(() => {
96
+ omitSessionModel = false; omitDefaultModel = false;
97
+ version = "2.0.22"; sessionDirectory = project; sessionId = "ses_Selected"; authGate = true; redirect = false; large = false; calls.length = 0;
98
+ forkPosts = 0; loseForkResponse = false; busy = false; busyDelivery = "";
99
+ for (const p of [project, join(project, ".anet"), join(project, ".anet", "nodes"), nodeDir]) chmodSync(p, 0o700);
100
+ writeFileSync(join(nodeDir, "config.json"), JSON.stringify({ node_id: "n_source", network_id: selection.network_id,
101
+ runtime: "opencode-cli", opencodeGeneration: "v2", alias: "source", flags: { opencodeUnsafeTools: true } }), { mode: 0o600 });
102
+ recordChildWorkdir(daemonDir, "source", project); endpoint();
103
+ publishSharedLaunchHealth(nodeDir, "ses_Selected", process.pid);
104
+ db.run("UPDATE api_tokens SET revoked_at=NULL WHERE token_id=?1", [daemon.token_id!]);
105
+ db.run("UPDATE network_members SET role='owner' WHERE user_id=?1 AND network_id=?2", [human.user!.user_id, selection.network_id]);
106
+ db.run("UPDATE sessions SET last_seen_at=datetime('now') WHERE resume_id IN ('ev_source','ev_daemon')");
107
+ db.run("UPDATE sessions SET env_transport='loopback' WHERE resume_id='ev_daemon'");
108
+ });
109
+ afterAll(() => { server.stop(true); rmSync(root, { recursive: true, force: true }); db.close(); });
110
+
111
+ test("actual loopback GET + private files + OS listener observation return challenge-bound evidence", async () => {
112
+ const q = queue(), challenge = enqueue(q), pulled = q.take(req(daemon.token), challenge.request_id)!;
113
+ expect(pulled).toEqual(challenge);
114
+ expect(q.take(req(daemon.token), challenge.request_id)).toBeNull();
115
+ const reader = createSessionSourceEvidenceReader(local()), result = await reader.read(pulled);
116
+ expect(result.ok).toBe(true); if (!result.ok) return;
117
+ expect(isSourceReadEvidence(result.evidence)).toBe(true);
118
+ expect(result.evidence.server.pid).toBe(process.pid);
119
+ expect(result.evidence.canonical_directory).toBe(project);
120
+ expect(q.ack(req(daemon.token), result.evidence)).toBe(true);
121
+ expect(q.result(req(human.token), challenge.request_id)).toEqual(result.evidence);
122
+ expect(q.ack(req(daemon.token), result.evidence)).toBe(false);
123
+ expect(await reader.recheck(result.evidence.lease_id)).toBe(true);
124
+ expect(await createSessionSourceEvidenceReader(local()).recheck(result.evidence.lease_id)).toBe(false);
125
+ expect(calls.every(c => c.startsWith("GET /api/info") || c === "GET /api/session/ses_Selected")).toBe(true);
126
+ expect(JSON.stringify(result.evidence)).not.toContain("b3BlbmNvZGU6Zml4dHVyZQ");
127
+ expect(db.get<{ n: number }>("SELECT COUNT(*) n FROM session_source_grants")!.n).toBe(0);
128
+ });
129
+
130
+ test("challenge spoof/replay, wrong daemon/human, missing take and restart cannot acknowledge", async () => {
131
+ const q = queue(), c = enqueue(q), reader = createSessionSourceEvidenceReader(local());
132
+ expect(q.take(req(source.token), c.request_id)).toBeNull();
133
+ expect(q.take(req(human.token), c.request_id)).toBeNull();
134
+ const r = await reader.read(c); expect(r.ok).toBe(true); if (!r.ok) return;
135
+ expect(q.ack(req(daemon.token), r.evidence)).toBe(false);
136
+ q.take(req(daemon.token), c.request_id);
137
+ expect(q.ack(req(source.token), r.evidence)).toBe(false);
138
+ for (const change of [{ challenge: "a".repeat(43) }, { session_id: "ses_Other" }, { source_node_id: "n_other" }, { network_id: "net_other" }]) {
139
+ expect(q.ack(req(daemon.token), { ...r.evidence, request: { ...c, ...change } })).toBe(false);
140
+ }
141
+ expect(queue().ack(req(daemon.token), r.evidence)).toBe(false);
142
+ expect(q.ack(req(daemon.token), { ...r.evidence, url: "http://untrusted.invalid" })).toBe(false);
143
+ expect(q.ack(req(daemon.token), r.evidence)).toBe(true);
144
+ expect(q.result(req(source.token), c.request_id)).toBeNull();
145
+ });
146
+
147
+ test("disabled production default, revoked daemon and demoted requester fail closed", async () => {
148
+ expect(createSessionSourceEvidenceQueue().queue(req(human.token), selection, "ses_Selected")).toBeNull();
149
+ const q = queue(), c = enqueue(q); q.take(req(daemon.token), c.request_id);
150
+ const r = await createSessionSourceEvidenceReader(local()).read(c); expect(r.ok).toBe(true); if (!r.ok) return;
151
+ db.run("UPDATE api_tokens SET revoked_at=datetime('now') WHERE token_id=?1", [daemon.token_id!]);
152
+ expect(q.ack(req(daemon.token), r.evidence)).toBe(false);
153
+ db.run("UPDATE api_tokens SET revoked_at=NULL WHERE token_id=?1", [daemon.token_id!]);
154
+ db.run("UPDATE network_members SET role='viewer' WHERE user_id=?1 AND network_id=?2", [human.user!.user_id, selection.network_id]);
155
+ expect(q.ack(req(daemon.token), r.evidence)).toBe(false);
156
+ expect(q.result(req(human.token), c.request_id)).toBeNull();
157
+ });
158
+
159
+ test("reader refuses expired/foreign challenges, URL/path fields and unregistered legacy fallback before HTTP", async () => {
160
+ const c = enqueue(queue()), reader = createSessionSourceEvidenceReader(local());
161
+ for (const change of [{ expires_at: Date.now() - 1 }, { daemon_node_id: "other" }, { network_id: "other" },
162
+ { url: "http://untrusted.invalid" }, { directory: "/etc" }, { alias: "../escape" }]) {
163
+ expect((await reader.read({ ...c, ...change })).ok).toBe(false);
164
+ }
165
+ forgetChildWorkdir(daemonDir, "source");
166
+ expect((await reader.read(c)).ok).toBe(false);
167
+ expect(calls).toEqual([]);
168
+ });
169
+
170
+ test("wrong API version/session directory/id, redirects, oversized body and absent auth gate refuse", async () => {
171
+ const c = enqueue(queue()), reader = createSessionSourceEvidenceReader(local());
172
+ version = "2.0.23"; expect((await reader.read(c)).ok).toBe(false); version = "2.0.22";
173
+ sessionDirectory = root; expect((await reader.read(c)).ok).toBe(false); sessionDirectory = project;
174
+ sessionId = "ses_Other"; expect((await reader.read(c)).ok).toBe(false); sessionId = "ses_Selected";
175
+ redirect = true; expect((await reader.read(c)).ok).toBe(false); redirect = false;
176
+ large = true; expect((await reader.read(c)).ok).toBe(false); large = false;
177
+ authGate = false; expect((await reader.read(c)).ok).toBe(false);
178
+ });
179
+
180
+ test("real directory permissions/symlinks, wrong source config and dead local binding refuse", async () => {
181
+ const c = enqueue(queue()), reader = createSessionSourceEvidenceReader(local());
182
+ chmodSync(project, 0o777); expect((await reader.read(c)).ok).toBe(false); chmodSync(project, 0o700);
183
+ writeFileSync(join(nodeDir, "config.json"), JSON.stringify({ node_id: "n_other" }));
184
+ expect((await reader.read(c)).ok).toBe(false);
185
+ writeFileSync(join(nodeDir, "config.json"), JSON.stringify({ node_id: "n_source", network_id: selection.network_id,
186
+ runtime: "opencode-cli", opencodeGeneration: "v2", alias: "source" }));
187
+ publishSharedLaunchHealth(nodeDir, "ses_NotSelected", process.pid);
188
+ expect((await reader.read(c)).ok).toBe(false);
189
+ publishSharedLaunchHealth(nodeDir, "ses_Selected", process.pid);
190
+ const link = join(root, "linked"); symlinkSync(project, link);
191
+ recordChildWorkdir(daemonDir, "source", link);
192
+ expect((await reader.read(c)).ok).toBe(false);
193
+ rmSync(link);
194
+ });
195
+
196
+ test("local recheck detects changed endpoint, session and directory without reusing lease after restart", async () => {
197
+ const c = enqueue(queue()), reader = createSessionSourceEvidenceReader(local());
198
+ const r = await reader.read(c); expect(r.ok).toBe(true); if (!r.ok) return;
199
+ sessionDirectory = root;
200
+ expect(await reader.recheck(r.evidence.lease_id)).toBe(false);
201
+ sessionDirectory = project;
202
+ expect(await reader.recheck(r.evidence.lease_id)).toBe(false);
203
+ });
204
+
205
+ test("internal pull/read/recheck/ack handler completes without public endpoint or doorbell", async () => {
206
+ const q = queue(), c = enqueue(q), reader = createSessionSourceEvidenceReader(local());
207
+ const deps = { reader, take: async (id: string) => q.take(req(daemon.token), id),
208
+ ack: async (value: any) => q.ack(req(daemon.token), value) };
209
+ expect(await handleSessionSourceEvidenceRead(c.request_id, deps)).toBe(true);
210
+ expect(q.result(req(human.token), c.request_id)?.kind).toBe("process_local_lease");
211
+ expect(await handleSessionSourceEvidenceRead(c.request_id, deps)).toBe(false);
212
+ db.run("UPDATE api_tokens SET revoked_at=datetime('now') WHERE token_id=?1", [daemon.token_id!]);
213
+ expect(q.result(req(human.token), c.request_id)).toBeNull();
214
+ });
215
+
216
+ test("local opaque lease is retired on endpoint replacement even if old endpoint is restored", async () => {
217
+ const c = enqueue(queue()), reader = createSessionSourceEvidenceReader(local());
218
+ const r = await reader.read(c); expect(r.ok).toBe(true); if (!r.ok) return;
219
+ writeOpenCodeV2CatalogEndpoint(nodeDir, { url: `http://127.0.0.1:${server.port}`, authorization: "Basic bm90LWF1dGg=", directory: project });
220
+ expect(await reader.recheck(r.evidence.lease_id)).toBe(false);
221
+ endpoint();
222
+ expect(await reader.recheck(r.evidence.lease_id)).toBe(false);
223
+ });
224
+
225
+ test("private registry and actual directory uid are required before network reads", async () => {
226
+ const c = enqueue(queue()), reader = createSessionSourceEvidenceReader(local());
227
+ const registry = join(daemonDir, ".anet", "child-workdirs.json");
228
+ chmodSync(registry, 0o644);
229
+ expect((await reader.read(c)).ok).toBe(false);
230
+ chmodSync(registry, 0o600);
231
+ // Docker --user 0 permits a real foreign-owner fixture, never touches host.
232
+ expect(process.getuid!()).toBe(0);
233
+ chownSync(project, 65534, 65534);
234
+ try { expect((await reader.read(c)).ok).toBe(false); }
235
+ finally { chownSync(project, 0, 0); }
236
+ expect(calls).toEqual([]);
237
+ });
238
+
239
+ test("Hub challenge and daemon lease expiry cannot be revived after the deadline", async () => {
240
+ const q = queue(), c = enqueue(q), reader = createSessionSourceEvidenceReader(local());
241
+ q.take(req(daemon.token), c.request_id);
242
+ const r = await reader.read(c); expect(r.ok).toBe(true); if (!r.ok) return;
243
+ const now = Date.now;
244
+ try {
245
+ Date.now = () => c.expires_at + 1;
246
+ expect(q.ack(req(daemon.token), r.evidence)).toBe(false);
247
+ expect(await reader.recheck(r.evidence.lease_id)).toBe(false);
248
+ } finally { Date.now = now; }
249
+ expect(q.ack(req(daemon.token), r.evidence)).toBe(false);
250
+ expect(await reader.recheck(r.evidence.lease_id)).toBe(false);
251
+ });
252
+
253
+ test("a different actual loopback listener cannot reuse a process-local lease", async () => {
254
+ const c = enqueue(queue()), reader = createSessionSourceEvidenceReader(local());
255
+ const r = await reader.read(c); expect(r.ok).toBe(true); if (!r.ok) return;
256
+ const second = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch(r) {
257
+ if (!r.headers.has("authorization")) return new Response("", { status: 401 });
258
+ return Response.json(new URL(r.url).pathname === "/api/info" ? { version: "2.0.22", pid: process.pid }
259
+ : { data: { id: "ses_Selected", location: { directory: project } } });
260
+ } });
261
+ try {
262
+ writeOpenCodeV2CatalogEndpoint(nodeDir, { url: `http://127.0.0.1:${second.port}`, authorization: "Basic b3BlbmNvZGU6Zml4dHVyZQ==", directory: project });
263
+ expect(await reader.recheck(r.evidence.lease_id)).toBe(false);
264
+ endpoint();
265
+ expect(await reader.recheck(r.evidence.lease_id)).toBe(false);
266
+ } finally { second.stop(true); }
267
+ });
268
+
269
+ const admissionCounts = () => ({
270
+ grants: db.get<{ n: number }>("SELECT COUNT(*) n FROM session_source_grants")!.n,
271
+ reservations: db.get<{ n: number }>("SELECT COUNT(*) n FROM node_create_requests WHERE source_ref IS NOT NULL")!.n,
272
+ tokens: db.get<{ n: number }>("SELECT COUNT(*) n FROM api_tokens")!.n,
273
+ });
274
+ async function prepared(mode: SourceSelection["mode"] = "attach_existing") {
275
+ const q = queue(), reader = createSessionSourceEvidenceReader(local());
276
+ const c = q.queue(req(human.token), { ...selection, mode }, "ses_Selected")!;
277
+ expect(await handleSessionSourceEvidenceRead(c.request_id, { reader,
278
+ take: async id => q.take(req(daemon.token), id), ack: async v => q.ack(req(daemon.token), v) })).toBe(true);
279
+ const dispatch = async (id: string) => {
280
+ expect(await handleSessionSourceLeaseRecheck(id, { reader,
281
+ take: async id => q.takeRecheck(req(daemon.token), id), ack: async v => q.ackRecheck(req(daemon.token), v) })).toBe(true);
282
+ };
283
+ return { q, reader, c, dispatch };
284
+ }
285
+
286
+ test("async authenticated lease consumption atomically issues/claims one grant and real reservation in both modes", async () => {
287
+ for (const mode of ["attach_existing", "fork_independent"] as const) {
288
+ const p = await prepared(mode), before = admissionCounts();
289
+ const receipt = await p.q.admit(req(human.token), p.c.request_id, `success_${mode}`, `child-${mode}`, p.dispatch);
290
+ expect(receipt.status).toBe("source_reserved");
291
+ expect(receipt.scope).toBe("admission_only");
292
+ expect(receipt.execution).toMatchObject({ mode, dispatchable: false, lease_kind: "process_local_lease",
293
+ guard: "daemon_recheck_in_execution_context_required", protocol: "source-aware-v1-required" });
294
+ expect(admissionCounts()).toEqual({ ...before, grants: before.grants + 1, reservations: before.reservations + 1 });
295
+ expect(db.get("SELECT state,create_request_id FROM session_source_grants WHERE source_ref=?1", receipt.source_ref))
296
+ .toEqual({ state: "claimed", create_request_id: receipt.request_id });
297
+ expect(db.get("SELECT status,child_token_id,workdir FROM node_create_requests WHERE request_id=?1", receipt.request_id))
298
+ .toEqual({ status: "source_reserved", child_token_id: null, workdir: project });
299
+ expect(db.get("SELECT execution_guard,lease_id,authorized_until FROM session_source_admission_intents WHERE evidence_request_id=?1", p.c.request_id))
300
+ .toEqual({ execution_guard: "daemon_recheck_in_execution_context_required", lease_id: receipt.execution.lease_id,
301
+ authorized_until: receipt.execution.authorized_until });
302
+ const restarted = queue();
303
+ expect(restarted.recoverAdmission(req(human.token), { ...selection, mode }, `success_${mode}`))
304
+ .toEqual({ request_id: receipt.request_id, status: "source_reserved", scope: "historical_admission_only", execution: "not_authorized", dispatchable: false });
305
+ expect(() => db.run("UPDATE node_create_requests SET status='pending' WHERE request_id=?1", [receipt.request_id])).toThrow("source_create_immutable");
306
+ await expect(restarted.admit(req(human.token), p.c.request_id, `success_${mode}`, "again", p.dispatch)).rejects.toThrow();
307
+ }
308
+ });
309
+
310
+ test("concurrent intent replay and fresh evidence/new intent cannot bypass single request association", async () => {
311
+ const p = await prepared(), before = admissionCounts();
312
+ const results = await Promise.allSettled([
313
+ p.q.admit(req(human.token), p.c.request_id, "concurrent_intent", "one-child", p.dispatch),
314
+ p.q.admit(req(human.token), p.c.request_id, "concurrent_intent", "one-child", p.dispatch),
315
+ ]);
316
+ expect(results.filter(r => r.status === "fulfilled")).toHaveLength(1);
317
+ expect(results.filter(r => r.status === "rejected")).toHaveLength(1);
318
+ await expect(p.q.admit(req(human.token), p.c.request_id, "different_intent", "other-child", p.dispatch))
319
+ .rejects.toThrow("source_intent_already_associated");
320
+ const fresh = await prepared();
321
+ await expect(fresh.q.admit(req(human.token), fresh.c.request_id, "concurrent_intent", "other-child", fresh.dispatch))
322
+ .rejects.toThrow("source_intent_already_associated");
323
+ expect(admissionCounts()).toEqual({ ...before, grants: before.grants + 1, reservations: before.reservations + 1 });
324
+ });
325
+
326
+ test("post-ACK permission revocation is rechecked in synchronous admission: zero new grants/reservations", async () => {
327
+ const p = await prepared(), before = admissionCounts();
328
+ await expect(p.q.admit(req(human.token), p.c.request_id, "demoted_at_ack", "never-child", async id => {
329
+ await p.dispatch(id);
330
+ db.run("UPDATE network_members SET role='viewer' WHERE user_id=?1 AND network_id=?2", [human.user!.user_id, selection.network_id]);
331
+ })).rejects.toThrow("source_lease_recheck_required");
332
+ expect(admissionCounts()).toEqual(before);
333
+ });
334
+
335
+ test("requester and daemon credential revocation after confirmation prevents synchronous issuance", async () => {
336
+ for (const [kind, tokenId] of [["human", human.token_id!], ["daemon", daemon.token_id!]]) {
337
+ const p = await prepared(), before = admissionCounts();
338
+ try {
339
+ await expect(p.q.admit(req(human.token), p.c.request_id, `revoked_${kind}`, "never-child", async id => {
340
+ await p.dispatch(id);
341
+ db.run("UPDATE api_tokens SET revoked_at=datetime('now') WHERE token_id=?1", [tokenId]);
342
+ })).rejects.toThrow("source_lease_recheck_required");
343
+ expect(admissionCounts()).toEqual(before);
344
+ } finally { db.run("UPDATE api_tokens SET revoked_at=NULL WHERE token_id=?1", [tokenId]); }
345
+ }
346
+ });
347
+
348
+ test("daemon reader restart, invalid local lease and missing queue state refuse admission with zero new rows", async () => {
349
+ for (const failure of ["reader_restart", "invalid_lease", "queue_restart"] as const) {
350
+ const p = await prepared(), before = admissionCounts();
351
+ if (failure === "invalid_lease") sessionDirectory = root;
352
+ await expect(p.q.admit(req(human.token), p.c.request_id, failure, "never-child", async id => {
353
+ const q = failure === "queue_restart" ? queue() : p.q;
354
+ const reader = failure === "reader_restart" ? createSessionSourceEvidenceReader(local()) : p.reader;
355
+ expect(await handleSessionSourceLeaseRecheck(id, { reader,
356
+ take: async id => q.takeRecheck(req(daemon.token), id), ack: async v => q.ackRecheck(req(daemon.token), v) })).toBe(false);
357
+ })).rejects.toThrow("source_lease_recheck_required");
358
+ expect(admissionCounts()).toEqual(before);
359
+ sessionDirectory = project;
360
+ const fresh = await prepared();
361
+ await expect(fresh.q.admit(req(human.token), fresh.c.request_id, failure, "retry-child", fresh.dispatch))
362
+ .rejects.toThrow("source_intent_already_associated");
363
+ expect(admissionCounts()).toEqual(before);
364
+ }
365
+ });
366
+
367
+ test("recheck exact challenge includes user/token/mode/intent; wrong daemon and replay cannot confirm", async () => {
368
+ const p = await prepared(), before = admissionCounts();
369
+ await p.q.admit(req(human.token), p.c.request_id, "scope_recheck", "scoped-child", async id => {
370
+ expect(p.q.takeRecheck(req(source.token), id)).toBeNull();
371
+ const q = p.q.takeRecheck(req(daemon.token), id)!;
372
+ expect(p.q.takeRecheck(req(daemon.token), id)).toBeNull();
373
+ for (const change of [{ mode: "fork_independent" }, { user_id: "other" }, { requester_token_id: "other" }]) {
374
+ expect(await p.reader.confirm({ ...q, evidence: { ...q.evidence, request: { ...q.evidence.request, ...change } } } as any)).toBeNull();
375
+ }
376
+ const response = (await p.reader.confirm(q))!; expect(response).not.toBeNull();
377
+ expect(p.q.ackRecheck(req(source.token), response)).toBe(false);
378
+ expect(p.q.ackRecheck(req(daemon.token), { ...response, request: { ...q, intent_id: "other_intent" } })).toBe(false);
379
+ expect(p.q.ackRecheck(req(daemon.token), { ...response, request: { ...q, challenge: "x".repeat(43) } })).toBe(false);
380
+ expect(p.q.ackRecheck(req(daemon.token), response)).toBe(true);
381
+ expect(p.q.ackRecheck(req(daemon.token), response)).toBe(false);
382
+ expect(await p.reader.confirm(q)).toBeNull();
383
+ });
384
+ expect(admissionCounts()).toEqual({ ...before, grants: before.grants + 1, reservations: before.reservations + 1 });
385
+ });
386
+
387
+ test("expired confirmed challenge and failed real INSERT roll back grant issuance and claim together", async () => {
388
+ const expired = await prepared(), before = admissionCounts(), now = Date.now;
389
+ try {
390
+ await expect(expired.q.admit(req(human.token), expired.c.request_id, "expired_admission", "never-child", async id => {
391
+ await expired.dispatch(id); Date.now = () => expired.c.expires_at + 1;
392
+ })).rejects.toThrow("source_lease_recheck_required");
393
+ } finally { Date.now = now; }
394
+ expect(admissionCounts()).toEqual(before);
395
+ const p = await prepared();
396
+ db.exec(`CREATE TRIGGER fail_source_admission_fixture BEFORE INSERT ON node_create_requests
397
+ WHEN NEW.source_ref IS NOT NULL BEGIN SELECT RAISE(ABORT,'fixture_insert_failure'); END;`);
398
+ try { await expect(p.q.admit(req(human.token), p.c.request_id, "insert_failure", "never-child", p.dispatch)).rejects.toThrow("fixture_insert_failure"); }
399
+ finally { db.exec("DROP TRIGGER fail_source_admission_fixture"); }
400
+ expect(admissionCounts()).toEqual(before);
401
+ });
402
+
403
+ test("post-recheck runtime drift does not pretend atomic execution: admission-only receipt still requires daemon execution-context recheck", async () => {
404
+ const p = await prepared();
405
+ const receipt = await p.q.admit(req(human.token), p.c.request_id, "admission_not_execution", "retained-only", async id => {
406
+ await p.dispatch(id); sessionDirectory = root; // cannot be locked by Hub SQL
407
+ });
408
+ expect(receipt.status).toBe("source_reserved");
409
+ expect(receipt.execution.dispatchable).toBe(false);
410
+ expect(receipt.execution.guard).toBe("daemon_recheck_in_execution_context_required");
411
+ expect(await p.reader.recheck(receipt.execution.lease_id)).toBe(false);
412
+ });
413
+
414
+ async function executable(mode: SourceSelection["mode"], intent: string) {
415
+ const p = await prepared(mode);
416
+ const receipt = await p.q.admit(req(human.token), p.c.request_id, intent, `ex-${intent}`, p.dispatch);
417
+ const hub = createSessionSourceExecutionQueue(p.q, { enabled: true });
418
+ const id = hub.queue(req(human.token), receipt.request_id)!;
419
+ expect(id).not.toBeNull();
420
+ const dir = mkdtempSync(join(root, "execution-journal-"));
421
+ const executor = createSessionSourceExecutor(p.reader, dir);
422
+ return { ...p, receipt, hub, id, dir, executor };
423
+ }
424
+
425
+ test("source-aware real HTTP attach retains original ID without POST; fork calls existing API once and verifies new ID", async () => {
426
+ for (const mode of ["attach_existing", "fork_independent"] as const) {
427
+ const p = await executable(mode, `execute_${mode}`), before = forkPosts;
428
+ expect(await handleSessionSourceExecution(p.id, { executor: p.executor,
429
+ take: async id => p.hub.take(req(daemon.token), id), ack: async v => p.hub.ack(req(daemon.token), v) })).toBe(true);
430
+ const result = p.hub.recover(req(human.token), p.id)!;
431
+ expect(result.status).toBe("session_ready");
432
+ expect(result.bridge).toBe("not_created");
433
+ expect(mode === "attach_existing" ? result.session_id === "ses_Selected" : result.session_id !== "ses_Selected").toBe(true);
434
+ expect(forkPosts - before).toBe(mode === "attach_existing" ? 0 : 1);
435
+ expect(p.hub.queue(req(human.token), p.receipt.request_id)).toBeNull();
436
+ expect(p.hub.take(req(daemon.token), p.id)).toBeNull();
437
+ expect(db.get("SELECT status,child_token_id FROM node_create_requests WHERE request_id=?1", p.receipt.request_id))
438
+ .toEqual({ status: "source_reserved", child_token_id: null });
439
+ }
440
+ });
441
+
442
+ test("wrong daemon, forged admission/source/session/dir, busy and duplicate bridge reject before fork POST", async () => {
443
+ const p = await executable("fork_independent", "execution_controls");
444
+ expect(createSessionSourceExecutionQueue(p.q).queue(req(human.token), p.receipt.request_id)).toBeNull();
445
+ expect(p.hub.queue(req(human.token), "cr_forged")).toBeNull();
446
+ expect(p.hub.take(req(source.token), p.id)).toBeNull();
447
+ const task = p.hub.take(req(daemon.token), p.id)!;
448
+ for (const change of [{ session_id: "ses_Other" }, { daemon_node_id: "n_wrong" }, { source_node_id: "n_wrong" }]) {
449
+ expect((await p.reader.execute({ ...task, evidence: { ...task.evidence, request: { ...task.evidence.request, ...change } } })).status).toBe("refused");
450
+ }
451
+ expect((await p.reader.execute({ ...task, evidence: { ...task.evidence, canonical_directory: root } })).status).toBe("refused");
452
+ busy = true;
453
+ expect((await p.executor.execute(task)).status).toBe("refused"); busy = false;
454
+ expect(forkPosts).toBe(0);
455
+ const second = await executable("fork_independent", "duplicate_owner");
456
+ const duplicate = join(project, ".anet", "nodes", "duplicate"); mkdirSync(duplicate, { mode: 0o700 });
457
+ publishSharedLaunchHealth(duplicate, "ses_Selected", process.pid);
458
+ try {
459
+ const t = second.hub.take(req(daemon.token), second.id)!;
460
+ expect((await second.executor.execute(t)).status).toBe("refused");
461
+ } finally { rmSync(duplicate, { recursive: true, force: true }); }
462
+ expect(forkPosts).toBe(0);
463
+ });
464
+
465
+ test("execution lease expiry, actual session-directory drift and reader restart refuse with zero POST", async () => {
466
+ for (const failure of ["expiry", "directory", "restart"] as const) {
467
+ const p = await executable("fork_independent", `execution_${failure}`), task = p.hub.take(req(daemon.token), p.id)!;
468
+ const now = Date.now;
469
+ try {
470
+ if (failure === "expiry") Date.now = () => task.authorized_until + 1;
471
+ if (failure === "directory") sessionDirectory = root;
472
+ const executor = failure === "restart" ? createSessionSourceExecutor(createSessionSourceEvidenceReader(local()), p.dir) : p.executor;
473
+ expect((await executor.execute(task)).status).toBe("refused");
474
+ } finally { Date.now = now; sessionDirectory = project; }
475
+ expect(forkPosts).toBe(0);
476
+ }
477
+ });
478
+
479
+ test("concurrent same execution task has one persistent claim and one fork; restarted local/Hub readers only recover", async () => {
480
+ const p = await executable("fork_independent", "concurrent_execution"), task = p.hub.take(req(daemon.token), p.id)!;
481
+ expect(p.hub.take(req(daemon.token), p.id)).toBeNull();
482
+ const results = await Promise.all([p.executor.execute(task), p.executor.execute(task)]);
483
+ const success = results.find(r => r.status === "session_ready")!;
484
+ expect(success.session_id).toBe(`ses_Child${nativeSessionSerial}`); expect(forkPosts).toBe(1);
485
+ const restarted = createSessionSourceExecutor(createSessionSourceEvidenceReader(local()), p.dir);
486
+ expect(restarted.recover(task)).toEqual(success);
487
+ expect(await restarted.execute(task)).toEqual(success); expect(forkPosts).toBe(1);
488
+ expect(p.hub.ack(req(daemon.token), success)).toBe(true);
489
+ const restartedHub = createSessionSourceExecutionQueue(p.q, { enabled: true });
490
+ expect(restartedHub.recover(req(human.token), p.id)).toEqual(success);
491
+ expect(restartedHub.take(req(daemon.token), p.id)).toBeNull(); expect(forkPosts).toBe(1);
492
+ });
493
+
494
+ test("lost fork success response persists unknown; no POST retry after local or Hub restart", async () => {
495
+ const p = await executable("fork_independent", "lost_fork_response"), task = p.hub.take(req(daemon.token), p.id)!;
496
+ loseForkResponse = true;
497
+ const outcome = await p.executor.execute(task);
498
+ expect(outcome.status).toBe("unknown"); expect(forkPosts).toBe(1);
499
+ expect(p.hub.ack(req(daemon.token), outcome)).toBe(true);
500
+ loseForkResponse = false;
501
+ const restarted = createSessionSourceExecutor(createSessionSourceEvidenceReader(local()), p.dir);
502
+ expect(await restarted.execute(task)).toEqual(outcome);
503
+ expect(createSessionSourceExecutionQueue(p.q, { enabled: true }).recover(req(human.token), p.id)).toEqual(outcome);
504
+ expect(forkPosts).toBe(1);
505
+ });
506
+
507
+ test("lost Hub ACK recovers the persisted child ID without API writes; missing daemon delivery stays unknown", async () => {
508
+ const p = await executable("fork_independent", "lost_hub_ack"), task = p.hub.take(req(daemon.token), p.id)!;
509
+ const done = await p.executor.execute(task); expect(done.status).toBe("session_ready");
510
+ expect(p.hub.recover(req(human.token), p.id)?.status).toBe("unknown"); // ACK never arrived
511
+ const restarted = createSessionSourceExecutor(createSessionSourceEvidenceReader(local()), p.dir);
512
+ expect(restarted.recover(task).session_id).toBe(done.session_id);
513
+ expect(p.hub.ack(req(daemon.token), restarted.recover(task))).toBe(true);
514
+ expect(p.hub.recover(req(human.token), p.id)).toEqual(done); expect(forkPosts).toBe(1);
515
+ const lost = await executable("fork_independent", "lost_delivery");
516
+ lost.hub.take(req(daemon.token), lost.id); // delivery lost, never execute
517
+ const hub = createSessionSourceExecutionQueue(lost.q, { enabled: true });
518
+ expect(hub.take(req(daemon.token), lost.id)).toBeNull();
519
+ expect(hub.recover(req(human.token), lost.id)?.status).toBe("unknown"); expect(forkPosts).toBe(1);
520
+ });
521
+
522
+ async function readyDelivery(intent: string, mode: SourceSelection["mode"] = "fork_independent") {
523
+ const p = await executable(mode, intent), task = p.hub.take(req(daemon.token), p.id)!;
524
+ const outcome = await p.executor.execute(task);
525
+ expect(outcome.status).toBe("session_ready"); expect(p.hub.ack(req(daemon.token), outcome)).toBe(true);
526
+ db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id='n_daemon'", [JSON.stringify({ role: "host_supervisor",
527
+ daemon_capabilities: { source_node_delivery: SOURCE_DELIVERY_CAPABILITY } })]);
528
+ const delivery = createSessionSourceDeliveryQueue(p.hub, { enabled: true });
529
+ return { ...p, delivery, outcome };
530
+ }
531
+ test("fork with absent native Session model uses scoped catalog default; absent default never guesses or reforks", async () => {
532
+ for (const missingDefault of [false, true]) {
533
+ const p = await readyDelivery(`missing_model_${missingDefault}`);
534
+ const id = p.delivery.queue(req(human.token), p.id)!;
535
+ const payload = p.delivery.take(req(daemon.token), id, SOURCE_DELIVERY_CAPABILITY)!;
536
+ omitSessionModel = true; omitDefaultModel = missingDefault;
537
+ const before = forkPosts; let workCalls = 0;
538
+ const result = await p.reader.deliver(payload, async context => { workCalls++; return context.model; });
539
+ expect(result).toBe(missingDefault ? null : "stub/stub-model");
540
+ expect(workCalls).toBe(missingDefault ? 0 : 1);
541
+ expect(forkPosts).toBe(before);
542
+ }
543
+ });
544
+ async function registerFromPrivateProfile(config: any) {
545
+ const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
546
+ const { registerTools } = await import("./tools");
547
+ const a = resolveToken(config.token)!;
548
+ const handlers: Record<string, (args: any) => Promise<any>> = {};
549
+ const mcp = new McpServer({ name: "source-registration-fixture", version: "0" });
550
+ const tool = mcp.tool.bind(mcp);
551
+ (mcp as any).tool = (name: string, desc: string, schema: any, handler: any) => { handlers[name] = handler; return tool(name, desc, schema, handler); };
552
+ registerTools(mcp, undefined, config.network_id, a.user.user_id, config.alias, true, a.tokenId!);
553
+ try {
554
+ const response = await handlers.report_status({ resume_id: `reg_${config.node_id}`, alias: config.alias,
555
+ node_id: config.node_id, session_id: config.sessionId, status: "idle", agent: "source-fixture" });
556
+ expect(JSON.parse(response.content[0].text).ok !== false).toBe(true);
557
+ } finally { await mcp.close(); }
558
+ }
559
+
560
+ test("real child token metadata -> one-shot source payload -> private profile -> resume-only runner stub -> real report_status registration", async () => {
561
+ const p = await readyDelivery("delivery_success"), beforePosts = forkPosts;
562
+ const id = p.delivery.queue(req(human.token), p.id)!; expect(id).not.toBeNull();
563
+ const payload = p.delivery.take(req(daemon.token), id, SOURCE_DELIVERY_CAPABILITY)!; expect(!!payload).toBe(true);
564
+ expect(isSourceNodeDelivery(payload)).toBe(true);
565
+ expect(await p.reader.recheck(payload.execution.evidence.lease_id)).toBe(true);
566
+ expect(await p.reader.deliver(payload, async () => "context-checked")).toBe("context-checked");
567
+ expect(p.delivery.take(req(daemon.token), id, SOURCE_DELIVERY_CAPABILITY)).toBeNull();
568
+ expect(p.delivery.confirmRegistration(req(payload.child_token), id)).toBe(false); // no self-asserted success
569
+ const home = mkdtempSync(join(root, "binding-home-")); let launches = 0;
570
+ const worker = createSessionSourceProfileWorker({ enabled: true, capability: SOURCE_DELIVERY_CAPABILITY, daemonWorkDir: daemonDir,
571
+ bindingHome: home, hubUrl: "http://isolated.invalid", reader: p.reader,
572
+ launch: async input => {
573
+ launches++;
574
+ expect(input.existingSessionId).toBe(p.outcome.session_id!); expect(input.resumeSessionId).toBe(input.existingSessionId);
575
+ expect(input.newSession).toBe(false); expect(input.expectedVersion).toBe("2.0.22");
576
+ const cfg = JSON.parse(readFileSync(input.configPath, "utf8"));
577
+ expect(cfg.token === payload.child_token).toBe(true);
578
+ expect(cfg.sessionId).toBe(p.outcome.session_id!); expect(cfg.node_id).toBe(payload.child_node_id);
579
+ expect(statSync(input.configPath).mode & 0o777).toBe(0o600);
580
+ await registerFromPrivateProfile(cfg);
581
+ }, confirmRegistration: async (id, token) => p.delivery.confirmRegistration(req(token), id) });
582
+ expect((await worker.run(payload)).status).toBe("registration_confirmed"); expect(launches).toBe(1);
583
+ expect(forkPosts).toBe(beforePosts);
584
+ const token = db.get<{ token_hash: string; bound_node_id: string; expires_at: string | null }>("SELECT token_hash,bound_node_id,expires_at FROM api_tokens WHERE token_id=?1", resolveToken(payload.child_token)!.tokenId!);
585
+ expect(token!.bound_node_id).toBe(payload.child_node_id); expect(token!.token_hash !== payload.child_token).toBe(true);
586
+ expect(token!.expires_at).toBeNull();
587
+ expect(JSON.stringify(db.all("SELECT * FROM session_source_node_deliveries")).includes(payload.child_token)).toBe(false);
588
+ expect(p.delivery.recover(req(human.token), id)?.status).toBe("registration_confirmed");
589
+ expect((await worker.run(payload)).status).toBe("unknown_rotation_required"); expect(launches).toBe(1);
590
+ });
591
+
592
+ test("delivery capability/source/busy/attach-owner checks reject without profile launch or repeat POST", async () => {
593
+ const p = await readyDelivery("delivery_negative"), beforePosts = forkPosts;
594
+ db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id='n_daemon'", [JSON.stringify({ role: "host_supervisor" })]);
595
+ expect(p.delivery.queue(req(human.token), p.id)).toBeNull();
596
+ db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id='n_daemon'", [JSON.stringify({ role: "host_supervisor", daemon_capabilities: { source_node_delivery: SOURCE_DELIVERY_CAPABILITY } })]);
597
+ const id = p.delivery.queue(req(human.token), p.id)!;
598
+ expect(p.delivery.take(req(daemon.token), id, "ordinary-create")).toBeNull();
599
+ expect(p.delivery.take(req(source.token), id, SOURCE_DELIVERY_CAPABILITY)).toBeNull();
600
+ const payload = p.delivery.take(req(daemon.token), id, SOURCE_DELIVERY_CAPABILITY)!;
601
+ let launches = 0; const home = mkdtempSync(join(root, "binding-home-"));
602
+ const worker = createSessionSourceProfileWorker({ enabled: true, capability: SOURCE_DELIVERY_CAPABILITY, daemonWorkDir: daemonDir,
603
+ bindingHome: home, hubUrl: "http://isolated.invalid", reader: p.reader, launch: async () => { launches++; }, confirmRegistration: async () => false });
604
+ expect((await worker.run({ ...payload, session_id: "ses_Unselected" })).status).toBe("refused");
605
+ expect((await worker.run({ ...payload, execution: { ...payload.execution, evidence: { ...payload.execution.evidence,
606
+ request: { ...payload.execution.evidence.request, source_node_id: "other_source" } } } })).status).toBe("refused");
607
+ busyDelivery = payload.session_id;
608
+ expect((await worker.run(payload)).status).toBe("refused"); busyDelivery = "";
609
+ const attach = await readyDelivery("delivery_attach", "attach_existing"), attachId = attach.delivery.queue(req(human.token), attach.id)!;
610
+ const attachPayload = attach.delivery.take(req(daemon.token), attachId, SOURCE_DELIVERY_CAPABILITY)!;
611
+ const attachWorker = createSessionSourceProfileWorker({ enabled: true, capability: SOURCE_DELIVERY_CAPABILITY,
612
+ daemonWorkDir: daemonDir, bindingHome: home, hubUrl: "http://isolated.invalid", reader: attach.reader,
613
+ launch: async () => { launches++; }, confirmRegistration: async () => false });
614
+ expect((await attachWorker.run(attachPayload)).status).toBe("refused");
615
+ expect(launches).toBe(0); expect(forkPosts).toBe(beforePosts);
616
+ });
617
+
618
+ test("expired child credential or lost in-memory secret becomes unknown/rotation; never remint or repeat session POST", async () => {
619
+ const p = await readyDelivery("delivery_expiry"), beforePosts = forkPosts;
620
+ const id = p.delivery.queue(req(human.token), p.id)!;
621
+ const r = db.get<{ token_id: string }>("SELECT token_id FROM session_source_node_deliveries WHERE delivery_id=?1", id)!;
622
+ db.run("UPDATE api_tokens SET expires_at=datetime('now','-1 minute') WHERE token_id=?1", [r.token_id]);
623
+ expect(p.delivery.take(req(daemon.token), id, SOURCE_DELIVERY_CAPABILITY)).toBeNull();
624
+ expect(p.delivery.recover(req(human.token), id)?.status).toBe("unknown_rotation_required");
625
+ expect(p.delivery.queue(req(human.token), p.id)).toBeNull();
626
+ const second = await readyDelivery("delivery_secret_lost"), secondId = second.delivery.queue(req(human.token), second.id)!;
627
+ stopBackgroundTimersForTest(); // models Hub restart losing pending blobs only
628
+ const restarted = createSessionSourceDeliveryQueue(second.hub, { enabled: true });
629
+ expect(restarted.take(req(daemon.token), secondId, SOURCE_DELIVERY_CAPABILITY)).toBeNull();
630
+ expect(restarted.recover(req(human.token), secondId)?.status).toBe("unknown_rotation_required");
631
+ expect(restarted.queue(req(human.token), second.id)).toBeNull();
632
+ expect(forkPosts).toBe(beforePosts + 1);
633
+ });
634
+
635
+ test("lost registration ACK leaves a durable no-relaunch claim and revokes unknown credential without session POST", async () => {
636
+ const p = await readyDelivery("delivery_ack_lost"), posts = forkPosts;
637
+ const id = p.delivery.queue(req(human.token), p.id)!;
638
+ const payload = p.delivery.take(req(daemon.token), id, SOURCE_DELIVERY_CAPABILITY)!;
639
+ let launches = 0;
640
+ const makeWorker = () => createSessionSourceProfileWorker({ enabled: true, capability: SOURCE_DELIVERY_CAPABILITY,
641
+ daemonWorkDir: daemonDir, bindingHome: mkdtempSync(join(root, "binding-home-")), hubUrl: "http://isolated.invalid", reader: p.reader,
642
+ launch: async input => { launches++; await registerFromPrivateProfile(JSON.parse(readFileSync(input.configPath, "utf8"))); },
643
+ confirmRegistration: async () => false });
644
+ const outcomes = await Promise.all([makeWorker().run(payload), makeWorker().run(payload)]);
645
+ expect(outcomes.every(v => v.status !== "registration_confirmed")).toBe(true);
646
+ expect(launches).toBe(1);
647
+ expect((await makeWorker().run(payload)).status).toBe("unknown_rotation_required");
648
+ expect(p.delivery.recover(req(human.token), id)?.status).toBe("unknown_rotation_required");
649
+ expect(resolveToken(payload.child_token)).toBeNull();
650
+ expect(p.delivery.queue(req(human.token), p.id)).toBeNull();
651
+ expect(forkPosts).toBe(posts); expect(launches).toBe(1);
652
+ });
653
+
654
+ test("default concrete launcher spawns isolated synthetic child using real shared V2 core and real Hub registration/ACK", async () => {
655
+ const p = await readyDelivery("concrete_launch"), before = forkPosts;
656
+ const id = p.delivery.queue(req(human.token), p.id)!;
657
+ const payload = p.delivery.take(req(daemon.token), id, SOURCE_DELIVERY_CAPABILITY)!;
658
+ const { createSourceResumeLauncher, recoverSourceResumeLaunch } = await import("../../agent-node/src/runtime/source-resume-launcher");
659
+ let child: Awaited<ReturnType<ReturnType<typeof createSourceResumeLauncher>>> | undefined;
660
+ const native = createSourceResumeLauncher({ command: process.execPath,
661
+ argsPrefix: [join(import.meta.dir, "../../agent-node/src/runtime/fixtures/source-resume-child.ts")],
662
+ env: { PATH: "/usr/local/bin:/usr/bin:/bin", HOME: mkdtempSync(join(root, "child-home-")) }, timeoutMs: 3000 });
663
+ const worker = createSessionSourceProfileWorker({ enabled: true, capability: SOURCE_DELIVERY_CAPABILITY,
664
+ daemonWorkDir: daemonDir, bindingHome: mkdtempSync(join(root, "binding-home-")), reader: p.reader,
665
+ hubUrl: `http://127.0.0.1:${server.port}`, launch: async input => { child = await native(input); return child; },
666
+ confirmRegistration: async (id, token) => p.delivery.confirmRegistration(req(token), id) });
667
+ try {
668
+ expect((await worker.run(payload)).status).toBe("registration_confirmed");
669
+ expect(!!child).toBe(true);
670
+ expect(p.delivery.recover(req(human.token), id)?.status).toBe("registration_confirmed");
671
+ const config = join(project, ".anet", "nodes", payload.child_name, "config.json");
672
+ expect(recoverSourceResumeLaunch(config).session_id).toBe(payload.session_id);
673
+ expect(forkPosts).toBe(before);
674
+ } finally { await child?.stop(); }
675
+ expect(await p.reader.recheck(payload.execution.evidence.lease_id)).toBe(true); // source/Server retained
676
+ });
677
+
678
+ test("actual anet CLI -> exact paired agent-node CLI -> shared V2 resume -> real report_status with synthetic native-package fixture", async () => {
679
+ const p = await readyDelivery("actual_cli_launch"), before = forkPosts;
680
+ const apiPostsBefore = calls.filter(c => /^POST \/api\/session(?:\/|$)/.test(c));
681
+ const id = p.delivery.queue(req(human.token), p.id)!;
682
+ const payload = p.delivery.take(req(daemon.token), id, SOURCE_DELIVERY_CAPABILITY)!;
683
+ // Container-only safe prefix. NOT a downloaded/real OpenCode binary.
684
+ const prefix = mkdtempSync("/work/source-cli-fixture-");
685
+ const pkg = join(prefix, "node_modules", "@opencode", "cli");
686
+ mkdirSync(join(pkg, "bin"), { recursive: true, mode: 0o700 }); mkdirSync(join(prefix, "bin"), { mode: 0o700 });
687
+ mkdirSync(join(prefix, "safe"), { mode: 0o700 }); mkdirSync(join(prefix, "home"), { mode: 0o700 });
688
+ writeFileSync(join(pkg, "package.json"), JSON.stringify({ name: "@opencode/cli", version: "2.0.22", bin: { opencode: "bin/opencode.exe" } }));
689
+ writeFileSync(join(pkg, "bin", "opencode.exe"), "#!/bin/sh\nif [ \"$1\" = \"--version\" ]; then echo 'opencode v2.0.22'; exit 0; fi\nexit 77\n", { mode: 0o700 });
690
+ symlinkSync(join(pkg, "bin", "opencode.exe"), join(prefix, "bin", "opencode"));
691
+ const entry = join(import.meta.dir, "../../agent-node/src/cli.ts");
692
+ const nodePackage = join(prefix, "node_modules", "@sleep2agi", "agent-node");
693
+ mkdirSync(nodePackage, { recursive: true, mode: 0o700 });
694
+ writeFileSync(join(nodePackage, "package.json"), readFileSync(join(import.meta.dir, "../../agent-node/package.json")));
695
+ for (const dep of ["@anthropic-ai", "@openai", "node-pty"]) {
696
+ symlinkSync(join(import.meta.dir, "../../agent-node/node_modules", dep), join(prefix, "node_modules", dep));
697
+ }
698
+ const dist = join(nodePackage, "dist");
699
+ const built = await Bun.build({ entrypoints: [entry], outdir: dist, target: "bun",
700
+ external: ["@anthropic-ai/claude-agent-sdk", "@openai/codex-sdk", "node-pty"] });
701
+ expect(built.success).toBe(true);
702
+ const nativeLaunch = { command: process.execPath,
703
+ argsPrefix: [join(import.meta.dir, "../../agent-network/bin/cli.ts")], env: {
704
+ PATH: `${join(prefix, "bin")}:/usr/local/bin:/usr/bin:/bin`, HOME: join(prefix, "home"),
705
+ ANET_AGENT_NODE_BIN: join(dist, "cli.js"), ANET_OPENCODE_SAFE_BASE: join(prefix, "safe"),
706
+ }, timeoutMs: 6000 };
707
+ const worker = createSessionSourceProfileWorker({ enabled: true, capability: SOURCE_DELIVERY_CAPABILITY,
708
+ daemonWorkDir: daemonDir, bindingHome: join(prefix, "home"), reader: p.reader, hubUrl: `http://127.0.0.1:${server.port}`,
709
+ nativeLaunch,
710
+ confirmRegistration: async (id, token) => p.delivery.confirmRegistration(req(token), id) });
711
+ try {
712
+ const result = await worker.run(payload);
713
+ expect(result.status).toBe("registration_confirmed");
714
+ expect(forkPosts).toBe(before);
715
+ // Fixture multiplexes Hub /api/node-session-control/bridge and native API.
716
+ expect(calls.filter(c => /^POST \/api\/session(?:\/|$)/.test(c))).toEqual(apiPostsBefore);
717
+ const health = JSON.parse(readFileSync(join(project, ".anet", "nodes", payload.child_name, "source-resume-health.json"), "utf8"));
718
+ expect(await worker.stopChild(id)).toBe(true);
719
+ expect(() => process.kill(health.pid, 0)).toThrow();
720
+ } finally { await worker.stopChild(id); rmSync(prefix, { recursive: true, force: true }); }
721
+ expect(await p.reader.recheck(payload.execution.evidence.lease_id)).toBe(true);
722
+ }, 20_000);
723
+
724
+ function transportFixture(fetchOverride?: typeof fetch) {
725
+ sourceTransport = createSessionSourceTransport({ enabled: true });
726
+ db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id='n_daemon'", [JSON.stringify({ role: "host_supervisor",
727
+ daemon_capabilities: { source_node_delivery: SOURCE_DELIVERY_CAPABILITY, source_fork_transport: SOURCE_FORK_CAPABILITY } })]);
728
+ const base = `http://127.0.0.1:${server.port}`;
729
+ const api = async (token: string, path: string, body?: any) => {
730
+ const response = await fetch(`${base}${SOURCE_FORK_ROOT}${path}`, { method: body === undefined ? "GET" : "POST",
731
+ headers: { authorization: `Bearer ${token}`, "content-type": "application/json" }, ...(body === undefined ? {} : { body: JSON.stringify(body) }) });
732
+ return { status: response.status, body: await response.json() };
733
+ };
734
+ const value = (intent: string) => ({ network_id: selection.network_id, source_node_id: "n_source", session_id: "ses_Selected",
735
+ mode: "fork_independent", child_name: `http-${intent}`, intent_id: intent });
736
+ const bindingHome = mkdtempSync(join(root, "transport-home-"));
737
+ const worker = createSessionSourceTransportWorker({ hubUrl: base, home: bindingHome, daemonWorkDir: daemonDir,
738
+ nativeLaunch: { command: process.execPath, argsPrefix: [join(import.meta.dir, "../../agent-node/src/runtime/fixtures/source-resume-child.ts")],
739
+ env: { HOME: bindingHome, PATH: "/usr/local/bin:/usr/bin:/bin" }, timeoutMs: 3000 },
740
+ pin: createSessionControlPin({ hubUrl: base, token: daemon.token!, nodeId: "n_daemon", networkId: selection.network_id,
741
+ epoch: 0, currentEpoch: () => 0, currentToken: () => daemon.token!, signal: new AbortController().signal, fetch: fetchOverride }) });
742
+ const binding = { expected: { node_id: "n_daemon", network_id: selection.network_id }, capability: SOURCE_FORK_CAPABILITY,
743
+ instance_id: "11111111-1111-4111-8111-111111111111" };
744
+ return { api, value, worker, binding };
745
+ }
746
+ test("HTTP source-fork human queue -> frozen daemon poll/read/recheck/execute/deliver -> real token registration -> human poll", async () => {
747
+ const { api, value, worker } = transportFixture();
748
+ await worker.tick(); // explicit capability/instance declaration, not CLI-version inference
749
+ const queued = await api(human.token, "", value("transport-success"));
750
+ expect(queued.status).toBe(200); expect(queued.body.status).toBe("evidence_pending");
751
+ const id = queued.body.request_id;
752
+ try {
753
+ for (let i = 0; i < 4; i++) await worker.tick();
754
+ const polled = await api(human.token, `/${id}?network_id=${selection.network_id}`);
755
+ expect(polled.status).toBe(200); expect(polled.body.status).toBe("registration_confirmed");
756
+ expect(polled.body.child_session_id).toMatch(/^ses_Child/); expect(polled.body.child_node_id).toMatch(/^node_srcd_/);
757
+ expect(JSON.stringify(polled.body)).not.toContain("ntok_");
758
+ expect(forkPosts).toBe(1);
759
+ expect((await api(human.token, "", value("transport-success"))).body.request_id).toBe(id);
760
+ await worker.tick(); expect(forkPosts).toBe(1);
761
+ expect((await api(daemon.token!, `/${id}?network_id=${selection.network_id}`)).status).toBe(403);
762
+ expect((await api(human.token, `/${id}?network_id=wrong`)).status).toBe(403);
763
+ expect((await api(human.token, "", { ...value("transport-success"), child_name: "different" })).status).toBe(409);
764
+ expect(db.get<{ status: string }>("SELECT status FROM node_create_requests WHERE request_id=(SELECT admission_request_id FROM session_source_executions WHERE execution_id=(SELECT execution_id FROM session_source_transports WHERE request_id=?1))", id)?.status).toBe("source_reserved");
765
+ } finally { await worker.stop(); }
766
+ }, 15_000);
767
+
768
+ test("HTTP source-fork refusals carry a diagnostic reason once source permissions are verified", async () => {
769
+ const { api, value, worker } = transportFixture();
770
+ try {
771
+ // Daemon never declared itself (offline / not polling): used to be a bare 409 the app showed as "conflict".
772
+ const offline = await api(human.token!, "", value("reason-offline"));
773
+ expect(offline.status).toBe(409);
774
+ expect(offline.body).toEqual({ ok: false, error: "source_fork_unavailable", reason: "daemon_offline" });
775
+ await worker.tick();
776
+ const queued = await api(human.token!, "", value("reason-reuse"));
777
+ expect(queued.status).toBe(200);
778
+ const reused = await api(human.token!, "", { ...value("reason-reuse"), child_name: "reason-different" });
779
+ expect(reused.status).toBe(409);
780
+ expect(reused.body.reason).toBe("intent_reused");
781
+ // Callers without permission on the source still get no reason (no management-state disclosure).
782
+ const outsider = register("reason_outsider", "Fixture-Strong-4150!");
783
+ const foreign = await api(outsider.token!, "", value("reason-foreign"));
784
+ expect(foreign.status).toBe(403);
785
+ expect(foreign.body.reason).toBeUndefined();
786
+ } finally { await worker.stop(); }
787
+ }, 15_000);
788
+
789
+ test("HTTP gate/caller/capability/scope/strict-selection checks; stale auth and daemon restart never requeue claimed work", async () => {
790
+ const { api, value, binding, worker } = transportFixture();
791
+ sourceTransport = createSessionSourceTransport();
792
+ expect((await api(human.token, "", value("gate-off"))).status).toBe(404);
793
+ sourceTransport = createSessionSourceTransport({ enabled: true });
794
+ expect((await api(daemon.token!, "", value("node-human"))).status).toBe(400);
795
+ expect((await api(human.token, "/daemon", binding)).status).toBe(403);
796
+ expect((await api(daemon.token!, "/daemon", { ...binding, expected: { ...binding.expected, network_id: "other" } })).status).toBe(403);
797
+ expect((await api(daemon.token!, "/daemon", { ...binding, capability: "guessed-from-version" })).status).toBe(403);
798
+ db.run("UPDATE sessions SET env_transport='plain' WHERE resume_id='ev_daemon'");
799
+ expect((await api(daemon.token!, "/daemon", binding)).status).toBe(403);
800
+ db.run("UPDATE sessions SET env_transport=NULL WHERE resume_id='ev_daemon'");
801
+ expect((await api(daemon.token!, "/daemon", binding)).status).toBe(403);
802
+ db.run("UPDATE sessions SET env_transport='loopback' WHERE resume_id='ev_daemon'");
803
+ expect((await api(daemon.token!, "/daemon", binding)).status).toBe(200);
804
+ expect((await api(human.token, "", { ...value("raw"), url: "http://127.0.0.1:1", token: "forged" })).status).toBe(400);
805
+ expect((await api(human.token, "", { ...value("attach"), mode: "attach_existing" })).status).toBe(400);
806
+ expect((await api(human.token, "", { ...value("cross"), network_id: "other" })).status).not.toBe(200);
807
+ const outsider = register("http_transport_outsider", "Fixture-Strong-4150!");
808
+ expect((await api(outsider.token!, "", value("foreign-human"))).status).toBe(403);
809
+ const queued = await api(human.token, "", value("lost-task")); expect(queued.status).toBe(200);
810
+ const first = await api(daemon.token!, "/pull", binding); expect(first.body.task.phase).toBe("evidence");
811
+ expect((await api(daemon.token!, "/pull", binding)).body.task).toBeNull();
812
+ const envelope = { ...binding, request_id: queued.body.request_id, intent_id: "wrong", network_id: selection.network_id,
813
+ source_node_id: "n_source", daemon_node_id: "n_daemon", phase: "evidence", result: {} };
814
+ expect((await api(daemon.token!, "/ack", envelope)).status).toBe(403);
815
+ // Different process-local daemon reader cannot recover old leases or restart it.
816
+ await worker.tick();
817
+ expect((await api(daemon.token!, "/daemon", binding)).status).toBe(409); // retired old instance cannot overwrite new
818
+ const poll = await api(human.token, `/${queued.body.request_id}?network_id=${selection.network_id}`);
819
+ expect(poll.body.status).toBe("unknown_rotation_required");
820
+ expect((await api(human.token, "", value("lost-task"))).body.status).toBe("unknown_rotation_required");
821
+ expect(forkPosts).toBe(0);
822
+ await worker.stop();
823
+ // Explicit capability disappearing makes a live token insufficient.
824
+ db.run("UPDATE nodes SET config_snapshot='{}' WHERE node_id='n_daemon'");
825
+ expect((await api(daemon.token!, "/daemon", binding)).status).toBe(403);
826
+ }, 10_000);
827
+
828
+ test("HTTP unknown fork response and Hub reconstruction are read-only convergence: one fork and no remint/replay", async () => {
829
+ const { api, value, worker } = transportFixture();
830
+ await worker.tick(); loseForkResponse = true;
831
+ const queued = await api(human.token, "", value("http-unknown")); expect(queued.status).toBe(200);
832
+ try {
833
+ for (let i = 0; i < 3; i++) await worker.tick();
834
+ expect(forkPosts).toBe(1);
835
+ expect((await api(human.token, `/${queued.body.request_id}?network_id=${selection.network_id}`)).body.status).toBe("unknown_rotation_required");
836
+ const minted = db.get<{ n: number }>("SELECT count(*) AS n FROM api_tokens")!.n;
837
+ sourceTransport = createSessionSourceTransport({ enabled: true }); // no process-local evidence/secret recovery
838
+ loseForkResponse = false;
839
+ await worker.tick();
840
+ expect((await api(human.token, "", value("http-unknown"))).body.status).toBe("unknown_rotation_required");
841
+ expect((await api(human.token, `/${queued.body.request_id}?network_id=${selection.network_id}`)).body.status).toBe("unknown_rotation_required");
842
+ expect(forkPosts).toBe(1); expect(db.get<{ n: number }>("SELECT count(*) AS n FROM api_tokens")!.n).toBe(minted);
843
+ } finally { await worker.stop(); }
844
+ }, 10_000);
845
+
846
+ test("HTTP permission revocation after take blocks ACK and poll; mismatched request evidence and peer daemon token cannot ACK", async () => {
847
+ const { api, value, binding } = transportFixture();
848
+ await api(daemon.token!, "/daemon", binding);
849
+ const queued = await api(human.token, "", value("http-auth")); expect(queued.status).toBe(200);
850
+ const pulled = (await api(daemon.token!, "/pull", binding)).body.task;
851
+ const reader = createSessionSourceEvidenceReader(local()), evidence = await reader.read(pulled.task);
852
+ expect(evidence.ok).toBe(true); if (!evidence.ok) return;
853
+ const envelope = { ...binding, request_id: queued.body.request_id, intent_id: "http-auth", network_id: selection.network_id,
854
+ source_node_id: "n_source", daemon_node_id: "n_daemon", phase: "evidence", result: evidence.evidence };
855
+ expect((await api(source.token!, "/ack", envelope)).status).toBe(403);
856
+ expect((await api(daemon.token!, "/ack", { ...envelope, result: { ...evidence.evidence,
857
+ request: { ...evidence.evidence.request, request_id: "srcq_00000000-0000-4000-8000-000000000000" } } })).status).toBe(400);
858
+ db.run("UPDATE network_members SET role='viewer' WHERE user_id=?1 AND network_id=?2", [human.user!.user_id, selection.network_id]);
859
+ expect((await api(daemon.token!, "/ack", envelope)).status).toBe(403);
860
+ expect((await api(human.token, `/${queued.body.request_id}?network_id=${selection.network_id}`)).status).toBe(403);
861
+ expect(forkPosts).toBe(0);
862
+ });
863
+
864
+ test("HTTP lost one-shot delivery body revokes unknown credential on recovery without remint, refork or launch", async () => {
865
+ let dropped = false;
866
+ const { api, value, worker } = transportFixture((async (input: any, init: any) => {
867
+ const response = await fetch(input, init);
868
+ if (String(input).endsWith(`${SOURCE_FORK_ROOT}/pull`)) {
869
+ const body: any = await response.clone().json();
870
+ if (body.task?.phase === "deliver") { dropped = true; await response.body?.cancel(); return Response.json({ ok: true, task: null }); }
871
+ }
872
+ return response;
873
+ }) as typeof fetch);
874
+ try {
875
+ await worker.tick();
876
+ const queued = await api(human.token, "", value("http-lost-secret")); expect(queued.status).toBe(200);
877
+ for (let i = 0; i < 3; i++) await worker.tick();
878
+ expect(dropped).toBe(true); expect(forkPosts).toBe(1);
879
+ const minted = db.get<{ n: number }>("SELECT count(*) AS n FROM api_tokens")!.n;
880
+ sourceTransport = createSessionSourceTransport({ enabled: true });
881
+ const polled = await api(human.token, `/${queued.body.request_id}?network_id=${selection.network_id}`);
882
+ expect(polled.body.status).toBe("unknown_rotation_required");
883
+ expect(polled.body.child_node_id).toMatch(/^node_srcd_/);
884
+ expect(db.get<{ revoked_at: string | null }>(`SELECT t.revoked_at FROM api_tokens t JOIN session_source_node_deliveries d ON d.token_id=t.token_id
885
+ JOIN session_source_transports r ON r.delivery_id=d.delivery_id WHERE r.request_id=?1`, queued.body.request_id)?.revoked_at).not.toBeNull();
886
+ await worker.tick();
887
+ expect((await api(human.token, "", value("http-lost-secret"))).body.status).toBe("unknown_rotation_required");
888
+ expect(forkPosts).toBe(1); expect(db.get<{ n: number }>("SELECT count(*) AS n FROM api_tokens")!.n).toBe(minted);
889
+ } finally { await worker.stop(); }
890
+ }, 10_000);