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

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

@@ -15,10 +15,15 @@ function projectionsBaseline(value) {
         asOfSeq: value.asOfSeq === -1 ? -1 : SessionSeq(value.asOfSeq),
     };
 }
-/** Messages requested per history page. */
+/** Minimum message count for ordinary history windows. */
 export const PAGE_MESSAGES = 50;
-/** Messages requested per page while a turn jump loops backwards (fewer, larger round trips). */
+const HISTORY_PAGE_OPTIONS = { maxMessages: 500, turnWindow: { minMessages: PAGE_MESSAGES, minTurns: 2 } };
+/** Minimum messages per page while a turn jump loops backwards. */
 export const JUMP_PAGE_MESSAGES = 200;
+const JUMP_PAGE_OPTIONS = {
+    ...HISTORY_PAGE_OPTIONS,
+    turnWindow: { ...HISTORY_PAGE_OPTIONS.turnWindow, minMessages: JUMP_PAGE_MESSAGES },
+};
 /**
  * Owns a session's event window, lifecycle state, and observable
  * snapshot. React bindings remain outside this data layer. Features see only
@@ -43,6 +48,7 @@ export class Session {
     jumpTargetSeq = null;
     /** The running jump loop's completion, shared by retargeting callers. */
     jumpPromise = null;
+    pendingHistory = null;
     stopObservingInbox;
     assistantStream = new ClientAssistantStream();
     running = false;
@@ -56,7 +62,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;
@@ -72,8 +78,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
@@ -140,16 +147,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;
@@ -213,19 +219,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;
     }
     /**
@@ -310,7 +309,7 @@ export class Session {
         this.openPromise = promise;
         return promise;
     }
-    /** Page up: pull one earlier page with the window's first seq as beforeSeq and prepend. */
+    /** Prepend one Turn-aligned page: at least 50 messages and two Turn starts, capped at 500 messages. */
     async loadOlder() {
         if (this.openState !== 'open' || !this.hasMore || this.loadingOlder)
             return;
@@ -320,7 +319,10 @@ export class Session {
         this.loadingOlder = true;
         this.notifier.markDirty();
         try {
-            await events.prepend({ beforeSeq: this.baseSeq, maxMessages: PAGE_MESSAGES });
+            await events.prepend({
+                beforeSeq: this.baseSeq,
+                ...HISTORY_PAGE_OPTIONS,
+            });
         }
         catch (error) {
             if (!isRemoteFailure(error)) {
@@ -347,6 +349,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();
@@ -356,17 +367,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, ...JUMP_PAGE_OPTIONS });
                     // 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;
                 }
             }
@@ -378,7 +386,11 @@ 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();
             }
         })();
@@ -424,8 +436,7 @@ export class Session {
      * @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();
@@ -465,13 +476,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))
@@ -499,10 +512,12 @@ export class Session {
     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.
-        for (const requestId of [...this.submissionSettlements.keys()]) {
-            this.retireFailedSubmission(requestId);
+        // release browser resources; admitted echoes keep their observed outcome.
+        for (const [requestId, settlement] of [...this.submissionSettlements]) {
+            if (settlement.admitted !== undefined)
+                this.scheduleObservedRetirement(requestId, settlement.admitted);
+            else
+                this.retireFailedSubmission(requestId);
         }
         this.openGeneration++;
         const events = this.events;
@@ -527,7 +542,7 @@ export class Session {
         });
         this.events = events;
         try {
-            await events.open({ maxMessages: PAGE_MESSAGES });
+            await events.open(HISTORY_PAGE_OPTIONS);
             if (generation !== this.openGeneration || this.events !== events)
                 return;
             this.openState = 'open';
@@ -570,13 +585,33 @@ 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 confirmed optimistic inputs 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;
+            for (const target of ['next-turn', 'next-step']) {
+                this.observeSubmissionInsertions(target, inbox?.[target] ?? [], 0, projections.asOfSeq);
+            }
+        }
         this.notifier.markDirty();
     }
     publishAssistantEntry(result) {
@@ -609,6 +644,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);
@@ -631,37 +673,91 @@ export class Session {
         if (this.submissionSettlements.size === 0)
             return;
         if (event.type === 'agent/inbox/spliced') {
-            const splice = event.data;
-            if (Array.isArray(splice?.inserted)) {
-                for (const message of splice.inserted)
-                    this.observeSubmissionEvent({ type: 'user/message', data: message });
+            const { target, start, removedCount = 0, inserted, outcome } = event.data;
+            for (const [requestId, settlement] of this.submissionSettlements) {
+                const receipt = settlement.receipt;
+                if (receipt?.target !== target || 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.observeSubmissionInsertions(target, 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.admitted === undefined && settlement.receipt?.index === null
+                    && settlement.receipt.seq < event.seq)
+                    this.retireFailedSubmission(requestId);
             }
             return;
         }
-        if (event.type !== 'user/message')
+        if (event.type === 'user/message')
+            this.observeSubmissionMessage(event.data, true);
+    }
+    observeSubmissionInsertions(target, 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 === undefined || settlement.placement === 'queued'
+                || settlement.retiring || (settlement.receipt?.seq ?? -1) > seq)
+                continue;
+            settlement.receipt = { target, seq, index: start + index, attachments: attachmentRefsIn(message.content) };
+        }
+    }
+    observeSubmissionMessage(message, admitted) {
+        const source = message.source;
+        if (source.kind !== 'user' || !('rpcId' in source))
+            return;
+        const settlement = this.submissionSettlements.get(source.rpcId);
+        if (settlement === undefined || settlement.retiring)
+            return;
+        if (!admitted) {
+            if (settlement.placement === 'queued')
+                this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(message.content));
+            return;
+        }
+        settlement.admitted = attachmentRefsIn(message.content);
+        this.retireAdmittedSubmission(source.rpcId);
+    }
+    /** Retire admitted Chat identities only after stale Inbox rows can no longer reappear. */
+    retireAdmittedSubmission(requestId) {
+        const settlement = this.submissionSettlements.get(requestId);
+        if (settlement?.admitted === undefined)
             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')
+        const receipt = settlement.receipt;
+        if (receipt?.index === null
+            && (this.projections.seqOf('inbox') ?? -1) < receipt.seq)
             return;
-        this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(data?.content));
+        this.scheduleObservedRetirement(requestId, settlement.admitted);
     }
-    /** Retire local echoes when their accepted messages appear in the durable Inbox projection. */
+    /** Inbox acceptance retires queued echoes; its watermark completes admitted Chat handoffs. */
     observeSubmissionInbox() {
         if (this.submissionSettlements.size === 0)
             return;
         const inbox = this.projections.get('inbox');
         if (inbox === undefined)
             return;
-        for (const message of [...inbox['next-turn'], ...inbox['next-step']]) {
-            const source = message.source;
-            if (source.kind === 'user' && 'rpcId' in source) {
-                this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(message.content));
-            }
+        const seq = this.projections.seqOf('inbox');
+        for (const target of ['next-turn', 'next-step']) {
+            if (seq !== undefined)
+                this.observeSubmissionInsertions(target, inbox[target], 0, seq);
+            for (const message of inbox[target])
+                this.observeSubmissionMessage(message, false);
         }
+        for (const requestId of this.submissionSettlements.keys())
+            this.retireAdmittedSubmission(requestId);
     }
     /**
      * Latch one observed settlement and remove the echo an animation frame
@@ -679,7 +775,7 @@ export class Session {
     /** Remove one unsettled echo immediately (prompt rejection, abort, or disposal). */
     retireFailedSubmission(requestId) {
         const settlement = this.submissionSettlements.get(requestId);
-        if (settlement === undefined || settlement.retiring)
+        if (settlement === undefined || settlement.retiring || settlement.admitted !== undefined)
             return;
         settlement.retiring = true;
         this.finishSubmission(requestId, { reason: 'failed' });
@@ -710,6 +806,7 @@ export class Session {
         this.notifier.markDirty();
     }
     buildSnapshot() {
+        const identity = this.projections.values().subagent;
         return {
             sessionId: this.sessionId,
             pendingSubmissions: this.pendingSubmissions,
@@ -717,7 +814,9 @@ export class Session {
             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/client/transport.js

@@ -76,7 +76,7 @@ export class SessionEventStream extends RemoteJournalStream {
         for await (const frame of this.remote.session.follow({
             address: this.address,
             assistantStream: true,
-            ...(request.maxMessages === undefined ? {} : { maxMessages: request.maxMessages }),
+            ...this.repairRequest(request),
         }, signal)) {
             if (frame.type === 'snapshot') {
                 for (const record of frame.records)
@@ -121,7 +121,10 @@ export class SessionEventStream extends RemoteJournalStream {
     }
     /** @inheritdoc */
     repairRequest(request) {
-        return request.maxMessages === undefined ? {} : { maxMessages: request.maxMessages };
+        return {
+            ...(request.maxMessages === undefined ? {} : { maxMessages: request.maxMessages }),
+            ...(request.turnWindow === undefined ? {} : { turnWindow: request.turnWindow }),
+        };
     }
 }
 //# sourceMappingURL=transport.js.map

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>;

package/lib/types/commands.js

@@ -55,6 +55,7 @@ import { randomUUID } from 'node:crypto';
 import { brandString } from '@deepseek-ai/dsh-brand';
 import { AttachmentError } from '@deepseek-ai/dsh-attachment';
 import { ReasoningEffortId, assistantStreamChunks, createUserMessage, freezeMessage, } from '@deepseek-ai/dsh-llm';
+import { buildForkSeed } from '@deepseek-ai/dsh-session/fork';
 import { SessionLogOffset, SessionSeq } from '@deepseek-ai/dsh-session';
 import { SessionQueryError } from '@deepseek-ai/dsh-session-query';
 import { SessionTitleInvalidError } from '@deepseek-ai/dsh-session-title';
@@ -65,6 +66,23 @@ import { ApiSessionCwdConflict, ApiSessionNotFound, ApiSessionPresetConflict, Ap
 function hasPromptContent(content) {
     return content.some(part => part.type !== 'text' || part.text.trim().length > 0);
 }
+/**
+ * Resolve the omitted-`atSeq` default to the latest completed-turn prefix,
+ * including standalone events before the next turn begins.
+ */
+function latestCompletedPrefixBoundary(events) {
+    const lastTurnEnd = events.findLast(event => event.type === 'turn/end');
+    if (lastTurnEnd === undefined)
+        return undefined;
+    let boundary = lastTurnEnd.seq;
+    for (const next of events.slice(boundary + 1)) {
+        if (next.type === 'turn/start' || (next.type === 'user/message' && next.surfaceOp === 'append')
+            || next.type === 'agent/inbox/spliced')
+            break;
+        boundary = next.seq;
+    }
+    return boundary;
+}
 /** Implements Session business commands delegated by the Session Controller Remote service. */
 export class SessionCommandController {
     ctx;
@@ -180,8 +198,10 @@ export class SessionCommandController {
         }
     }
     /**
-     * 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.
      */
     async fork(request) {
@@ -208,20 +228,13 @@ export class SessionCommandController {
                 throw new RemoteError('gateway/internal', `fork source unavailable for session "${request.sessionId}": ${String(error)}`, {});
             }
             const source = __addDisposableResource(env_1, observed, false);
-            const lastSeq = source.events.at(-1)?.seq ?? -1;
-            const anchoredBoundary = atSeq === undefined
-                ? undefined
-                : source.events.find(event => event.type === 'turn/end' && event.seq >= atSeq);
-            const boundary = anchoredBoundary
-                ?? (atSeq === undefined || atSeq > lastSeq
-                    ? source.events.findLast(event => event.type === 'turn/end')
-                    : undefined);
-            if (boundary === undefined) {
-                throw new RemoteError('session/fork-unavailable', atSeq !== undefined && atSeq <= lastSeq
-                    ? `session "${request.sessionId}" has not completed the turn containing event ${String(atSeq)}`
-                    : `session "${request.sessionId}" has no completed turn to fork from`, { sessionId: request.sessionId });
+            const boundary = atSeq ?? latestCompletedPrefixBoundary(source.events);
+            if (boundary === undefined || source.events[boundary]?.seq !== boundary) {
+                throw new RemoteError('session/fork-unavailable', request.atSeq === undefined
+                    ? `session "${request.sessionId}" has no completed turn to fork from`
+                    : `event ${String(request.atSeq)} does not exist in session "${request.sessionId}" (last seq: ${String(source.events.at(-1)?.seq ?? 'none')})`, { sessionId: request.sessionId });
             }
-            const cut = SessionLogOffset(boundary.seq + 1);
+            const seed = buildForkSeed(source.events, boundary);
             let workspace;
             try {
                 workspace = await this.forkWorkspace(source.header);
@@ -235,8 +248,8 @@ export class SessionCommandController {
                 const { provider, model } = this.ctx.agentDefaultModel.currentSelection();
                 await this.ctx.agents.create({
                     sessionId: childId,
-                    seed: source.events.slice(0, cut),
-                    inheritedEventCount: cut,
+                    seed,
+                    inheritedEventCount: SessionLogOffset(boundary + 1),
                     meta: {
                         ...(source.header.cwd === undefined ? {} : { cwd: source.header.cwd }),
                         parentSession: source.header.id,
@@ -383,6 +396,7 @@ export class SessionCommandController {
      */
     async updateQueue(request) {
         if (request.action.kind === 'edit') {
+            // oxlint-disable-next-line typescript/no-unnecessary-condition -- Remote callers can submit untyped JSON.
             if (request.action.content.some(block => block.type !== 'text')) {
                 throw new RemoteError('session/attachment-invalid', 'queue edits accept text content only', { reason: 'QUEUE_EDIT_NON_TEXT' });
             }
@@ -471,6 +485,9 @@ export class SessionCommandController {
     rejectCreation(sessionId, error) {
         if (remoteErrorOf(error) !== undefined)
             throw error;
+        if (error instanceof Error && error.name === 'SessionAlreadyOwnedError') {
+            throw new RemoteError('session/writer-held', error.message, { sessionId });
+        }
         if (error instanceof ApiSessionPresetConflict) {
             throw new RemoteError('agent-preset/conflict', error.message, {
                 sessionId: error.sessionId,
@@ -554,33 +571,52 @@ function imageBlockIn(content, match) {
             if (match(ref))
                 return ref;
         }
-        if (block.type === 'tool-result') {
-            const nested = imageBlockIn(block.content, match);
-            if (nested !== undefined)
-                return nested;
-        }
     }
     return undefined;
 }
+/** Read only first-party declared content fields; unknown event payloads stay opaque. */
 function imageInEvent(event, match) {
     const data = event.data;
-    const direct = imageBlockIn(data.content, match);
-    if (direct !== undefined)
-        return direct;
-    const message = imageBlockIn(data.message?.content, match);
-    if (message !== undefined)
-        return message;
-    for (const inserted of data.inserted ?? []) {
-        const found = imageBlockIn(inserted.content, match);
-        if (found !== undefined)
-            return found;
-    }
-    if (event.type === 'assistant/message' || event.type === 'assistant/attempt') {
-        for (const chunk of assistantStreamChunks(event.data.stream, 'block-end')) {
-            const found = imageBlockIn([chunk.block], match);
+    // First-party event payloads can be present without their producer plugin mounted.
+    const type = event.type;
+    switch (type) {
+        case 'user/message':
+        case 'tool/ptc-dispatch':
+            return imageBlockIn(data.content, match);
+        case 'system/message':
+        case 'developer/message':
+        case 'tool/result':
+        case 'team/message/queued':
+            return imageBlockIn(data.message?.content, match);
+        case 'agent/inbox/spliced': {
+            const messages = data.inserted;
+            if (!Array.isArray(messages))
+                return undefined;
+            for (const message of messages) {
+                if (typeof message !== 'object' || message === null || Array.isArray(message))
+                    continue;
+                const found = imageBlockIn(message.content, match);
+                if (found !== undefined)
+                    return found;
+            }
+            return undefined;
+        }
+        case 'compaction/summary':
+            return imageBlockIn(data.summary, match) ?? imageBlockIn(data.rawOutput, match);
+        case 'assistant/message': {
+            const found = imageBlockIn(data.message?.content, match);
             if (found !== undefined)
                 return found;
+            break;
         }
+        case 'assistant/attempt': break;
+        default: return undefined;
+    }
+    const assistant = event;
+    for (const chunk of assistantStreamChunks(assistant.data.stream, 'block-end')) {
+        const found = imageBlockIn([chunk.block], match);
+        if (found !== undefined)
+            return found;
     }
     return undefined;
 }

package/lib/types/control.d.ts

@@ -1,11 +1,11 @@
-/** Live Session jobs and projection state with reconnect baselines. */
+/** Live Session projection state with reconnect baselines. */
 import type { Context } from '@deepseek-ai/cordis';
 import type { SessionControlFrame } from './types.ts';
 /** Owns the Host-wide Session control stream. */
 export declare class SessionControlController {
     private readonly ctx;
     private readonly streams;
-    /** @param ctx - Host context carrying live Agent, projection, and jobs services. */
+    /** @param ctx - Host context carrying live Agent and projection services. */
     constructor(ctx: Context);
     /**
      * Open one generation of Host-wide live control state.
@@ -15,8 +15,6 @@ export declare class SessionControlController {
     control(signal: AbortSignal): AsyncIterable<SessionControlFrame>;
     private baseline;
     private projectionBaseline;
-    private onJobsChanged;
-    private jobsFor;
     private broadcast;
 }
 //# sourceMappingURL=control.d.ts.map