@dsh-enhanced/assistant-delivery 0.1.31 → 0.1.34

package/lib/agent-runtime.js

@@ -1,7 +1,9 @@
 import { createHash } from 'node:crypto';
 import { mkdir, stat } from 'node:fs/promises';
+import { isDeepStrictEqual } from 'node:util';
 import { installModelSelection, } from '@deepseek-ai/dsh-agent';
 import { contentHasImage, createUserMessage, ReasoningEffortId, } from '@deepseek-ai/dsh-llm';
+import { TOOL_ABORTED_BEFORE_DISPATCH } from '@deepseek-ai/dsh-tools';
 import { setSandboxMode } from '@deepseek-ai/dsh-sandbox-policy';
 import { isAppendSurfaceEvent, SessionId } from '@deepseek-ai/dsh-session';
 import { setApprovalPolicy, } from '@deepseek-ai/dsh-user-approval';
@@ -328,6 +330,13 @@ export function deliveryProgressFromSessionEvent(event) {
     if (event.type === 'assistant/message') {
         return undefined;
     }
+    if (event.type === 'approval/asked') {
+        // approval/asked is appended before the review waterfall runs, so this label
+        // must stay accurate for both the (usually fast) automatic review and a real
+        // human escalation (which additionally renders a separate allow/reject card).
+        // A tool name here is policy-controlled, but bound it like every other field.
+        return { kind: 'step', text: `正在确认工具「${boundedProgressText(event.data.toolName)}」的调用权限…` };
+    }
     if (event.type === 'tool/call') {
         if (event.data.name === 'ask_user_question') {
             return { kind: 'step', text: '等待您的回答…' };
@@ -864,6 +873,12 @@ function sessionResumeFailureCode(error) {
         return 'session-persistence-corrupt';
     return 'session-resume-unavailable';
 }
+function sessionFormatUnsupportedReply() {
+    return {
+        text: '旧会话格式无法由当前 Host 恢复，记录已保留。请使用 /new 开启会话。',
+        format: 'plain',
+    };
+}
 function sessionFingerprint(value) {
     return createHash('sha256').update(value).digest('hex').slice(0, 8);
 }
@@ -970,13 +985,14 @@ function automaticCompletionPrompt(kind, maxTextBytes, maxOutputTokens) {
 }
 function finalAssistant(events, from, expectedTurn) {
     if (expectedTurn === undefined) {
-        return { text: '', completed: false, truncated: false, stopped: false, hasUnpairedToolCall: false };
+        return { text: '', completed: false, truncated: false, stopped: false, hasUnpairedToolCall: false, hadToolCall: false };
     }
     let text = '';
     let completed = false;
     let truncated = false;
     let stopped = false;
     const unpairedToolCalls = new Set();
+    let hadToolCall = false;
     let failureCode;
     for (const event of events.slice(from)) {
         if (event.type === 'assistant/message' && event.data.turn === expectedTurn) {
@@ -984,6 +1000,7 @@ function finalAssistant(events, from, expectedTurn) {
                 .map(block => block.type === 'text' ? block.text : '').join('');
             for (const block of event.data.message.content) {
                 if (block.type === 'tool-call') {
+                    hadToolCall = true;
                     unpairedToolCalls.add(String(block.id));
                 }
             }
@@ -1019,6 +1036,7 @@ function finalAssistant(events, from, expectedTurn) {
         truncated,
         stopped,
         hasUnpairedToolCall: unpairedToolCalls.size > 0,
+        hadToolCall,
         ...(failureCode === undefined ? {} : { failureCode }),
     };
 }
@@ -1026,6 +1044,58 @@ function isScheduledGoalRuntimeContext(source) {
     return (source.kind === 'plugin' && source.plugin === '@deepseek-ai/dsh-system-prompt' && source.form === 'snapshot')
         || (source.kind === 'skill-catalog' && source.form === 'catalog');
 }
+/**
+ * Trusted Host clarification injected after the human deliberately cancels a
+ * tool call before it dispatched.
+ *
+ * Why this exists: when a turn is aborted by the human, the agent loop persists
+ * a `tool/result` pair whose ONLY model-visible text is the bare technical
+ * string "Error: tool call aborted before dispatch" (`isError: true`). The
+ * accurate structured facts — `error.code = ABORTED_BEFORE_DISPATCH` and the
+ * `turn/end` reason `{ aborted, reason: { user } }` — are not surface events,
+ * so the model never sees them. A string of those error-looking results makes a
+ * later no-op message (e.g. "hi") look like "retry the fetch the system kept
+ * interrupting", causing the model to re-fire the cancelled tool unprompted.
+ *
+ * This text is a FIXED Host constant. It never interpolates message content,
+ * tool names, or arguments, so untrusted input cannot flow into the trusted
+ * snapshot. The predicate keys only off structured, Host-owned fields.
+ */
+const USER_CANCELLED_TOOL_NOTICE = [
+    'The most recent turn was stopped deliberately by the human (they pressed stop or declined the tool permission).',
+    'Any earlier tool result reading "Error: tool call aborted before dispatch" is that human cancellation, NOT a tool or system failure and NOT an instruction to retry.',
+    'Do not retry, resume, restart, or continue any tool call or task that was interrupted by that stop.',
+    'Respond only to the human\'s latest message on its own terms. Resume the earlier work only if the human explicitly asks for it again.',
+].join(' ');
+/** Whether a `turn/end` reason is a human-initiated abort (stop, /new, or a declined approval). */
+function isUserAbortedTurnEnd(reason) {
+    return typeof reason === 'object' && reason !== null
+        && reason.kind === 'aborted'
+        && typeof reason.reason === 'object'
+        && reason.reason?.kind === 'user';
+}
+/**
+ * Returns the fixed Host clarification when the most recent turn boundary is a
+ * human abort whose turn contains an aborted-before-dispatch tool result;
+ * otherwise `''`. Pure over the supplied events so the projection dedups stable
+ * text across repeated no-op messages and flips to empty once a turn completes.
+ */
+function userCancelledToolNotice(events) {
+    let lastEnd;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event?.type === 'turn/end') {
+            lastEnd = event;
+            break;
+        }
+    }
+    if (lastEnd === undefined || !isUserAbortedTurnEnd(lastEnd.data.reason))
+        return '';
+    const abortedBeforeDispatch = events.some(event => event.type === 'tool/result'
+        && event.data.turn === lastEnd.data.turn
+        && event.data.error?.code === TOOL_ABORTED_BEFORE_DISPATCH);
+    return abortedBeforeDispatch ? USER_CANCELLED_TOOL_NOTICE : '';
+}
 export class DshDeliveryRuntime {
     ctx;
     policy;
@@ -1385,6 +1455,7 @@ export class DshDeliveryRuntime {
             aborted();
         return {
             settle: beginSettling,
+            pinActiveArmedGoal: pinArmedGoal,
             teardownTimeoutMs,
             isQuiescent,
             dispose: () => {
@@ -1658,8 +1729,8 @@ export class DshDeliveryRuntime {
                 releaseToolBarriers();
         }
     }
-    async setupAgent(agentCtx, workspace, presetId, principal, selected, agentPresets, initiator = 'external') {
-        const agent = agentCtx.agent;
+    async setupAgent(agentCtx, preparedAgent, workspace, presetId, principal, selected, agentPresets, initiator = 'external') {
+        const agent = preparedAgent ?? agentCtx.agent;
         if (agent === undefined)
             throw new Error('assistant-delivery: unpublished Agent identity is missing');
         if (agent.session.header.cwd !== workspace || agent.session.header.agentPreset !== presetId) {
@@ -1668,6 +1739,36 @@ export class DshDeliveryRuntime {
         const unbind = this.policy.bindInitiator(agent, initiator, principal);
         agentCtx.effect(() => unbind, `assistant-delivery.${initiator}-initiator`);
         installModelSelection(agentCtx, { current: selected, assembled: undefined });
+        // The trusted post-cancellation clarification is installed LAZILY and only
+        // for a session whose history actually contains a human-aborted turn with an
+        // aborted-before-dispatch tool result. Merely registering a runtime context
+        // flips the system-prompt assembly out of its empty baseline and perturbs the
+        // cold-resume/lease-recovery accounting for EVERY ordinary session (a
+        // permission /stop compensation run has no such tool result, yet regressed
+        // when the context was registered unconditionally). Keep the exact baseline —
+        // no contribution installed at all — until the Host-owned predicate matches.
+        let cancelNoticeInstalled = false;
+        const installUserCancelledToolNotice = () => {
+            if (cancelNoticeInstalled)
+                return;
+            if (!userCancelledToolNotice(agent.session.snapshotEvents()))
+                return;
+            cancelNoticeInstalled = true;
+            agentCtx.inject(['systemPrompt'], promptCtx => promptCtx.systemPrompt.context({
+                name: 'assistant-delivery:user-cancelled-tool-notice',
+                order: 260,
+                text: () => userCancelledToolNotice(agent.session.snapshotEvents()),
+            }));
+        };
+        // A cold resume may already carry the abort (the real Feishu sequence did).
+        installUserCancelledToolNotice();
+        // A live abort only becomes visible once its turn/end + tool/result land.
+        agentCtx.on('session/event', (eventSession, event) => {
+            if (eventSession !== agent.session)
+                return;
+            if (event.type === 'turn/end' || event.type === 'tool/result')
+                installUserCancelledToolNotice();
+        });
         await agentPresets?.mount(agentCtx, presetId);
     }
     /**
@@ -1858,8 +1959,8 @@ export class DshDeliveryRuntime {
                     model: selected.model,
                     maxTokens: this.options.maxOutputTokens,
                 },
-                setup: async (agentCtx) => {
-                    await this.setupAgent(agentCtx, binding.workspace, presetId, externalPrincipalId(binding.principal), selected, agentPresets);
+                setup: async (agentCtx, preparedAgent) => {
+                    await this.setupAgent(agentCtx, preparedAgent, binding.workspace, presetId, externalPrincipalId(binding.principal), selected, agentPresets);
                 },
             });
             signal.throwIfAborted();
@@ -2177,8 +2278,8 @@ export class DshDeliveryRuntime {
         await ensureWorkspace(workspace);
         const selected = agentSelection(toModelRoute(this.options.getModelSelection(input.envelope.conversation)
             ?? { provider: this.options.provider, model: this.options.model }));
-        const setup = async (agentCtx) => {
-            await this.setupAgent(agentCtx, workspace, presetId, externalPrincipalId(input.envelope.principal), selected, agentPresets);
+        const setup = async (agentCtx, preparedAgent) => {
+            await this.setupAgent(agentCtx, preparedAgent, workspace, presetId, externalPrincipalId(input.envelope.principal), selected, agentPresets);
         };
         const lease = this.sessionLeases.open({ kind: 'construction', sessionId: String(id),
             conversation: input.envelope.conversation, principal: input.envelope.principal,
@@ -2292,17 +2393,18 @@ export class DshDeliveryRuntime {
                 resumeSessionId: SessionId(binding.sessionId),
                 signal: control.controller.signal,
                 agentOptions: { provider: selected.provider, model: selected.model, maxTokens: this.options.maxOutputTokens },
-                setup: async (agentCtx) => {
+                setup: async (agentCtx, preparedAgent) => {
                     // Restored inbox entries may wake immediately on Session publication.
                     // Install the background-only gate before that publication boundary.
-                    if (agentCtx.agent === undefined)
+                    const agent = preparedAgent ?? agentCtx.agent;
+                    if (agent === undefined)
                         throw new Error('assistant-delivery: wake Agent missing');
-                    releaseFences = this.installScheduledGoalFences(agentCtx.agent, input);
-                    await this.setupAgent(agentCtx, binding.workspace, presetId, input.attestation.principalId, selected, presets, 'background');
+                    releaseFences = this.installScheduledGoalFences(agent, input);
+                    await this.setupAgent(agentCtx, agent, binding.workspace, presetId, input.attestation.principalId, selected, presets, 'background');
                     const llm = this.ctx.get('llm');
                     if (llm === undefined)
                         throw new Error('assistant-delivery: llm service is required');
-                    requireAdapterToolCallProtocol(llm, selected.provider, selected.model, presetId, agentCtx.tools.schemas(agentCtx.agent).length);
+                    requireAdapterToolCallProtocol(llm, selected.provider, selected.model, presetId, agentCtx.tools.schemas(preparedAgent ?? agentCtx.agent).length);
                 },
             });
             const agent = handle.agent;
@@ -2414,6 +2516,39 @@ export class DshDeliveryRuntime {
         input.assertCurrent(agent, phase);
     }
     installScheduledGoalFences(agent, input) {
+        let pendingGoalStep;
+        const nativeGoalStep = (source) => {
+            const native = this.ctx.get('goals')?.get(agent);
+            const round = source.round;
+            if (source.kind !== 'goal' || String(source.goalId) !== input.native.goalId
+                || source.revision !== input.native.revision + 1 || typeof round !== 'number' || !Number.isSafeInteger(round) || round < 1
+                || native === undefined || native.phase !== 'active' || String(native.id) !== input.native.goalId
+                || native.revision !== source.revision || round !== native.roundsStarted + 1)
+                return undefined;
+            return { turn: 0, step: 0, goalId: String(source.goalId), revision: source.revision, round };
+        };
+        const durableTurnMessages = (turn) => {
+            const events = agent.session.snapshotEvents();
+            const start = events.findLast(event => event.type === 'turn/start');
+            if (start?.type !== 'turn/start' || start.data.turn !== turn
+                || events.some(event => event.seq > start.seq && event.type === 'turn/end')) {
+                throw new Error('assistant-delivery: exact native goal turn required');
+            }
+            return events.filter(event => event.seq > start.seq && event.type === 'user/message'
+                && !isScheduledGoalRuntimeContext(event.data.source));
+        };
+        const pendingCurrent = (turn, step) => {
+            const pending = pendingGoalStep;
+            if (pending === undefined || pending.turn !== turn || pending.step !== step)
+                return undefined;
+            const native = this.ctx.get('goals')?.get(agent);
+            // Only bridge the gap before the accepted goal input is durably folded.
+            // Once any input appears, the ordinary snapshot fence must verify it.
+            if (native === undefined || native.phase !== 'active' || String(native.id) !== pending.goalId
+                || native.revision !== pending.revision || native.roundsStarted !== pending.round - 1)
+                return undefined;
+            return pending;
+        };
         const goalTurn = () => {
             const events = agent.session.snapshotEvents();
             const start = events.findLast(event => event.type === 'turn/start');
@@ -2439,23 +2574,57 @@ export class DshDeliveryRuntime {
             catch { }
             throw new Error('assistant-delivery: scheduled goal wake authorization changed');
         };
-        const request = agent.ctx.on('agent/request', async (_payload, next) => {
-            try {
-                goalTurn();
+        const clearPending = () => { pendingGoalStep = undefined; };
+        input.signal.addEventListener('abort', clearPending, { once: true });
+        const preStep = agent.ctx.on('agent/pre-step', async (payload, next) => {
+            // A pre-step decision is the sole new-Host bridge between the claimed
+            // inbox item and its later durable append.  Never carry it into another
+            // boundary, rejection, replacement, or retry.
+            clearPending();
+            const offered = payload.messages.filter(message => !isScheduledGoalRuntimeContext(message.source));
+            const offeredMessage = offered.length === 1 ? structuredClone(offered[0]) : undefined;
+            const decision = await next();
+            if (payload.signal.aborted || input.signal.aborted || decision.kind !== 'enter')
+                return decision;
+            const entered = decision.messages.filter(message => !isScheduledGoalRuntimeContext(message.source));
+            if (offeredMessage === undefined || entered.length !== 1
+                || typeof offeredMessage.id !== 'string' || offeredMessage.id.length === 0
+                || !isDeepStrictEqual(entered[0], offeredMessage))
+                return decision;
+            const candidate = nativeGoalStep(entered[0].source);
+            if (candidate === undefined)
+                return decision;
+            pendingGoalStep = { ...candidate, turn: payload.turn, step: payload.step };
+            return decision;
+        }, { prepend: true });
+        const request = agent.ctx.on('agent/request', async (payload, next) => {
+            const assertRequest = () => {
+                payload.signal.throwIfAborted();
+                if (durableTurnMessages(payload.turn).length > 0)
+                    goalTurn();
+                else if (pendingCurrent(payload.turn, payload.step) === undefined)
+                    throw new Error('assistant-delivery: native goal step not admitted');
                 this.assertScheduledGoal(input, agent, 'running');
-            }
-            catch {
-                return reject();
-            }
-            const result = await next();
+            };
             try {
-                goalTurn();
-                this.assertScheduledGoal(input, agent, 'running');
+                try {
+                    assertRequest();
+                }
+                catch {
+                    return reject();
+                }
+                const result = await next();
+                try {
+                    assertRequest();
+                }
+                catch {
+                    return reject();
+                }
+                return result;
             }
-            catch {
-                return reject();
+            finally {
+                clearPending();
             }
-            return result;
         }, { prepend: true });
         const preExecute = agent.ctx.on('tools/pre-execute', async (_payload, next) => {
             try {
@@ -2485,7 +2654,7 @@ export class DshDeliveryRuntime {
                 return 'assistant-delivery: scheduled goal wake authorization changed';
             }
         });
-        return () => { request(); preExecute(); guard(); };
+        return () => { input.signal.removeEventListener('abort', clearPending); clearPending(); preStep(); request(); preExecute(); guard(); };
     }
     waitForScheduledGoalTerminal(agent, input, signal) {
         return new Promise(resolve => {
@@ -2988,8 +3157,8 @@ export class DshDeliveryRuntime {
                     model: selected.model,
                     maxTokens: this.options.maxOutputTokens,
                 },
-                setup: async (agentCtx) => {
-                    await this.setupAgent(agentCtx, binding.workspace, presetId, externalPrincipalId(binding.principal), selected, agentPresets);
+                setup: async (agentCtx, preparedAgent) => {
+                    await this.setupAgent(agentCtx, preparedAgent, binding.workspace, presetId, externalPrincipalId(binding.principal), selected, agentPresets);
                 },
             });
             resumed = true;
@@ -3301,6 +3470,8 @@ export class DshDeliveryRuntime {
         let handle;
         let dispatched = false;
         let acceptance;
+        let foregroundExecution;
+        let removeAcceptanceRequest;
         let acceptanceSucceeded = false;
         let goalContinuation;
         let goalContinuationQuiescent = true;
@@ -3329,12 +3500,12 @@ export class DshDeliveryRuntime {
             handle = await this.resumeAgent({ resumeSessionId: SessionId(binding.sessionId), signal,
                 agentOptions: { provider: selected.provider, model: selected.model,
                     maxTokens: this.options.maxOutputTokens },
-                setup: async (agentCtx) => {
-                    await this.setupAgent(agentCtx, binding.workspace, presetId, externalPrincipalId(binding.principal), selected, agentPresets);
+                setup: async (agentCtx, preparedAgent) => {
+                    await this.setupAgent(agentCtx, preparedAgent, binding.workspace, presetId, externalPrincipalId(binding.principal), selected, agentPresets);
                     const llm = this.ctx.get('llm');
                     if (llm === undefined)
                         throw new Error('assistant-delivery: llm service is required');
-                    requireAdapterToolCallProtocol(llm, selected.provider, selected.model, presetId, agentCtx.tools.schemas(agentCtx.agent).length);
+                    requireAdapterToolCallProtocol(llm, selected.provider, selected.model, presetId, agentCtx.tools.schemas(preparedAgent ?? agentCtx.agent).length);
                 } });
             const agent = handle.agent;
             await this.reconcileNativeFullPermissionReviewer(agent.session);
@@ -3398,6 +3569,20 @@ export class DshDeliveryRuntime {
             // host driver is otherwise free to claim its first round at idle.
             goalContinuation = this.waitForNativeGoalContinuation(binding, envelope, agent, signal);
             acceptance = this.options.prepareForegroundTaskAcceptance(binding, envelope);
+            foregroundExecution = this.options.beginForegroundTaskExecution(binding, envelope);
+            if (acceptance !== undefined || foregroundExecution !== undefined)
+                removeAcceptanceRequest = this.ctx.on('session/event', (session, event) => {
+                    if (session !== agent.session || event.type !== 'request/header')
+                        return;
+                    // `agent/request` exposes the candidate route.  The native loop writes
+                    // this header only after `llm.prepareCall()` has applied adapter
+                    // defaults such as reasoning effort, which is the route actually sent
+                    // to the provider.
+                    if (foregroundExecution !== undefined)
+                        this.options.recordForegroundExecutionModelSelection(foregroundExecution, event.data.header.config);
+                    if (acceptance !== undefined)
+                        this.options.recordForegroundTaskModelSelection(acceptance, event.data.header.config);
+                });
             markDispatching();
             // Once the durable marker exists, even a synchronous followup failure is ambiguous:
             // implementations may enqueue before throwing, so no retry is safe.
@@ -3561,18 +3746,28 @@ export class DshDeliveryRuntime {
                     return { outcome: 'not-processed', failureCode: 'agent-turn-incomplete', retryable: false };
                 }
                 if (currentEmpty || assembledText.trim() === '') {
-                    const hasPartial = bestEffortText.trim() !== '';
-                    this.options.replyCommand(binding, envelope.eventId, {
-                        text: hasPartial
-                            ? truncatedAgentReply(bestEffortText, this.options.maxTextBytes)
-                            : emptyAgentReply(this.options.maxTextBytes),
-                        format: 'markdown',
-                    });
-                    publishProgress({
-                        kind: 'failed',
-                        code: hasPartial ? AGENT_OUTPUT_TRUNCATED_CODE : AGENT_EMPTY_RESPONSE_CODE,
-                    });
-                    return { outcome: 'processed' };
+                    // A tool-only foreground turn can arm a native goal (typically
+                    // `goal_create`); the host round driver then continues with its own
+                    // rounds and this turn has no user-facing reply text. It must not be
+                    // classified as an empty response, which would dispose the armed
+                    // continuation fence and cancel the in-flight goal round.
+                    if (output.hadToolCall && goalContinuation?.pinActiveArmedGoal()) {
+                        // Fall through to the continuation fence below instead of replying.
+                    }
+                    else {
+                        const hasPartial = bestEffortText.trim() !== '';
+                        this.options.replyCommand(binding, envelope.eventId, {
+                            text: hasPartial
+                                ? truncatedAgentReply(bestEffortText, this.options.maxTextBytes)
+                                : emptyAgentReply(this.options.maxTextBytes),
+                            format: 'markdown',
+                        });
+                        publishProgress({
+                            kind: 'failed',
+                            code: hasPartial ? AGENT_OUTPUT_TRUNCATED_CODE : AGENT_EMPTY_RESPONSE_CODE,
+                        });
+                        return { outcome: 'processed' };
+                    }
                 }
                 break;
             }
@@ -3580,10 +3775,12 @@ export class DshDeliveryRuntime {
             // The foreground reply has already crossed its durable reply path.
             // Retain the same Agent afterwards only for the native goal driver; its
             // unknown result must never turn the original reply into a claim that
-            // the business goal was achieved.
-            const learning = await this.options.replyCompletedPreferenceTurn(agent, binding, envelope, { text: assembledText, format: 'markdown' });
-            if (learning === 'unknown') {
-                this.ctx.logger.warn('assistant-delivery: completed-turn preference projection is ambiguous');
+            // the business goal was achieved. A tool-only turn has no reply text.
+            if (assembledText.trim() !== '') {
+                const learning = await this.options.replyCompletedPreferenceTurn(agent, binding, envelope, { text: assembledText, format: 'markdown' });
+                if (learning === 'unknown') {
+                    this.ctx.logger.warn('assistant-delivery: completed-turn preference projection is ambiguous');
+                }
             }
             if (goalContinuation !== undefined) {
                 goalContinuationQuiescent = await goalContinuation.settle();
@@ -3609,6 +3806,21 @@ export class DshDeliveryRuntime {
             if (causedByDurableIdentity(error)) {
                 return { outcome: 'not-processed', failureCode: 'agent-identity-mismatch', retryable: false };
             }
+            if (errorChainHasName(error, 'SessionFormatUnsupportedError')) {
+                this.ctx.logger.warn(`assistant-delivery: session-format-unsupported for session ${sessionFingerprint(binding.sessionId)}`);
+                try {
+                    this.options.replyCommand(binding, envelope.eventId, sessionFormatUnsupportedReply());
+                    // The durable reply is the only user effect.  Dead-letter the original
+                    // inbound event so a legacy format cannot consume the normal retry
+                    // budget or produce a second notification.
+                    return { outcome: 'not-processed', failureCode: 'session-format-unsupported', retryable: false };
+                }
+                catch {
+                    // Do not mark a terminal diagnosis without its owner-authorized,
+                    // durable reply; Coordinator may retry this pre-dispatch failure.
+                    return { outcome: 'not-processed', failureCode: 'session-format-unsupported-notice-failed', retryable: true };
+                }
+            }
             if (error instanceof ImageCapabilityAdmissionError) {
                 try {
                     this.options.replyCommand(binding, envelope.eventId, imageCapabilityReply(error));
@@ -3632,6 +3844,7 @@ export class DshDeliveryRuntime {
         }
         finally {
             removeAbort?.();
+            removeAcceptanceRequest?.();
             removeProgress?.();
             progressOpen = false;
             let disposed = false;
@@ -3641,6 +3854,16 @@ export class DshDeliveryRuntime {
             finally {
                 acceptanceSucceeded = acceptanceSucceeded && disposed && !signal.aborted
                     && (goalContinuation?.isQuiescent() ?? true);
+                if (foregroundExecution !== undefined) {
+                    try {
+                        this.options.completeForegroundTaskExecution(foregroundExecution, {
+                            status: acceptanceSucceeded ? 'succeeded' : 'unknown', quiescent: acceptanceSucceeded,
+                        });
+                    }
+                    catch (error) {
+                        this.ctx.logger.warn(`assistant-delivery: foreground execution completion failed: ${String(error)}`);
+                    }
+                }
                 if (acceptance !== undefined) {
                     try {
                         await this.options.completeForegroundTaskAcceptance(acceptance, {