@deepseek-ai/dsh-api-session-controller 0.1.6-alpha.1 → 0.1.7-alpha.1

package/lib/types/client/sessions/session.d.ts

@@ -3,7 +3,7 @@ import type { AttachmentIdType, ImageAttachmentRef } from '@deepseek-ai/dsh-atta
 import type { SubagentAddress } from '@deepseek-ai/dsh-subagent/client';
 import type { MessageId } from '@deepseek-ai/dsh-llm/brand';
 import { SessionSeq, type SessionId } from '@deepseek-ai/dsh-session/types';
-import type { PromptContentPart, QueueAction, SessionControlFrame, SessionQueuedItem, SessionRequestId } from '../../types.ts';
+import type { PromptContentPart, QueueAction, SessionRequestId } from '../../types.ts';
 import type { BeginSubmissionInput, SessionFace, SubmissionHandle } from '../contract/session.ts';
 import type { SessionSnapshot } from '../contract/snapshot.ts';
 import { MutableSessionEventSource } from '../contract/events.ts';
@@ -18,15 +18,12 @@ export declare const JUMP_PAGE_MESSAGES = 200;
 export interface SessionOptions {
     /** Catalog-discovered address selecting non-activating subagent transport. */
     address?: SubagentAddress;
-    /** Whether the exact direct parent Agent was live at the latest catalog read; absent before that read. */
+    /** Whether the exact direct parent Agent is available in Host summaries; absent until known. */
     parentAvailable?: boolean;
     /**
-     * First ACCEPTED prompt on a blank session (fires at most once, on the
-     * prompt RPC's success response): the manager mirrors the blank→false flip
-     * into its list row so the session surfaces without waiting for a host
-     * frame. Acceptance is the flip point because it proves the user message
-     * is in the host log; a rejected first prompt keeps the session blank
-     * (hidden, still reusable by connectWorkspace).
+     * Publish each accepted prompt to the Manager, including after this Session
+     * object is replaced. Acceptance converts display state, but does not
+     * establish that a turn started or reached durable history.
      */
     onEngaged?(session: Session): void;
     /**
@@ -59,8 +56,8 @@ export declare class Session implements SessionFace {
     private jumpTargetSeq;
     /** The running jump loop's completion, shared by retargeting callers. */
     private jumpPromise;
-    /** Authoritative stream-only inbox snapshot; pending work never hits history. */
-    private readonly queueMirror;
+    private pendingHistory;
+    private readonly stopObservingInbox;
     private readonly assistantStream;
     private running;
     private address;
@@ -73,7 +70,7 @@ export declare class Session implements SessionFace {
     private promptAttempted;
     /** A first accepted prompt stays in the engaging phase until its turn is observable. */
     private firstPromptPendingTurn;
-    /** Empty-log mirror (see ConversationSnapshot.blank); unknown bare sessions begin conservatively blank. */
+    /** New Session display state; unknown bare sessions begin conservatively blank. */
     private blankBit;
     private removed;
     private promptError;
@@ -81,7 +78,7 @@ export declare class Session implements SessionFace {
     /** Local submission echoes, insertion-ordered (see SessionSnapshot.pendingSubmissions). */
     private pendingSubmissions;
     /** Per-echo settlement state; `retiring` latches the first observation so a
-     *  queue frame and its durable event cannot both retire one echo. */
+     *  Inbox projection and its durable event cannot both retire one echo. */
     private readonly submissionSettlements;
     /** Owns the addressed page/follow lifecycle while this Session is open. */
     private events;
@@ -89,8 +86,9 @@ export declare class Session implements SessionFace {
      * Per-session projection value store (push model; see the session-projection
      * subsystem page, docs/subsystems/session-projection.md): finished whole
      * values computed on the Host, seeded by the tail page's
-     * projections block and updated by Session Controller control frames under the
-     * one higher-seq-wins rule. Keys are read via `projections.faceOf(key)`
+     * projections block and updated by Session Controller control frames;
+     * Host-sequenced writes merge under higher-seq-wins and cached list blocks
+     * yield to them (projection-store.ts). Keys are read via `projections.faceOf(key)`
      * (the useProjection resolution face); the conversation snapshot never
      * carries projection values, and no client-side domain folding exists.
      * Manager-owned when constructed through SessionManager (frames route and
@@ -199,7 +197,7 @@ export declare class Session implements SessionFace {
     /** Jump loader: page backwards until the window covers seq (see ISession.loadThrough). */
     loadThrough(seq: SessionSeq): Promise<void>;
     /** Rebuild an opened history source after address replacement.
-     *  Invalidates any in-flight open first; queue state belongs to the independently
+     *  Invalidates any in-flight open first; projection state belongs to the independently
      *  reconnecting control stream and remains untouched. */
     resync(): Promise<void>;
     /**
@@ -213,18 +211,6 @@ export declare class Session implements SessionFace {
      * @returns the cached reference (stable until the next flush).
      */
     getSnapshot(): SessionSnapshot;
-    /**
-     * Replace every transient control value for this Session from one stream baseline.
-     * @param queue - complete pending queue for this Session.
-     */
-    replaceControl(queue: readonly SessionQueuedItem[]): void;
-    /**
-     * Apply one Session-addressed live control update.
-     * @param frame - queue replacement addressed to this Session.
-     */
-    handleControlFrame(frame: Extract<SessionControlFrame, {
-        type: 'queue';
-    }>): void;
     /**
      * Running-bit relay from the host stream (list entry and snapshot stay consistent).
      * @param running - the new running state.
@@ -243,11 +229,12 @@ export declare class Session implements SessionFace {
      */
     handleSubagentParentAvailable(available: boolean): void;
     /**
-     * Blank-bit relay from the authoritative summary source (`session.list` and
-     * `api-session/added`). Monotone: once any signal (local first send,
-     * running flip, an earlier summary) cleared it, a stale true never
-     * re-blanks.
-     * @param blank - the summary's derived empty-log bit.
+     * Apply the Manager's effective display blank, further reconciled with the
+     * current `sessionListMetadata` projection. Local send attempts and current
+     * running state prevent re-blanking; an earlier false summary alone does not.
+     * The Manager retains acceptance and earlier running observations across
+     * Session-object replacement.
+     * @param blank - New Session display state after Manager reconciliation.
      */
     handleBlank(blank: boolean): void;
     /** `api-session/removed` relay: flag the snapshot while retaining the resident instance. */
@@ -273,10 +260,12 @@ export declare class Session implements SessionFace {
     private prependWindow;
     /** Append one stream-validated live event. */
     private appendLive;
-    /** Retire the matching echo when a durable browser-prompt `user/message` becomes visible. */
+    /** Observe durable acceptance even when insertion and claim share one projection notification. */
     private observeSubmissionEvent;
-    /** Retire echoes whose prompts landed in the host inbox instead of the log (running-turn submissions). */
-    private observeSubmissionQueue;
+    private observeSteeringInsertions;
+    private observeSubmissionMessage;
+    /** Retire non-steering echoes when the Inbox accepts their queue occurrences. */
+    private observeSubmissionInbox;
     /**
      * Latch one observed settlement and remove the echo an animation frame
      * later. The delay keeps the echo in the snapshot until the frame in which

package/lib/types/client/sessions/session.js

@@ -8,7 +8,6 @@ import { isRemoteFailure } from '@deepseek-ai/dsh-api-gateway/client';
 import { RemoteError } from '@deepseek-ai/dsh-typert-protocol';
 import { ProjectionValueStore } from "./projection-store.js";
 import { resolvedClientTimeZone } from "../time-zone.js";
-import { SessionQueueMirror } from "./queue-mirror.js";
 import { ClientAssistantStream, } from "./assistant-stream.js";
 function projectionsBaseline(value) {
     return {
@@ -44,8 +43,8 @@ export class Session {
     jumpTargetSeq = null;
     /** The running jump loop's completion, shared by retargeting callers. */
     jumpPromise = null;
-    /** Authoritative stream-only inbox snapshot; pending work never hits history. */
-    queueMirror = new SessionQueueMirror();
+    pendingHistory = null;
+    stopObservingInbox;
     assistantStream = new ClientAssistantStream();
     running = false;
     address;
@@ -58,7 +57,7 @@ export class Session {
     promptAttempted = false;
     /** A first accepted prompt stays in the engaging phase until its turn is observable. */
     firstPromptPendingTurn = false;
-    /** Empty-log mirror (see ConversationSnapshot.blank); unknown bare sessions begin conservatively blank. */
+    /** New Session display state; unknown bare sessions begin conservatively blank. */
     blankBit = true;
     removed = false;
     promptError = null;
@@ -66,7 +65,7 @@ export class Session {
     /** Local submission echoes, insertion-ordered (see SessionSnapshot.pendingSubmissions). */
     pendingSubmissions = [];
     /** Per-echo settlement state; `retiring` latches the first observation so a
-     *  queue frame and its durable event cannot both retire one echo. */
+     *  Inbox projection and its durable event cannot both retire one echo. */
     submissionSettlements = new Map();
     /** Owns the addressed page/follow lifecycle while this Session is open. */
     events;
@@ -74,8 +73,9 @@ export class Session {
      * Per-session projection value store (push model; see the session-projection
      * subsystem page, docs/subsystems/session-projection.md): finished whole
      * values computed on the Host, seeded by the tail page's
-     * projections block and updated by Session Controller control frames under the
-     * one higher-seq-wins rule. Keys are read via `projections.faceOf(key)`
+     * projections block and updated by Session Controller control frames;
+     * Host-sequenced writes merge under higher-seq-wins and cached list blocks
+     * yield to them (projection-store.ts). Keys are read via `projections.faceOf(key)`
      * (the useProjection resolution face); the conversation snapshot never
      * carries projection values, and no client-side domain folding exists.
      * Manager-owned when constructed through SessionManager (frames route and
@@ -111,6 +111,9 @@ export class Session {
             this.snapshotCache = this.buildSnapshot();
         });
         this.snapshotCache = this.buildSnapshot();
+        this.stopObservingInbox = this.projections.faceOf('inbox').subscribe(() => {
+            this.observeSubmissionInbox();
+        });
     }
     /**
      * Bind the Agent-scoped context minted by ClientSessions (single write;
@@ -139,16 +142,15 @@ export class Session {
      */
     beginSubmission(input) {
         const requestId = randomUUID();
+        const placement = this.running ? input.mode === 'steer' ? 'steering' : 'queued' : 'transcript';
         this.pendingSubmissions = [...this.pendingSubmissions, {
                 requestId,
-                placement: this.running
-                    ? input.mode === 'steer' ? 'steering' : 'queued'
-                    : 'transcript',
+                placement,
                 time: Date.now(),
                 text: input.text,
                 attachments: input.attachments,
             }];
-        this.submissionSettlements.set(requestId, { onRetire: input.onRetire, retiring: false });
+        this.submissionSettlements.set(requestId, { placement, onRetire: input.onRetire, retiring: false });
         // The blank → engaging edge flips here, ahead of prompt(): the composer
         // docks and the echo renders on the click's own frame.
         this.promptAttempted = true;
@@ -212,19 +214,12 @@ export class Session {
             this.notifier.markDirty();
             return result;
         }
-        // Blank flips on ACCEPTANCE, not attempt: an accepted prompt starts the
-        // conversation's first turn on the host (the host criterion — a logged
-        // turn/start — is fact, not optimism; standalone command and projection
-        // events never flip it), while a rejected first prompt must keep the
-        // session blank — the client-side blank mirror only ever lowers, so
-        // flipping early on a failure would surface the session forever and
-        // strip its connectWorkspace reuse eligibility against the host's
-        // authority.
+        // Rejection must leave a first prompt blank and eligible for workspace reuse.
         if (this.blankBit) {
             this.blankBit = false;
-            this.options.onEngaged?.(this);
             this.notifier.markDirty();
         }
+        this.options.onEngaged?.(this);
         return result;
     }
     /**
@@ -346,6 +341,15 @@ export class Session {
         // loop starts here.
         if (this.loadingOlder)
             return Promise.resolve();
+        const events = this.events;
+        if (events === undefined)
+            return Promise.resolve();
+        const pending = {
+            beforeSeq: this.baseSeq,
+            hasMore: this.hasMore,
+            pages: [],
+        };
+        this.pendingHistory = pending;
         this.jumpTargetSeq = seq;
         this.loadingOlder = true;
         this.notifier.markDirty();
@@ -355,17 +359,14 @@ export class Session {
         const generation = this.openGeneration;
         this.jumpPromise = (async () => {
             try {
-                while (this.hasMore && this.jumpTargetSeq !== null && this.baseSeq > this.jumpTargetSeq) {
+                while (pending.hasMore && this.jumpTargetSeq !== null && pending.beforeSeq > this.jumpTargetSeq) {
                     if (generation !== this.openGeneration)
                         return;
-                    const events = this.events;
-                    if (events === undefined)
-                        return;
-                    const before = this.baseSeq;
-                    await events.prepend({ beforeSeq: this.baseSeq, maxMessages: JUMP_PAGE_MESSAGES });
+                    const before = pending.beforeSeq;
+                    await events.prepend({ beforeSeq: before, maxMessages: JUMP_PAGE_MESSAGES });
                     // No-progress guard: an empty or dropped page that still claims more
                     // history must end the loop, not spin it.
-                    if (this.baseSeq >= before)
+                    if (pending.beforeSeq >= before)
                         return;
                 }
             }
@@ -377,14 +378,18 @@ export class Session {
             finally {
                 this.jumpTargetSeq = null;
                 this.jumpPromise = null;
+                this.pendingHistory = null;
                 this.loadingOlder = false;
+                if (generation === this.openGeneration && pending.pages.length > 0) {
+                    this.prependWindow(pending.pages.reverse().flat(), pending.hasMore);
+                }
                 this.notifier.markDirty();
             }
         })();
         return this.jumpPromise;
     }
     /** Rebuild an opened history source after address replacement.
-     *  Invalidates any in-flight open first; queue state belongs to the independently
+     *  Invalidates any in-flight open first; projection state belongs to the independently
      *  reconnecting control stream and remains untouched. */
     async resync() {
         if (this.openState === 'cold')
@@ -418,31 +423,12 @@ export class Session {
         return this.snapshotCache;
     }
     // ---- Manager-only entry points (@internal; never called by the UI) ----
-    /**
-     * Replace every transient control value for this Session from one stream baseline.
-     * @param queue - complete pending queue for this Session.
-     */
-    replaceControl(queue) {
-        this.queueMirror.replace(queue);
-        this.observeSubmissionQueue(queue);
-        this.notifier.markDirty();
-    }
-    /**
-     * Apply one Session-addressed live control update.
-     * @param frame - queue replacement addressed to this Session.
-     */
-    handleControlFrame(frame) {
-        this.queueMirror.replace(frame.items);
-        this.observeSubmissionQueue(frame.items);
-        this.notifier.markDirty();
-    }
     /**
      * Running-bit relay from the host stream (list entry and snapshot stay consistent).
      * @param running - the new running state.
      */
     handleRunning(running) {
-        // Turn-start conversion: a blank session never runs, so the first
-        // running:true proves another side's first message landed.
+        // Running converts display state without establishing durable turn history.
         if (running && this.blankBit) {
             this.blankBit = false;
             this.notifier.markDirty();
@@ -482,13 +468,15 @@ export class Session {
         this.notifier.markDirty();
     }
     /**
-     * Blank-bit relay from the authoritative summary source (`session.list` and
-     * `api-session/added`). Monotone: once any signal (local first send,
-     * running flip, an earlier summary) cleared it, a stale true never
-     * re-blanks.
-     * @param blank - the summary's derived empty-log bit.
+     * Apply the Manager's effective display blank, further reconciled with the
+     * current `sessionListMetadata` projection. Local send attempts and current
+     * running state prevent re-blanking; an earlier false summary alone does not.
+     * The Manager retains acceptance and earlier running observations across
+     * Session-object replacement.
+     * @param blank - New Session display state after Manager reconciliation.
      */
     handleBlank(blank) {
+        blank = blank && this.projections.values().sessionListMetadata?.blank !== false;
         if (blank === this.blankBit)
             return;
         if (blank && (this.promptAttempted || this.running))
@@ -514,6 +502,7 @@ export class Session {
      * @returns when the Remote iterator has completed teardown.
      */
     async dispose() {
+        this.stopObservingInbox();
         // Unsettled echoes retire as failed so their owners can restore or
         // release browser resources; echoes already scheduled as observed keep
         // that settlement.
@@ -586,13 +575,31 @@ export class Session {
         const visible = this.assistantStream.replace(entries, assistantStream);
         this.baseSeq = SessionLogOffset(entries[0]?.event.seq ?? 0);
         this.hasMore = hasMore;
+        if (this.pendingHistory !== null) {
+            this.pendingHistory.beforeSeq = this.baseSeq;
+            this.pendingHistory.hasMore = hasMore;
+            this.pendingHistory.pages.length = 0;
+        }
         if (visible.some(entry => entry.event.type === 'turn/start'))
             this.firstPromptPendingTurn = false;
         if (projections !== undefined)
             this.projections.seed(projections);
         this.eventSource.replace(visible, hasMore);
+        // A new follow baseline replaces optimistic steering with Host-owned rows.
+        // Receipt-backed inputs are accepted, not failed, even if their history is outside this window.
+        if (projections !== undefined) {
+            for (const [requestId, { receipt }] of this.submissionSettlements) {
+                if (receipt !== undefined && receipt.seq <= projections.asOfSeq) {
+                    this.scheduleObservedRetirement(requestId, receipt.attachments);
+                }
+            }
+        }
         for (const entry of visible)
             this.observeSubmissionEvent(entry.event);
+        if (projections !== undefined) {
+            const inbox = projections.values.inbox;
+            this.observeSteeringInsertions(inbox?.['next-step'] ?? [], 0, projections.asOfSeq);
+        }
         this.notifier.markDirty();
     }
     publishAssistantEntry(result) {
@@ -625,6 +632,13 @@ export class Session {
     }
     /** Prepend one stream-validated history page. */
     prependWindow(entries, hasMore) {
+        if (this.pendingHistory !== null) {
+            const pending = this.pendingHistory;
+            pending.beforeSeq = entries[0] === undefined ? pending.beforeSeq : SessionLogOffset(entries[0].event.seq);
+            pending.hasMore = hasMore;
+            pending.pages.push(entries);
+            return;
+        }
         this.baseSeq = entries[0] === undefined ? this.baseSeq : SessionLogOffset(entries[0].event.seq);
         this.hasMore = hasMore;
         this.eventSource.prepend(entries, hasMore);
@@ -635,36 +649,78 @@ export class Session {
         const awaitingFirstTurn = this.firstPromptPendingTurn;
         if (event.type === 'turn/start')
             this.firstPromptPendingTurn = false;
-        const queueChanged = this.queueMirror.acceptDurable(event);
         this.eventSource.append(entry);
         // After the feed append: the conversation assembly's animation frame is
         // registered by the feed subscribers above, so the echo-retirement frame
         // scheduled here always runs after the durable node became renderable.
         this.observeSubmissionEvent(event);
-        return queueChanged || awaitingFirstTurn !== this.firstPromptPendingTurn;
+        return awaitingFirstTurn !== this.firstPromptPendingTurn;
     }
-    /** Retire the matching echo when a durable browser-prompt `user/message` becomes visible. */
+    /** Observe durable acceptance even when insertion and claim share one projection notification. */
     observeSubmissionEvent(event) {
-        if (this.submissionSettlements.size === 0 || event.type !== 'user/message')
+        if (this.submissionSettlements.size === 0)
+            return;
+        if (event.type === 'agent/inbox/spliced') {
+            const { target, start, removedCount = 0, inserted, outcome } = event.data;
+            if (target === 'next-step') {
+                for (const [requestId, settlement] of this.submissionSettlements) {
+                    const receipt = settlement.receipt;
+                    if (receipt === undefined || receipt.index === null || receipt.seq >= event.seq)
+                        continue;
+                    const removed = receipt.index >= start && receipt.index < start + removedCount;
+                    if (removed && outcome === 'canceled')
+                        this.retireFailedSubmission(requestId);
+                    else
+                        settlement.receipt = {
+                            ...receipt,
+                            seq: event.seq,
+                            index: removed ? null : receipt.index < start ? receipt.index : receipt.index + inserted.length - removedCount,
+                        };
+                }
+                this.observeSteeringInsertions(inserted, start, event.seq);
+            }
+            for (const message of inserted)
+                this.observeSubmissionMessage(message, false);
+            return;
+        }
+        if (event.type === 'request/context' || event.type === 'turn/end') {
+            for (const [requestId, settlement] of this.submissionSettlements) {
+                if (settlement.receipt?.index === null && settlement.receipt.seq < event.seq)
+                    this.retireFailedSubmission(requestId);
+            }
             return;
-        // Structural read: window entries may be compact history records, so the
-        // fields are narrowed rather than trusted (same posture as Conversation
-        // assembly matchers).
-        const data = event.data;
-        const source = data?.source;
-        if (source?.kind !== 'user' || typeof source.rpcId !== 'string')
+        }
+        if (event.type === 'user/message')
+            this.observeSubmissionMessage(event.data, true);
+    }
+    observeSteeringInsertions(messages, start, seq) {
+        for (const [index, message] of messages.entries()) {
+            const source = message.source;
+            if (source.kind !== 'user' || !('rpcId' in source))
+                continue;
+            const settlement = this.submissionSettlements.get(source.rpcId);
+            if (settlement?.placement !== 'steering' || settlement.retiring || (settlement.receipt?.seq ?? -1) > seq)
+                continue;
+            settlement.receipt = { seq, index: start + index, attachments: attachmentRefsIn(message.content) };
+        }
+    }
+    observeSubmissionMessage(message, admitted) {
+        const source = message.source;
+        if (source.kind !== 'user' || !('rpcId' in source))
             return;
-        this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(data?.content));
+        if (!admitted && this.submissionSettlements.get(source.rpcId)?.placement === 'steering')
+            return;
+        this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(message.content));
     }
-    /** Retire echoes whose prompts landed in the host inbox instead of the log (running-turn submissions). */
-    observeSubmissionQueue(items) {
+    /** Retire non-steering echoes when the Inbox accepts their queue occurrences. */
+    observeSubmissionInbox() {
         if (this.submissionSettlements.size === 0)
             return;
-        for (const item of items) {
-            if (item.rpcId !== undefined) {
-                this.scheduleObservedRetirement(item.rpcId, attachmentRefsIn(item.message.content));
-            }
-        }
+        const inbox = this.projections.get('inbox');
+        if (inbox === undefined)
+            return;
+        for (const message of [...inbox['next-turn'], ...inbox['next-step']])
+            this.observeSubmissionMessage(message, false);
     }
     /**
      * Latch one observed settlement and remove the echo an animation frame
@@ -713,15 +769,17 @@ export class Session {
         this.notifier.markDirty();
     }
     buildSnapshot() {
+        const identity = this.projections.values().subagent;
         return {
             sessionId: this.sessionId,
-            queue: this.queueMirror.snapshot(),
             pendingSubmissions: this.pendingSubmissions,
             running: this.running,
             subagent: this.address === undefined
                 ? null
                 : {
-                    address: this.address,
+                    address: this.address.mode === 'unknown' && identity != null
+                        ? { ...this.address, mode: identity.mode }
+                        : this.address,
                     ...(this.parentAvailable === undefined ? {} : { parentAvailable: this.parentAvailable }),
                 },
             removed: this.removed,

package/lib/types/commands.d.ts

@@ -32,8 +32,10 @@ export declare class SessionCommandController {
      */
     rename(request: SessionRenameRequest): Promise<SessionRenameValue>;
     /**
-     * Create a new ordinary Session from one completed-turn prefix.
-     * @param request - source Session and optional event anchor.
+     * Create a new ordinary Session from an exact event prefix. An explicit
+     * `atSeq` is the inclusive cut; an omitted value selects the latest
+     * completed-turn prefix. An open cut receives synthetic fork closers.
+     * @param request - source Session and optional exact event boundary.
      * @returns the new Session identity.
      */
     fork(request: SessionForkRequest): Promise<SessionForkValue>;
@@ -50,11 +52,11 @@ export declare class SessionCommandController {
      */
     attachment(request: SessionAttachmentRequest): Promise<SessionAttachmentValue>;
     /**
-     * Mutate one still-pending queue occurrence without resuming a cold Agent.
+     * Mutate one pending Inbox occurrence, restoring an ordinary cold Agent when needed.
      * @param request - Session, queue item, and requested mutation.
      * @returns acknowledgement that the queue mutation was applied.
      */
-    updateQueue(request: SessionUpdateQueueRequest): SessionUpdateQueueValue;
+    updateQueue(request: SessionUpdateQueueRequest): Promise<SessionUpdateQueueValue>;
     /**
      * Cancel one live ordinary Agent while retaining pending inbox work.
      * @param request - Session whose active Agent turn is cancelled.