Merge remote-tracking branch 'origin/master' into mergebot/pr1667

# Conflicts:
#	apps/web/tests/snapshots/queue-actions/preserved.expected.md
#	docs/cordis-catalog/services.md
#	docs/core-data-structures/session.i18n.yaml
#	packages/client/runtime/src/client/session-history/history-fold.ts
#	packages/client/ui-conversation/README.i18n.yaml
#	packages/core/session/src/index.ts

packages/core/session/src/surface.ts

@@ -16,13 +16,12 @@ const SURFACE_EVENT_TYPES = new Set<string>([
   'user/message',
   'assistant/message',
   'tool/result',
-  'steering/message',
 ])
 
 /**
  * Whether an event type can join the model-visible surface.
  * @param type - event type to test.
- * @returns true for one of the four message-producing event types.
+ * @returns true for one of the three message-producing event types.
  */
 export function isSurfaceEligibleType(type: string): boolean {
   return SURFACE_EVENT_TYPES.has(type)
@@ -86,21 +85,17 @@ export function deriveEventMessage(event: SessionEvent): Message | null {
   // history; turn/step boundaries, chunks, usage, and errors are trace/replay
   // data.
   switch (event.type) {
-    // Ordinary prompts, injected context, and mid-turn steering project
-    // identically in user role: the event's model-facing content stays
-    // verbatim. Steering's `turn` is log-only. Do NOT re-add per-type framing
-    // (e.g. `<context>`/`<steering>`) here: framing is caller-owned — a
-    // producer bakes it into `content`, as workspace-context does with
-    // `<system-reminder>` — or, if reintroduced, must be driven by the event
-    // `meta` map and a dedicated renderer, keeping this projection a verbatim
-    // pass-through. See the deferred design note in
+    // Ordinary prompts and injected context project in user role: the event's
+    // model-facing content stays verbatim. Do NOT re-add per-type framing
+    // (e.g. `<context>`) here: framing is caller-owned — a producer bakes it
+    // into `content`, as workspace-context does with `<system-reminder>` — or,
+    // if reintroduced, must be driven by the event `meta` map and a dedicated
+    // renderer, keeping this projection a verbatim pass-through. See the
+    // deferred design note in
     // ../../../../.agents/notes/implemented/simplification/2026-07-20-unwrap-injected-content-envelopes.md
     case 'user/message': {
       return event.data
     }
-    case 'steering/message': {
-      return event.data.message
-    }
     case 'assistant/message': {
       // Skip an empty-content assistant/message: it exists only to host a
       // max-tokens step's usage and must not inject a content-less assistant
@@ -293,13 +288,14 @@ function assertToolResultRewrite(
   event: SessionEvent,
   shadowedSeqs: readonly number[],
   events: readonly SessionEvent[],
+  baseSeq: number,
 ): void {
   if (event.type !== 'tool/result') return
   if (shadowedSeqs.length !== 1) {
     throw new Error('tool/result surface replacement must rewrite exactly one current node')
   }
   for (const originalSeq of shadowedSeqs) {
-    const original = events[originalSeq]
+    const original = events[originalSeq - baseSeq]
     if (original?.type !== 'tool/result') {
       throw new Error('tool/result surface replacement must target a current tool/result')
     }
@@ -327,6 +323,7 @@ function planSurfaceEvent(
   event: SessionEvent,
   expectedSeq: number,
   events: readonly SessionEvent[],
+  baseSeq: number,
 ): SurfacePlan | undefined {
   if (event.seq !== expectedSeq) {
     throw new Error(`session event seq ${event.seq} is not contiguous; expected ${expectedSeq}`)
@@ -339,7 +336,7 @@ function planSurfaceEvent(
   }
   const range = replacementRange(state, surfaceOp)
   assertProvenance(event, range.shadowedSeqs)
-  assertToolResultRewrite(event, range.shadowedSeqs, events)
+  assertToolResultRewrite(event, range.shadowedSeqs, events, baseSeq)
   return {
     kind: 'replace',
     seq: event.seq,
@@ -355,8 +352,9 @@ function applySurfaceEvent(
   event: SessionEvent,
   expectedSeq: number,
   events: readonly SessionEvent[],
+  baseSeq: number,
 ): SurfaceFoldReplacement | undefined {
-  const plan = planSurfaceEvent(state, event, expectedSeq, events)
+  const plan = planSurfaceEvent(state, event, expectedSeq, events, baseSeq)
   if (plan?.kind === 'append') {
     state.nodes.push(plan.seq)
   } else if (plan?.kind === 'replace') {
@@ -382,7 +380,7 @@ export function foldSurface(events: readonly SessionEvent[]): SurfaceFoldResult
   const state = createFoldState()
   const replacements: SurfaceFoldReplacement[] = []
   for (const [index, event] of events.entries()) {
-    const replacement = applySurfaceEvent(state, event, index, events)
+    const replacement = applySurfaceEvent(state, event, index, events, 0)
     if (replacement !== undefined) replacements.push(replacement)
   }
   return { nodes: [...state.nodes], replacements }
@@ -392,38 +390,55 @@ export function foldSurface(events: readonly SessionEvent[]): SurfaceFoldResult
 export class SurfaceManager implements SessionSurface {
   /** Shared transition state; replacement history is not retained. */
   private _state = createFoldState()
-  /** Last processed seq; -1 folds a seeded log on first access. */
-  private _lastProcessedSeq = -1
+  /** Last processed absolute seq. */
+  private _lastProcessedSeq: number
 
-  constructor(private log: readonly SessionEvent[]) {}
+  /**
+   * @param log - Contiguous complete log or loaded event window.
+   * @param baseSeq - Absolute sequence of the window's first event.
+   */
+  constructor(
+    private log: readonly SessionEvent[],
+    private readonly baseSeq = 0,
+  ) {
+    this._lastProcessedSeq = baseSeq - 1
+  }
 
   /**
    * Validate the next candidate without mutating the committed surface.
    * @param event - candidate event that has not entered the log yet.
    */
   validateNext(event: SessionEvent): void {
-    if (this._lastProcessedSeq < this.log.length - 1) this._processDelta()
-    planSurfaceEvent(this._state, event, this.log.length, this.log)
+    if (this._lastProcessedSeq < this.baseSeq + this.log.length - 1) this._processDelta()
+    planSurfaceEvent(
+      this._state,
+      event,
+      this.baseSeq + this.log.length,
+      this.log,
+      this.baseSeq,
+    )
   }
 
   /** Monotonic count of folded positional replacements. */
   get replaceGeneration(): number {
-    if (this._lastProcessedSeq < this.log.length - 1) this._processDelta()
+    if (this._lastProcessedSeq < this.baseSeq + this.log.length - 1) this._processDelta()
     return this._state.replaceGeneration
   }
 
   /** Surface event sequences in model-visible order. */
   get nodes(): readonly number[] {
-    if (this._lastProcessedSeq < this.log.length - 1) this._processDelta()
+    if (this._lastProcessedSeq < this.baseSeq + this.log.length - 1) this._processDelta()
     return this._state.nodes
   }
 
   /** Fold events appended since the previous access. */
   private _processDelta(): void {
-    for (let i = this._lastProcessedSeq + 1; i < this.log.length; i++) {
+    const tailSeq = this.baseSeq + this.log.length - 1
+    for (let seq = this._lastProcessedSeq + 1; seq <= tailSeq; seq++) {
+      const index = seq - this.baseSeq
       // oxlint-disable-next-line typescript/no-non-null-assertion -- bounded by the loop condition
-      applySurfaceEvent(this._state, this.log[i]!, i, this.log)
-      this._lastProcessedSeq = i
+      applySurfaceEvent(this._state, this.log[index]!, seq, this.log, this.baseSeq)
+      this._lastProcessedSeq = seq
     }
   }
 }