@deepseek-ai/dsh-api-session-controller 0.1.2-rc.1 → 0.1.5-alpha.1

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

@@ -7,22 +7,22 @@
  * must stub); implementation-internal entry points (history staging, wire-frame
  * dispatch) stay on the class, invisible out here.
  */
-import type { AttachmentIdType, ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import type { AttachmentIdType, FileAttachmentRef, ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
 import type { MessageId } from '@deepseek-ai/dsh-llm/brand';
 import type { SessionId, SessionSeq } from '@deepseek-ai/dsh-session/types';
 import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
 import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
 import type { PromptContentPart, QueueAction, SessionRequestId } from '../../types.ts';
-import type { PendingSubmissionImage, SessionSnapshot } from './snapshot.ts';
+import type { PendingSubmissionAttachment, SessionSnapshot } from './snapshot.ts';
 /**
  * Why a local submission echo left the snapshot: `observed` when its durable
  * `user/message` event or host queue occurrence arrived (with the admitted
- * image references in prompt order), `failed` when the prompt was rejected,
+ * attachment references in prompt order), `failed` when the prompt was rejected,
  * threw, or was aborted before acceptance.
  */
 export type PendingSubmissionRetirement = {
     readonly reason: 'observed';
-    readonly attachments: readonly ImageAttachmentRef[];
+    readonly attachments: readonly (ImageAttachmentRef | FileAttachmentRef)[];
 } | {
     readonly reason: 'failed';
 };
@@ -32,8 +32,8 @@ export interface BeginSubmissionInput {
     readonly mode: 'queue' | 'steer';
     /** Prompt text exactly as the upcoming prompt will send it. */
     readonly text: string;
-    /** Ordered image previews matching the upcoming prompt's image parts. */
-    readonly images: readonly PendingSubmissionImage[];
+    /** Ordered image previews and durable file metadata matching the upcoming prompt attachments. */
+    readonly attachments: readonly PendingSubmissionAttachment[];
     /** Settlement callback fired exactly once when the echo retires. */
     readonly onRetire?: (retirement: PendingSubmissionRetirement) => void;
 }
@@ -91,7 +91,7 @@ export interface ISession {
         data: Uint8Array;
     }>>;
     /**
-     * Apply one edit, remove, or strict steer action to a still-pending queue occurrence.
+     * Apply one edit, remove, or Steer action to a still-pending queue occurrence.
      * @param itemId - agent-owned inbox occurrence identity.
      * @param action - requested queue operation.
      * @returns acceptance, or a business/transport error.

package/lib/types/client/contract/snapshot.d.ts

@@ -1,5 +1,6 @@
 /** Session-owned observable state excluding Conversation target data. */
 import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
+import type { FileAttachmentRef } from '@deepseek-ai/dsh-attachment';
 import type { MessageId } from '@deepseek-ai/dsh-llm/brand';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { SubagentAddress } from '@deepseek-ai/dsh-subagent/client';
@@ -27,6 +28,18 @@ export interface PendingSubmissionImage {
     /** Intrinsic pixel height, when the submitter has probed it. */
     readonly height?: number;
 }
+/** Image branch of a local submission echo attachment. */
+export interface PendingSubmissionImageAttachment {
+    readonly type: 'image';
+    readonly value: PendingSubmissionImage;
+}
+/** File branch of a local submission echo attachment. */
+export interface PendingSubmissionFileAttachment {
+    readonly type: 'file';
+    readonly value: FileAttachmentRef;
+}
+/** One attachment displayed by a local submission echo, in prompt order. */
+export type PendingSubmissionAttachment = PendingSubmissionImageAttachment | PendingSubmissionFileAttachment;
 /** Client surface selected when a local submission begins. */
 export type PendingSubmissionPlacement = 'transcript' | 'queued' | 'steering';
 /**
@@ -44,8 +57,8 @@ export interface PendingSubmission {
     readonly time: number;
     /** Prompt text exactly as it will be sent (one text block). */
     readonly text: string;
-    /** Ordered image previews matching the prompt's image parts. */
-    readonly images: readonly PendingSubmissionImage[];
+    /** Ordered image previews and durable file metadata matching the prompt attachments. */
+    readonly attachments: readonly PendingSubmissionAttachment[];
 }
 /** History-open lifecycle of a Session event window. */
 export type OpenState = 'cold' | 'loading' | 'open' | 'error';

package/lib/types/client/index.d.ts

@@ -12,8 +12,8 @@ export type { ProjectionsBaseline, ProjectionValueStore, SessionProjectionMap, U
 export type { BeginSubmissionInput, ISession, PendingSubmissionRetirement, ProjectionsFace, SessionFace, SubmissionHandle, } from './contract/session.ts';
 export type { ISessions } from './contract/sessions.ts';
 export { MutableSessionEventSource } from './contract/events.ts';
-export type { SessionEventChange, SessionEventLike, SessionEventLikeEntry, SessionEventSource, SessionEventWindow, SessionLiveEventEntry, } from './contract/events.ts';
-export type { OpenState, PendingSubmission, PendingSubmissionImage, PendingSubmissionPlacement, PromptError, QueuedMessage, SessionSnapshot, } from './contract/snapshot.ts';
+export type { AssistantLiveChunkEvent, SessionAssistantSettlementEntry, SessionEventChange, SessionEventLike, SessionEventLikeEntry, SessionEventSource, SessionEventWindow, SessionLiveEventEntry, SessionTransientEventEntry, } from './contract/events.ts';
+export type { OpenState, PendingSubmission, PendingSubmissionAttachment, PendingSubmissionFileAttachment, PendingSubmissionImage, PendingSubmissionImageAttachment, PendingSubmissionPlacement, PromptError, QueuedMessage, SessionSnapshot, } from './contract/snapshot.ts';
 declare module '@deepseek-ai/cordis' {
     interface Context {
         /** Client Session object layer and Agent scope owner. */

package/lib/types/client/index.js

@@ -7,6 +7,8 @@ export { SessionCreateError, SessionForkError } from "./sessions/service.js";
 export { MutableSessionEventSource } from "./contract/events.js";
 /** Required Remote and Context projection services. */
 export const inject = [
+    'connection',
+    'fileUpload',
     'typert',
     'remote',
     'remote.commands',

package/lib/types/client/session-wire-event.d.ts

@@ -0,0 +1,11 @@
+/** Event-local acceptance for raw Session journal responses; payloads remain owner-defined JSON. */
+import type { SessionWireEvent } from '../types.ts';
+/**
+ * Reject non-current event envelopes without stripping or normalizing wire fields.
+ * Range membership and source existence require the durable log and remain Host-owned.
+ * @param value - one event received in a follow frame or history page.
+ * @returns nothing after narrowing the accepted event envelope.
+ * @throws when the envelope or current event-local metadata is invalid.
+ */
+export declare function assertSessionWireEvent(value: unknown): asserts value is SessionWireEvent;
+//# sourceMappingURL=session-wire-event.d.ts.map

package/lib/types/client/session-wire-event.js

@@ -0,0 +1,43 @@
+/** Event-local acceptance for raw Session journal responses; payloads remain owner-defined JSON. */
+import { validateSessionEventData, validateSurfaceMetadata } from '@deepseek-ai/dsh-session/surface';
+/**
+ * Reject non-current event envelopes without stripping or normalizing wire fields.
+ * Range membership and source existence require the durable log and remain Host-owned.
+ * @param value - one event received in a follow frame or history page.
+ * @returns nothing after narrowing the accepted event envelope.
+ * @throws when the envelope or current event-local metadata is invalid.
+ */
+export function assertSessionWireEvent(value) {
+    const subject = 'session wire event';
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`${subject} must be an object`);
+    }
+    const event = value;
+    for (const key of Object.keys(event)) {
+        switch (key) {
+            case 'type':
+            case 'seq':
+            case 'time':
+            case 'data':
+            case 'ignorable':
+            case 'surfaceOp':
+            case 'sourceEventSeqs':
+                break;
+            default:
+                throw new Error(`${subject} has unexpected field ${key}`);
+        }
+    }
+    const seq = event['seq'];
+    if (typeof event['type'] !== 'string'
+        || typeof seq !== 'number' || !Number.isSafeInteger(seq) || seq < 0 || Object.is(seq, -0)
+        || typeof event['time'] !== 'number' || !Number.isSafeInteger(event['time'])
+        || !Object.hasOwn(event, 'data') || event['data'] === undefined
+        || (Object.hasOwn(event, 'ignorable') && event['ignorable'] !== true)) {
+        throw new Error(`${subject} has an invalid envelope`);
+    }
+    // Event names and payloads are merge-extensible; only event-local owner rules run here.
+    const current = event;
+    validateSurfaceMetadata(current);
+    validateSessionEventData(current, subject);
+}
+//# sourceMappingURL=session-wire-event.js.map

package/lib/types/client/sessions/assistant-stream.d.ts

@@ -0,0 +1,51 @@
+/** Web presentation fold joining transient Assistant frames to one durable v2 settlement. */
+import type { SessionAssistantStreamBaseline, SessionAssistantStreamFrame } from '../../types.ts';
+import type { LlmAttemptId } from '@deepseek-ai/dsh-llm/brand';
+import type { SessionAssistantSettlementEntry, SessionEventLikeEntry, SessionLiveEventEntry, SessionTransientEventEntry } from '../contract/events.ts';
+/** One Web publication decision from the assistant stream fold. */
+export type ClientAssistantStreamResult = {
+    readonly type: 'publish';
+    readonly entry: SessionLiveEventEntry;
+} | {
+    readonly type: 'settlement';
+    readonly attemptId: LlmAttemptId;
+    readonly entry: SessionAssistantSettlementEntry;
+} | {
+    readonly type: 'abandonment';
+    readonly attemptId: LlmAttemptId;
+} | {
+    readonly type: 'transient';
+    readonly entry: SessionTransientEventEntry;
+} | {
+    readonly type: 'rebaseline';
+} | undefined;
+/** Keeps transient Assistant presentation behind one settlement-aware interface. */
+export declare class ClientAssistantStream {
+    private activeAttempt;
+    private readonly pending;
+    private publishedSeqs;
+    private durableCursor;
+    private transientInGap;
+    /**
+     * Replace the durable Web window and adopt an optional reconnect baseline.
+     * @param entries - durable entries in the replacement window.
+     * @param baseline - compact prefix for an Assistant attempt that is still live.
+     * @returns immediately visible durable entries plus reconstructed transient chunks.
+     */
+    replace(entries: readonly SessionEventLikeEntry[], baseline?: SessionAssistantStreamBaseline): readonly SessionEventLikeEntry[];
+    /**
+     * Stage one durable v2 settlement while its matching live attempt is open.
+     * @param entry - newly followed durable entry.
+     * @returns a publication decision, or `undefined` when no entry becomes visible.
+     */
+    acceptDurable(entry: SessionLiveEventEntry): ClientAssistantStreamResult;
+    /**
+     * Fold one dense transient frame and release its named durable settlement.
+     * @param frame - next Assistant stream frame received by the follow connection.
+     * @returns a transient, publication, or rebaseline decision, or `undefined` when no entry becomes visible.
+     */
+    acceptFrame(frame: SessionAssistantStreamFrame): ClientAssistantStreamResult;
+    private attemptForSettlement;
+    private publish;
+}
+//# sourceMappingURL=assistant-stream.d.ts.map

package/lib/types/client/sessions/assistant-stream.js

@@ -0,0 +1,168 @@
+/** Web presentation fold joining transient Assistant frames to one durable v2 settlement. */
+import { expandAssistantStream } from '@deepseek-ai/dsh-llm/assistant-stream';
+/** Keeps transient Assistant presentation behind one settlement-aware interface. */
+export class ClientAssistantStream {
+    activeAttempt;
+    pending = new Map();
+    publishedSeqs = new Set();
+    durableCursor = -1;
+    transientInGap = 0;
+    /**
+     * Replace the durable Web window and adopt an optional reconnect baseline.
+     * @param entries - durable entries in the replacement window.
+     * @param baseline - compact prefix for an Assistant attempt that is still live.
+     * @returns immediately visible durable entries plus reconstructed transient chunks.
+     */
+    replace(entries, baseline) {
+        this.pending.clear();
+        this.transientInGap = 0;
+        this.activeAttempt = undefined;
+        const opening = baseline?.activeAttempt;
+        if (opening !== undefined) {
+            this.activeAttempt = {
+                attemptId: opening.attemptId,
+                startedAfterSeq: opening.startedAfterSeq,
+                turn: opening.turn,
+                step: opening.step,
+                nextIndex: opening.nextIndex,
+            };
+        }
+        const visible = [...entries];
+        this.publishedSeqs = new Set(visible.map(entry => entry.event.seq));
+        this.durableCursor = visible.reduce((cursor, entry) => Math.max(cursor, entry.event.seq), -1);
+        if (opening !== undefined) {
+            for (const [index, member] of expandAssistantStream(opening.stream).entries()) {
+                this.transientInGap += 1;
+                visible.push({
+                    type: 'transient',
+                    event: {
+                        type: 'assistant/live-chunk',
+                        seq: this.durableCursor + 1 - 1 / (this.transientInGap + 1),
+                        time: member.time,
+                        data: {
+                            attemptId: opening.attemptId,
+                            turn: opening.turn,
+                            step: opening.step,
+                            chunk: member.chunk,
+                        },
+                    },
+                });
+                if (index + 1 >= opening.nextIndex)
+                    break;
+            }
+        }
+        return visible;
+    }
+    /**
+     * Stage one durable v2 settlement while its matching live attempt is open.
+     * @param entry - newly followed durable entry.
+     * @returns a publication decision, or `undefined` when no entry becomes visible.
+     */
+    acceptDurable(entry) {
+        const event = entry.event;
+        this.durableCursor = Math.max(this.durableCursor, event.seq);
+        this.transientInGap = 0;
+        const settlement = assistantSettlementEntry(entry);
+        if (settlement !== undefined && this.attemptForSettlement(settlement.event) !== undefined) {
+            if (this.pending.has(event.seq))
+                return { type: 'rebaseline' };
+            this.pending.set(event.seq, settlement);
+            return undefined;
+        }
+        return this.publish(entry);
+    }
+    /**
+     * Fold one dense transient frame and release its named durable settlement.
+     * @param frame - next Assistant stream frame received by the follow connection.
+     * @returns a transient, publication, or rebaseline decision, or `undefined` when no entry becomes visible.
+     */
+    acceptFrame(frame) {
+        switch (frame.type) {
+            case 'start':
+                if (this.activeAttempt !== undefined || this.pending.size > 0)
+                    return { type: 'rebaseline' };
+                this.pending.clear();
+                this.activeAttempt = {
+                    attemptId: frame.attemptId,
+                    startedAfterSeq: frame.startedAfterSeq,
+                    turn: frame.turn,
+                    step: frame.step,
+                    nextIndex: 0,
+                };
+                return undefined;
+            case 'chunk': {
+                const attempt = this.activeAttempt;
+                // A controller mounted after the Host saw this attempt has no start
+                // frame to reconstruct. Its durable settlement publishes directly;
+                // ignore the transient suffix until the next known start.
+                if (attempt === undefined || attempt.attemptId !== frame.attemptId)
+                    return undefined;
+                if (frame.index !== attempt.nextIndex)
+                    return { type: 'rebaseline' };
+                attempt.nextIndex += 1;
+                this.transientInGap += 1;
+                return {
+                    type: 'transient',
+                    entry: {
+                        type: 'transient',
+                        event: {
+                            type: 'assistant/live-chunk',
+                            seq: this.durableCursor + 1 - 1 / (this.transientInGap + 1),
+                            time: frame.time,
+                            data: {
+                                attemptId: frame.attemptId,
+                                turn: attempt.turn,
+                                step: attempt.step,
+                                chunk: frame.chunk,
+                            },
+                        },
+                    },
+                };
+            }
+            case 'end': {
+                const attempt = this.activeAttempt;
+                if (attempt === undefined || attempt.attemptId !== frame.attemptId) {
+                    return undefined;
+                }
+                this.activeAttempt = undefined;
+                if (frame.index !== attempt.nextIndex)
+                    return { type: 'rebaseline' };
+                if (frame.outcome.kind === 'abandoned') {
+                    return this.pending.size === 0
+                        ? { type: 'abandonment', attemptId: attempt.attemptId }
+                        : { type: 'rebaseline' };
+                }
+                if (this.publishedSeqs.has(frame.outcome.seq))
+                    return undefined;
+                const entry = this.pending.get(frame.outcome.seq);
+                if (entry === undefined
+                    || entry.event.type !== frame.outcome.eventType) {
+                    return { type: 'rebaseline' };
+                }
+                this.pending.delete(frame.outcome.seq);
+                this.publishedSeqs.add(entry.event.seq);
+                return { type: 'settlement', attemptId: attempt.attemptId, entry };
+            }
+        }
+    }
+    attemptForSettlement(event) {
+        const attempt = this.activeAttempt;
+        if (attempt === undefined
+            || (event.type === 'assistant/message' && event.surfaceOp !== 'append')
+            || event.seq <= attempt.startedAfterSeq
+            || attempt.turn !== event.data.turn
+            || attempt.step !== event.data.step)
+            return undefined;
+        return attempt;
+    }
+    publish(entry) {
+        this.publishedSeqs.add(entry.event.seq);
+        return { type: 'publish', entry };
+    }
+}
+function assistantSettlementEntry(entry) {
+    return entry.event.type === 'assistant/message' || entry.event.type === 'assistant/attempt'
+        ? entry
+        : undefined;
+}
+//# sourceMappingURL=assistant-stream.js.map

package/lib/types/client/sessions/history-records.d.ts

@@ -9,13 +9,13 @@ import type { SessionEventLikeEntry } from '../contract/events.ts';
 export declare function historyEntries(records: readonly SessionHistoryRecord[]): readonly SessionEventLikeEntry[];
 /**
  * Read the first logical sequence represented by one wire record.
- * @param record - validated scalar event or packed Assistant delta run.
+ * @param record - validated Session event.
  * @returns inclusive first Session sequence.
  */
 export declare function historyRecordFirstSeq(record: SessionHistoryRecord): number;
 /**
  * Read the final logical sequence represented by one wire record.
- * @param record - validated scalar event or packed Assistant delta run.
+ * @param record - validated Session event.
  * @returns inclusive final Session sequence.
  */
 export declare function historyRecordLastSeq(record: SessionHistoryRecord): number;

package/lib/types/client/sessions/history-records.js

@@ -9,7 +9,7 @@ export function historyEntries(records) {
 }
 /**
  * Read the first logical sequence represented by one wire record.
- * @param record - validated scalar event or packed Assistant delta run.
+ * @param record - validated Session event.
  * @returns inclusive first Session sequence.
  */
 export function historyRecordFirstSeq(record) {
@@ -17,15 +17,10 @@ export function historyRecordFirstSeq(record) {
 }
 /**
  * Read the final logical sequence represented by one wire record.
- * @param record - validated scalar event or packed Assistant delta run.
+ * @param record - validated Session event.
  * @returns inclusive final Session sequence.
  */
 export function historyRecordLastSeq(record) {
-    if (record.type === 'event')
-        return record.event.seq;
-    const length = record.event.type === 'chunkrow/tool-call-chunks'
-        ? record.event.data.args.length
-        : record.event.data.texts.length;
-    return record.event.seq + length - 1;
+    return record.event.seq;
 }
 //# sourceMappingURL=history-records.js.map

package/lib/types/client/sessions/queue-mirror.js

@@ -1,9 +1,9 @@
 const QUEUE_PREVIEW_CHARS = 200;
-// Image blocks are excluded: queue presentation renders them as thumbnails
-// from `content`, so the text preview covers only what has no visual form.
+// Attachment blocks are excluded: queue presentation renders them from
+// `content`, so the text preview covers only what has no visual form.
 function previewOf(content) {
     const flat = content
-        .filter(block => block.type !== 'image')
+        .filter(block => block.type !== 'image' && block.type !== 'file')
         .map(block => (block.type === 'text' ? block.text : `[${block.type}]`))
         .join(' ').replace(/\s+/g, ' ').trim();
     const chars = Array.from(flat);

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

@@ -4,15 +4,15 @@
  *
  * @module @deepseek-ai/dsh-api-session-controller/client/sessions/remotes
  */
-import type { EncodedImageAttachment } from '@deepseek-ai/dsh-attachment/types';
 import type { ClientRemote } from '@deepseek-ai/dsh-api-gateway/client';
+import type { CommandSubmitAttachment } from '@deepseek-ai/dsh-commands/types';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { SubagentCatalog, SubagentInterruptReceipt, SubagentPromptReceipt, SubagentPromptRequest } from '@deepseek-ai/dsh-subagent/client';
 import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
 import type { SessionRemote } from '../transport.ts';
 /** Narrow Commands namespace consumed by a Client Session. */
 export interface SessionCommandsRemote {
-    execute(agentId: SessionId, line: string, images: readonly EncodedImageAttachment[], signal?: AbortSignal): Promise<RemoteResult<object | undefined>>;
+    execute(agentId: SessionId, line: string, attachments: readonly CommandSubmitAttachment[], signal?: AbortSignal): Promise<RemoteResult<object | undefined>>;
 }
 /** Narrow subagent namespace consumed by a Client Session and its manager. */
 export interface SessionSubagentsRemote {

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

@@ -61,6 +61,7 @@ export declare class Session implements SessionFace {
     private jumpPromise;
     /** Authoritative stream-only inbox snapshot; pending work never hits history. */
     private readonly queueMirror;
+    private readonly assistantStream;
     private running;
     private address;
     private parentAvailable;
@@ -136,7 +137,7 @@ export declare class Session implements SessionFace {
     beginSubmission(input: BeginSubmissionInput): SubmissionHandle;
     /**
      * Send (queue/steer passed through 1:1); failures land in the snapshot's promptError.
-     * @param content - text plus browser-owned temporary image uploads.
+     * @param content - text, browser-owned temporary image uploads, and staged-file receipts.
      * @param mode - queue appends after the current turn; steer interrupts it.
      * @param signal - optional caller cancellation for the complete admission round-trip.
      * @param requestId - identity from {@link beginSubmission}; a failed identified prompt retires its echo.
@@ -267,6 +268,7 @@ export declare class Session implements SessionFace {
     private acceptEventChange;
     /** Replace the complete contiguous window and apply page-owned projection metadata. */
     private installWindow;
+    private publishAssistantEntry;
     /** Prepend one stream-validated history page. */
     private prependWindow;
     /** Append one stream-validated live event. */

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

@@ -5,9 +5,11 @@ import { SessionEventStream } from "../transport.js";
 import { MutableSessionEventSource } from "../contract/events.js";
 import { Notifier } from "./notifier.js";
 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 {
         ...value,
@@ -44,6 +46,7 @@ export class Session {
     jumpPromise = null;
     /** Authoritative stream-only inbox snapshot; pending work never hits history. */
     queueMirror = new SessionQueueMirror();
+    assistantStream = new ClientAssistantStream();
     running = false;
     address;
     parentAvailable;
@@ -143,7 +146,7 @@ export class Session {
                     : 'transcript',
                 time: Date.now(),
                 text: input.text,
-                images: input.images,
+                attachments: input.attachments,
             }];
         this.submissionSettlements.set(requestId, { onRetire: input.onRetire, retiring: false });
         // The blank → engaging edge flips here, ahead of prompt(): the composer
@@ -154,7 +157,7 @@ export class Session {
     }
     /**
      * Send (queue/steer passed through 1:1); failures land in the snapshot's promptError.
-     * @param content - text plus browser-owned temporary image uploads.
+     * @param content - text, browser-owned temporary image uploads, and staged-file receipts.
      * @param mode - queue appends after the current turn; steer interrupts it.
      * @param signal - optional caller cancellation for the complete admission round-trip.
      * @param requestId - identity from {@link beginSubmission}; a failed identified prompt retires its echo.
@@ -181,13 +184,23 @@ export class Session {
                 clientTimeZone,
             }, signal);
         }
+        else if (content.some(part => part.type === 'file')) {
+            result = {
+                ok: false,
+                error: new RemoteError('subagent/attachment-invalid', 'subagent continuation does not accept files', { reason: 'SUBAGENT_FILE_UNSUPPORTED' }),
+            };
+        }
         else {
+            // The preceding branch rejects file parts before the narrower subagent
+            // wire type is used; this array is not filtered or reordered.
+            const routedContent = content;
             const routed = await this.remote.subagents.prompt({
                 requestId: randomUUID(),
                 parentSessionId: this.address.parentSessionId,
                 childSessionId: this.address.childSessionId,
                 mode: 'continuable',
-                content,
+                delivery: mode,
+                content: routedContent,
                 clientTimeZone: resolvedClientTimeZone(),
             }, signal);
             result = routed.ok ? { ok: true, value: { accepted: true } } : routed;
@@ -553,29 +566,63 @@ export class Session {
     acceptEventChange(change) {
         switch (change.type) {
             case 'replace':
-                this.installWindow(change.entries, change.hasMore, change.page.projections === undefined ? undefined : projectionsBaseline(change.page.projections));
+                this.installWindow(change.entries, change.hasMore, change.page.projections === undefined ? undefined : projectionsBaseline(change.page.projections), change.page.assistantStream);
                 return;
             case 'prepend':
                 this.prependWindow(change.entries, change.hasMore);
                 return;
             case 'append':
-                if (this.appendLive(change.entry))
-                    this.notifier.markDirty();
+                this.publishAssistantEntry(this.assistantStream.acceptDurable(change.entry));
+                return;
+            case 'assistant-stream':
+                this.publishAssistantEntry(this.assistantStream.acceptFrame(change.frame));
         }
     }
     /** Replace the complete contiguous window and apply page-owned projection metadata. */
-    installWindow(entries, hasMore, projections) {
+    installWindow(entries, hasMore, projections, assistantStream) {
+        // A durable gap-repair page has no assistant baseline. Clearing transient
+        // attempts makes a held notification reopen follow once for an atomic
+        // page/baseline pair instead of applying it to an unrelated repair cut.
+        const visible = this.assistantStream.replace(entries, assistantStream);
         this.baseSeq = SessionLogOffset(entries[0]?.event.seq ?? 0);
         this.hasMore = hasMore;
-        if (entries.some(entry => entry.event.type === 'turn/start'))
+        if (visible.some(entry => entry.event.type === 'turn/start'))
             this.firstPromptPendingTurn = false;
         if (projections !== undefined)
             this.projections.seed(projections);
-        this.eventSource.replace(entries, hasMore);
-        for (const entry of entries)
+        this.eventSource.replace(visible, hasMore);
+        for (const entry of visible)
             this.observeSubmissionEvent(entry.event);
         this.notifier.markDirty();
     }
+    publishAssistantEntry(result) {
+        if (result?.type === 'rebaseline') {
+            const events = this.events;
+            queueMicrotask(() => {
+                if (events !== undefined && this.events === events)
+                    events.restart();
+            });
+            return;
+        }
+        if (result?.type === 'settlement') {
+            this.eventSource.settleAssistant(result.attemptId, result.entry);
+            this.observeSubmissionEvent(result.entry.event);
+            this.notifier.markDirty();
+            return;
+        }
+        if (result?.type === 'abandonment') {
+            this.eventSource.settleAssistant(result.attemptId);
+            this.notifier.markDirty();
+            return;
+        }
+        if (result?.type === 'publish' && this.appendLive(result.entry)) {
+            this.notifier.markDirty();
+        }
+        else if (result?.type === 'transient') {
+            this.eventSource.append(result.entry);
+            this.notifier.markDirty();
+        }
+    }
     /** Prepend one stream-validated history page. */
     prependWindow(entries, hasMore) {
         this.baseSeq = entries[0] === undefined ? this.baseSeq : SessionLogOffset(entries[0].event.seq);
@@ -607,7 +654,7 @@ export class Session {
         const source = data?.source;
         if (source?.kind !== 'user' || typeof source.rpcId !== 'string')
             return;
-        this.scheduleObservedRetirement(source.rpcId, imageRefsIn(data?.content));
+        this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(data?.content));
     }
     /** Retire echoes whose prompts landed in the host inbox instead of the log (running-turn submissions). */
     observeSubmissionQueue(items) {
@@ -615,7 +662,7 @@ export class Session {
             return;
         for (const item of items) {
             if (item.rpcId !== undefined) {
-                this.scheduleObservedRetirement(item.rpcId, imageRefsIn(item.message.content));
+                this.scheduleObservedRetirement(item.rpcId, attachmentRefsIn(item.message.content));
             }
         }
     }
@@ -702,8 +749,8 @@ function scheduleFrame(fn) {
     else
         setTimeout(fn, 0);
 }
-/** Image attachment references in one structurally-read content block list, in block order. */
-function imageRefsIn(content) {
+/** Attachment references in one structurally-read content block list, in block order. */
+function attachmentRefsIn(content) {
     if (!Array.isArray(content))
         return [];
     const refs = [];
@@ -711,7 +758,8 @@ function imageRefsIn(content) {
         if (typeof block !== 'object' || block === null)
             continue;
         const candidate = block;
-        if (candidate.type === 'image' && typeof candidate.attachment === 'object' && candidate.attachment !== null) {
+        if ((candidate.type === 'image' || candidate.type === 'file')
+            && typeof candidate.attachment === 'object' && candidate.attachment !== null) {
             refs.push(candidate.attachment);
         }
     }