crewx-agent-cli 0.2.3 → 0.2.5

package/dist/daemon.js

@@ -3,13 +3,17 @@ import { realpathSync } from "node:fs";
 import { hostname, platform, arch } from "node:os";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { runAdapter, verifyOpenClawRuntime, } from "./adapters.js";
-import { ApiError } from "./api.js";
-import { CLI_VERSION, MAX_EVENT_CONTENT_LENGTH } from "./constants.js";
-import { errorMessage, redactSecrets } from "./errors.js";
+import { ApiError, serializeOutboundEventBatch, } from "./api.js";
+import { CLI_VERSION, MAX_BUFFERED_EVENT_BYTES, MAX_BUFFERED_EVENTS, MAX_EVENT_BATCH_BYTES, MAX_EVENT_CONTENT_LENGTH, } from "./constants.js";
+import { CliError, errorMessage, redactSecrets } from "./errors.js";
 import { assemblePrompt, assignmentFromEvent } from "./prompt.js";
+import { startRuntimeCredentialProxy, } from "./runtime-proxy.js";
+import { DurableEventOutbox, agentEventOutboxPath, eventOutboxLockPath, } from "./outbox.js";
+import { AgentProcessLock, } from "./process-lock.js";
 const ASSIGNMENT_CONTROL_INTERVAL_MS = 5_000;
 const EVENT_RETRY_BASE_DELAY_MS = 2_000;
 const EVENT_RETRY_MAX_DELAY_MS = 30_000;
+const MAX_IDLE_POLL_DELAY_MS = 8_000;
 const MAX_RUNTIME_DIAGNOSTICS = 20;
 function timestamp() {
     return new Date().toISOString();
@@ -22,6 +26,19 @@ function event(type, payload) {
         occurred_at: timestamp(),
     };
 }
+function assignmentEvent(assignment, type, payload) {
+    return {
+        id: crypto.randomUUID(),
+        type,
+        payload: {
+            ...payload,
+            ...(assignment.claim_token
+                ? { claim_token: assignment.claim_token }
+                : {}),
+        },
+        occurred_at: timestamp(),
+    };
+}
 function truncate(value) {
     return value.length > MAX_EVENT_CONTENT_LENGTH
         ? `${value.slice(0, MAX_EVENT_CONTENT_LENGTH)}… [truncated]`
@@ -43,6 +60,50 @@ function record(value) {
 function nonEmptyString(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+function runtimeFailure(adapter, detail) {
+    if (adapter !== "openclaw") {
+        return { code: "runtime_exit_nonzero", message: detail };
+    }
+    if (/\b429\b|rate[ -]?limit|quota|too many requests|cool(?:ing)?[ -]?down/i.test(detail)) {
+        return {
+            code: "openclaw_provider_rate_limited",
+            message: `${detail} Check \`openclaw models status --agent <agent-id> --json\` for provider cooldowns, then retry after the provider limit resets.`,
+        };
+    }
+    if (/unauthori[sz]ed|\bauth\b|authentication|credential|oauth|invalid token|expired/i.test(detail)) {
+        return {
+            code: "openclaw_auth_failed",
+            message: `${detail} Run \`openclaw models auth --agent <agent-id> list --json\` and repair the selected provider credentials.`,
+        };
+    }
+    if (/model.+(?:not found|unknown|unavailable|not allowed)/i.test(detail)) {
+        return {
+            code: "openclaw_model_unavailable",
+            message: `${detail} Run \`openclaw models status --agent <agent-id> --json\` and select an available model.`,
+        };
+    }
+    return { code: "openclaw_runtime_failed", message: detail };
+}
+const OPENCLAW_DIAGNOSTIC_NOISE = /^\[openclaw\]\s+(?:Debug|Try|Help):/i;
+export function runtimeFailureDetail(adapter, stderr, exitCode) {
+    const lines = stderr.map((line) => line.trim()).filter(Boolean);
+    if (adapter === "openclaw") {
+        const reason = [...lines]
+            .reverse()
+            .find((line) => /^\[openclaw\]\s+Reason:/i.test(line));
+        if (reason) {
+            return reason.replace(/^\[openclaw\]\s+Reason:\s*/i, "").trim();
+        }
+        const actionable = [...lines]
+            .reverse()
+            .find((line) => !OPENCLAW_DIAGNOSTIC_NOISE.test(line));
+        if (actionable) {
+            return actionable.replace(/^\[openclaw\]\s*/i, "").trim();
+        }
+    }
+    return (lines.at(-1) ??
+        `${adapter} exited with code ${String(exitCode)}`);
+}
 function identifier(value) {
     if (typeof value === "number" && Number.isSafeInteger(value))
         return String(value);
@@ -130,7 +191,7 @@ export function assignmentWorkingDirectory(assignment, context, fallback, locked
     if (relativePath === ".." ||
         relativePath.startsWith(`..${sep}`) ||
         isAbsolute(relativePath)) {
-        throw new Error(`CrewX Bridge rejected assignment directory "${requested}" because it is outside the approved folder.`);
+        throw new Error("CrewX Bridge rejected the assignment directory because it is outside the approved folder.");
     }
     return canonicalCandidate;
 }
@@ -138,18 +199,65 @@ export class EventBuffer {
     api;
     sessionId;
     queue = [];
+    inFlight = new Set();
     flushing;
     retryNotBefore = 0;
     consecutiveFailures = 0;
-    constructor(api, sessionId) {
+    maxEvents;
+    maxBytes;
+    random;
+    durableSnapshot;
+    constructor(api, sessionId, options = {}) {
         this.api = api;
         this.sessionId = sessionId;
+        this.maxEvents = options.maxEvents ?? MAX_BUFFERED_EVENTS;
+        this.maxBytes = options.maxBytes ?? MAX_BUFFERED_EVENT_BYTES;
+        this.random = options.random ?? Math.random;
+        this.outbox = options.outbox;
+        if (this.outbox) {
+            this.queue.push(...this.outbox.load());
+            this.enforceBounds();
+        }
+        this.durableSnapshot = this.serializeDurableEvents();
     }
+    outbox;
     push(item) {
-        this.queue.push(item);
+        this.pushMany([item]);
+    }
+    pushMany(items) {
+        if (items.length === 0)
+            return;
+        const previous = [...this.queue];
+        try {
+            for (const item of items) {
+                if (!this.coalesce(item))
+                    this.queue.push(item);
+            }
+            this.enforceBounds();
+            this.persistDurableEvents();
+        }
+        catch (error) {
+            this.queue.splice(0, this.queue.length, ...previous);
+            throw error;
+        }
         if (this.queue.length >= 25)
             void this.flush().catch(() => undefined);
     }
+    pendingCount() {
+        return this.queue.length;
+    }
+    pendingBytes() {
+        return this.queue.reduce((total, item) => total + this.eventBytes(item), 0);
+    }
+    hasPendingTerminalOutcome(assignmentId) {
+        const isTerminalOutcome = (item) => item.type === "lifecycle" &&
+            item.payload.assignment_id === assignmentId &&
+            (item.payload.stage === "completed" ||
+                item.payload.stage === "failed" ||
+                item.payload.stage === "cancelled");
+        return (this.queue.some(isTerminalOutcome) ||
+            [...this.inFlight].some(isTerminalOutcome));
+    }
     async flush(signal) {
         if (this.flushing) {
             await this.flushing;
@@ -171,21 +279,143 @@ export class EventBuffer {
                 await sleep(retryDelay, signal);
             if (signal?.aborted)
                 return;
-            const batch = this.queue.slice(0, 100);
+            const batch = [];
+            for (const item of this.queue) {
+                if (batch.length >= 100) {
+                    break;
+                }
+                const candidate = [...batch, item];
+                const candidateBytes = Buffer.byteLength(serializeOutboundEventBatch(this.sessionId, candidate), "utf8");
+                if (candidateBytes > MAX_EVENT_BATCH_BYTES) {
+                    if (batch.length === 0) {
+                        throw new CliError(`CrewX cannot send event ${item.id ?? "(without an ID)"} because its exact serialized batch exceeds ${String(MAX_EVENT_BATCH_BYTES)} bytes.`, 1, { code: "event_batch_too_large" });
+                    }
+                    break;
+                }
+                batch.push(item);
+            }
+            for (const item of batch)
+                this.inFlight.add(item);
             try {
                 await this.api.sendEvents(this.sessionId, batch, signal);
-                this.queue.splice(0, batch.length);
+                const delivered = this.queue.splice(0, batch.length);
+                try {
+                    this.persistDurableEvents();
+                }
+                catch (error) {
+                    this.queue.unshift(...delivered);
+                    throw error;
+                }
                 this.consecutiveFailures = 0;
                 this.retryNotBefore = 0;
             }
             catch (error) {
                 this.consecutiveFailures += 1;
                 const exponentialDelay = Math.min(EVENT_RETRY_MAX_DELAY_MS, EVENT_RETRY_BASE_DELAY_MS * 2 ** (this.consecutiveFailures - 1));
+                const jitterDelay = Math.floor(this.random() * (exponentialDelay + 1));
                 const serverDelay = error instanceof ApiError ? error.retryAfterMs : undefined;
                 this.retryNotBefore =
-                    Date.now() + Math.max(exponentialDelay, serverDelay ?? 0);
+                    Date.now() + Math.max(jitterDelay, serverDelay ?? 0);
                 throw error;
             }
+            finally {
+                for (const item of batch)
+                    this.inFlight.delete(item);
+            }
+        }
+    }
+    coalesce(item) {
+        if (item.id) {
+            const duplicateIndex = this.findNewestIndex((candidate) => candidate.id === item.id);
+            if (duplicateIndex >= 0) {
+                this.queue[duplicateIndex] = item;
+                return true;
+            }
+        }
+        if (item.type === "heartbeat") {
+            const existingIndex = this.findNewestIndex((candidate) => candidate.type === "heartbeat");
+            if (existingIndex >= 0) {
+                this.queue[existingIndex] = item;
+                return true;
+            }
+        }
+        if (item.type === "output") {
+            const existingIndex = this.findNewestIndex((candidate) => candidate.type === "output" &&
+                candidate.payload.assignment_id === item.payload.assignment_id &&
+                candidate.payload.stream === item.payload.stream);
+            const existing = this.queue[existingIndex];
+            if (existingIndex >= 0 && existing?.type === "output") {
+                const combined = `${existing.payload.content}\n${item.payload.content}`;
+                const content = combined.length <= MAX_EVENT_CONTENT_LENGTH
+                    ? combined
+                    : `[earlier output omitted during backpressure]\n${combined.slice(-(MAX_EVENT_CONTENT_LENGTH - 47))}`;
+                this.queue[existingIndex] = {
+                    ...item,
+                    payload: {
+                        ...item.payload,
+                        content,
+                    },
+                };
+                return true;
+            }
+        }
+        return false;
+    }
+    findNewestIndex(predicate) {
+        for (let index = this.queue.length - 1; index >= 0; index -= 1) {
+            const candidate = this.queue[index];
+            if (candidate &&
+                !this.inFlight.has(candidate) &&
+                predicate(candidate)) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    eventPriority(item) {
+        if (item.type === "heartbeat" || item.type === "output")
+            return 0;
+        if (item.type === "error" ||
+            (item.type === "message" && item.payload.role === "assistant") ||
+            (item.type === "lifecycle" &&
+                ["completed", "failed", "cancelled", "stopped"].includes(item.payload.stage))) {
+            return 2;
+        }
+        return 1;
+    }
+    eventBytes(item) {
+        return Buffer.byteLength(JSON.stringify(item));
+    }
+    persistDurableEvents() {
+        if (!this.outbox)
+            return;
+        const durable = this.queue.filter((item) => this.eventPriority(item) === 2);
+        const snapshot = JSON.stringify(durable);
+        if (snapshot === this.durableSnapshot)
+            return;
+        this.outbox.replace(durable);
+        this.durableSnapshot = snapshot;
+    }
+    serializeDurableEvents() {
+        return JSON.stringify(this.queue.filter((item) => this.eventPriority(item) === 2));
+    }
+    enforceBounds() {
+        let bytes = this.pendingBytes();
+        while (this.queue.length > this.maxEvents ||
+            bytes > this.maxBytes) {
+            let removeIndex = -1;
+            for (const priority of [0, 1]) {
+                removeIndex = this.queue.findIndex((item) => !this.inFlight.has(item) &&
+                    this.eventPriority(item) === priority);
+                if (removeIndex >= 0)
+                    break;
+            }
+            if (removeIndex < 0) {
+                throw new CliError("CrewX cannot buffer another final agent outcome while event delivery is unavailable. Existing final outcomes were retained; restore connectivity before accepting more work.", 1, { code: "event_buffer_capacity_exceeded" });
+            }
+            const [removed] = this.queue.splice(removeIndex, 1);
+            if (removed)
+                bytes -= this.eventBytes(removed);
         }
     }
 }
@@ -202,6 +432,18 @@ function sleep(milliseconds, signal) {
         signal?.addEventListener("abort", finish, { once: true });
     });
 }
+export function adaptiveIdlePollDelay(baseDelayMs, consecutiveEmptyPolls, options = {}) {
+    const base = Math.max(250, Math.floor(baseDelayMs));
+    const maximum = Math.max(base, MAX_IDLE_POLL_DELAY_MS);
+    const exponent = Math.max(0, Math.min(8, consecutiveEmptyPolls - 1));
+    const cap = Math.min(maximum, base * 2 ** exponent);
+    const random = options.random ?? Math.random;
+    const jittered = cap <= base
+        ? base
+        : base +
+            Math.round(Math.max(0, Math.min(1, random())) * (cap - base));
+    return Math.max(jittered, options.retryAfterMs ?? 0);
+}
 function linkedAbortController(parent) {
     const controller = new AbortController();
     const abort = () => controller.abort(parent?.reason);
@@ -222,17 +464,24 @@ async function monitorAssignmentControl(options) {
     while (!options.isFinished() && !options.controller.signal.aborted) {
         let nextCheckDelay = ASSIGNMENT_CONTROL_INTERVAL_MS;
         try {
-            const control = await options.api.control(options.sessionId, options.assignmentId, options.controller.signal);
+            const control = await options.api.control(options.sessionId, options.assignmentId, options.controller.signal, options.assignmentEventCursor);
             if (control.cancelled) {
                 options.log(`CrewX cancelled ${options.assignmentId}; stopping the local agent…`);
                 options.controller.abort(new Error("Assignment cancelled by CrewX"));
-                return;
+                return undefined;
             }
             lastLoggedError = undefined;
         }
         catch (error) {
-            if (options.controller.signal.aborted || options.isFinished())
-                return;
+            if (options.controller.signal.aborted || options.isFinished()) {
+                return undefined;
+            }
+            if (error instanceof ApiError &&
+                (error.status === 401 || error.status === 403)) {
+                options.log("CrewX revoked this agent connection; stopping the local agent and daemon…");
+                options.controller.abort(error);
+                return error;
+            }
             const message = errorMessage(error);
             const now = Date.now();
             if (message !== lastLoggedError || now - lastErrorLoggedAt >= 30_000) {
@@ -246,38 +495,68 @@ async function monitorAssignmentControl(options) {
         }
         await sleep(nextCheckDelay, options.controller.signal);
     }
+    return undefined;
 }
 export async function executeAssignment(options) {
     const { assignment, events } = options;
-    const secrets = options.environment?.CREWX_TOKEN
-        ? [options.environment.CREWX_TOKEN]
-        : [];
+    const secrets = [
+        ...(options.environment?.CREWX_TOKEN
+            ? [options.environment.CREWX_TOKEN]
+            : []),
+        ...(assignment.claim_token ? [assignment.claim_token] : []),
+    ];
     const nativeJsonRuntime = !options.codingCommand &&
         (options.adapter === "codex" ||
             options.adapter === "claude" ||
             options.adapter === "pi");
     const runtimeDiagnostics = new Set();
-    events.push(event("lifecycle", {
+    const pendingRuntimeMessages = [];
+    let terminalizationStarted = false;
+    events.push(assignmentEvent(assignment, "lifecycle", {
         stage: "claimed",
         assignment_id: assignment.id,
         adapter: options.adapter,
     }));
-    events.push(event("message", {
+    events.push(assignmentEvent(assignment, "message", {
         assignment_id: assignment.id,
         role: "user",
         content: assignment.prompt,
     }));
-    events.push(event("lifecycle", {
+    events.push(assignmentEvent(assignment, "lifecycle", {
         stage: "started",
         assignment_id: assignment.id,
         adapter: options.adapter,
     }));
     await events.flush(options.signal);
+    let runtimeProxy;
     try {
         const agent = record(options.context.agent);
         const permissionPreset = agent?.permission_preset;
         const configuredModel = nonEmptyString(agent?.model);
         const runtimeAgentId = nonEmptyString(agent?.runtime_agent_id);
+        const upstreamToken = options.environment?.CREWX_TOKEN?.trim();
+        const cliPath = options.environment?.CREWX_CLI_PATH?.trim();
+        if (upstreamToken && cliPath) {
+            runtimeProxy = await startRuntimeCredentialProxy({
+                upstreamUrl: options.serverUrl,
+                upstreamToken,
+                cliPath,
+                assignmentId: assignment.id,
+                ...(assignment.claim_token
+                    ? { claimToken: assignment.claim_token }
+                    : {}),
+                ...(options.sessionId ? { sessionId: options.sessionId } : {}),
+                permissionPreset: permissionPreset === "read_only" ||
+                    permissionPreset === "standard" ||
+                    permissionPreset === "full_access"
+                    ? permissionPreset
+                    : "read_only",
+                chatOnly: agent?.chat_only === true,
+            });
+            const proxyToken = runtimeProxy.environment.CREWX_TOKEN;
+            if (proxyToken)
+                secrets.push(proxyToken);
+        }
         const result = await (options.runAgent ?? runAdapter)({
             adapter: options.adapter,
             prompt: assemblePrompt(assignment, options.context),
@@ -297,6 +576,9 @@ export async function executeAssignment(options) {
             },
             ...(options.codingCommand ? { codingCommand: options.codingCommand } : {}),
             ...(options.environment ? { environment: options.environment } : {}),
+            ...(runtimeProxy
+                ? { controlEnvironment: runtimeProxy.environment }
+                : {}),
             ...(options.signal ? { signal: options.signal } : {}),
             onStdout(line, parsed) {
                 if (nativeJsonRuntime) {
@@ -309,7 +591,7 @@ export async function executeAssignment(options) {
                         return;
                     }
                     runtimeDiagnostics.add(content);
-                    events.push(event("output", {
+                    events.push(assignmentEvent(assignment, "output", {
                         assignment_id: assignment.id,
                         stream: "stdout",
                         content,
@@ -318,7 +600,7 @@ export async function executeAssignment(options) {
                 }
                 const content = truncate(redactSecrets(line, secrets));
                 const raw = sanitizedRaw(parsed.raw, secrets);
-                events.push(event("output", {
+                events.push(assignmentEvent(assignment, "output", {
                     assignment_id: assignment.id,
                     stream: "stdout",
                     content,
@@ -330,14 +612,20 @@ export async function executeAssignment(options) {
                 }));
             },
             onMessage(message, role) {
-                events.push(event("message", {
+                const runtimeMessage = assignmentEvent(assignment, "message", {
                     assignment_id: assignment.id,
                     role,
                     content: truncate(redactSecrets(message, secrets)),
-                }));
+                });
+                if (role === "assistant" || role === "tool") {
+                    pendingRuntimeMessages.push(runtimeMessage);
+                }
+                else {
+                    events.push(runtimeMessage);
+                }
             },
             onStderr(line) {
-                events.push(event("output", {
+                events.push(assignmentEvent(assignment, "output", {
                     assignment_id: assignment.id,
                     stream: "stderr",
                     content: truncate(redactSecrets(line, secrets)),
@@ -345,55 +633,111 @@ export async function executeAssignment(options) {
             },
         });
         if (options.signal?.aborted) {
-            events.push(event("lifecycle", {
-                stage: "cancelled",
-                assignment_id: assignment.id,
-                adapter: options.adapter,
-            }));
+            terminalizationStarted = true;
+            events.pushMany([
+                ...pendingRuntimeMessages,
+                assignmentEvent(assignment, "lifecycle", {
+                    stage: "cancelled",
+                    assignment_id: assignment.id,
+                    adapter: options.adapter,
+                }),
+            ]);
         }
         else if (result.exitCode === 0) {
-            events.push(event("lifecycle", {
-                stage: "completed",
-                assignment_id: assignment.id,
-                adapter: options.adapter,
-                exit_code: result.exitCode,
-            }));
+            terminalizationStarted = true;
+            events.pushMany([
+                ...pendingRuntimeMessages,
+                assignmentEvent(assignment, "lifecycle", {
+                    stage: "completed",
+                    assignment_id: assignment.id,
+                    adapter: options.adapter,
+                    exit_code: result.exitCode,
+                }),
+            ]);
         }
         else {
-            const detail = result.stderr.at(-1) ??
-                `${options.adapter} exited with code ${String(result.exitCode)}`;
-            const safeDetail = redactSecrets(detail, secrets);
-            events.push(event("error", {
+            const detail = runtimeFailureDetail(options.adapter, result.stderr, result.exitCode);
+            const failure = runtimeFailure(options.adapter, detail);
+            const safeDetail = redactSecrets(failure.message, secrets);
+            if (options.adapter === "openclaw") {
+                options.log?.(`OpenClaw task ${assignment.id} failed: ${truncate(safeDetail)}`);
+            }
+            terminalizationStarted = true;
+            events.pushMany([
+                ...pendingRuntimeMessages,
+                assignmentEvent(assignment, "error", {
+                    assignment_id: assignment.id,
+                    message: truncate(safeDetail),
+                    code: failure.code,
+                    retryable: false,
+                }),
+                assignmentEvent(assignment, "lifecycle", {
+                    stage: "failed",
+                    assignment_id: assignment.id,
+                    adapter: options.adapter,
+                    exit_code: result.exitCode,
+                    detail: truncate(safeDetail),
+                }),
+            ]);
+        }
+    }
+    catch (error) {
+        if (terminalizationStarted)
+            throw error;
+        const message = truncate(redactSecrets(errorMessage(error), secrets));
+        if (options.adapter === "openclaw") {
+            options.log?.(`OpenClaw task ${assignment.id} failed: ${message}`);
+        }
+        terminalizationStarted = true;
+        events.pushMany([
+            ...pendingRuntimeMessages,
+            assignmentEvent(assignment, "error", {
                 assignment_id: assignment.id,
-                message: truncate(safeDetail),
+                message,
+                ...(error instanceof CliError && error.code
+                    ? { code: error.code }
+                    : {}),
                 retryable: false,
-            }));
-            events.push(event("lifecycle", {
-                stage: "failed",
+            }),
+            assignmentEvent(assignment, "lifecycle", {
+                stage: options.signal?.aborted ? "cancelled" : "failed",
                 assignment_id: assignment.id,
                 adapter: options.adapter,
-                exit_code: result.exitCode,
-                detail: truncate(safeDetail),
-            }));
-        }
+                detail: message,
+            }),
+        ]);
     }
-    catch (error) {
-        const message = truncate(redactSecrets(errorMessage(error), secrets));
-        events.push(event("error", {
-            assignment_id: assignment.id,
-            message,
-            retryable: false,
-        }));
-        events.push(event("lifecycle", {
-            stage: options.signal?.aborted ? "cancelled" : "failed",
-            assignment_id: assignment.id,
-            adapter: options.adapter,
-            detail: message,
-        }));
+    finally {
+        await runtimeProxy?.close();
     }
     await events.flush(options.signal?.aborted ? undefined : options.signal);
 }
 export async function runDaemon(options) {
+    const agentToken = options.environment?.CREWX_TOKEN?.trim();
+    const automaticOutboxPath = agentToken
+        ? agentEventOutboxPath(options.api.baseUrl, agentToken, options.adapter, options.environment)
+        : undefined;
+    const durablePath = options.outbox?.path ?? automaticOutboxPath;
+    const processLock = options.processLock ??
+        (durablePath
+            ? new AgentProcessLock(eventOutboxLockPath(durablePath))
+            : undefined);
+    // The lock precedes both session registration and outbox loading. This is
+    // intentionally wider than the network loop: two same-profile daemons must
+    // never hold independent cached snapshots of the same durable outcomes.
+    await processLock?.acquire();
+    try {
+        const durableOutbox = options.outbox ??
+            (automaticOutboxPath
+                ? new DurableEventOutbox(automaticOutboxPath)
+                : undefined);
+        await runOwnedDaemon(options, durableOutbox);
+    }
+    finally {
+        await processLock?.release();
+    }
+}
+async function runOwnedDaemon(options, durableOutbox) {
     const log = options.log ?? (() => undefined);
     const startedAt = Date.now();
     const session = await options.api.createSession({
@@ -409,14 +753,20 @@ export async function runDaemon(options) {
             cwd: options.cwd,
         },
     }, options.signal);
-    const events = new EventBuffer(options.api, session.session_id);
     let cursor = session.cursor;
     let activeAssignmentId;
+    let activeAssignmentClaimToken;
     let stopping = false;
     const seenAssignmentEvents = new Set();
     let workspaceContext = await options.api.context(session.session_id, options.signal);
+    const agent = record(workspaceContext.agent);
+    const events = new EventBuffer(options.api, session.session_id, {
+        ...(durableOutbox ? { outbox: durableOutbox } : {}),
+    });
+    // Reuse original event UUIDs against the new session so the server can
+    // idempotently acknowledge outcomes persisted before a crash or restart.
+    await events.flush(options.signal);
     if (options.adapter === "openclaw") {
-        const agent = record(workspaceContext.agent);
         const runtimeAgentId = nonEmptyString(agent?.runtime_agent_id);
         if (!runtimeAgentId) {
             throw new Error("CrewX did not provide an OpenClaw runtime agent ID for this profile.");
@@ -439,6 +789,9 @@ export async function runDaemon(options) {
         events.push(event("heartbeat", {
             status: activeAssignmentId ? "running" : stopping ? "stopping" : "idle",
             ...(activeAssignmentId ? { assignment_id: activeAssignmentId } : {}),
+            ...(activeAssignmentClaimToken
+                ? { claim_token: activeAssignmentClaimToken }
+                : {}),
             uptime_seconds: Math.floor((Date.now() - startedAt) / 1_000),
         }));
         void events
@@ -448,6 +801,8 @@ export async function runDaemon(options) {
     heartbeatTimer.unref();
     try {
         let polls = 0;
+        let consecutivePollFailures = 0;
+        let consecutiveEmptyPolls = 0;
         while (!options.signal?.aborted) {
             try {
                 // Never acknowledge a claimed page while its lifecycle/output batch is
@@ -455,7 +810,7 @@ export async function runDaemon(options) {
                 await events.flush(options.signal);
                 const requestedCursor = cursor;
                 const response = await options.api.poll(session.session_id, cursor, options.signal);
-                cursor = response.cursor;
+                consecutivePollFailures = 0;
                 polls += 1;
                 for (const inbound of response.events) {
                     const assignment = assignmentFromEvent(inbound);
@@ -469,49 +824,85 @@ export async function runDaemon(options) {
                         continue;
                     seenAssignmentEvents.add(executionKey);
                     activeAssignmentId = assignment.id;
+                    activeAssignmentClaimToken = assignment.claim_token;
                     log(`Running ${assignment.title ?? assignment.id}…`);
                     try {
-                        workspaceContext = await options.api.context(session.session_id, options.signal);
+                        try {
+                            workspaceContext = await options.api.context(session.session_id, options.signal);
+                        }
+                        catch (error) {
+                            log(`Context refresh failed; using the previous snapshot: ${errorMessage(error)}`);
+                        }
+                        const linked = linkedAbortController(options.signal);
+                        let assignmentFinished = false;
+                        const assignmentEventCursor = typeof assignment.metadata?.assignment_event_cursor === "number"
+                            ? assignment.metadata.assignment_event_cursor
+                            : undefined;
+                        const canMonitor = typeof options.api.control === "function" &&
+                            /^\d+$/.test(assignment.id);
+                        const monitor = canMonitor
+                            ? monitorAssignmentControl({
+                                api: options.api,
+                                sessionId: session.session_id,
+                                assignmentId: assignment.id,
+                                assignmentEventCursor,
+                                controller: linked.controller,
+                                isFinished: () => assignmentFinished,
+                                log,
+                            })
+                            : Promise.resolve(undefined);
+                        let fatalControlError;
+                        try {
+                            await (options.executeAssignment ?? executeAssignment)({
+                                assignment,
+                                adapter: options.adapter,
+                                cwd: assignmentWorkingDirectory(assignment, workspaceContext, options.cwd, options.lockedRoot ?? process.env.CREWX_BRIDGE_ROOT),
+                                context: workspaceContext,
+                                events,
+                                serverUrl: options.api.baseUrl,
+                                sessionId: session.session_id,
+                                ...(options.codingCommand
+                                    ? { codingCommand: options.codingCommand }
+                                    : {}),
+                                ...(options.environment
+                                    ? { environment: options.environment }
+                                    : {}),
+                                log,
+                                signal: linked.controller.signal,
+                            });
+                        }
+                        finally {
+                            assignmentFinished = true;
+                            linked.controller.abort();
+                            linked.detach();
+                            fatalControlError = await monitor;
+                        }
+                        if (fatalControlError)
+                            throw fatalControlError;
+                        await events.flush(options.signal);
                     }
                     catch (error) {
-                        log(`Context refresh failed; using the previous snapshot: ${errorMessage(error)}`);
-                    }
-                    const linked = linkedAbortController(options.signal);
-                    let assignmentFinished = false;
-                    const canMonitor = typeof options.api.control === "function" &&
-                        /^\d+$/.test(assignment.id);
-                    const monitor = canMonitor
-                        ? monitorAssignmentControl({
-                            api: options.api,
-                            sessionId: session.session_id,
-                            assignmentId: assignment.id,
-                            controller: linked.controller,
-                            isFinished: () => assignmentFinished,
-                            log,
-                        })
-                        : Promise.resolve();
-                    try {
-                        await (options.executeAssignment ?? executeAssignment)({
-                            assignment,
-                            adapter: options.adapter,
-                            cwd: assignmentWorkingDirectory(assignment, workspaceContext, options.cwd, options.lockedRoot ?? process.env.CREWX_BRIDGE_ROOT),
-                            context: workspaceContext,
-                            events,
-                            serverUrl: options.api.baseUrl,
-                            ...(options.codingCommand ? { codingCommand: options.codingCommand } : {}),
-                            ...(options.environment ? { environment: options.environment } : {}),
-                            signal: linked.controller.signal,
-                        });
+                        // A failed pre-run lifecycle flush means the runtime never
+                        // started. Leave the page unacknowledged and allow that event to
+                        // execute after delivery recovers. If a terminal outcome is
+                        // queued, retain the seen fence: the next loop first delivers
+                        // that durable outcome, then acknowledges the page without
+                        // executing the runtime twice.
+                        if (!events.hasPendingTerminalOutcome(assignment.id)) {
+                            seenAssignmentEvents.delete(executionKey);
+                        }
+                        throw error;
                     }
                     finally {
-                        assignmentFinished = true;
-                        linked.controller.abort();
-                        linked.detach();
-                        await monitor;
+                        activeAssignmentId = undefined;
+                        activeAssignmentClaimToken = undefined;
                     }
-                    await events.flush(options.signal);
-                    activeAssignmentId = undefined;
                 }
+                // Advancing the local cursor is the acknowledgement boundary. Do it
+                // only after every assignment on the page has a delivered terminal
+                // outcome (or was previously terminalized and fenced).
+                cursor = response.cursor;
+                seenAssignmentEvents.clear();
                 if (options.once && polls >= 1) {
                     if (String(cursor) !== String(requestedCursor)) {
                         // A final poll acknowledges the page that was just processed. Any
@@ -520,10 +911,21 @@ export async function runDaemon(options) {
                     }
                     break;
                 }
-                if (response.has_more)
+                if (response.has_more) {
+                    consecutiveEmptyPolls = 0;
                     continue;
+                }
+                consecutiveEmptyPolls =
+                    response.events.length === 0 ? consecutiveEmptyPolls + 1 : 0;
                 const serverDelay = response.retry_after_ms;
-                await sleep(serverDelay ?? options.pollIntervalMs, options.signal);
+                const pollDelay = consecutiveEmptyPolls > 0
+                    ? adaptiveIdlePollDelay(options.pollIntervalMs, consecutiveEmptyPolls, {
+                        ...(serverDelay !== undefined
+                            ? { retryAfterMs: serverDelay }
+                            : {}),
+                    })
+                    : Math.max(options.pollIntervalMs, serverDelay ?? 0);
+                await sleep(pollDelay, options.signal);
             }
             catch (error) {
                 if (options.signal?.aborted)
@@ -532,9 +934,12 @@ export async function runDaemon(options) {
                     throw error;
                 const message = redactSecrets(errorMessage(error), [options.api.token]);
                 log(`Polling failed: ${message}. Retrying…`);
-                events.push(event("error", { message, retryable: true }));
+                consecutivePollFailures += 1;
                 const serverDelay = error instanceof ApiError ? error.retryAfterMs : undefined;
-                await sleep(Math.max(options.pollIntervalMs, 2_000, serverDelay ?? 0), options.signal);
+                const retryCap = Math.min(EVENT_RETRY_MAX_DELAY_MS, Math.max(options.pollIntervalMs, EVENT_RETRY_BASE_DELAY_MS) *
+                    2 ** Math.min(8, consecutivePollFailures - 1));
+                const jitterDelay = Math.floor(Math.random() * (retryCap + 1));
+                await sleep(Math.max(250, jitterDelay, serverDelay ?? 0), options.signal);
             }
         }
     }