@love-moon/conductor-sdk 0.2.16 → 0.2.18

package/dist/client.js

@@ -1,10 +1,11 @@
 import crypto from 'node:crypto';
-import { BackendApiClient } from './backend/index.js';
+import { BackendApiClient, BackendApiError } from './backend/index.js';
 import { loadConfig } from './config/index.js';
 import { getPlanLimitMessageFromError } from './limits/index.js';
 import { MessageRouter } from './message/index.js';
+import { DownstreamCursorStore, DurableUpstreamOutboxStore, normalizeDownstreamCommandCursor, } from './outbox/index.js';
 import { SessionDiskStore, SessionManager, currentHostname } from './session/index.js';
-import { ConductorWebSocketClient } from './ws/index.js';
+import { ConductorWebSocketClient, } from './ws/index.js';
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 export class ConductorClient {
     config;
@@ -15,11 +16,15 @@ export class ConductorClient {
     sessions;
     sessionStore;
     messageRouter;
+    upstreamOutbox;
+    downstreamCursorStore;
     agentHost;
     onStopTask;
+    deliveryScopeId;
     closed = false;
-    pendingOutbound = new Map();
-    ACK_TIMEOUT_MS = 30000; // 30 seconds timeout for acknowledgment
+    durableOutboxFlushPromise = null;
+    durableOutboxTimer = null;
+    durableOutboxTimerDueAt = null;
     constructor(init) {
         this.config = init.config;
         this.env = init.env;
@@ -29,8 +34,11 @@ export class ConductorClient {
         this.sessions = init.sessionManager;
         this.sessionStore = init.sessionStore;
         this.messageRouter = init.messageRouter;
+        this.upstreamOutbox = init.upstreamOutbox;
+        this.downstreamCursorStore = init.downstreamCursorStore;
         this.agentHost = init.agentHost;
         this.onStopTask = init.onStopTask;
+        this.deliveryScopeId = init.deliveryScopeId;
         this.wsClient.registerHandler(this.handleBackendEvent);
     }
     static async connect(options = {}) {
@@ -42,29 +50,39 @@ export class ConductorClient {
         const sessionStore = options.sessionStore ?? SessionDiskStore.forBackendUrl(config.backendUrl);
         const messageRouter = options.messageRouter ?? new MessageRouter(sessions);
         const agentHost = resolveAgentHost(env, options.agentHost);
+        const deliveryScopeId = normalizeDeliveryScopeId(options.deliveryScopeId ?? `agent:${agentHost}`);
+        const upstreamOutbox = options.upstreamOutbox ?? DurableUpstreamOutboxStore.forProjectPath(projectPath, deliveryScopeId);
+        const downstreamCursorStore = options.downstreamCursorStore ?? DownstreamCursorStore.forProjectPath(projectPath, deliveryScopeId);
         const wsClient = options.wsClient ??
             new ConductorWebSocketClient(config, {
                 hostName: agentHost,
                 onConnected: options.onConnected,
                 onDisconnected: options.onDisconnected,
                 onReconnected: () => {
-                    // Resend pending confirmable messages after reconnection
-                    void client.flushPendingOutbound();
+                    if (client.shouldAutoFlushDurableOutbox()) {
+                        void client.requestDurableOutboxFlush(true);
+                    }
                 },
             });
         const client = new ConductorClient({
             config,
             env,
             projectPath,
+            deliveryScopeId,
             backendApi,
             wsClient,
             sessionManager: sessions,
             sessionStore,
             messageRouter,
+            upstreamOutbox,
+            downstreamCursorStore,
             agentHost,
             onStopTask: options.onStopTask,
         });
         await client.wsClient.connect();
+        if (client.shouldAutoFlushDurableOutbox()) {
+            void client.requestDurableOutboxFlush(true);
+        }
         return client;
     }
     async close() {
@@ -72,6 +90,7 @@ export class ConductorClient {
             return;
         }
         this.closed = true;
+        this.clearDurableOutboxTimer();
         await this.wsClient.disconnect();
     }
     async createTaskSession(payload) {
@@ -112,6 +131,7 @@ export class ConductorClient {
                 id: taskId,
                 projectId,
                 title,
+                status: 'running',
                 backendType,
                 sessionId: logicalSessionId,
                 sessionFilePath: explicitSessionFilePath,
@@ -132,6 +152,7 @@ export class ConductorClient {
             throw error;
         }
         await this.waitForTaskCreation(projectId, taskId);
+        this.promoteTaskDeliveryScope(taskId);
         const projectPath = typeof payload.project_path === 'string' && payload.project_path
             ? payload.project_path
             : this.projectPath;
@@ -152,25 +173,31 @@ export class ConductorClient {
     }
     async sendMessage(taskId, content, metadata) {
         const messageId = safeRandomUuid();
-        const payload = {
-            task_id: taskId,
-            content,
-            metadata,
-            message_id: messageId,
-        };
-        await this.sendConfirmable('sdk_message', payload, messageId);
-        return { delivered: true, message_id: messageId };
+        const result = await this.persistAndCommitUpstreamEvent({
+            stableId: messageId,
+            eventType: 'sdk_message',
+            payload: {
+                taskId,
+                content,
+                metadata,
+                messageId,
+            },
+        });
+        return { ...result, message_id: messageId };
     }
     async sendTaskStatus(taskId, payload) {
-        await this.sendEnvelope({
-            type: 'task_status_update',
+        const statusEventId = safeRandomUuid();
+        const result = await this.persistAndCommitUpstreamEvent({
+            stableId: statusEventId,
+            eventType: 'task_status_update',
             payload: {
-                task_id: taskId,
+                taskId,
                 status: payload?.status,
                 summary: payload?.summary,
+                statusEventId,
             },
         });
-        return { delivered: true };
+        return { ...result, status_event_id: statusEventId };
     }
     async sendRuntimeStatus(taskId, payload) {
         await this.sendEnvelope({
@@ -199,6 +226,13 @@ export class ConductorClient {
         return { delivered: true };
     }
     async sendAgentResume(payload = {}) {
+        const storedCursor = this.downstreamCursorStore.get(this.agentHost);
+        const lastAppliedCursor = payload.last_applied_cursor ?? (storedCursor
+            ? {
+                created_at: storedCursor.createdAt,
+                request_id: storedCursor.requestId,
+            }
+            : undefined);
         await this.sendEnvelope({
             type: 'agent_resume',
             payload: {
@@ -207,6 +241,7 @@ export class ConductorClient {
                     : [],
                 source: payload.source,
                 metadata: payload.metadata,
+                last_applied_cursor: lastAppliedCursor,
             },
         });
         return { delivered: true };
@@ -222,8 +257,17 @@ export class ConductorClient {
             event_type: payload.event_type,
             accepted: payload.accepted !== false,
         };
-        await this.sendConfirmable('agent_command_ack', envelopePayload, requestId);
-        return { delivered: true, request_id: requestId };
+        const result = await this.persistAndCommitUpstreamEvent({
+            stableId: requestId,
+            eventType: 'agent_command_ack',
+            payload: {
+                requestId,
+                taskId: envelopePayload.task_id,
+                commandEventType: envelopePayload.event_type,
+                accepted: envelopePayload.accepted,
+            },
+        });
+        return { ...result, request_id: requestId };
     }
     async sendTaskStopAck(payload) {
         const taskId = String(payload.task_id || '').trim();
@@ -234,15 +278,16 @@ export class ConductorClient {
         if (!requestId) {
             throw new Error('request_id is required');
         }
-        await this.sendEnvelope({
-            type: 'task_stop_ack',
+        const result = await this.persistAndCommitUpstreamEvent({
+            stableId: requestId,
+            eventType: 'task_stop_ack',
             payload: {
-                task_id: taskId,
-                request_id: requestId,
+                taskId,
+                requestId,
                 accepted: payload.accepted !== false,
             },
         });
-        return { delivered: true };
+        return { ...result, request_id: requestId, task_id: taskId };
     }
     async receiveMessages(taskId, limit = 20) {
         const messages = await this.sessions.popMessages(taskId, limit);
@@ -330,6 +375,7 @@ export class ConductorClient {
         if (!normalizedTaskId) {
             throw new Error('task_id is required');
         }
+        this.promoteTaskDeliveryScope(normalizedTaskId);
         const existing = this.sessionStore.findByTaskId(normalizedTaskId);
         const inMemorySession = await this.sessions.getSession(normalizedTaskId);
         const projectId = existing?.projectId ||
@@ -422,142 +468,270 @@ export class ConductorClient {
         };
     }
     handleBackendEvent = async (payload) => {
-        // First handle acknowledgments for confirmable outbound messages
-        this.handleAcknowledgment(payload);
-        const stopCommandAccepted = await this.handleStopTaskEvent(payload);
-        await this.messageRouter.handleBackendEvent(payload);
+        const command = this.extractDownstreamCommandContext(payload);
+        if (command?.eventType === 'stop_task') {
+            await this.handleStopTaskCommand(payload, command);
+            return;
+        }
+        const alreadyApplied = command ? this.downstreamCursorStore.hasApplied(this.agentHost, command.cursor) : false;
+        if (!alreadyApplied) {
+            await this.messageRouter.handleBackendEvent(payload);
+            if (command) {
+                this.downstreamCursorStore.advance(this.agentHost, command.cursor);
+            }
+        }
         await this.maybeAckInboundCommand(payload, {
-            accepted: typeof stopCommandAccepted === 'boolean'
-                ? stopCommandAccepted
-                : undefined,
+            accepted: true,
         });
     };
-    /**
-     * Handle acknowledgment messages from backend for confirmable outbound messages
-     */
-    handleAcknowledgment(payload) {
+    extractDownstreamCommandContext(payload) {
         const eventType = typeof payload?.type === 'string' ? payload.type : '';
+        if (eventType !== 'task_user_message' && eventType !== 'task_action' && eventType !== 'stop_task') {
+            return null;
+        }
         const data = payload?.payload && typeof payload.payload === 'object'
             ? payload.payload
             : null;
-        if (!data)
-            return;
-        if (eventType === 'message_recorded') {
-            // Acknowledgment for sdk_message
-            const messageId = typeof data.message_id === 'string' ? data.message_id : null;
-            if (messageId && this.pendingOutbound.has(messageId)) {
-                const pending = this.pendingOutbound.get(messageId);
-                if (pending.type === 'sdk_message') {
-                    this.pendingOutbound.delete(messageId);
-                    pending.resolve();
-                }
+        if (!data) {
+            return null;
+        }
+        const taskId = typeof data.task_id === 'string' ? data.task_id.trim() : '';
+        const requestId = typeof data.request_id === 'string' ? data.request_id.trim() : '';
+        const cursor = normalizeDownstreamCommandCursor(data.delivery_cursor);
+        if (!taskId || !requestId || !cursor) {
+            return null;
+        }
+        return {
+            eventType,
+            taskId,
+            requestId,
+            cursor,
+        };
+    }
+    async handleStopTaskCommand(payload, command) {
+        const alreadyApplied = this.downstreamCursorStore.hasApplied(this.agentHost, command.cursor);
+        let accepted = false;
+        if (alreadyApplied) {
+            accepted = true;
+        }
+        else {
+            accepted = await this.invokeStopTaskHandler(payload);
+            if (accepted) {
+                this.downstreamCursorStore.advance(this.agentHost, command.cursor);
             }
         }
-        else if (eventType === 'agent_command_ack_recorded') {
-            // Acknowledgment for agent_command_ack
-            const requestId = typeof data.request_id === 'string' ? data.request_id : null;
-            if (requestId && this.pendingOutbound.has(requestId)) {
-                const pending = this.pendingOutbound.get(requestId);
-                if (pending.type === 'agent_command_ack') {
-                    this.pendingOutbound.delete(requestId);
-                    pending.resolve();
-                }
+        if (!command.requestId) {
+            return;
+        }
+        try {
+            await this.sendTaskStopAck({
+                task_id: command.taskId,
+                request_id: command.requestId,
+                accepted,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[sdk] failed to send task_stop_ack for task ${command.taskId}: ${message}`);
+        }
+    }
+    async invokeStopTaskHandler(payload) {
+        const data = payload?.payload && typeof payload.payload === 'object'
+            ? payload.payload
+            : null;
+        if (!data) {
+            return false;
+        }
+        const taskId = typeof data.task_id === 'string' ? data.task_id.trim() : '';
+        const requestId = typeof data.request_id === 'string' ? data.request_id.trim() : '';
+        const reason = typeof data.reason === 'string' ? data.reason.trim() : '';
+        if (!taskId) {
+            return false;
+        }
+        if (!this.onStopTask) {
+            return false;
+        }
+        try {
+            await this.onStopTask({
+                taskId,
+                requestId: requestId || undefined,
+                reason: reason || undefined,
+            });
+            return true;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[sdk] stop_task callback failed for task ${taskId}: ${message}`);
+            return false;
+        }
+    }
+    async persistAndCommitUpstreamEvent(entry) {
+        const stored = this.upstreamOutbox.upsert(entry);
+        if (stored.eventType === 'sdk_message' && this.hasEarlierPendingSdkMessage(stored.stableId)) {
+            this.scheduleDurableOutboxFlush(0);
+            return { delivered: false, pending: true };
+        }
+        try {
+            await this.commitDurableUpstreamEvent(stored);
+            this.upstreamOutbox.remove(stored.stableId);
+            return { delivered: true };
+        }
+        catch (error) {
+            if (!this.isRetryableUpstreamError(error)) {
+                this.upstreamOutbox.remove(stored.stableId);
+                throw error;
             }
+            const updated = this.upstreamOutbox.markRetry(stored.stableId, this.computeDurableOutboxRetryDelay(stored.attemptCount + 1));
+            const delay = updated?.nextAttemptAt
+                ? Math.max(Date.parse(updated.nextAttemptAt) - Date.now(), 0)
+                : this.computeDurableOutboxRetryDelay(stored.attemptCount + 1);
+            console.warn(`[sdk] queued ${stored.eventType} (${stored.stableId}) for durable retry after HTTP failure: ${error instanceof Error ? error.message : String(error)}`);
+            this.scheduleDurableOutboxFlush(delay);
+            return { delivered: false, pending: true };
         }
     }
-    /**
-     * Send a confirmable message and wait for acknowledgment from backend.
-     * Implements reliable delivery with idempotency.
-     */
-    async sendConfirmable(type, payload, stableId) {
-        // Check if there's already a pending message with this stableId
-        const existingPending = this.pendingOutbound.get(stableId);
-        if (existingPending) {
-            // Return the existing promise to deduplicate in-flight requests
-            return new Promise((resolve, reject) => {
-                const checkResolved = () => {
-                    if (!this.pendingOutbound.has(stableId)) {
-                        resolve();
-                        return;
+    async requestDurableOutboxFlush(force = false) {
+        if (this.closed) {
+            return;
+        }
+        if (this.durableOutboxFlushPromise) {
+            return this.durableOutboxFlushPromise;
+        }
+        this.durableOutboxFlushPromise = (async () => {
+            const readyEntries = force ? this.upstreamOutbox.load() : this.upstreamOutbox.listReady();
+            let sdkMessageBlocked = false;
+            for (const entry of readyEntries) {
+                if (this.closed) {
+                    break;
+                }
+                if (sdkMessageBlocked && entry.eventType === 'sdk_message') {
+                    continue;
+                }
+                try {
+                    await this.commitDurableUpstreamEvent(entry);
+                    this.upstreamOutbox.remove(entry.stableId);
+                }
+                catch (error) {
+                    if (!this.isRetryableUpstreamError(error)) {
+                        this.upstreamOutbox.remove(entry.stableId);
+                        console.warn(`[sdk] dropping durable upstream event ${entry.eventType} (${entry.stableId}) after terminal HTTP failure: ${error instanceof Error ? error.message : String(error)}`);
+                        continue;
                     }
-                    const pending = this.pendingOutbound.get(stableId);
-                    if (pending.retryCount > 100) { // Safety limit
-                        reject(new Error(`Message ${stableId} exceeded max retry attempts`));
-                        return;
+                    const updated = this.upstreamOutbox.markRetry(entry.stableId, this.computeDurableOutboxRetryDelay(entry.attemptCount + 1));
+                    console.warn(`[sdk] durable retry failed for ${entry.eventType} (${entry.stableId}): ${error instanceof Error ? error.message : String(error)}`);
+                    if (entry.eventType === 'sdk_message') {
+                        sdkMessageBlocked = true;
+                    }
+                    if (updated?.nextAttemptAt) {
+                        this.scheduleDurableOutboxFlush(Math.max(Date.parse(updated.nextAttemptAt) - Date.now(), 0));
                     }
-                    setTimeout(checkResolved, 100);
-                };
-                checkResolved();
-            });
-        }
-        return new Promise((resolve, reject) => {
-            const now = Date.now();
-            const pendingMessage = {
-                type,
-                payload,
-                stableId,
-                firstSentAt: now,
-                lastSentAt: now,
-                retryCount: 0,
-                resolve,
-                reject,
-            };
-            this.pendingOutbound.set(stableId, pendingMessage);
-            // Send the message
-            void this.doSendConfirmable(stableId);
-            // Set timeout for acknowledgment
-            setTimeout(() => {
-                if (this.pendingOutbound.has(stableId)) {
-                    this.pendingOutbound.delete(stableId);
-                    reject(new Error(`Timeout waiting for acknowledgment of ${type} (${stableId})`));
                 }
-            }, this.ACK_TIMEOUT_MS);
+            }
+            const nextDelay = this.upstreamOutbox.nextRetryDelay();
+            if (nextDelay !== null) {
+                this.scheduleDurableOutboxFlush(nextDelay);
+            }
+        })().finally(() => {
+            this.durableOutboxFlushPromise = null;
         });
+        return this.durableOutboxFlushPromise;
     }
-    /**
-     * Actually send a confirmable message over websocket.
-     * Called initially and on reconnection.
-     */
-    async doSendConfirmable(stableId) {
-        const pending = this.pendingOutbound.get(stableId);
-        if (!pending)
-            return; // Already acknowledged or timed out
-        try {
-            await this.sendEnvelope({
-                type: pending.type,
-                payload: pending.payload,
+    hasEarlierPendingSdkMessage(stableId) {
+        const entries = this.upstreamOutbox.load();
+        const currentIndex = entries.findIndex((candidate) => candidate.stableId === stableId);
+        if (currentIndex <= 0) {
+            return false;
+        }
+        return entries.slice(0, currentIndex).some((candidate) => candidate.eventType === 'sdk_message');
+    }
+    async commitDurableUpstreamEvent(entry) {
+        if (entry.eventType === 'sdk_message') {
+            await this.backendApi.commitSdkMessage({
+                agentHost: this.agentHost,
+                taskId: String(entry.payload.taskId || ''),
+                content: String(entry.payload.content || ''),
+                metadata: entry.payload.metadata && typeof entry.payload.metadata === 'object' && !Array.isArray(entry.payload.metadata)
+                    ? entry.payload.metadata
+                    : undefined,
+                messageId: entry.payload.messageId ? String(entry.payload.messageId) : null,
             });
-            pending.lastSentAt = Date.now();
-            pending.retryCount++;
+            return;
         }
-        catch (error) {
-            // Send failed - message remains in pending queue for retry on reconnection
-            console.warn(`[sdk] Failed to send ${pending.type} (${stableId}): ${error instanceof Error ? error.message : String(error)}`);
+        if (entry.eventType === 'task_status_update') {
+            await this.backendApi.commitTaskStatusUpdate({
+                agentHost: this.agentHost,
+                taskId: String(entry.payload.taskId || ''),
+                status: String(entry.payload.status || ''),
+                summary: entry.payload.summary ? String(entry.payload.summary) : null,
+                statusEventId: entry.payload.statusEventId ? String(entry.payload.statusEventId) : null,
+            });
+            return;
         }
-    }
-    /**
-     * Flush all pending confirmable messages.
-     * Called after websocket reconnection.
-     */
-    async flushPendingOutbound() {
-        if (this.pendingOutbound.size === 0)
+        if (entry.eventType === 'task_stop_ack') {
+            await this.backendApi.commitTaskStopAck({
+                agentHost: this.agentHost,
+                taskId: String(entry.payload.taskId || ''),
+                requestId: String(entry.payload.requestId || ''),
+                accepted: entry.payload.accepted !== false,
+            });
             return;
-        console.log(`[sdk] Flushing ${this.pendingOutbound.size} pending confirmable messages after reconnection`);
-        const promises = [];
-        for (const [stableId, pending] of this.pendingOutbound) {
-            promises.push(this.doSendConfirmable(stableId));
-        }
-        // Wait for all sends to complete (but not for acknowledgments)
-        await Promise.all(promises).catch(() => {
-            // Errors are logged in doSendConfirmable, messages remain pending
+        }
+        await this.backendApi.commitAgentCommandAck({
+            agentHost: this.agentHost,
+            requestId: String(entry.payload.requestId || ''),
+            taskId: entry.payload.taskId ? String(entry.payload.taskId) : null,
+            accepted: entry.payload.accepted !== false,
+            commandEventType: entry.payload.commandEventType ? String(entry.payload.commandEventType) : null,
         });
     }
+    isRetryableUpstreamError(error) {
+        if (!(error instanceof BackendApiError)) {
+            return true;
+        }
+        if (error.statusCode === undefined || error.statusCode === null) {
+            return true;
+        }
+        if (error.statusCode >= 500) {
+            return true;
+        }
+        return error.statusCode === 408 || error.statusCode === 429;
+    }
+    computeDurableOutboxRetryDelay(attemptCount) {
+        const cappedExponent = Math.max(0, Math.min(attemptCount - 1, 5));
+        return 1_000 * 2 ** cappedExponent;
+    }
+    scheduleDurableOutboxFlush(delayMs) {
+        if (this.closed) {
+            return;
+        }
+        const normalizedDelay = Math.max(delayMs, 0);
+        const dueAt = Date.now() + normalizedDelay;
+        if (this.durableOutboxTimer &&
+            this.durableOutboxTimerDueAt !== null &&
+            this.durableOutboxTimerDueAt <= dueAt) {
+            return;
+        }
+        this.clearDurableOutboxTimer();
+        this.durableOutboxTimerDueAt = dueAt;
+        this.durableOutboxTimer = setTimeout(() => {
+            this.durableOutboxTimer = null;
+            this.durableOutboxTimerDueAt = null;
+            void this.requestDurableOutboxFlush(false);
+        }, normalizedDelay);
+    }
+    clearDurableOutboxTimer() {
+        if (this.durableOutboxTimer) {
+            clearTimeout(this.durableOutboxTimer);
+            this.durableOutboxTimer = null;
+        }
+        this.durableOutboxTimerDueAt = null;
+    }
     async sendEnvelope(envelope) {
         await this.wsClient.sendJson(envelope);
     }
     async maybeAckInboundCommand(payload, options = {}) {
         const eventType = typeof payload?.type === 'string' ? payload.type : '';
-        if (eventType !== 'task_user_message' && eventType !== 'task_action' && eventType !== 'stop_task') {
+        if (eventType !== 'task_user_message' && eventType !== 'task_action') {
             return;
         }
         const data = payload?.payload && typeof payload.payload === 'object'
@@ -583,51 +757,41 @@ export class ConductorClient {
             console.warn(`[sdk] failed to ack inbound command ${requestId}: ${message}`);
         }
     }
-    async handleStopTaskEvent(payload) {
-        if (typeof payload?.type !== 'string' || payload.type !== 'stop_task') {
-            return undefined;
-        }
-        const data = payload?.payload && typeof payload.payload === 'object'
-            ? payload.payload
-            : null;
-        if (!data) {
-            return false;
+    promoteTaskDeliveryScope(taskId) {
+        const normalizedTaskId = String(taskId || '').trim();
+        if (!normalizedTaskId) {
+            return;
         }
-        const taskId = typeof data.task_id === 'string' ? data.task_id.trim() : '';
-        const requestId = typeof data.request_id === 'string' ? data.request_id.trim() : '';
-        const reason = typeof data.reason === 'string' ? data.reason.trim() : '';
-        if (!taskId) {
-            return false;
+        this.setDeliveryScopeId(`task:${normalizedTaskId}`);
+    }
+    setDeliveryScopeId(scopeId) {
+        const nextScopeId = normalizeDeliveryScopeId(scopeId);
+        if (nextScopeId === this.deliveryScopeId) {
+            return;
         }
-        let accepted = false;
-        if (this.onStopTask) {
-            try {
-                await this.onStopTask({
-                    taskId,
-                    requestId: requestId || undefined,
-                    reason: reason || undefined,
-                });
-                accepted = true;
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                console.warn(`[sdk] stop_task callback failed for task ${taskId}: ${message}`);
-            }
+        const currentUpstream = this.upstreamOutbox;
+        const currentCursorStore = this.downstreamCursorStore;
+        const nextUpstream = DurableUpstreamOutboxStore.forProjectPath(this.projectPath, nextScopeId);
+        const nextCursorStore = DownstreamCursorStore.forProjectPath(this.projectPath, nextScopeId);
+        for (const entry of currentUpstream.load()) {
+            nextUpstream.upsert({
+                stableId: entry.stableId,
+                eventType: entry.eventType,
+                payload: entry.payload,
+            });
+            currentUpstream.remove(entry.stableId);
         }
-        if (requestId) {
-            try {
-                await this.sendTaskStopAck({
-                    task_id: taskId,
-                    request_id: requestId,
-                    accepted,
-                });
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                console.warn(`[sdk] failed to send task_stop_ack for task ${taskId}: ${message}`);
-            }
+        const currentCursor = currentCursorStore.get(this.agentHost);
+        if (currentCursor && !nextCursorStore.get(this.agentHost)) {
+            nextCursorStore.advance(this.agentHost, currentCursor);
         }
-        return accepted;
+        this.upstreamOutbox = nextUpstream;
+        this.downstreamCursorStore = nextCursorStore;
+        this.deliveryScopeId = nextScopeId;
+        void this.requestDurableOutboxFlush(true);
+    }
+    shouldAutoFlushDurableOutbox() {
+        return this.deliveryScopeId.startsWith('task:') || this.deliveryScopeId.startsWith('session:');
     }
     resolveHostname() {
         const records = this.sessionStore.load();
@@ -678,6 +842,8 @@ function formatMessagesResponse(messages) {
             role: msg.role,
             content: msg.content,
             ack_token: msg.ackToken,
+            metadata: msg.metadata ?? undefined,
+            attachments: msg.attachments?.length ? msg.attachments : undefined,
             created_at: msg.createdAt.toISOString(),
         })),
         next_ack_token: messages.length ? messages[messages.length - 1].ackToken ?? null : null,
@@ -706,3 +872,7 @@ function resolveAgentHost(env, explicit) {
     const host = env.HOSTNAME || env.COMPUTERNAME || 'unknown-host';
     return `conductor-fire-${host}-${pid}`;
 }
+function normalizeDeliveryScopeId(scopeId) {
+    const normalized = String(scopeId || '').trim();
+    return normalized || 'default';
+}