@amaster.ai/dsh-a2a 0.1.26 → 0.1.28

package/lib/inbox.js

@@ -5,48 +5,6 @@ import { AgentEvent, ServerCallContext, STATE_HEADERS_KEY, } from '@a2a-js/sdk/s
 import { createUserMessage } from '@deepseek-ai/dsh-llm/message';
 import { agentTextMessage, SessionTranslator, terminalStatusUpdate } from './translator.js';
 export const INBOX_EXTENSION = 'https://github.com/TGYD-helige/dsh-plugins/blob/main/docs/protocol/inbox-v1.md';
-/** Fold native input mutations; a claimed input is recoverable only before user/message. */
-export function recoverInbox(events) {
-    const pending = new Map();
-    const lists = { 'next-step': [], 'next-turn': [] };
-    let paused = false;
-    let claimed = new Set();
-    const committed = new Set();
-    for (const event of events) {
-        if (event.type === 'agent/inbox/paused')
-            paused = event.data.paused;
-        else if (event.type === 'turn/start') {
-            claimed = new Set();
-        }
-        else if (event.type === 'turn/end') {
-            if (!paused &&
-                (event.data.reason.kind === 'error' ||
-                    event.data.reason.kind === 'blocked' ||
-                    (event.data.reason.kind === 'aborted' && event.data.reason.reason.kind !== 'disposed')))
-                for (const id of claimed)
-                    pending.delete(id);
-        }
-        else if (event.type === 'agent/inbox/spliced') {
-            const { target, start, removedCount = 0, inserted, outcome } = event.data;
-            const removed = lists[target].splice(start, removedCount, ...inserted);
-            for (const message of removed) {
-                if (outcome === 'canceled')
-                    pending.delete(message.id);
-                else
-                    claimed.add(message.id);
-            }
-            for (const message of inserted)
-                if (message.source.kind === 'a2a')
-                    pending.set(message.id, message);
-        }
-        else if (event.type === 'user/message') {
-            pending.delete(event.data.id);
-            if (event.data.source.kind === 'a2a')
-                committed.add(event.data.source.taskId);
-        }
-    }
-    return { paused, pending: [...pending.values()], committed };
-}
 export class NativeInbox {
     ctx;
     bridge;
@@ -55,17 +13,65 @@ export class NativeInbox {
     resolving = new Map();
     stopping = false;
     shutdownPromise;
-    waking = new Map();
     preadmitted = new WeakMap();
     server;
     constructor(ctx, bridge, store) {
         this.ctx = ctx;
         this.bridge = bridge;
         this.store = store;
-        if (ctx.agents.nativeInboxVersion !== 1)
-            throw new Error('Native inbox requires a DSH factory with nativeInboxVersion 1. Upgrade DSH before enabling inbox.enabled.');
         bridge.inbox = this;
-        ctx.on('agent/before-assembly', (detail) => this.prepare(detail));
+        ctx.on('agent/pre-step', async (detail, next) => {
+            await this.prepare(detail);
+            return next();
+        });
+        ctx.on('goal/changed', ({ agent, change }) => {
+            const run = this.contexts.get(agent.session.id);
+            if (!run)
+                return;
+            const previous = run.goalOwner;
+            if (change.goal?.phase === 'active' && change.goal.activation === 'armed') {
+                const task = previous?.goalId === change.ref.id ? previous.task : run.active;
+                if (task && !task.settled)
+                    run.goalOwner = { goalId: change.ref.id, task };
+            }
+            else
+                run.goalOwner = undefined;
+            if (previous)
+                this.settle(run, previous.task);
+        });
+        ctx.on('agent/status', ({ agent, status }) => {
+            const run = this.contexts.get(agent.session.id);
+            if (status !== 'idle' || !run?.goalOwner)
+                return;
+            const { task } = run.goalOwner;
+            try {
+                const goal = ctx.get('goals')?.get(agent);
+                if (goal?.phase === 'active' && goal.activation === 'armed')
+                    return;
+                run.goalOwner = undefined;
+                this.settle(run, task);
+            }
+            catch (error) {
+                run.goalOwner = undefined;
+                this.fail(task, agent.session.id, error);
+            }
+        });
+        ctx.on('agent/inbox/claimed', ({ agent, message, turn }) => {
+            const run = this.contexts.get(agent.session.id);
+            if (!run)
+                return;
+            const task = this.owner(run, message);
+            if (task && !task.settled) {
+                run.claimed.add(task);
+                if (!run.active)
+                    this.select(run, task);
+                if (run.active === task) {
+                    const selectedAt = Date.now();
+                    task.selectedAt.set(message.id, selectedAt);
+                    this.observeInput('selected', run, message, { selectedAt, turn });
+                }
+            }
+        });
     }
     content(message, contextId) {
         return this.bridge.buildContent(message, contextId);
@@ -85,9 +91,7 @@ export class NativeInbox {
             const admitted = { ...message, taskId, contextId: run.entry.sessionId };
             task.pendingRequests++;
             try {
-                await this.admit(run, task, admitted, task.context, options.target ?? 'next-turn');
-                if (options.wakeup !== false && !run.paused)
-                    await this.wake(run.entry.sessionId, { context: task.context });
+                await this.admit(run, task, admitted, task.context, options.target ?? 'next-turn', options.wakeup !== false);
             }
             finally {
                 task.pendingRequests--;
@@ -97,7 +101,182 @@ export class NativeInbox {
         }
         throw new Error('Host input must address a live A2A task.');
     }
-    context(contextId) {
+    // A non-canceled removal keeps an interrupted move distinguishable from explicit cancellation.
+    moveInput(agent, message, target) {
+        const from = target === 'next-step' ? 'next-turn' : 'next-step';
+        const items = from === 'next-turn' ? agent.inbox.nextTurn : agent.inbox.nextStep;
+        const index = items.findIndex((item) => item.id === message.id);
+        if (index < 0)
+            throw new Error('Queued input has already been claimed.');
+        agent.session.append('agent/inbox/spliced', {
+            target: from,
+            start: index,
+            removedCount: 1,
+            inserted: [],
+        });
+        agent.inbox.append(target, message);
+    }
+    async promote(contextId, messageId, taskId) {
+        const run = await this.context(contextId);
+        const operation = run.admissionTail.then(() => this.promoteInput(run, messageId, taskId));
+        run.admissionTail = operation.catch(() => { });
+        run.promotions.set(messageId, operation);
+        const clear = () => {
+            if (run.promotions.get(messageId) === operation)
+                run.promotions.delete(messageId);
+        };
+        void operation.then(clear, clear);
+        return operation;
+    }
+    async promoteInput(run, messageId, taskId) {
+        const agent = run.entry.handle.agent;
+        const target = run.tasks.get(taskId);
+        const message = agent.inbox.nextTurn.find((item) => item.id === messageId);
+        if (message?.source.kind !== 'a2a')
+            throw new Error('Queued input has already been claimed.');
+        const source = run.tasks.get(message.source.taskId);
+        if (!target || !source)
+            throw new Error('Promotion requires live source and target tasks.');
+        const valid = () => !this.stopping &&
+            !this.bridge.isClearing(run.entry.sessionId) &&
+            !target.settled &&
+            !target.controller.signal.aborted &&
+            run.active === target &&
+            source !== target &&
+            !source.settled &&
+            !source.controller.signal.aborted &&
+            source.task.history.length === 1 &&
+            !source.pendingRequests &&
+            !run.claimed.has(source) &&
+            agent.inbox.nextTurn.some((item) => item === message);
+        if (!valid())
+            throw new Error('Promotion requires an unclaimed independent input and an active target.');
+        const original = Message.fromJSON(JSON.parse(message.source.message));
+        original.taskId = taskId;
+        original.referenceTaskIds = [...new Set([...original.referenceTaskIds, source.task.id])];
+        const promotionId = randomUUID();
+        const promoted = {
+            ...message,
+            source: {
+                ...message.source,
+                taskId,
+                target: 'next-step',
+                promotedFrom: source.task.id,
+                promotionId,
+                message: JSON.stringify(Message.toJSON(original)),
+            },
+        };
+        target.pendingRequests++;
+        try {
+            await this.checkpoint(target.task, target.context);
+            if (!valid())
+                throw new Error('Promotion raced input consumption or task settlement.');
+            target.task.history = [...target.task.history, original];
+            target.headers.set(message.id, source.headers.get(message.id));
+            if (!agent.inbox.replace(message.id, promoted))
+                throw new Error('Queued input has already been claimed.');
+            this.moveInput(agent, promoted, 'next-step');
+            try {
+                await this.flush(agent.session);
+            }
+            catch (error) {
+                // Until the session checkpoint succeeds, the independent task still owns this input.
+                const rollback = {
+                    ...message,
+                    source: { ...message.source, promotedFrom: source.task.id },
+                };
+                run.rolledBack.add(promotionId);
+                const live = this.contexts.get(run.entry.sessionId) === run &&
+                    !this.stopping &&
+                    !this.bridge.isClearing(run.entry.sessionId);
+                if (live && !source.settled && !source.controller.signal.aborted) {
+                    if (this.pending(run).some((item) => item.id === message.id)) {
+                        agent.inbox.replace(message.id, rollback);
+                        this.moveInput(agent, rollback, 'next-turn');
+                    }
+                    else
+                        agent.inbox.append('next-turn', rollback);
+                }
+                else if (live)
+                    agent.inbox.remove(message.id);
+                target.task.history = target.task.history.filter((item) => item.messageId !== original.messageId);
+                target.headers.delete(message.id);
+                try {
+                    if (live)
+                        await this.flush(agent.session);
+                }
+                catch (rollbackError) {
+                    console.error('[dsh-a2a] promotion rollback checkpoint failed:', rollbackError);
+                }
+                throw error;
+            }
+            if (this.stopping ||
+                this.contexts.get(run.entry.sessionId) !== run ||
+                this.bridge.isClearing(run.entry.sessionId))
+                throw new Error('Promotion was interrupted by context disposal.');
+            source.controller.abort();
+            try {
+                await this.checkpoint(target.task, target.context);
+            }
+            finally {
+                await this.cancel(source.task.id);
+            }
+            this.observeInput('promoted', run, promoted);
+        }
+        finally {
+            target.pendingRequests--;
+            this.settle(run, target);
+        }
+    }
+    /** Repair only an incomplete ownership move, never an ordinary DSH claim. */
+    async recoverPromotions(run, context) {
+        const agent = run.entry.handle.agent;
+        const transfers = new Map();
+        for (const event of agent.session.snapshotEvents()) {
+            if (event.type !== 'agent/inbox/spliced')
+                continue;
+            for (const message of event.data.inserted) {
+                if (message.source.kind !== 'a2a' || !message.source.promotedFrom)
+                    continue;
+                transfers.set(message.id, {
+                    message: message,
+                    placed: event.data.target === message.source.target,
+                });
+            }
+        }
+        for (const { message, placed } of transfers.values()) {
+            if (!placed) {
+                const queued = this.pending(run).find((item) => item.id === message.id);
+                if (queued)
+                    this.moveInput(agent, message, message.source.target);
+                else
+                    agent.inbox.append(message.source.target, message);
+            }
+            if (this.pending(run).some((item) => item.id === message.id)) {
+                const recipient = await this.store.load(message.source.taskId, context);
+                if (!recipient || recipient.contextId !== agent.session.id)
+                    throw new Error('Promoted A2A task is not accessible.');
+                const original = Message.fromJSON(JSON.parse(message.source.message));
+                if (!recipient.history.some((item) => item.messageId === original.messageId)) {
+                    recipient.history.push(original);
+                    await this.checkpoint(recipient, context);
+                }
+            }
+            if (message.source.promotedFrom === message.source.taskId)
+                continue;
+            const former = await this.store.load(message.source.promotedFrom, context);
+            if (!former || this.terminal(former))
+                continue;
+            former.status = {
+                state: TaskState.TASK_STATE_CANCELED,
+                message: undefined,
+                timestamp: new Date().toISOString(),
+            };
+            await this.flush(agent.session);
+            await this.checkpoint(former, context);
+        }
+    }
+    context(contextId, context = new ServerCallContext()) {
         if (this.stopping)
             return Promise.reject(new Error('Native inbox is unloading.'));
         const existing = this.contexts.get(contextId);
@@ -107,25 +286,32 @@ export class NativeInbox {
         if (!creating) {
             creating = (async () => {
                 const { entry } = await this.bridge.ensureTask(randomUUID(), contextId);
-                const agent = entry.handle.agent;
-                if (typeof agent.wake !== 'function' ||
-                    typeof agent.inbox.setPaused !== 'function')
-                    throw new Error('Native inbox requires DSH Agent.wake(), agent/before-assembly, and inbox-preserving disposal. See the native inbox compatibility notes.');
-                const recovered = recoverInbox(agent.session.snapshotEvents());
                 const run = {
                     entry,
-                    paused: recovered.paused,
                     tasks: new Map(),
+                    claimed: new Set(),
                     admissions: new Set(),
                     admissionTail: Promise.resolve(),
+                    promotions: new Map(),
+                    rolledBack: new Set(),
                 };
-                this.contexts.set(contextId, run);
-                const queued = new Set([...agent.inbox.nextStep, ...agent.inbox.nextTurn].map((message) => message.id));
-                for (const message of recovered.pending.slice().reverse()) {
-                    if (!queued.has(message.id) && message.source.kind === 'a2a')
-                        agent.inbox.prepend(message.source.target, message);
+                await this.recoverPromotions(run, context);
+                const snapshots = new Map();
+                for (const message of this.pending(run)) {
+                    if (message.source.kind !== 'a2a' || snapshots.has(message.source.taskId))
+                        continue;
+                    const snapshot = await this.store.load(message.source.taskId, context);
+                    if (!snapshot || snapshot.contextId !== contextId)
+                        throw new Error('Queued A2A task is not accessible.');
+                    if (this.terminal(snapshot))
+                        entry.handle.agent.inbox.remove(message.id);
+                    else
+                        snapshots.set(snapshot.id, snapshot);
                 }
-                await this.flush(agent.session);
+                await this.flush(entry.handle.agent.session);
+                for (const snapshot of snapshots.values())
+                    this.restoreTask(run, snapshot, context);
+                this.contexts.set(contextId, run);
                 this.observe('resolved', run);
                 for (const message of this.pending(run))
                     this.observeInput('restored', run, message);
@@ -144,7 +330,6 @@ export class NativeInbox {
                 contextId: run.entry.sessionId,
                 at: Date.now(),
                 pending: pending.length,
-                paused: run.paused,
                 agentStatus: run.entry.handle.agent.status,
                 taskIds: [
                     ...new Set([...run.tasks.values()]
@@ -162,21 +347,22 @@ export class NativeInbox {
     }
     observeInput(phase, run, message, fields = {}) {
         try {
-            if (message.source.kind !== 'a2a')
+            const task = this.owner(run, message);
+            if (!task)
                 return;
-            const original = Message.fromJSON(JSON.parse(message.source.message));
+            const original = this.protocolMessage(run, task, message);
             const position = this.pending(run).findIndex((input) => input.id === message.id);
             this.observe(phase, run, {
-                target: message.source.target,
+                target: message.source.kind === 'a2a' ? message.source.target : 'next-turn',
                 input: original.parts
                     .flatMap((part) => (part.content?.$case === 'text' ? [part.content.value] : []))
                     .join('\n'),
                 position: position < 0 ? undefined : position + 1,
-                taskId: message.source.taskId,
+                taskId: task.task.id,
                 messageId: original.messageId,
                 referenceTaskIds: original.referenceTaskIds,
                 nativeMessageId: message.id,
-                queuedAt: message.source.queuedAt,
+                queuedAt: message.source.kind === 'a2a' ? message.source.queuedAt : undefined,
                 ...fields,
             });
         }
@@ -198,6 +384,7 @@ export class NativeInbox {
     task(task, bus, context) {
         let complete;
         let finished = false;
+        const selectedAt = new Map();
         const done = new Promise((resolve) => {
             complete = resolve;
         });
@@ -209,6 +396,7 @@ export class NativeInbox {
             const run = this.contexts.get(task.contextId);
             if (phase && run)
                 this.observe(phase, run, { taskId: task.id });
+            selectedAt.clear();
             complete();
         };
         return {
@@ -219,6 +407,7 @@ export class NativeInbox {
             finish,
             settled: false,
             headers: new Map(),
+            selectedAt,
             controller: new AbortController(),
             pendingRequests: 0,
             context: new ServerCallContext({ tenant: context.tenant, user: context.user }),
@@ -260,13 +449,13 @@ export class NativeInbox {
             (message.contextId && snapshot.contextId !== message.contextId) ||
             this.terminal(snapshot))
             return;
-        const run = await this.context(snapshot.contextId);
+        const run = await this.context(snapshot.contextId, context);
         let task = run.tasks.get(snapshot.id);
         if (!task)
             task = this.restoreTask(run, snapshot, context);
         task.pendingRequests++;
         try {
-            await this.admit(run, task, message, context, controls.target);
+            await this.admit(run, task, message, context, controls.target, controls.wakeup);
         }
         catch (error) {
             task.pendingRequests--;
@@ -291,9 +480,12 @@ export class NativeInbox {
         const snapshot = await this.store.load(taskId, context);
         if (!snapshot || this.terminal(snapshot))
             return;
-        const run = await this.context(snapshot.contextId);
-        if (!run.tasks.has(taskId))
-            this.restoreTask(run, snapshot, context);
+        const run = await this.context(snapshot.contextId, context);
+        const task = run.tasks.get(taskId) ?? this.restoreTask(run, snapshot, context);
+        if (task.settled) {
+            await task.done;
+            await this.checkpoint(structuredClone(task.task), task.context);
+        }
     }
     outcome(task) {
         if (task.status?.state === TaskState.TASK_STATE_COMPLETED)
@@ -313,7 +505,7 @@ export class NativeInbox {
                 TaskState.TASK_STATE_REJECTED,
             ].includes(task.status.state));
     }
-    async admit(run, task, a2aMessage, context, target) {
+    async admit(run, task, a2aMessage, context, target, wakeup, accepted) {
         if (target === 'next-step' && run.active !== task)
             throw new Error('Steering must address an active task.');
         const duplicate = () => [...run.tasks.values()].some((owned) => owned.task.history.some((message) => message.messageId === a2aMessage.messageId));
@@ -364,9 +556,10 @@ export class NativeInbox {
             abort.signal.throwIfAborted();
             task.task.history = acceptedHistory;
             task.headers.set(message.id, headers);
-            run.entry.handle.agent.send(message, target, false);
-            await this.flush(run.entry.handle.agent.session);
+            accepted?.();
+            run.entry.handle.agent.send(message, target, wakeup);
             this.observeInput('admitted', run, message);
+            await this.flush(run.entry.handle.agent.session);
             void this.ctx
                 .parallel('a2a/message-admitted', {
                 contextId: run.entry.sessionId,
@@ -403,7 +596,7 @@ export class NativeInbox {
         let ownsTask = false;
         try {
             const controls = this.controls(userMessage, context);
-            const run = await this.context(contextId);
+            const run = await this.context(contextId, context);
             task = run.tasks.get(taskId);
             if (!task) {
                 task = this.task({
@@ -423,13 +616,12 @@ export class NativeInbox {
             }
             const preadmitted = this.preadmitted.get(context)?.delete(userMessage.messageId);
             if (!preadmitted)
-                await this.admit(run, task, userMessage, context, controls.target);
-            else
+                await this.admit(run, task, userMessage, context, controls.target, controls.wakeup, () => bus.publish(AgentEvent.task(structuredClone(task.task))));
+            else {
                 task.pendingRequests--;
-            bus.publish(AgentEvent.task(structuredClone(task.task)));
+                bus.publish(AgentEvent.task(structuredClone(task.task)));
+            }
             this.settle(run, task);
-            if (controls.wakeup && !run.paused && !task.settled)
-                await this.wake(contextId, { context });
             await task.done;
             if (task.bus !== bus && task.final)
                 bus.publish(task.final);
@@ -455,13 +647,12 @@ export class NativeInbox {
                 metadata: undefined,
             };
             bus.publish(AgentEvent.task(snapshot));
-            bus.publish(terminalStatusUpdate(taskId, contextId, 'failed', text));
             if (task) {
-                task.task.status = snapshot.status;
-                task.settled = true;
-                task.controller.abort();
-                task.finish();
+                this.fail(task, contextId, error);
+                await task.done;
             }
+            else
+                bus.publish(terminalStatusUpdate(taskId, contextId, 'failed', text));
         }
         finally {
             bus.finished();
@@ -475,18 +666,80 @@ export class NativeInbox {
         run.tasks.set(snapshot.id, restored);
         void restored.done.finally(() => bus.finished());
         bus.publish(AgentEvent.task(snapshot));
+        if (snapshot.status?.state !== TaskState.TASK_STATE_INPUT_REQUIRED &&
+            !this.pending(run).some((message) => message.source.kind === 'a2a' && message.source.taskId === snapshot.id))
+            this.fail(restored, snapshot.contextId, new Error('Task execution was interrupted; DSH has no pending input to resume.'));
         return restored;
     }
-    drive(run) {
-        run.entry.handle.agent.wake();
+    select(run, task) {
+        run.active = task;
+        this.bridge.bindInboxTask(run.entry, task.task.id, task.translator, task.bus, task.done, task.controller);
+        if (run.turnStart) {
+            this.publish(task, run.turnStart);
+            run.turnStart = undefined;
+        }
+    }
+    protocolMessage(run, task, message) {
+        if (message.source.kind === 'a2a')
+            return Message.fromJSON(JSON.parse(message.source.message));
+        return Message.fromJSON({
+            messageId: message.id,
+            taskId: task.task.id,
+            contextId: run.entry.sessionId,
+            role: 'ROLE_USER',
+            parts: message.content
+                .filter((block) => block.type === 'text')
+                .map((block) => ({ text: block.text })),
+        });
+    }
+    owner(run, message) {
+        if (message.source.kind === 'a2a')
+            return run.tasks.get(message.source.taskId);
+        if (message.source.kind !== 'goal' || message.source.round <= 0)
+            return;
+        const goal = this.ctx.get('goals')?.get(run.entry.handle.agent);
+        if (run.goalOwner &&
+            goal &&
+            run.goalOwner.goalId === message.source.goalId &&
+            goal.id === message.source.goalId &&
+            goal.revision === message.source.revision &&
+            goal.phase === 'active' &&
+            goal.activation === 'armed')
+            return run.goalOwner.task;
     }
     async prepare(detail) {
         const run = this.contexts.get(detail.agent.session.id);
         if (!run)
             return;
-        if (this.stopping || run.paused)
-            throw new Error('Inbox is paused.');
-        if (detail.messages.some((message) => message.source.kind !== 'a2a'))
+        if (this.stopping)
+            throw new Error('Inbox is unloading.');
+        for (let index = detail.messages.length - 1; index >= 0; index--) {
+            const message = detail.messages[index];
+            if (message.source.kind !== 'a2a' || !message.source.promotionId)
+                continue;
+            const promotion = run.promotions.get(message.id);
+            if (promotion) {
+                let onAbort;
+                try {
+                    await Promise.race([
+                        promotion.catch(() => { }),
+                        new Promise((_resolve, reject) => {
+                            onAbort = () => reject(detail.signal.reason);
+                            detail.signal.addEventListener('abort', onAbort, { once: true });
+                            if (detail.signal.aborted)
+                                onAbort();
+                        }),
+                    ]);
+                    detail.signal.throwIfAborted();
+                }
+                finally {
+                    detail.signal.removeEventListener('abort', onAbort);
+                }
+            }
+            if (run.rolledBack.delete(message.source.promotionId))
+                detail.messages.splice(index, 1);
+        }
+        if (!run.active && detail.messages.some((message) => !this.owner(run, message)))
             throw new Error('Native host input requires task-attributed a2aInbox.enqueue().');
         // Restarted steering and an ordinary queued turn may be claimed together by the core.
         // Requeue other owners before committing any user message, keeping task lifecycles separate.
@@ -494,36 +747,36 @@ export class NativeInbox {
         if (owner?.source.kind === 'a2a') {
             const taskId = owner.source.taskId;
             const deferred = detail.messages.filter((message) => message.source.kind === 'a2a' && message.source.taskId !== taskId);
-            for (const message of deferred.slice().reverse())
+            for (const message of deferred.slice().reverse()) {
                 detail.agent.inbox.prepend('next-turn', message);
+                if (message.source.kind === 'a2a') {
+                    const task = run.tasks.get(message.source.taskId);
+                    if (task)
+                        run.claimed.delete(task);
+                }
+            }
             for (let index = detail.messages.length - 1; index >= 0; index--)
                 if (deferred.includes(detail.messages[index]))
                     detail.messages.splice(index, 1);
         }
         for (const message of detail.messages) {
-            if (message.source.kind !== 'a2a')
+            const task = this.owner(run, message);
+            if (!task && message.source.kind !== 'a2a')
                 continue;
-            const task = run.tasks.get(message.source.taskId);
             if (!task || task.settled)
                 throw new Error('Queued input has no live A2A task; restore it before waking.');
             if (run.active && run.active !== task)
                 throw new Error('A model step cannot consume inputs from different A2A tasks.');
-            run.active = task;
-            this.bridge.bindInboxTask(run.entry, task.task.id, task.translator, task.bus, task.done, task.controller);
-            if (run.turnStart) {
-                this.publish(task, run.turnStart);
-                run.turnStart = undefined;
-            }
-            const selectedAt = Date.now();
+            this.select(run, task);
+            const selectedAt = task.selectedAt.get(message.id) ?? Date.now();
             const timing = { selectedAt, turn: detail.turn, step: detail.step };
-            this.observeInput('selected', run, message, timing);
             try {
                 await this.flush(detail.agent.session);
-                await this.ctx.serial('a2a/before-assembly', {
+                await this.ctx.serial('a2a/before-step', {
                     agent: detail.agent,
                     contextId: detail.agent.session.id,
                     taskId: task.task.id,
-                    a2aMessage: Message.fromJSON(JSON.parse(message.source.message)),
+                    a2aMessage: this.protocolMessage(run, task, message),
                     dshMessageId: message.id,
                     requestHeaders: task.headers.get(message.id),
                     signal: detail.signal,
@@ -548,15 +801,19 @@ export class NativeInbox {
         const run = this.contexts.get(session.id);
         if (!run)
             return false;
-        if (event.type === 'agent/inbox/paused') {
-            run.paused = event.data.paused;
-            return true;
-        }
         if (event.type === 'turn/start') {
+            run.claimed.clear();
             run.turnStart = event;
             return true;
         }
         const task = run.active;
+        if (event.type === 'turn/end') {
+            if (!this.stopping && ['error', 'blocked', 'aborted'].includes(event.data.reason.kind))
+                for (const owner of run.claimed)
+                    if (owner !== task && !owner.settled)
+                        this.fail(owner, session.id, new Error('Selected input was interrupted before its task step.'));
+            run.claimed.clear();
+        }
         if (!task)
             return true;
         if (task.settled) {
@@ -573,19 +830,14 @@ export class NativeInbox {
             if (this.stopping)
                 return true;
             const outputs = task.translator.handle(event);
-            if (run.paused) {
-                void this.cancel(task.task.id, { retainInbox: true }).catch((error) => console.error('[dsh-a2a] pause cancellation failed:', error));
-                return true;
-            }
             task.final = outputs.at(-1);
-            if (event.data.reason.kind === 'error' || event.data.reason.kind === 'blocked') {
-                void run.entry.handle.agent
-                    .whenIdle()
-                    .then(() => {
-                    if (!this.stopping && !run.paused && !this.bridge.isClearing(session.id))
-                        this.drive(run);
-                })
-                    .catch((error) => console.error('[dsh-a2a] queue continuation failed:', error));
+            if (task.final?.kind === 'statusUpdate' &&
+                [TaskState.TASK_STATE_FAILED, TaskState.TASK_STATE_CANCELED].includes(task.final.data.status.state)) {
+                // Official inbox edits append session events; wait until turn/end publication exits.
+                void Promise.resolve()
+                    .then(() => this.settle(run, task))
+                    .catch((error) => this.fail(task, session.id, error));
+                return true;
             }
             if (!task.settlementStarted) {
                 task.settlementStarted = true;
@@ -611,11 +863,16 @@ export class NativeInbox {
         return true;
     }
     settle(run, task) {
-        if (task.settled ||
-            this.stopping ||
-            run.paused ||
-            !task.settlementReady ||
+        const terminal = task.final?.kind === 'statusUpdate' &&
+            [TaskState.TASK_STATE_FAILED, TaskState.TASK_STATE_CANCELED].includes(task.final.data.status.state);
+        if (task.settled || this.stopping)
+            return;
+        if (terminal) {
+            this.discard(run, task.task.id);
+        }
+        else if (!task.settlementReady ||
             task.pendingRequests ||
+            run.goalOwner?.task === task ||
             run.active === task ||
             this.pending(run).some((message) => message.source.kind === 'a2a' && message.source.taskId === task.task.id))
             return;
@@ -650,146 +907,44 @@ export class NativeInbox {
     }
     fail(task, contextId, error) {
         console.error('[dsh-a2a] native inbox failed:', error);
-        if (!task.settled) {
-            task.final = terminalStatusUpdate(task.task.id, contextId, 'failed', error instanceof Error ? error.message : String(error));
-            if (task.final.kind === 'statusUpdate')
-                task.task.status = task.final.data.status;
-            task.bus.publish(task.final);
-        }
+        if (task.settled)
+            return;
         task.settled = true;
         task.controller.abort();
-        task.headers.clear();
-        task.finish();
-    }
-    async pause(contextId) {
-        await this.waking.get(contextId);
-        const run = await this.context(contextId);
-        run.paused = true;
-        for (const admission of run.admissions)
-            admission.abort();
-        run.entry.handle.agent.inbox.setPaused(true);
-        this.observe('paused', run);
-        for (const task of run.tasks.values())
-            if (!task.settled && task.task.status?.state === TaskState.TASK_STATE_WORKING)
-                await this.cancel(task.task.id, { retainInbox: true });
-        run.entry.handle.agent.cancel({ kind: 'user' }, { keepInbox: true });
-        await run.entry.handle.agent.whenIdle();
-        await this.flush(run.entry.handle.agent.session);
-    }
-    async wake(contextId, options = {}) {
-        const operation = (this.waking.get(contextId) ?? Promise.resolve())
-            .catch(() => { })
-            .then(() => this.wakeInner(contextId, options));
-        this.waking.set(contextId, operation);
-        const release = () => {
-            if (this.waking.get(contextId) === operation)
-                this.waking.delete(contextId);
-        };
-        void operation.then(release, release);
-        return operation;
-    }
-    async wakeInner(contextId, options) {
-        const run = await this.context(contextId);
-        if (run.paused && !options.resume)
-            return [];
-        if (options.resume && run.entry.handle.agent.status === 'idle') {
-            const recovered = recoverInbox(run.entry.handle.agent.session.snapshotEvents());
-            const queued = new Set(this.pending(run).map((message) => message.id));
-            for (const message of recovered.pending.slice().reverse())
-                if (!queued.has(message.id) && message.source.kind === 'a2a')
-                    run.entry.handle.agent.inbox.prepend(message.source.target, message);
-        }
-        const context = options.context ?? new ServerCallContext();
-        const tasks = new Set();
-        const reassigned = new Map();
-        for (const message of this.pending(run)) {
-            if (message.source.kind !== 'a2a')
-                throw new Error('Cannot wake input without A2A task attribution.');
-            const oldId = message.source.taskId;
-            let id = oldId;
-            if (run.tasks.has(id) && !run.tasks.get(id).settled) {
-                tasks.add(id);
-                continue;
-            }
-            if (!this.server)
-                throw new Error('A2A task recovery requires the running server.');
-            let task = run.tasks.get(id)?.task ?? (await this.store.load(id, context));
-            if (!task || task.contextId !== contextId)
-                throw new Error('Queued A2A task is not accessible.');
-            if (this.terminal(task)) {
-                if (!options.resume)
-                    throw new Error('Retained input needs explicit resume under a new task.');
-                let replacement = reassigned.get(oldId);
-                const original = Message.fromJSON(JSON.parse(message.source.message));
-                if (!replacement) {
-                    replacement = {
-                        ...task,
-                        id: randomUUID(),
-                        history: [],
-                        artifacts: [],
-                        status: {
-                            state: TaskState.TASK_STATE_SUBMITTED,
-                            timestamp: new Date().toISOString(),
-                            message: undefined,
-                        },
-                    };
-                    reassigned.set(oldId, replacement);
+        task.final = terminalStatusUpdate(task.task.id, contextId, 'failed', error instanceof Error ? error.message : String(error));
+        if (task.final.kind === 'statusUpdate')
+            task.task.status = task.final.data.status;
+        // Cleanup may append inbox events, so it must run outside session publication.
+        queueMicrotask(() => {
+            try {
+                const run = this.contexts.get(contextId);
+                if (run) {
+                    this.discard(run, task.task.id);
+                    if (run.active === task)
+                        run.entry.handle.agent.cancel({ kind: 'user' }, { keepInbox: true });
                 }
-                id = replacement.id;
-                original.taskId = id;
-                original.referenceTaskIds = [...new Set([...original.referenceTaskIds, oldId])];
-                replacement.history.push(original);
-                await this.checkpoint(replacement, context);
-                this.observe(this.outcome(task), run, { taskId: oldId });
-                const replacementInput = {
-                    ...message,
-                    source: {
-                        ...message.source,
-                        taskId: id,
-                        message: JSON.stringify(Message.toJSON(original)),
-                    },
-                };
-                run.entry.handle.agent.inbox.replace(message.id, replacementInput);
-                this.observeInput('reassigned', run, replacementInput);
-                task = replacement;
             }
-            tasks.add(id);
-            if (run.tasks.has(id))
-                continue;
-            this.restoreTask(run, task, context);
-        }
-        const recovered = recoverInbox(run.entry.handle.agent.session.snapshotEvents());
-        for (const id of recovered.committed) {
-            const owned = run.tasks.get(id);
-            if (tasks.has(id) ||
-                (owned && (owned.settled || owned.settlementStarted || run.active === owned)))
-                continue;
-            const interrupted = owned?.task ?? (await this.store.load(id, context));
-            if (!interrupted || interrupted.contextId !== contextId || this.terminal(interrupted))
-                continue;
-            const failed = owned ?? this.restoreTask(run, interrupted, context);
-            this.fail(failed, contextId, new Error('Committed input has no durable terminal task checkpoint; automatic replay is disabled.'));
-            await this.checkpoint(structuredClone(failed.task), failed.context);
-        }
-        if (this.stopping || this.bridge.isClearing(contextId))
-            return [];
-        if (options.resume) {
-            run.paused = false;
-            run.entry.handle.agent.inbox.setPaused(false);
-        }
-        await this.flush(run.entry.handle.agent.session);
-        this.observe(options.resume ? 'resume' : 'wake', run);
-        if (tasks.size)
-            this.drive(run);
-        return [...tasks];
+            catch (cleanupError) {
+                console.error('[dsh-a2a] failed task cleanup failed:', cleanupError);
+            }
+            finally {
+                task.headers.clear();
+                task.bus.publish(task.final);
+                task.finish();
+            }
+        });
     }
-    async cancel(taskId, options = {}) {
+    discard(run, taskId) {
+        for (const message of this.pending(run))
+            if (message.source.kind === 'a2a' && message.source.taskId === taskId)
+                run.entry.handle.agent.inbox.remove(message.id);
+    }
+    async cancel(taskId) {
         if (this.stopping)
             throw new Error('Native inbox is unloading.');
         for (const [contextId, run] of this.contexts) {
             if (!run.tasks.has(taskId))
                 continue;
-            await this.waking.get(contextId);
             const task = run.tasks.get(taskId);
             if (!task)
                 continue;
@@ -799,7 +954,7 @@ export class NativeInbox {
                 return contextId;
             let operation = task.cancellation;
             if (!operation) {
-                operation = this.cancelTask(run, task, options);
+                operation = this.cancelTask(run, task);
                 task.cancellation = operation;
                 void operation.catch(() => {
                     if (task.cancellation === operation)
@@ -811,19 +966,10 @@ export class NativeInbox {
         }
         return undefined;
     }
-    async cancelTask(run, task, options) {
+    async cancelTask(run, task) {
         const contextId = run.entry.sessionId;
         const taskId = task.task.id;
-        if (options.retainInbox) {
-            run.paused = true;
-            run.entry.handle.agent.inbox.setPaused(true);
-            this.observe('paused', run);
-        }
-        else {
-            for (const message of this.pending(run))
-                if (message.source.kind === 'a2a' && message.source.taskId === taskId)
-                    run.entry.handle.agent.inbox.remove(message.id);
-        }
+        this.discard(run, taskId);
         task.controller.abort();
         task.settled = true;
         task.final = terminalStatusUpdate(taskId, contextId, 'canceled', 'Task canceled by request.');
@@ -831,13 +977,6 @@ export class NativeInbox {
             task.task.status = task.final.data.status;
         if (run.active === task) {
             run.entry.handle.agent.cancel({ kind: 'user' }, { keepInbox: true });
-            void run.entry.handle.agent
-                .whenIdle()
-                .then(() => {
-                if (!run.paused && !this.stopping)
-                    this.drive(run);
-            })
-                .catch((error) => console.error('[dsh-a2a] cancellation failed:', error));
         }
         try {
             try {
@@ -853,7 +992,6 @@ export class NativeInbox {
         }
     }
     async clear(contextId) {
-        await this.waking.get(contextId);
         await this.resolving.get(contextId);
         const run = this.contexts.get(contextId);
         if (!run)
@@ -864,7 +1002,6 @@ export class NativeInbox {
                 .map((task) => task.task.id)
                 .concat(this.pending(run).flatMap((message) => message.source.kind === 'a2a' ? [message.source.taskId] : []))),
         ];
-        run.paused = true;
         for (const admission of run.admissions)
             admission.abort();
         run.entry.handle.agent.inbox.clear();
@@ -885,15 +1022,20 @@ export class NativeInbox {
         const run = this.contexts.get(session.id);
         if (!run)
             return;
-        this.observe('disposed', run);
         for (const admission of run.admissions)
             admission.abort();
         for (const task of run.tasks.values()) {
-            // Disposal interrupts transport ownership; retained durable input keeps its task state.
+            if (!task.settled) {
+                const final = terminalStatusUpdate(task.task.id, session.id, 'canceled', 'Agent disposed.');
+                if (final.kind === 'statusUpdate')
+                    task.task.status = final.data.status;
+                task.bus.publish(final);
+            }
             task.settled = true;
             task.controller.abort();
             task.finish();
         }
+        this.observe('disposed', run);
         this.contexts.delete(session.id);
     }
     shutdown() {
@@ -902,7 +1044,7 @@ export class NativeInbox {
         this.stopping = true;
         this.shutdownPromise = (async () => {
             const failures = [];
-            await Promise.allSettled([...this.waking.values(), ...this.resolving.values()]);
+            await Promise.allSettled([...this.resolving.values()]);
             const cancellations = [...this.contexts.values()].flatMap((run) => [...run.tasks.values()].flatMap((task) => (task.cancellation ? [task.cancellation] : [])));
             for (const outcome of await Promise.allSettled(cancellations))
                 if (outcome.status === 'rejected')
@@ -911,7 +1053,7 @@ export class NativeInbox {
                 for (const admission of run.admissions)
                     admission.abort();
                 try {
-                    run.entry.handle.agent.cancel({ kind: 'disposed' }, { keepInbox: true });
+                    run.entry.handle.agent.cancel({ kind: 'disposed' });
                 }
                 catch (error) {
                     failures.push(error);
@@ -929,11 +1071,17 @@ export class NativeInbox {
                     failures.push(error);
                 }
                 finally {
-                    this.observe('disposed', run);
                     for (const task of run.tasks.values()) {
-                        task.controller.abort();
+                        try {
+                            if (!task.settled)
+                                await this.cancelTask(run, task);
+                        }
+                        catch (error) {
+                            failures.push(error);
+                        }
                         task.finish();
                     }
+                    this.observe('disposed', run);
                 }
             }
             if (failures.length)