fix(sidechat): stamp the seed with fork markers so the child inherits no pending inbox

sidechat.start passed `seed` without `meta.isSeeded: true` +
`inheritedEventCount`, so dsh-session treated the whole seed as the
child's OWN events and the child's Inbox constructor replayed the
parent's `agent/inbox/spliced` history — inheriting whatever input sat
UNCLAIMED in the parent at the click moment:

- next-turn: a queued follow-up behind a still-running turn;
- next-step (the reported long-context case, parent queue empty): a
  tool-result context / steering spliced between step boundaries.

The first side prompt then claimed [phantom, boundary, question] — the
stale parent message was sent to the model BEFORE the boundary and
logged as a user/message. The fix passes the exact marker pair the
host's own session.fork uses (api-session-controller); ownEvents() now
stops at the end-seed boundary and the inherited inbox replays empty.

Regression tests run the REAL Session.create + Inbox in both
directions (old shape inherits the phantom, marked shape stays empty);
routes tests pin the two create options. Verified: pnpm typecheck /
test (5 pre-existing unrelated UI-spec failures on main unchanged) /
build.

tests/sidechat-routes.spec.ts

@@ -113,6 +113,7 @@ describe('sidechat.start', () => {
       sessionId: string
       meta: Record<string, unknown>
       seed: readonly { type: string; data: Record<string, unknown> }[]
+      inheritedEventCount: number
       agentOptions: { provider: string; model: string }
       setup: unknown
     }
@@ -120,10 +121,15 @@ describe('sidechat.start', () => {
     expect(options.meta).toMatchObject({
       parentSession: 'parent',
       origin: 'subagent',
+      isSeeded: true,
       delegationDepth: 1,
       agentPreset: 'preset-a',
       cwd: '/p',
     })
+    // The fork-marker pair is load-bearing: without it the child's Inbox
+    // replays the parent's seed inbox splices and inherits whatever input sat
+    // unclaimed in the parent (see sidechat-seed-validation.spec.ts).
+    expect(options.inheritedEventCount).toBe(options.seed.length)
     expect(options.agentOptions).toEqual({ provider: 'test', model: 'model-x' })
     // The child carries the parent's completed turns as a verbatim seed,
     // closed by the durable subagent descriptor (honest catalog citizenship:
@@ -221,6 +227,16 @@ describe('sidechat.start', () => {
 
     const { childId } = await api['sidechat.start']({ sessionId: 'parent', question: '   ' })
 
+    // The empty thread carries the same fork-marker pair (isSeeded +
+    // inheritedEventCount = seed length) as the prompted create.
+    const options = services.create.mock.calls[0]![0] as {
+      meta: Record<string, unknown>
+      seed: readonly { type: string }[]
+      inheritedEventCount: number
+    }
+    expect(options.meta.isSeeded).toBe(true)
+    expect(options.inheritedEventCount).toBe(options.seed.length)
+
     // No prompt yet: the composer owns the first message; the placeholder
     // label is pinned and the in-progress snapshot is parked for it.
     expect(child.inject).not.toHaveBeenCalled()

tests/sidechat-seed-validation.spec.ts

@@ -10,8 +10,9 @@
  * not a mock, so the class of bug cannot silently return.
  */
 import { describe, expect, it } from 'vitest'
-import { Session } from '@deepseek-ai/dsh-session'
+import { Session, SessionLogOffset } from '@deepseek-ai/dsh-session'
 import type { SessionId } from '@deepseek-ai/dsh-session'
+import { Inbox } from '@deepseek-ai/dsh-agent'
 import { snapshotSubagentDescriptor } from '@deepseek-ai/dsh-subagent'
 import type { SidebarSessionEvent } from '../src/context-types.ts'
 import { buildSidechatInheritance } from '../src/sidechat-core.ts'
@@ -111,3 +112,115 @@ describe('sidechat seed against the real dsh-session validator', () => {
     expect(types.at(-1)).toBe('session/end-seed')
   })
 })
+
+describe('sidechat seed fork markers vs the real dsh-agent Inbox replay', () => {
+  /**
+   * Regression: the thread-create call originally passed `seed` WITHOUT the
+   * fork-marker pair (`meta.isSeeded: true` + `inheritedEventCount`). A seed
+   * without them is REPLAY history, not an inherited prefix, so the child's
+   * ownEvents() includes the whole seed and its Inbox constructor replays the
+   * parent's `agent/inbox/spliced` events — inheriting whatever input sat
+   * UNCLAIMED in the parent at the click moment (a queued follow-up, or a
+   * tool-result context spliced into next-step between step boundaries of a
+   * long-running turn). The first side prompt then claimed and SENT that stale
+   * message before the boundary + question. These tests run the REAL
+   * dsh-session Session and dsh-agent Inbox.
+   */
+  const pendingMessage = (id: string, kind: string, text: string) => ({
+    id,
+    role: 'user',
+    content: [{ type: 'text', text }],
+    source: { kind },
+  })
+  const inboxOver = (session: Session): { nextTurn: number; nextStep: number } => {
+    const inbox = new Inbox(session, { inserted() {}, discarded() {}, claimed() {} })
+    return { nextTurn: inbox.nextTurn.length, nextStep: inbox.nextStep.length }
+  }
+  /** The shape the routes pass since the fix: isSeeded + inheritedEventCount. */
+  const forkMarkedSession = (id: string, seed: readonly SidebarSessionEvent[]): Session =>
+    Session.create(
+      id as SessionId,
+      seed as never,
+      { version: 0, id: id as SessionId, createdAt: Date.now(), isSeeded: true },
+      SessionLogOffset(seed.length),
+    )
+  /** Real loop order: inbox insert → turn/start → claim deletion → step/start
+   *  → user/message. One completed, fully claimed turn (seq 0-7). */
+  const completedTurnLog = (): SidebarSessionEvent[] => [
+    ev('agent/inbox/spliced', 0, { target: 'next-turn', start: 0, inserted: [pendingMessage('m-q', 'user', 'q')] }),
+    ev('turn/start', 1, { turn: 1 }),
+    ev('agent/inbox/spliced', 2, { target: 'next-turn', start: 0, removedCount: 1, inserted: [] }),
+    ev('step/start', 3, { turn: 1, step: 1 }),
+    ev('user/message', 4, pendingMessage('m-q', 'user', 'q')),
+    ev('assistant/message', 5, { turn: 1, step: 1, message: assistantMessage('a') }),
+    ev('step/end', 6, { turn: 1, step: 1 }),
+    ev('turn/end', 7, { turn: 1, reason: { kind: 'completed' } }),
+  ]
+  /** Mid-turn with an UNCLAIMED tool-result context in next-step (seq 15). */
+  const midTurnLog = (): SidebarSessionEvent[] => [
+    ...completedTurnLog(),
+    ev('agent/inbox/spliced', 8, { target: 'next-turn', start: 0, inserted: [pendingMessage('m-q2', 'user', 'q2')] }),
+    ev('turn/start', 9, { turn: 2 }),
+    ev('agent/inbox/spliced', 10, { target: 'next-turn', start: 0, removedCount: 1, inserted: [] }),
+    ev('step/start', 11, { turn: 2, step: 1 }),
+    ev('user/message', 12, pendingMessage('m-q2', 'user', 'q2')),
+    ev('tool/call', 13, { turn: 2, step: 1, callId: 'c1', name: 'bash', arguments: '{}' }),
+    ev('tool/result', 14, {
+      turn: 2, step: 1,
+      message: {
+        id: 'm-r',
+        role: 'user',
+        content: [{ type: 'tool-result', toolCallId: 'c1', content: [{ type: 'text', text: 'ok' }] }],
+        source: { kind: 'tool', callId: 'c1' },
+      },
+    }),
+    ev('agent/inbox/spliced', 15, {
+      target: 'next-step',
+      start: 0,
+      inserted: [pendingMessage('m-ctx', 'tool', 'tool bash finished: exit 0 ... now continue the plan')],
+    }),
+  ]
+
+  it('inherits the parent\'s UNCLAIMED next-step tool context without the fork markers (root cause)', () => {
+    // Parent mid-turn (user queue empty): the bash tool returned and spliced
+    // its follow-up context into next-step; the next step boundary has not
+    // claimed it yet. The reported long-context scenario.
+    const { seed } = buildSidechatInheritance(midTurnLog())
+    // OLD call shape (seed only): the whole seed counts as own events and the
+    // phantom context is inherited as pending input.
+    const unmarked = Session.create('session-inbox-unmarked' as SessionId, seed as never)
+    expect(unmarked.ownEvents().length).toBe(seed.length + 1)
+    expect(inboxOver(unmarked)).toEqual({ nextTurn: 0, nextStep: 1 })
+  })
+
+  it('inherits the parent\'s QUEUED follow-up (next-turn) without the fork markers', () => {
+    const queued = pendingMessage('m-queued', 'user', 'queued second message')
+    const log: SidebarSessionEvent[] = [
+      ...completedTurnLog(),
+      ev('agent/inbox/spliced', 8, { target: 'next-turn', start: 0, inserted: [queued] }),
+    ]
+    const { seed } = buildSidechatInheritance(log)
+    const unmarked = Session.create('session-inbox-unmarked-turn' as SessionId, seed as never)
+    expect(inboxOver(unmarked)).toEqual({ nextTurn: 1, nextStep: 0 })
+  })
+
+  it('the fork-marker pair (isSeeded + inheritedEventCount) leaves the inherited inbox empty', () => {
+    // Same mid-turn log as the root-cause case, plus the descriptor the
+    // routes append — exactly what sidechat.start passes to agents.create.
+    const { seed } = buildSidechatInheritance(midTurnLog())
+    const withDescriptor = [
+      ...seed,
+      {
+        type: 'subagent/descriptor',
+        seq: seed.length,
+        time: Date.now(),
+        data: snapshotSubagentDescriptor({ mode: 'continuable', provider: 'sidechat', label: 'Side: test' }),
+      } as unknown as SidebarSessionEvent,
+    ]
+    const marked = forkMarkedSession('session-inbox-marked', withDescriptor)
+    // Only the end-seed marker is own; the transcript cut is unchanged.
+    expect(marked.ownEvents().map(event => event.type)).toEqual(['session/end-seed'])
+    expect(marked.snapshotEvents().map(event => event.type).at(-1)).toBe('session/end-seed')
+    expect(inboxOver(marked)).toEqual({ nextTurn: 0, nextStep: 0 })
+  })
+})