@amaster.ai/dsh-a2a 0.1.26 → 0.1.27

package/README.md

@@ -14,42 +14,13 @@ dsh plugin --profile my-agent add @amaster.ai/dsh-a2a
 
 ## Native inbox execution
 
-`inbox.enabled: true` opts into durable native DSH input instead of request-serialized execution. **This requires the unreleased upstream native inbox capability (`ctx.agents.nativeInboxVersion === 1`); the tested `0.2.0-rc.2` runtime does not provide it.** Startup rejects unsupported factories before opening a backend. Legacy execution remains the default.
+`inbox.enabled: true` uses the official DSH inbox (`Agent.send`) for ordinary `next-turn` input and `next-step` steering. Tested with the unmodified npm runtime `0.2.1-rc.2`; no core patch is required. The queue and its durable projection belong to DSH. The plugin only materializes messages, attaches A2A task identities, and translates execution events.
 
-In this mode, ordinary `SendMessage` / `SendStreamingMessage` calls enter the DSH inbox before their initial task response is published. Nonblocking sends return a submitted task after durable admission. A context owns one agent, while tasks retain separate message identities, streams, and terminal states. A completed unit of work settles `completed`; use the same context with a new task for later work. Disconnecting an HTTP client does not cancel execution. Task snapshots, polling, and subscriptions use the standard A2A operations.
+Standard `SendMessage` / `SendStreamingMessage`, task queries, cancellation and subscriptions remain the wire interface. The negotiated [inbox extension](../../docs/protocol/inbox-v1.md) forwards `target` and `wakeup` to DSH. `wakeup: false` leaves an idle driver parked; it does not prevent an active driver from consuming pending input. A later real waking message releases pending input.
 
-The optional [inbox extension](../../docs/protocol/inbox-v1.md) selects parked admission (`wakeup: false`) or next-step steering (`target: next-step`). Steering must address the currently active task. It cannot pull an unrelated task's input into the active model step.
+The same-process `a2aInbox` service exposes `resolve(contextId)`, `content(message, contextId)`, `enqueue(taskId, message, { target?, wakeup? })`, and `cancel(taskId)`. There is no separate pause, wake-only, resume, or retained-task restart operation. Cancellation is terminal and removes that task's pending input. Other tasks' input is retained according to official DSH cancellation semantics, and may wait for the next waking message. Clearing a context discards all its pending work.
 
-The same-process `a2aInbox` service implements the exported `A2aInbox` interface:
-
-```ts
-const inbox = ctx.get('a2aInbox') as A2aInbox;
-const agent = await inbox.resolve(contextId);
-const blocks = await inbox.content(message, contextId);
-await inbox.enqueue(taskId, message); // Host follow-up with explicit task ownership.
-await inbox.pause(contextId);
-await inbox.wake(contextId); // Leaves a persisted pause intact.
-await inbox.wake(contextId, { resume: true }); // Explicitly unpauses existing work.
-await inbox.cancel(taskId, { retainInbox: true }); // Terminal task; pending input stays parked.
-```
-
-`pause` cancels active tasks while retaining their unconsumed input and other queued tasks; resumed input from a canceled task gets a fresh task identity. `CancelTask` remains terminal and removes that task's pending input, retaining other tasks' input. The service's explicit retention option parks the context; resuming retained input creates a new task when its former owner is terminal. `a2aTasks.clearContext` discards pending work even when idle. Plugin unload preserves the native inbox and drains its session writes. For restart recovery, configure durable DSH session persistence and a Redis or GCS TaskStore, then call `wake` for the contexts the host chooses to restore. `SubscribeToTask` observes recovered work without submitting a wake message.
-
-In native mode, host settlement hooks submit follow-ups through `a2aInbox.enqueue(taskId, message)`; it binds and persists the task identity before enqueueing. Raw `Agent.send` / `followup` inputs without A2A attribution are rejected rather than assigned to the most recent hook.
-
-`a2a/before-followup` validates admission; use `a2a/before-assembly` for per-input runtime state. The latter runs after the model-step batch is selected, before prompt assembly, and receives the same `A2aTurnContext` fields. Request headers are process-local: restored inputs receive `requestHeaders: undefined`. Persist replay-safe metadata in the message, never credentials in the queue. Admission observers remain non-vetoing.
-
-Recovery only restores an interrupted claim without a committed `user/message`; it never replays committed model input or promises exactly-once tool effects. A task with committed input, no remaining pending input, and no durable terminal A2A checkpoint becomes failed on recovery, including when the turn ended before the process stopped. The host can then decide what to do next. Keep file parts on persistent storage with `uploadsDir` or `a2aFileMaterializer` when queued inputs must survive host or machine restarts. The memory TaskStore and temporary upload default do not provide that durability. In-process task handles remain until context clear or plugin unload; long-lived hosts should clear finished contexts.
-
-Run the real loop / A2A HTTP / JSONL recovery checks against a prepared upstream checkout:
-
-```bash
-DSH_SOURCE_ROOT=/absolute/path/to/deepseek-harness node .github/scripts/check-native-inbox.mjs
-```
-
-The Integration workflow runs this suite without secrets, including on fork PRs, against a pinned upstream source checkout plus the checked-in native inbox source companion. It verifies insertion during an active turn, FIFO execution, independent task completion, and exactly one user-message commit per input.
-
-The checkout needs its installed dependencies and `pnpm run build:native-system`; model responses are scripted, so this check needs no gateway or model credentials. The upstream source companion is required before native mode can be released; no dependency artifact patch is installed by this plugin.
+`a2a/before-followup` validates admission; `a2a/before-step` runs at the official pre-step boundary, after system-prompt assembly and before model execution. It cannot change the already assembled system prompt. Original request headers remain process-local. DSH persistence restores its own pending projection; the plugin does not replay splice logs or recover consumed claims. Graceful disposal follows the official runtime's cancellation behavior. Durable A2A task snapshots still require a Redis or GCS TaskStore; an in-memory store is sufficient without restart requirements.
 
 ## Configuration
 

package/lib/bridge.js

@@ -191,14 +191,12 @@ export class A2aBridge {
                 resumeSessionId: sessionId,
                 agentOptions,
                 setup,
-                ...(this.inbox ? { keepInboxOnDispose: true } : {}),
             })
             : await this.ctx.agents.create({
                 sessionId,
                 meta: { cwd: this.options.cwd, ...(agentPreset ? { agentPreset } : {}) },
                 agentOptions,
                 setup,
-                ...(this.inbox ? { keepInboxOnDispose: true } : {}),
             });
         const entry = {
             taskId,
@@ -299,7 +297,7 @@ export class A2aBridge {
     async waitForTurn(entry) {
         await Promise.allSettled([...entry.running]);
     }
-    /** The native inbox selects task ownership before assembling its first prompt. */
+    /** The official inbox claim selects the task that owns the next model step. */
     bindInboxTask(entry, taskId, translator, bus, completion, controller) {
         this.tasks.delete(entry.taskId);
         entry.taskId = taskId;

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,33 @@ 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('agent/inbox/claimed', ({ agent, message, turn }) => {
+            const run = this.contexts.get(agent.session.id);
+            if (!run || message.source.kind !== 'a2a')
+                return;
+            const task = run.tasks.get(message.source.taskId);
+            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 +59,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 +69,7 @@ export class NativeInbox {
         }
         throw new Error('Host input must address a live A2A task.');
     }
-    context(contextId) {
+    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 +79,29 @@ 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(),
                 };
-                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);
+                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 +120,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()]
@@ -198,6 +173,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 +185,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 +196,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 +238,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 +269,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 +294,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 +345,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 +385,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 +405,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 +436,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 +455,26 @@ 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;
+        }
     }
     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.');
+        if (!run.active && detail.messages.some((message) => message.source.kind !== 'a2a'))
             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,8 +482,14 @@ 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);
@@ -508,18 +502,12 @@ export class NativeInbox {
                 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,
@@ -548,15 +536,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 +565,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,10 +598,14 @@ 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.active === task ||
             this.pending(run).some((message) => message.source.kind === 'a2a' && message.source.taskId === task.task.id))
@@ -650,146 +641,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();
+            }
+        });
+    }
+    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, options = {}) {
+    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 +688,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 +700,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 +711,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 +726,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 +736,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 +756,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 +778,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 +787,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 +805,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)

package/lib/index.js

@@ -29,7 +29,7 @@ export const name = 'dsh-a2a';
 /** The bridge creates and owns agents through the registry service. */
 export const inject = ['agents'];
 export const Config = Schema.object({
-    inbox: Schema.object({ enabled: Schema.boolean().default(false) }).description('Use durable native inbox execution (requires the upstream native inbox capability).'),
+    inbox: Schema.object({ enabled: Schema.boolean().default(false) }).description('Use the official DSH inbox for queued turns and steering.'),
     enabled: Schema.boolean().default(false),
     host: Schema.string().default('127.0.0.1'),
     port: Schema.natural().default(41241),

package/lib/types/bridge.d.ts

@@ -102,7 +102,7 @@ export declare class A2aBridge {
     };
     private findApproval;
     waitForTurn(entry: TaskEntry): Promise<void>;
-    /** The native inbox selects task ownership before assembling its first prompt. */
+    /** The official inbox claim selects the task that owns the next model step. */
     bindInboxTask(entry: TaskEntry, taskId: string, translator: SessionTranslator, bus: ExecutionEventBus, completion: Promise<void>, controller: AbortController): void;
     /** Inspect a message for a live task before the SDK starts its next request. */
     beforeWorkingTaskMessage(a2aMessage: Message, requestHeaders: unknown): Promise<void>;

package/lib/types/inbox.d.ts

@@ -2,7 +2,7 @@ import { Message } from '@a2a-js/sdk';
 import { type ExecutionEventBus, type RequestContext, ServerCallContext } from '@a2a-js/sdk/server';
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent, AssistantStreamFrame, InboxTarget } from '@deepseek-ai/dsh-agent';
-import type { ContentBlock, UserMessage } from '@deepseek-ai/dsh-llm/types';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session';
 import type { A2aBridge } from './bridge.js';
 import type { A2aTurnContext } from './index.js';
@@ -17,7 +17,6 @@ export interface A2aInboxEvent {
     target?: 'next-turn' | 'next-step';
     input?: string;
     position?: number;
-    paused?: boolean;
     agentStatus?: string;
     taskId?: string;
     taskIds?: string[];
@@ -42,26 +41,12 @@ declare module '@deepseek-ai/dsh-llm/types' {
         a2a: InboxSource;
     }
 }
-declare module '@deepseek-ai/dsh-session/types' {
-    interface SessionEventMap {
-        'agent/inbox/paused': {
-            paused: boolean;
-        };
-    }
-}
 declare module '@deepseek-ai/cordis' {
     interface Events {
         /** Native inbox lifecycle; content consumers must honor their capture settings. */
         'a2a/inbox'(detail: A2aInboxEvent): void;
-        'agent/before-assembly'(detail: {
-            agent: Agent;
-            messages: UserMessage[];
-            turn: number;
-            step: number;
-            signal: AbortSignal;
-        }): void | Promise<void>;
-        /** Selected input, before system-prompt assembly; restored input has no original headers. */
-        'a2a/before-assembly'(detail: A2aTurnContext): void | Promise<void>;
+        /** Selected input at the official pre-step boundary, after system-prompt assembly. */
+        'a2a/before-step'(detail: A2aTurnContext): void | Promise<void>;
     }
 }
 /** Same-process queue control; wire messages and task subscriptions remain standard A2A. */
@@ -73,23 +58,9 @@ export interface A2aInbox {
         target?: InboxTarget;
         wakeup?: boolean;
     }): Promise<void>;
-    pause(contextId: string): Promise<void>;
-    /** Cancellation is terminal; retained pending input stays paused until explicit resume. */
-    cancel(taskId: string, options?: {
-        retainInbox?: boolean;
-    }): Promise<string | undefined>;
-    /** Recovery does not override a persisted pause unless resume is explicitly true. */
-    wake(contextId: string, options?: {
-        resume?: boolean;
-        context?: ServerCallContext;
-    }): Promise<string[]>;
+    /** Standard cancellation is terminal and removes only this task's pending input. */
+    cancel(taskId: string): Promise<string | undefined>;
 }
-/** Fold native input mutations; a claimed input is recoverable only before user/message. */
-export declare function recoverInbox(events: readonly SessionEvent[]): {
-    paused: boolean;
-    pending: UserMessage[];
-    committed: Set<string>;
-};
 export declare class NativeInbox implements A2aInbox {
     private readonly ctx;
     private readonly bridge;
@@ -98,7 +69,6 @@ export declare class NativeInbox implements A2aInbox {
     private readonly resolving;
     private stopping;
     private shutdownPromise?;
-    private readonly waking;
     private readonly preadmitted;
     server?: A2aServer;
     constructor(ctx: Context, bridge: A2aBridge, store: ManagedTaskStore);
@@ -125,22 +95,15 @@ export declare class NativeInbox implements A2aInbox {
     private admit;
     execute(request: RequestContext, bus: ExecutionEventBus): Promise<void>;
     private restoreTask;
-    private drive;
+    private select;
     private prepare;
     private publish;
     onSessionEvent(session: Session, event: SessionEvent): boolean;
     private settle;
     onAssistantStream(agent: Agent, frame: AssistantStreamFrame): boolean;
     private fail;
-    pause(contextId: string): Promise<void>;
-    wake(contextId: string, options?: {
-        resume?: boolean;
-        context?: ServerCallContext;
-    }): Promise<string[]>;
-    private wakeInner;
-    cancel(taskId: string, options?: {
-        retainInbox?: boolean;
-    }): Promise<string | undefined>;
+    private discard;
+    cancel(taskId: string): Promise<string | undefined>;
     private cancelTask;
     clear(contextId: string): Promise<void>;
     onDisposed(session: Session): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/dsh-a2a",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "A2A protocol (JSON-RPC + SSE) server plugin for DeepSeek Harness: expose dsh agents as A2A agents.",
   "type": "module",
   "main": "lib/index.js",
@@ -38,7 +38,7 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": ">=0.1.5-rc.1 || >=0.1.6-alpha.1 || >=0.1.7-alpha.1 || >=0.2.0-rc.1",
+    "@deepseek-ai/dsh-agent": ">=0.2.0-rc.2 || >=0.2.1-alpha.1",
     "@deepseek-ai/dsh-attachment": ">=0.1.5-rc.1 || >=0.1.6-alpha.1 || >=0.1.7-alpha.1 || >=0.2.0-rc.1",
     "@deepseek-ai/dsh-llm": ">=0.1.5-rc.1 || >=0.1.6-alpha.1 || >=0.1.7-alpha.1 || >=0.2.0-rc.1",
     "@deepseek-ai/dsh-session": ">=0.2.0-rc.1",
@@ -63,14 +63,14 @@
   },
   "devDependencies": {
     "@a2a-js/sdk-v03": "npm:@a2a-js/sdk@0.3.14",
-    "@deepseek-ai/cordis": "^4.0.4",
-    "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-attachment": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-session": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-session-projection": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-user-approval": "0.2.0-rc.2",
+    "@deepseek-ai/cordis": "4.0.5",
+    "@deepseek-ai/dsh-agent": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-attachment": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-session": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-user-approval": "0.2.1-rc.2",
     "@google-cloud/storage": "^7.0.0",
     "@types/express": "^4.17.21",
     "@types/node": "^22.0.0",