@relaycast/engine 10.0.1 → 10.0.3

package/dist/engine/node.js

@@ -6,12 +6,13 @@ import { actionInvocations, agents, agentNodeBindings, channelMembers, channels,
 import { randomHex, sha256Hex } from '../lib/crypto.js';
 import { codedError } from '../lib/httpError.js';
 import { acceptTaskInvocation, completeTaskInvocation } from './taskInvocation.js';
-import { runAtomic, runAtomicWrites } from '../ports/database.js';
+import { databaseConstraintKind, runAtomic, runAtomicWrites } from '../ports/database.js';
+import { retryD1Write } from '../lib/d1Retry.js';
 import { generateId } from './snowflake.js';
 import { assertRegistrableAgentName } from './agent.js';
 import { rotateAgentIdentity } from './agentIdentity.js';
 import { isNodeLive, isReusableForMachineMatch, nodeHasCapacity, NODE_LIVENESS_TTL_MS } from './placement.js';
-import { DEFAULT_PROVIDER_NAME, capabilityKind, heartbeatProvider, isProviderLive, markProviderOffline, materializeProviderActions, recomputeNodeAggregate, removeProvider, upsertProvider, } from './nodeProvider.js';
+import { DEFAULT_PROVIDER_NAME, assertActionTaskMode, capabilityKind, heartbeatProvider, isProviderLive, markProviderOffline, materializeProviderActions, providerActionsMaterialized, recomputeNodeAggregate, removeProvider, upsertProvider, } from './nodeProvider.js';
 import { serializeNodeOp } from './nodeLock.js';
 import { completeNodeInvocation, dispatchCapacitySpawn, rescheduleInvocationsForLostNode, rescheduleNodeInvocation, } from './action.js';
 import { emitInvocationCompletionEffects, emitAgentExitedEffects, emitNodeStatusEffects, fleetInvocationId } from './invocationCompletion.js';
@@ -158,6 +159,30 @@ function withRegisteredProtocolCapabilities(heartbeatCapabilities, registeredCap
         ...registeredCapabilities.filter(isNegotiatedProtocolCapability),
     ];
 }
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value !== null && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .filter(([, field]) => field !== undefined)
+            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+            .map(([key, field]) => `${JSON.stringify(key)}:${stableJson(field)}`);
+        return `{${entries.join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'null';
+}
+/**
+ * Order-insensitive structural equality on capability sets. The persisted
+ * manifest is a JSON round-trip of what the client sent, so key order and
+ * absent-vs-undefined fields must not count as a roster change.
+ */
+function sameCapabilities(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const left = a.map(stableJson).sort();
+    const right = b.map(stableJson).sort();
+    return left.every((entry, index) => entry === right[index]);
+}
 /**
  * Whether the provider's LIVE connection negotiated cursor-gated delivery at
  * `node.register` — i.e. whether it was denied the register-time flush and so
@@ -718,33 +743,65 @@ export async function heartbeatNode(db, workspaceId, nodeId, providerName, messa
             .returning();
         return updated ? publicNode(updated) : null;
     }
+    let updated;
     await runAtomic(db, async (tx) => {
+        const now = new Date();
         if (message.capabilities !== undefined) {
             const [existingProvider] = await tx
-                .select({
-                instanceId: nodeProviders.instanceId,
-                maxAgents: nodeProviders.maxAgents,
-                version: nodeProviders.version,
-                capabilities: nodeProviders.capabilities,
-            })
+                .select()
                 .from(nodeProviders)
                 .where(and(eq(nodeProviders.workspaceId, workspaceId), eq(nodeProviders.nodeId, nodeId), eq(nodeProviders.name, providerName)));
             const caps = withRegisteredProtocolCapabilities(normalizeCapabilities(message.capabilities), existingProvider?.capabilities ?? []);
-            await upsertProvider(tx, workspaceId, nodeId, {
-                name: providerName,
-                instanceId: existingProvider?.instanceId ?? `${providerName}:heartbeat`,
+            assertActionTaskMode(caps);
+            const maxAgents = message.max_agents ?? existingProvider?.maxAgents ?? 0;
+            // heartbeatProvider's load rule folded in here: a numeric load only
+            // counts as a measurement when the provider opts in via load_reported
+            // and is capacity-bounded (zero is the unbounded sentinel).
+            const reportedLoad = maxAgents > 0 && message.load_reported === true && typeof message.load === 'number'
+                ? message.load
+                : undefined;
+            // One write carries both the roster refresh (capabilities/max_agents/
+            // version) and the liveness signal (load/active_agents/handlers_live)
+            // that upsertProvider + heartbeatProvider used to write separately.
+            const providerWrite = {
                 capabilities: caps,
-                maxAgents: message.max_agents ?? existingProvider?.maxAgents ?? 0,
-                version: message.version ?? existingProvider?.version ?? 'unknown',
-                handlersLive: message.handlers_live,
-            });
-            await heartbeatProvider(tx, workspaceId, nodeId, providerName, {
-                load: message.load,
-                loadReported: message.load_reported,
+                maxAgents,
+                load: reportedLoad ?? 0,
+                loadReported: reportedLoad !== undefined,
                 activeAgents: message.active_agents,
                 handlersLive: message.handlers_live,
-            });
-            await materializeProviderActions(tx, workspaceId, nodeId, providerName, caps);
+                status: 'online',
+                lastHeartbeatAt: now,
+            };
+            if (existingProvider) {
+                await tx
+                    .update(nodeProviders)
+                    .set({ ...providerWrite, version: message.version ?? existingProvider.version })
+                    .where(eq(nodeProviders.id, existingProvider.id));
+            }
+            else {
+                await tx.insert(nodeProviders).values({
+                    id: `nprov_${generateId()}`,
+                    workspaceId,
+                    nodeId,
+                    name: providerName,
+                    instanceId: `${providerName}:heartbeat`,
+                    version: message.version ?? 'unknown',
+                    createdAt: now,
+                    ...providerWrite,
+                });
+            }
+            // Re-materializing an identical manifest rewrites the same action rows
+            // on every beat (~4 statements per action capability, every ~12s per
+            // provider). The prune/upsert pass runs only when the roster actually
+            // changes or the materialized rows drifted (a cheap one-read check that
+            // keeps the heartbeat self-healing); every node.register still goes
+            // through materializeProviderActions unconditionally.
+            if (existingProvider === undefined
+                || !sameCapabilities(existingProvider.capabilities ?? [], caps)
+                || !(await providerActionsMaterialized(tx, workspaceId, nodeId, providerName, caps.filter((cap) => capabilityKind(cap) === 'action')))) {
+                await materializeProviderActions(tx, workspaceId, nodeId, providerName, caps);
+            }
         }
         else {
             await heartbeatProvider(tx, workspaceId, nodeId, providerName, {
@@ -757,19 +814,15 @@ export async function heartbeatNode(db, workspaceId, nodeId, providerName, messa
         if (message.name !== undefined) {
             await tx.update(nodes).set({ name: message.name }).where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, nodeId)));
         }
-        await recomputeNodeAggregate(tx, workspaceId, nodeId, message.version !== undefined ? { version: message.version } : {});
-        // Stamped after the aggregate so it cannot be overwritten by it: the
-        // aggregate derives lastHeartbeatAt from provider rows, which registration
-        // also writes, whereas this column is only ever set by an arriving frame.
-        await tx
-            .update(nodes)
-            .set({ provenLiveAt: new Date() })
-            .where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, nodeId)));
+        // provenLiveAt rides the same UPDATE as the aggregate, preserving the
+        // ordering the separate stamp used to guarantee: the aggregate derives
+        // lastHeartbeatAt from provider rows, which registration also writes,
+        // whereas this column is only ever set by an arriving frame.
+        updated = await recomputeNodeAggregate(tx, workspaceId, nodeId, {
+            ...(message.version !== undefined ? { version: message.version } : {}),
+            provenLiveAt: now,
+        });
     });
-    const [updated] = await db
-        .select()
-        .from(nodes)
-        .where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, nodeId)));
     return updated ? publicNode(updated) : null;
 }
 export async function markNodeOffline(db, registry, workspaceId, nodeId, effects) {
@@ -905,19 +958,6 @@ export async function sweepOfflineNodes(db, registry, deps) {
     }
     return swept;
 }
-async function autoJoinGeneral(db, workspaceId, agentId) {
-    const [generalChannel] = await db
-        .select()
-        .from(channels)
-        .where(and(eq(channels.workspaceId, workspaceId), eq(channels.name, 'general')));
-    if (generalChannel) {
-        await db.insert(channelMembers).values({
-            channelId: generalChannel.id,
-            agentId,
-            role: 'member',
-        }).onConflictDoNothing();
-    }
-}
 /**
  * Statements that bind `agent` to `nodeId` and move its routable location onto
  * that node. Built, not executed: a caller that owns the whole move hands them
@@ -993,7 +1033,22 @@ async function activeBindingNodeIdsForAgent(db, workspaceId, agentId) {
         .where(and(eq(agentNodeBindings.workspaceId, workspaceId), eq(agentNodeBindings.agentId, agentId), eq(agentNodeBindings.status, 'active')));
     return rows.map((row) => row.nodeId);
 }
-async function reserveNodeAgentSlot(db, workspaceId, node, claim) {
+/**
+ * The capacity-admission statement (at most one reserved slot). Built, not
+ * executed, so a caller that owns the whole registration can commit it in the
+ * same atomic unit as the identity insert the reservation is for.
+ *
+ * A refused admission must *fail*, not merely match no rows: batched
+ * statements cannot inspect each other's results, so a soft refusal lets the
+ * insert in the same unit commit a ghost agent until a compensating delete
+ * lands (and in that window a same-named registration reads a false
+ * `agent_already_exists`). Writing NULL into `active_agents` when the
+ * capacity predicate fails makes the refusal a statement error that aborts
+ * the whole atomic group on every adapter — the same NOT NULL sentinel the
+ * workspace growth guards use. `databaseConstraintKind` reports it as
+ * 'node_capacity'.
+ */
+function reserveNodeAgentSlotStatement(db, workspaceId, node, claim) {
     const reservationCorrelation = claim?.invocationId
         ? eq(actionInvocations.id, claim.invocationId)
         : claim
@@ -1015,18 +1070,35 @@ async function reserveNodeAgentSlot(db, workspaceId, node, claim) {
           AND json_extract(${actionInvocations.input}, '$.name') = ${claim.agentName}
       )`
         : sql `0`;
-    const [reserved] = await db
+    return db
         .update(nodes)
         .set({
-        activeAgents: sql `${nodes.activeAgents} + 1`,
+        activeAgents: sql `CASE WHEN ${or(eq(nodes.maxAgents, 0), and(ownsSpawnReservation, sql `${nodes.activeAgents} < ${nodes.maxAgents}`), and(sql `NOT (${ownsSpawnReservation})`, sql `${nodes.activeAgents} + ${nodes.reservedAgents} < ${nodes.maxAgents}`))} THEN ${nodes.activeAgents} + 1 ELSE NULL END`,
     })
-        .where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, node.id), or(eq(nodes.maxAgents, 0), and(ownsSpawnReservation, sql `${nodes.activeAgents} < ${nodes.maxAgents}`), and(sql `NOT (${ownsSpawnReservation})`, sql `${nodes.activeAgents} + ${nodes.reservedAgents} < ${nodes.maxAgents}`))))
+        .where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, node.id)))
         .returning({ id: nodes.id });
-    if (!reserved) {
-        throw codedError(`Node "${node.name}" is at capacity`, 'node_capacity_exceeded', 409);
+}
+/** Translate the admission sentinel (and the node-row-gone empty update) into the capacity refusal callers expect. */
+async function reserveNodeAgentSlot(db, workspaceId, node, claim) {
+    try {
+        const [reserved] = await reserveNodeAgentSlotStatement(db, workspaceId, node, claim);
+        if (!reserved) {
+            throw codedError(`Node "${node.name}" is at capacity`, 'node_capacity_exceeded', 409);
+        }
+    }
+    catch (err) {
+        if (databaseConstraintKind(err) === 'node_capacity') {
+            throw codedError(`Node "${node.name}" is at capacity`, 'node_capacity_exceeded', 409);
+        }
+        throw err;
     }
 }
-async function rejectMigrationCanceledSpawnRegistration(db, workspaceId, registration) {
+/**
+ * The migration-tombstone read for a pending registration. Built, not
+ * executed: registration batches it with the rest of its read phase so the
+ * whole phase costs one D1 request.
+ */
+function canceledSpawnTombstoneQuery(db, workspaceId, registration) {
     // Provider ownership added in migration 0030 is intentionally NULL for
     // legacy rows whose multi-provider owner could not be inferred. Treat that
     // unknown owner conservatively as matching any provider on the exact node
@@ -1036,17 +1108,10 @@ async function rejectMigrationCanceledSpawnRegistration(db, workspaceId, registr
     const correlation = registration.invocationId
         ? and(eq(actionInvocations.id, registration.invocationId), eq(actionInvocations.dispatchedNodeId, registration.nodeId), providerCorrelation, sql `json_extract(${actionInvocations.input}, '$.name') = ${registration.agentName}`)
         : and(eq(actionInvocations.dispatchedNodeId, registration.nodeId), providerCorrelation, sql `json_extract(${actionInvocations.input}, '$.name') = ${registration.agentName}`);
-    const [canceled] = await db
+    return db
         .select({ id: actionInvocations.id })
         .from(actionInvocations)
         .where(and(eq(actionInvocations.workspaceId, workspaceId), correlation, eq(actionInvocations.invocationOrigin, 'legacy_unknown'), eq(actionInvocations.status, 'failed'), eq(actionInvocations.error, 'invocation_origin_unavailable'), or(eq(actionInvocations.actionName, 'spawn'), sql `${actionInvocations.actionName} LIKE 'spawn:%'`)));
-    if (canceled) {
-        // An ID-less legacy registration cannot distinguish a stale canceled
-        // worker from a newer reservation for the same tuple. Fail closed until
-        // the replacement echoes its invocation id; otherwise the stale process
-        // can consume the replacement generation's capacity and identity.
-        throw codedError(`Spawn invocation "${canceled.id}" was canceled during migration`, 'spawn_invocation_canceled', 409);
-    }
 }
 /**
  * The statement (at most one) that gives back one agent slot on each of
@@ -1428,102 +1493,227 @@ export async function listNodeAgents(db, workspaceId, nodeName) {
 }
 export async function registerAgentViaNode(db, workspaceId, nodeId, providerName, message, options = {}) {
     assertRegistrableAgentName(message.name);
+    const wantsAutoJoin = message.auto_join_general !== false;
     const registered = await runAtomic(db, async (tx) => {
-        await rejectMigrationCanceledSpawnRegistration(tx, workspaceId, {
-            invocationId: message.invocation_id,
-            nodeId,
-            providerName,
-            agentName: message.name,
-        });
-        const [node] = await tx
-            .select()
-            .from(nodes)
-            .where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, nodeId)));
+        // Every awaited statement is a separate D1 round-trip — and this path runs
+        // under the node-control liveness deadline whose misses surface as
+        // `d1_pressure`. The reads have no interdependencies and the writes split
+        // into an admission pair (slot reserve + identity insert) and a landing
+        // set (membership + bindings), so on a batch-capable handle each group
+        // ships as one atomic `batch` call. Inside an interactive transaction
+        // (Node adapters) the tx handle exposes no batch, and the same groups run
+        // sequentially — with results still pushed into the sinks as they land,
+        // so the catch below compensates exactly the writes that committed, no
+        // more and no less.
+        const hasBatch = typeof tx.batch === 'function';
+        const runStatements = async (statements, sink) => {
+            if (hasBatch) {
+                const results = await runAtomicWrites(tx, statements);
+                // A batch is all-or-nothing: populate the sink only once it has
+                // committed every statement.
+                sink.push(...results);
+                return results;
+            }
+            for (const statement of statements)
+                sink.push(await statement);
+            return sink;
+        };
+        const [canceledRows, nodeRows, providerRows, existingRows, channelRows,] = await runStatements([
+            canceledSpawnTombstoneQuery(tx, workspaceId, {
+                invocationId: message.invocation_id,
+                nodeId,
+                providerName,
+                agentName: message.name,
+            }),
+            tx
+                .select()
+                .from(nodes)
+                .where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, nodeId))),
+            tx
+                .select({ capabilities: nodeProviders.capabilities })
+                .from(nodeProviders)
+                .where(and(eq(nodeProviders.workspaceId, workspaceId), eq(nodeProviders.nodeId, nodeId), eq(nodeProviders.name, providerName))),
+            tx
+                .select({ id: agents.id })
+                .from(agents)
+                .where(and(eq(agents.workspaceId, workspaceId), eq(agents.name, message.name))),
+            tx
+                .select()
+                .from(channels)
+                .where(and(eq(channels.workspaceId, workspaceId), eq(channels.name, 'general'))),
+        ], []);
+        const [canceled] = canceledRows;
+        if (canceled) {
+            // An ID-less legacy registration cannot distinguish a stale canceled
+            // worker from a newer reservation for the same tuple. Fail closed until
+            // the replacement echoes its invocation id; otherwise the stale process
+            // can consume the replacement generation's capacity and identity.
+            throw codedError(`Spawn invocation "${canceled.id}" was canceled during migration`, 'spawn_invocation_canceled', 409);
+        }
+        const [node] = nodeRows;
         if (!node)
             throw codedError(`Node "${nodeId}" not found`, 'node_not_found', 404);
+        const [provider] = providerRows;
         const cursorHandshake = (options.deliveryCursorSupported ?? true)
-            && await providerAdvertisesDeliveryCursor(tx, workspaceId, nodeId, providerName);
+            && (provider?.capabilities?.some((capability) => capability.name === FLEET_DELIVERY_CURSOR_CAPABILITY) ?? false);
         // Preserve the established identity conflict even when this node is full.
         // A concurrent create after this read is still caught by the unique insert
         // below, whose reserved slot is then compensated in the catch path.
-        const [existing] = await tx
-            .select({ id: agents.id })
-            .from(agents)
-            .where(and(eq(agents.workspaceId, workspaceId), eq(agents.name, message.name)));
+        const [existing] = existingRows;
         if (existing) {
             throw codedError(`Agent "${message.name}" already exists; use agent.recover with proof of the immutable id`, 'agent_already_exists', 409);
         }
+        const [generalChannel] = channelRows;
         const token = `at_live_${randomHex(16)}`;
         const tokenHash = await sha256Hex(token);
         const now = new Date().toISOString();
         const agentId = generateId();
-        let reservedTargetSlot = false;
-        let createdAgent = false;
-        // D1 has no interactive transaction, so acquire capacity before the first
-        // durable agent or membership write. Any later failure compensates both
-        // the exact new identity and the slot rather than leaving a ghost agent.
-        await reserveNodeAgentSlot(tx, workspaceId, node, {
-            invocationId: message.invocation_id,
-            providerName,
-            agentName: message.name,
+        const admissionResults = [];
+        // Landing writes are all idempotent (conflict-ignore inserts, upserted
+        // binding, guarded retirement), so the ambiguous-commit recovery below can
+        // safely replay them when the admission group committed but its response
+        // was lost.
+        const landingWrites = () => [
+            ...(wantsAutoJoin && generalChannel
+                ? [tx
+                        .insert(channelMembers)
+                        .values({
+                        channelId: generalChannel.id,
+                        agentId,
+                        role: 'member',
+                    })
+                        .onConflictDoNothing()]
+                : []),
+            ...agentNodeBindingWrites(tx, workspaceId, { id: agentId, locationNodeId: nodeId }, nodeId, {
+                sessionRef: message.session_ref ?? null,
+                deactivateExisting: true,
+            }),
+        ];
+        const registeredReply = (agent) => ({
+            agent_id: agent.id,
+            name: agent.name,
+            token,
+            ...(cursorHandshake ? { delivery_ack_seq: agent.deliveryAckSeq } : {}),
         });
-        reservedTargetSlot = true;
+        // D1 has no interactive transaction, so the slot and the identity commit
+        // as one batch; any later failure compensates whichever of them landed
+        // rather than leaving a ghost agent or a leaked slot.
         try {
-            const [result] = await tx
-                .insert(agents)
-                .values({
-                id: agentId,
-                workspaceId,
-                name: message.name,
-                handle: `@${message.name}`,
-                type: 'agent',
-                tokenHash,
-                status: 'active',
-                persona: null,
-                metadata: { fleet: { node_id: nodeId, invocation_id: message.invocation_id ?? null, registered_at: now } },
-                locationType: 'via_node',
-                locationNodeId: nodeId,
-                providerName,
-                originNodeId: nodeId,
-                resumable: message.resumable ?? false,
-                sessionRef: message.session_ref ?? null,
-            })
-                .onConflictDoNothing({ target: [agents.workspaceId, agents.name] })
-                .returning();
-            if (!result) {
+            await runStatements([
+                reserveNodeAgentSlotStatement(tx, workspaceId, node, {
+                    invocationId: message.invocation_id,
+                    providerName,
+                    agentName: message.name,
+                }),
+                tx
+                    .insert(agents)
+                    .values({
+                    id: agentId,
+                    workspaceId,
+                    name: message.name,
+                    handle: `@${message.name}`,
+                    type: 'agent',
+                    tokenHash,
+                    status: 'active',
+                    persona: null,
+                    metadata: { fleet: { node_id: nodeId, invocation_id: message.invocation_id ?? null, registered_at: now } },
+                    locationType: 'via_node',
+                    locationNodeId: nodeId,
+                    providerName,
+                    originNodeId: nodeId,
+                    resumable: message.resumable ?? false,
+                    sessionRef: message.session_ref ?? null,
+                })
+                    .onConflictDoNothing({ target: [agents.workspaceId, agents.name] })
+                    .returning(),
+            ], admissionResults);
+            const [reserved] = (admissionResults[0] ?? []);
+            const [agent] = (admissionResults[1] ?? []);
+            if (!reserved) {
+                throw codedError(`Node "${node.name}" is at capacity`, 'node_capacity_exceeded', 409);
+            }
+            if (!agent) {
                 throw codedError(`Agent "${message.name}" already exists; use agent.recover with proof of the immutable id`, 'agent_already_exists', 409);
             }
-            createdAgent = true;
-            if (message.auto_join_general !== false)
-                await autoJoinGeneral(tx, workspaceId, result.id);
-            await upsertAgentNodeBinding(tx, workspaceId, result, nodeId, {
-                sessionRef: message.session_ref ?? null,
-                deactivateExisting: true,
-            });
-            return {
-                agent_id: result.id,
-                name: result.name,
-                token,
-                ...(cursorHandshake ? { delivery_ack_seq: result.deliveryAckSeq } : {}),
-            };
+            await runStatements(landingWrites(), []);
+            return registeredReply(agent);
         }
         catch (err) {
-            try {
-                if (createdAgent) {
-                    await tx
-                        .delete(agents)
-                        .where(and(eq(agents.workspaceId, workspaceId), eq(agents.id, agentId)));
-                }
+            // The reserve statement writes NULL into active_agents on a refused
+            // admission, aborting the group before the identity insert can run —
+            // nothing landed, so there is nothing to compensate.
+            if (databaseConstraintKind(err) === 'node_capacity') {
+                throw codedError(`Node "${node.name}" is at capacity`, 'node_capacity_exceeded', 409);
             }
-            finally {
-                if (reservedTargetSlot) {
-                    await releaseNodeAgentSlots(tx, workspaceId, [nodeId]);
+            // A batch is all-or-nothing, but its response is not: D1 can commit the
+            // admission group and then drop the reply, leaving the sink empty while
+            // the slot and identity are durable. A row bearing this freshly
+            // generated id can only have come from our own insert, so probe for it
+            // (with bounded transient retries) before deciding nothing landed —
+            // otherwise the committed agent strands the name behind a permanent
+            // agent_already_exists while leaking the slot it holds.
+            if (admissionResults.length === 0) {
+                let landed;
+                try {
+                    [landed] = await retryD1Write(() => db
+                        .select()
+                        .from(agents)
+                        .where(and(eq(agents.workspaceId, workspaceId), eq(agents.id, agentId)))
+                        .limit(1), 3);
+                }
+                catch {
+                    // Probe inconclusive — fall through and surface the original error.
                 }
+                if (landed) {
+                    try {
+                        await runStatements(landingWrites(), []);
+                        return registeredReply(landed);
+                    }
+                    catch (landingErr) {
+                        // The replayed landing can hit the same lost-reply ambiguity —
+                        // a committed landing leaves this agent's binding active on the
+                        // node, so probe it before deciding the outcome.
+                        let bound = false;
+                        try {
+                            const [row] = await retryD1Write(() => db
+                                .select({ id: agentNodeBindings.id })
+                                .from(agentNodeBindings)
+                                .where(and(eq(agentNodeBindings.workspaceId, workspaceId), eq(agentNodeBindings.agentId, agentId), eq(agentNodeBindings.nodeId, nodeId), eq(agentNodeBindings.status, 'active')))
+                                .limit(1), 3);
+                            bound = !!row;
+                        }
+                        catch {
+                            // Probe inconclusive — treat as not landed and roll back.
+                        }
+                        if (bound)
+                            return registeredReply(landed);
+                        // Landing never committed: roll the admitted identity back so a
+                        // retry registers cleanly instead of meeting agent_already_exists.
+                        await runStatements([
+                            tx
+                                .delete(agents)
+                                .where(and(eq(agents.workspaceId, workspaceId), eq(agents.id, agentId))),
+                            ...releaseNodeAgentSlotWrites(tx, workspaceId, [nodeId]),
+                        ], []);
+                        throw landingErr;
+                    }
+                }
+            }
+            const compensations = [];
+            if (admissionResults[1]?.[0]) {
+                compensations.push(tx
+                    .delete(agents)
+                    .where(and(eq(agents.workspaceId, workspaceId), eq(agents.id, agentId))));
+            }
+            if (admissionResults[0]?.[0]) {
+                compensations.push(...releaseNodeAgentSlotWrites(tx, workspaceId, [nodeId]));
             }
+            if (compensations.length > 0)
+                await runStatements(compensations, []);
             throw err;
         }
     });
-    if (message.auto_join_general !== false)
+    if (wantsAutoJoin)
         await invalidateChannelCache(workspaceId, 'general');
     return registered;
 }