Merge PR #941 dependency into manual compaction stack

# Conflicts: # docs/cordis-catalog/services.md # docs/core-data-structures/session.i18n.yaml # packages/host/apiproxy/README.i18n.yaml # packages/host/apiproxy/src/api-proxy.ts # packages/ui/tui/src/index.ts
2026-07-30 16:42:24 +08:00
parent 3b3d5579cb 9e679c89b6
commit 86b95a3856
50 changed files with 889 additions and 147 deletions
--- a/packages/cordis/tool-cordis/src/api-catalog.ts
+++ b/packages/cordis/tool-cordis/src/api-catalog.ts
@@ -2177,7 +2177,7 @@ export const TYPE_API: readonly TypeApiEntry[] = [
  },
  {
    name: 'SessionEventMap',
-    declaration: 'export interface SessionEventMap {\n    \'turn/start\': {\n        turn: number;\n        trigger: TurnTrigger;\n    };\n    \'turn/end\': {\n        turn: number;\n        reason: TurnEndReason;\n    };\n    \'step/start\': {\n        turn: number;\n        step: number;\n    };\n    \'step/end\': {\n        turn: number;\n        step: number;\n    };\n    \'user/message\': UserMessage;\n    \'assistant/chunk\': {\n        turn: number;\n        step: number;\n        chunk: StreamChunk;\n    };\n    \'assistant/message\': {\n        turn: number;\n        step: number;\n        message: AssistantMessage;\n        usage?: TokenUsage;\n    };\n    \'tool/call\': {\n        turn: number;\n        step: number;\n        callId: CallId;\n        name: string;\n        arguments: string;\n    };\n    \'tool/result\': {\n        turn: number;\n        step: number;\n        message: ToolResultMessage;\n        error?: {\n            name: string;\n            code: string;\n        };\n        meta?: JsonValue;\n    };\n    \'steering/message\': {\n        turn: number;\n        message: UserMessage;\n    };\n    \'todo/write\': {\n        todos: TodoItem[];\n    };\n    \'request/header\': {\n        header: EpochHeader;\n        reason: RequestHeaderReason;\n    };\n}',
+    declaration: 'export interface SessionEventMap {\n    \'turn/start\': {\n        turn: number;\n        trigger: TurnTrigger;\n    };\n    \'turn/end\': {\n        turn: number;\n        reason: TurnEndReason;\n    };\n    \'step/start\': {\n        turn: number;\n        step: number;\n    };\n    \'step/end\': {\n        turn: number;\n        step: number;\n    };\n    \'user/message\': UserMessage;\n    \'assistant/chunk\': {\n        turn: number;\n        step: number;\n        chunk: StreamChunk;\n    };\n    \'assistant/message\': {\n        turn: number;\n        step: number;\n        message: AssistantMessage;\n        usage?: TokenUsage;\n    };\n    \'tool/call\': {\n        turn: number;\n        step: number;\n        callId: CallId;\n        name: string;\n        arguments: string;\n    };\n    \'tool/result\': {\n        turn: number;\n        step: number;\n        message: ToolResultMessage;\n        error?: {\n            name: string;\n            code: string;\n        };\n        meta?: JsonValue;\n    };\n    \'steering/message\': {\n        turn: number;\n        message: UserMessage;\n    };\n    \'todo/write\': {\n        todos: TodoItem[];\n    };\n    \'request/header\': {\n        header: EpochHeader;\n        reason: RequestHeaderReason;\n    };\n    \'session/end-seed\': Record<string, never>;\n}',
  },
  {
    name: 'SessionEventMetadataFilter',
--- a/packages/core/agent-loop/tests/loop.spec.ts
+++ b/packages/core/agent-loop/tests/loop.spec.ts
@@ -1221,8 +1221,9 @@ describe('agent loop', () => {

    const replayed = ctx.sessions.create(SessionId('replayed'), { seed: [...agent.session.events] })
    expect(replayed.deriveMessages()).toEqual(agent.session.deriveMessages())
-    // event-by-event identity of types
-    expect(replayed.events.map(e => e.type)).toEqual(
+    // event-by-event identity of types over the inherited prefix
+    expect(replayed.events.slice(0, agent.session.seq).map(e => e.type)).toEqual(
      agent.session.events.map(e => e.type))
+    expect(replayed.events.at(-1)?.type).toBe('session/end-seed')
  })
 })
--- a/packages/core/agent-loop/tests/resume.spec.ts
+++ b/packages/core/agent-loop/tests/resume.spec.ts
@@ -283,7 +283,8 @@ describe('the session-persistence Agent Note: AgentLoop factory create/resume',
      agentOptions: { provider: 'mock', model: 'mock' },
      setup: async (agentCtx) => {
        expect(agentCtx.agent?.id).toBe(sessionId)
-        expect(agentCtx.agent?.session.events).toHaveLength(2)
+        // The two persisted events plus the end-seed marker.
+        expect(agentCtx.agent?.session.events).toHaveLength(3)
        agentCtx.on('session/created', () => void order.push('setup-listener:session/created'))
        agentCtx.on('agent/created', () => void order.push('setup-listener:agent/created'))
        order.push('setup:start')
@@ -585,7 +586,10 @@ describe('the session-persistence Agent Note: AgentLoop factory create/resume',
    const a2 = (await ctx2.agents.resume({ resumeSessionId: SessionId('sess-resume') })).agent
    // The resumed session carries the prior history…
    expect(a2.session.id).toBe('sess-resume')
-    expect(a2.session.events.length).toBe(events1.length)
+    // …followed by one end-seed event marking the constructor seed.
+    expect(a2.session.events.length).toBe(events1.length + 1)
+    expect(a2.session.firstLiveSeq).toBe(events1.length)
+    expect(a2.session.events.at(-1)?.type).toBe('session/end-seed')
    const replay = new Session(SessionId('replay'), events1)
    expect(a2.session.deriveMessages()).toEqual(replay.deriveMessages())

--- a/packages/core/session/src/index.ts
+++ b/packages/core/session/src/index.ts
@@ -23,7 +23,7 @@ export * from './types.ts'
 export type { AssistantMessage, ToolResultMessage, UserMessage } from '@deepseek-ai/dsh-llm'
 export { isJsonValue, snapshotJsonValue } from './json.ts'
 export type { JsonValue } from './json.ts'
-export { interruptedTurnClosers, TOOL_NOT_STARTED, TOOL_OUTCOME_UNKNOWN } from './repair.ts'
+export { interruptedTurnClosers, lastActivityTime, TOOL_NOT_STARTED, TOOL_OUTCOME_UNKNOWN } from './repair.ts'
 export { decodeStorageRecord, packChunkRuns } from './chunk-rows.ts'
 export type { ChunkRow, StorageRecord } from './chunk-rows.ts'
 export type { SessionSurface, SurfaceFoldReplacement, SurfaceFoldResult } from './surface.ts'
@@ -382,14 +382,25 @@ export class Session {

  /**
   * The first seq appended IN THIS PROCESS: the length of the constructor
-   * seed (0 without one). Events below it entered through construction —
-   * replay, fork, or resume — and were never published on the `session/event`
-   * firehose (constructor seeds do not emit), so consumers that replay the
-   * log as a publication substitute (telemetry adoption) start here. Distinct
-   * from `header.seedLength`, the DURABLE fork-lineage boundary: a resumed
-   * session's constructor seed is its full stored log, while its header keeps
-   * the original fork value — this field is the in-process construction fact
-   * and is deliberately not persisted.
+   * seed (0 without one). Events with smaller seq values entered through
+   * construction — replay, fork, or resume — and were never published on the
+   * `session/event` firehose (constructor seeds do not emit), so consumers
+   * that replay the log as a publication substitute (telemetry adoption)
+   * start here. Distinct from `header.seedLength`, the DURABLE fork-lineage
+   * boundary: a resumed session's constructor seed is its full stored log,
+   * while its header keeps the original fork value — this field is the
+   * in-process construction fact.
+   *
+   * Not persisted itself: a seeded session projects it into the log as the
+   * `session/end-seed` event, which is what a consumer reading STORED history
+   * reads. Locate the LAST such event, not necessarily one at this seq — a
+   * seed already ending in one is not re-marked, so reopening an untouched
+   * session leaves that event at a smaller seq than `firstLiveSeq`. Prefer
+   * this field in-process: it is exact before the marker reaches storage.
+   *
+   * When this lifecycle appends the marker, it occupies this seq before the
+   * store attaches and therefore does not publish either. Otherwise this seq
+   * holds an ordinary published write.
   */
  readonly firstLiveSeq: number

@@ -427,6 +438,13 @@ export class Session {
    }
    this.firstLiveSeq = this.log.length
    this.header = snapshotSessionHeader(id, header)
+    // Appended here so the marker is already in `events` when a backend
+    // captures the creation seed: no load-time write. Re-marking is skipped
+    // because a cold session is resumed on first touch, so repeatedly opening
+    // one must not grow its log per open.
+    if (this.firstLiveSeq > 0 && this.log.at(-1)?.type !== 'session/end-seed') {
+      this.append('session/end-seed', {})
+    }
  }

  /** Cached immutable public snapshot of the private append-only log. */
--- a/packages/core/session/src/invariant.ts
+++ b/packages/core/session/src/invariant.ts
@@ -144,6 +144,9 @@ function validateEvent(
    }
    case 'user/message':
      break
+    case 'session/end-seed':
+      // Unconstrained: an unbalanced seed legally puts it inside an open turn.
+      break
    case 'steering/message':
    case 'todo/write':
    case 'request/header': {
--- a/packages/core/session/src/repair.ts
+++ b/packages/core/session/src/repair.ts
@@ -1,7 +1,10 @@
 /**
 * Crash-recovery repair for an interrupted session log. It preserves a fully
 * written final turn and supplies the missing tool, step, and turn boundaries
- * needed to resume with a provider-valid transcript.
+ * needed to resume with a provider-valid transcript, plus the activity-time
+ * read that must skip the end-seed boundary — which this module does
+ * not write (`Session`'s constructor does) but whose synthetic closers can
+ * inherit that boundary's timestamp, the one real coupling between the two.
 * @module @deepseek-ai/dsh-session/repair
 */

@@ -9,6 +12,22 @@ import { MessageId, freezeMessage, type CallId } from '@deepseek-ai/dsh-llm'
 import type { ToolResultMessage } from '@deepseek-ai/dsh-llm'
 import type { SessionEvent } from './types.ts'

+/**
+ * The `time` of the log's last event representing actual work, skipping the
+ * `session/end-seed` boundary — picking a session up is not activity, so
+ * activity ordering must exclude it.
+ *
+ * Excluded by type, so a pickup time still leaks when a boundary is the last
+ * event of an open turn: {@link interruptedTurnClosers} copies it onto the
+ * synthetic `turn/end`, which this counts as work. Reachable only by seeding an
+ * unbalanced log directly — `load()` balances first.
+ * @param events - the log to scan, in seq order.
+ * @returns the latest non-boundary event's `time`, or undefined when there is none.
+ */
+export function lastActivityTime(events: readonly SessionEvent[]): number | undefined {
+  return events.findLast(event => event.type !== 'session/end-seed')?.time
+}
+
 /** Recovery code for an assistant tool request that never reached a recorded call start. */
 export const TOOL_NOT_STARTED = 'TOOL_NOT_STARTED'

--- a/packages/core/session/src/types.ts
+++ b/packages/core/session/src/types.ts
@@ -250,6 +250,29 @@ export interface SessionEventMap {
   * It is log-only; the latest snapshot reconstructs the request header.
   */
  'request/header': { header: EpochHeader; reason: RequestHeaderReason }
+  /**
+   * Marks the end of a constructor seed. Events before it have smaller seq
+   * values and came from the seed (resume, fork, or replay); this lifecycle
+   * produced none of them. This log-only event is the durable projection of
+   * {@link Session.firstLiveSeq}. Its payload is empty — position and `time`
+   * carry the meaning.
+   *
+   * Locate the LAST one in stored history. A seed already ending in one is not
+   * re-marked, so reopening an untouched session does not grow its log per
+   * pickup and the event need not be at the current `firstLiveSeq`.
+   *
+   * `Session`'s constructor is the only legitimate writer. The invariant
+   * companion deliberately constrains nothing here, so a plugin appending one
+   * would silently classify every live bracket before it as seed history.
+   *
+   * An owner of a standalone open/close bracket (`compact/start` …
+   * `compact/end`) reads it because seed history and live work are otherwise
+   * byte-identical: an unmatched opening marker before this event belongs to
+   * an ended lifecycle, whatever ended it. NOT a liveness signal about other
+   * writers — a concurrently live session holds its own boundary elsewhere,
+   * so tolerating concurrent writers needs a signal beyond the log.
+   */
+  'session/end-seed': Record<string, never>
 }

 /** The appendable event-type keys of {@link SessionEventMap}, plugin-merged extensions included. */
--- a/packages/core/session/tests/fork.spec.ts
+++ b/packages/core/session/tests/fork.spec.ts
@@ -7,6 +7,8 @@ import type { SessionEvent, TurnEndReason } from '@deepseek-ai/dsh-session'
 declare module '@deepseek-ai/dsh-session' {
  interface SessionEventMap {
    'test/log-only': { value: string }
+    /** Stands in for a plugin's open/close bracket (`compact/start`). */
+    'test/bracket-open': { id: string }
  }
 }

@@ -50,6 +52,14 @@ function lastSeq(session: Session): number {
  return event.seq
 }

+/** A seeded child's constructor seed: its log minus the end-seed marker. */
+function inherited(session: Session): readonly SessionEvent[] {
+  const events = session.events
+  const last = events.at(-1)
+  if (last?.type !== 'session/end-seed') throw new Error('seeded child is missing its end-seed marker')
+  return events.slice(0, -1)
+}
+
 describe('SessionStore.fork', () => {
  it('forks an empty live session as an empty child with lineage metadata', async () => {
    const { ctx, sessions } = await setup()
@@ -73,7 +83,7 @@ describe('SessionStore.fork', () => {

    const child = sessions.fork(SessionId('parent'), undefined, SessionId('child'))

-    expect(child.events).toEqual(source.events)
+    expect(inherited(child)).toEqual(source.events)
    expect(child.events).not.toBe(source.events)
    expect(child.events[1]).not.toBe(source.events[1])
    expect(() => {
@@ -97,8 +107,8 @@ describe('SessionStore.fork', () => {

    const child = sessions.fork(source, undefined, SessionId('log-only-child'))

-    expect(child.events).toEqual(source.events)
-    expect(child.events.at(-1)).toMatchObject({
+    expect(inherited(child)).toEqual(source.events)
+    expect(inherited(child).at(-1)).toMatchObject({
      type: 'test/log-only',
      data: { value: 'after execution' },
    })
@@ -114,7 +124,7 @@ describe('SessionStore.fork', () => {

    const child = sessions.fork(source, firstBoundary, SessionId('child-from-first'))

-    expect(child.events).toEqual(source.events.slice(0, firstBoundary + 1))
+    expect(inherited(child)).toEqual(source.events.slice(0, firstBoundary + 1))
    expect(child.header.seedLength).toBe(firstBoundary + 1)
    expect(child.deriveMessages()).toEqual([{
      id: expect.any(String) as unknown,
@@ -141,11 +151,32 @@ describe('SessionStore.fork', () => {

      const child = sessions.fork(source, lastSeq(source), SessionId(`child-${reason.kind}`))

-      expect(child.events.at(-1)?.type).toBe('turn/end')
+      expect(inherited(child).at(-1)?.type).toBe('turn/end')
      expect(child.header.seedLength).toBe(source.events.length)
    }
  })

+  it('marks a bracket the child inherited from a still-running parent', async () => {
+    // The constructor placement's central claim, unreachable from the
+    // persistence load path.
+    const { ctx, sessions } = await setup()
+    const parent = ctx.sessions.create(SessionId('bracket-parent'), { meta: { cwd: '/workspace' } })
+    appendClosedTurn(parent, 1, 'work')
+    const open = parent.append('test/bracket-open', { id: 'op-1' })
+
+    const child = sessions.fork(parent, undefined, SessionId('bracket-child'))
+
+    // Parent: no end-seed event follows the bracket, so its owner treats it as live.
+    expect(parent.events.at(-1)).toBe(open)
+    expect(parent.events.some(event => event.type === 'session/end-seed')).toBe(false)
+    // Child: the same bracket is before end-seed, so it belongs to the seed.
+    const boundary = child.events.at(-1)
+    expect(boundary).toMatchObject({ type: 'session/end-seed' })
+    expect(boundary!.seq).toBeGreaterThan(open.seq)
+    expect(child.firstLiveSeq).toBe(open.seq + 1)
+    expect(inherited(child).at(-1)).toMatchObject({ type: 'test/bracket-open', data: { id: 'op-1' } })
+  })
+
  it('rejects invalid boundaries before creating a child', async () => {
    const { ctx, sessions } = await setup()
    const empty = ctx.sessions.create(SessionId('empty'))
--- a/packages/core/session/tests/invariant.spec.ts
+++ b/packages/core/session/tests/invariant.spec.ts
@@ -382,6 +382,24 @@ describe('session-log invariants', () => {
      .toThrow(/turn 1 is still open/)
  })

+  it('accepts end-seed whether or not a turn is open', async () => {
+    const { ctx } = await setup()
+    // Balanced seed: between turns.
+    expect(() => ctx.sessions.create(SessionId('inherited-between-turns'), { seed: [
+      { type: 'turn/start', seq: 0, time: 1, data: { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } } },
+      { type: 'turn/end', seq: 1, time: 2, data: { turn: 1, reason: { kind: 'completed' } } },
+    ] })).not.toThrow()
+    // Unbalanced seed: inside the open turn, which the relation permits.
+    const open = ctx.sessions.create(SessionId('inherited-inside-open-turn'), { seed: [
+      { type: 'turn/start', seq: 0, time: 1, data: { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } } },
+    ] })
+    expect(open.events.map(event => event.type)).toEqual(['turn/start', 'session/end-seed'])
+    // Still open afterwards: the boundary moves no cursor.
+    expect(() => open.append('turn/start', { turn: 2, trigger: { kind: 'message', source: { kind: 'user' } } }))
+      .toThrow(/turn 1 is still open/)
+    expect(() => open.append('turn/end', { turn: 1, reason: { kind: 'completed' } })).not.toThrow()
+  })
+
  it('removes all listeners when the companion is disposed', async () => {
    const { ctx, fiber } = await setup()
    const session = ctx.sessions.create()
--- a/packages/core/session/tests/properties.spec.ts
+++ b/packages/core/session/tests/properties.spec.ts
@@ -112,7 +112,19 @@ describe('Session properties', () => {
      const original = build(events)
      const replayed = new Session(SessionId(`replay-${counter++}`), [...original.events])
      expect(replayed.deriveMessages()).toEqual(original.deriveMessages())
-      expect(replayed.seq).toBe(original.seq)
+      // A non-empty replay grows by exactly one log-only boundary.
+      expect(replayed.events.slice(0, original.seq)).toEqual(original.events)
+      expect(replayed.seq).toBe(original.seq === 0 ? 0 : original.seq + 1)
+    }))
+  })
+
+  it('replaying a log that already ends in end-seed adds no further marker', () => {
+    fc.assert(fc.property(logArb, (events) => {
+      const original = build(events)
+      const once = new Session(SessionId(`idem-a-${counter++}`), [...original.events])
+      const twice = new Session(SessionId(`idem-b-${counter++}`), [...once.events])
+      // Lazy resume makes browsing a pickup, so this must not grow per open.
+      expect(twice.events).toEqual(once.events)
    }))
  })

--- a/packages/core/session/tests/repair.spec.ts
+++ b/packages/core/session/tests/repair.spec.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { CallId , createMessage, createToolResultMessage } from '@deepseek-ai/dsh-llm'
-import { interruptedTurnClosers, TOOL_NOT_STARTED, TOOL_OUTCOME_UNKNOWN } from '../src/index.ts'
+import { interruptedTurnClosers, lastActivityTime, TOOL_NOT_STARTED, TOOL_OUTCOME_UNKNOWN } from '../src/index.ts'
 import type { SessionEvent, SurfaceEvent } from '../src/index.ts'

 /**
@@ -273,3 +273,44 @@ describe('interruptedTurnClosers', () => {
    expect(closers.map(e => e.type)).toEqual(['step/end', 'turn/end'])
  })
 })
+
+describe('lastActivityTime', () => {
+  const endSeedAt = (seq: number, time: number): SessionEvent =>
+    ({ type: 'session/end-seed', seq, time, data: {} })
+
+  it('has no answer for an empty log', () => {
+    expect(lastActivityTime([])).toBeUndefined()
+  })
+
+  it('reports the log tail when no boundary is present', () => {
+    const events: SessionEvent[] = [
+      userTurnStart(1, 0),
+      { type: 'turn/end', seq: 1, time: 500, data: { turn: 1, reason: { kind: 'completed' } } },
+    ]
+    expect(lastActivityTime(events)).toBe(500)
+  })
+
+  it('skips a trailing boundary in favour of the last real work', () => {
+    const events: SessionEvent[] = [
+      userTurnStart(1, 0),
+      { type: 'turn/end', seq: 1, time: 500, data: { turn: 1, reason: { kind: 'completed' } } },
+      endSeedAt(2, 9_000),
+    ]
+    // Resumed long after the work, but never worked in again.
+    expect(lastActivityTime(events)).toBe(500)
+  })
+
+  it('reports work appended after end-seed', () => {
+    const events: SessionEvent[] = [
+      userTurnStart(1, 0),
+      endSeedAt(1, 9_000),
+      { type: 'turn/end', seq: 2, time: 9_500, data: { turn: 1, reason: { kind: 'completed' } } },
+    ]
+    expect(lastActivityTime(events)).toBe(9_500)
+  })
+
+  it('has no answer for a log of nothing but boundaries', () => {
+    // Unreachable via the constructor, but the projection is a pure function.
+    expect(lastActivityTime([endSeedAt(0, 1), endSeedAt(1, 2)])).toBeUndefined()
+  })
+})
--- a/packages/core/session/tests/session.spec.ts
+++ b/packages/core/session/tests/session.spec.ts
@@ -112,7 +112,7 @@ describe('Session', () => {
    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
    session.append('turn/end', { turn: 1, reason: { kind: 'aborted' } })
    const replayed = new Session(SessionId('aborted-replay'), structuredClone(session.events))
-    expect(replayed.events).toEqual(session.events)
+    expect(replayed.events.slice(0, -1)).toEqual(session.events)
    const turnEnd = replayed.events.findLast(event => event.type === 'turn/end')
    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted' })
  })
@@ -188,7 +188,10 @@ describe('Session', () => {

    const replayed = new Session(SessionId('s3-replay'), [...original.events])
    expect(replayed.deriveMessages()).toEqual(original.deriveMessages())
-    expect(replayed.seq).toBe(original.seq)
+    // The seed verbatim, plus the end-seed event the constructor appends.
+    expect(replayed.events.slice(0, original.seq)).toEqual(original.events)
+    expect(replayed.seq).toBe(original.seq + 1)
+    expect(replayed.firstLiveSeq).toBe(original.seq)
  })

  it('rejects pre-provider request headers and assistant messages on seed/load', () => {
@@ -217,7 +220,7 @@ describe('Session', () => {
    const unrelatedPrimitiveData = {
      type: 'plugin/event', seq: 0, time: 1, data: null,
    } as unknown as SessionEvent
-    expect(new Session(SessionId('primitive-plugin-data'), [unrelatedPrimitiveData]).events)
+    expect(new Session(SessionId('primitive-plugin-data'), [unrelatedPrimitiveData]).events.slice(0, 1))
      .toEqual([unrelatedPrimitiveData])
  })

@@ -522,7 +525,8 @@ describe('Session', () => {
      { type: 'turn/end' as const, seq: 2, time: 3, data: { turn: 1, reason: { kind: 'completed' as const } } },
    ] as SessionEvent[]
    const session = new Session(SessionId('seed-ok'), goodSeed)
-    expect(session.events).toHaveLength(3)
+    expect(session.events.slice(0, 3)).toEqual(goodSeed)
+    expect(session.firstLiveSeq).toBe(3)
  })

  it('reads each seed array entry once so validation and storage use the same event', () => {
@@ -546,7 +550,7 @@ describe('Session', () => {
    const session = new Session(SessionId('seed-entry-snapshot'), seed)

    expect(reads).toBe(1)
-    expect(session.events).toEqual([accepted])
+    expect(session.events.slice(0, 1)).toEqual([accepted])
  })

  it('reads a nested seed-data getter once and stores its first JSON value', () => {
@@ -624,7 +628,7 @@ describe('Session', () => {

    const session = new Session(SessionId('seed-null-prototype'), [event])

-    expect(session.events).toEqual([{ ...event }])
+    expect(session.events.slice(0, 1)).toEqual([{ ...event }])
  })

  it('reads a nested seed-metadata getter once and stores its first JSON value', () => {
@@ -1647,6 +1651,7 @@ describe('todo/write event', () => {
    const replayed = new Session(SessionId('t4-replay'), [...original.events])
    expect(replayed.events.findLast(e => e.type === 'todo/write')!.data.todos)
      .toEqual([{ content: 'only', status: 'completed' }])
-    expect(replayed.seq).toBe(original.seq)
+    expect(replayed.events.slice(0, original.seq)).toEqual(original.events)
+    expect(replayed.firstLiveSeq).toBe(original.seq)
  })
 })
--- a/packages/host/apiproxy/README.i18n.yaml
+++ b/packages/host/apiproxy/README.i18n.yaml
@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/host/apiproxy/README.md
-README.md: 8efb47acca08e6179aa2fbfbe705550c7ed45561
-README.zh.md: 69ccc5c36334e5f5b573ea9fd1608df56714e67a
+README.md: d839563319350ed91eee769fb05b6a9ee2391265
+README.zh.md: 3a3021f1770f2629e8667aa33886712c5d5d002b
--- a/packages/host/apiproxy/README.md
+++ b/packages/host/apiproxy/README.md
@@ -46,3 +46,4 @@ None; this package neither assembles nor sends a provider request.
 - **Reserved seams stay out of `RpcMethodMap`** — `session.fork`, `prompt.mode: 'inject'`, `task.list`, `host.listModels`, and a describe `hostInstanceId` are documented reservations; an unknown method fails loud at envelope parse rather than getting a not-implemented code.
 - **No protocol version field** — client and host ship together; `host.describe` gains a version negotiation field only when an independently released client exists.
 - **Linux native picker requires desktop tooling** — under the `native` capability, `host.pickDirectory` reports an actionable error when neither Zenity nor KDialog is installed; the browse backend is the composition-level fallback (see the [native backend README](../directory-picker-native/README.md)).
+- **A cold session's `updatedAt` counts a mere pickup as a write (per-file backends only)** — the attached projection excludes the `session/end-seed` boundary, because picking a session up is not activity, but a cold session's `updatedAt` is its log file's mtime and every durable write refreshes that, the boundary included. `agentFor()` resumes a cold session on first touch, so merely opening one in a client writes it. This applies only where `locate()` resolves a per-session artifact, i.e. JSONL; SQLite returns `undefined`, so its cold sessions fall back to `createdAt` and are skewed the other way — too old rather than too new — independently of this boundary. A session touched without being worked in therefore sorts newer than its last real activity until it attaches. Separating the two needs a log read, which is exactly what the mtime path exists to avoid; a stored last-activity field in the index would fix it at the source, scoped in the [last-activity-index Agent Note](../../../.agents/notes/proposed/architecture/2026-07-29-durable-last-activity-index.md).
--- a/packages/host/apiproxy/README.zh.md
+++ b/packages/host/apiproxy/README.zh.md
@@ -46,3 +46,4 @@ Workspace 列表与 Session 列表是相互独立的重连基线。`workspace.cr
 - **预留 seam 不进入 `RpcMethodMap`**：`session.fork`、`prompt.mode: 'inject'`、`task.list`、`host.listModels` 和描述字段 `hostInstanceId` 都是已记录的预留项；未知方法会在信封解析时直接失败，而不会返回「尚未实现」错误码。
 - **没有协议版本字段**：客户端与宿主一同发布；只有出现独立发布的客户端后，`host.describe` 才会增加版本协商字段。
 - **Linux 原生选择器依赖桌面工具**：在 `native` 能力下，Zenity 和 KDialog 均未安装时，`host.pickDirectory` 会给出包含解决建议的错误提示；组合层面的回退是 browse 后端（见 [native 后端 README](../directory-picker-native/README.md)）。
+- **冷会话的 `updatedAt` 会把一次单纯的拾起算作写入（仅逐文件后端）**：已附加投影排除了 `session/end-seed` 边界，因为接手一个会话不算活动；但冷会话的 `updatedAt` 取自其日志文件的 mtime，而每一次持久写入都会刷新它，包括这条边界。`agentFor()` 会在首次触碰时恢复一个冷会话，因此在客户端里仅仅打开一个会话就会写入它。这只适用于 `locate()` 能解析出逐会话产物的场景，即 JSONL；SQLite 返回 `undefined`，因此它的冷会话回退到 `createdAt`，偏差方向相反——偏旧而不是偏新——且与这条边界无关。于是一个被触碰过却没有在里面工作过的会话，在重新附加之前会排在它最后一次真实活动之后。要把两者区分开需要读取日志，而这恰恰是 mtime 路径存在的目的；在索引中存储一个最后活动字段可以从源头修好它，范围见[最后活动索引 Agent Note](../../../.agents/notes/proposed/architecture/2026-07-29-durable-last-activity-index.md)。
--- a/packages/host/apiproxy/src/api-proxy.ts
+++ b/packages/host/apiproxy/src/api-proxy.ts
@@ -14,7 +14,7 @@ import type {
 import { createUserMessage, ReasoningEffortId } from '@deepseek-ai/dsh-llm'
 import { errorChain } from '@deepseek-ai/dsh-llm'
 import type { MessageSource } from '@deepseek-ai/dsh-llm'
-import { isAppendSurfaceEvent } from '@deepseek-ai/dsh-session'
+import { isAppendSurfaceEvent, lastActivityTime } from '@deepseek-ai/dsh-session'
 import type { Session, SessionEvent, SessionHeader, SessionId, UserMessage } from '@deepseek-ai/dsh-session'
 import type { SessionPersistence } from '@deepseek-ai/dsh-session-persistence'
 import type { Workspace, WorkspaceRecord } from '@deepseek-ai/dsh-workspace'
@@ -169,7 +169,9 @@ function sessionBlank(session: Session): boolean {
 function summarize(session: Session, running: boolean): SessionSummary {
  return {
    sessionId: session.id,
-    updatedAt: session.events.at(-1)?.time ?? session.header.createdAt,
+    // Excludes end-seed: a resumed-but-untouched session
+    // must not sort as freshly worked in.
+    updatedAt: lastActivityTime(session.events) ?? session.header.createdAt,
    running,
    blank: sessionBlank(session),
    ...session.header.parentSession === undefined ? {} : { parentSessionId: session.header.parentSession },
--- a/packages/host/apiproxy/src/api/sessions.ts
+++ b/packages/host/apiproxy/src/api/sessions.ts
@@ -133,7 +133,11 @@ export type QueueAction =
 /** Session list entry (v1 builds no index: list does readdir+stat). */
 export interface SessionSummary {
  sessionId: SessionId
-  /** Persisted file mtime. */
+  /**
+   * Last activity. Attached: the last non-`session/end-seed` event, since a
+   * pickup is not activity. Cold: the log's mtime, or `createdAt` for a backend
+   * with no per-session file (README Known Limitations covers the skew).
+   */
  updatedAt: number
  /** Status of the attached agent; always false for cold (unattached) sessions. */
  running: boolean
--- a/packages/host/apiproxy/tests/api-proxy-cold.spec.ts
+++ b/packages/host/apiproxy/tests/api-proxy-cold.spec.ts
@@ -78,6 +78,42 @@ describe('sessions.list cold merge', () => {
  })
 })

+describe('attached updatedAt excludes end-seed', () => {
+  it('reports the last real work, not the pickup, so a resumed-untouched session does not float', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SessionStore)
+    await ctx.plugin(UserInteractionService)
+    await ctx.plugin(AgentRegistry)
+    const api = createApiProxy(ctx, { provider: 'p', model: 'm', cwd: '/tmp', workspaceRoot: '/tmp' })
+
+    // Old work, resumed just now: the log tail would report the pickup.
+    const worked = 1_000_000
+    const resumed = ctx.sessions.create(sid('resumed-untouched'), {
+      seed: [
+        { type: 'turn/start', seq: 0, time: worked, data: { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } } },
+        { type: 'turn/end', seq: 1, time: worked, data: { turn: 1, reason: { kind: 'completed' } } },
+      ],
+      meta: { cwd: '/proj', createdAt: 500 },
+    })
+    ctx.agents.register({ id: resumed.id, session: resumed, status: 'idle', ctx } as Agent)
+    const boundary = resumed.events.at(-1)
+    expect(boundary?.type).toBe('session/end-seed')
+    expect(boundary?.time).toBeGreaterThan(worked)
+
+    const listed = await api.sessions.list(request({}))
+    if (!listed.result.ok) throw new Error('list failed')
+    const summary = listed.result.value.items.find(item => item.sessionId === 'resumed-untouched')
+    expect(summary?.updatedAt).toBe(worked)
+
+    // Real work appended after end-seed does move it.
+    resumed.append('turn/start', { turn: 2, trigger: { kind: 'message', source: { kind: 'user' } } })
+    const after = await api.sessions.list(request({}))
+    if (!after.result.ok) throw new Error('list failed')
+    const moved = after.result.value.items.find(item => item.sessionId === 'resumed-untouched')
+    expect(moved?.updatedAt).toBeGreaterThan(worked)
+  })
+})
+
 describe('degenerate composition (no persistence, no factory)', () => {
  it('list skips the cold merge and resume maps a non-not-found failure to internal', async () => {
    const ctx = new Context()
--- a/packages/llm/token-meter/tests/token-meter.spec.ts
+++ b/packages/llm/token-meter/tests/token-meter.spec.ts
@@ -417,7 +417,8 @@ describe('replay anchors and surface folds', () => {
    expect(after.surfaceDeltaTokens).toBeLessThan(0)
    expectSurfaceTotal(after)
    expect(before.nodes).toHaveLength(2)
-    expect(before.logRevision).toBe(original.events.length)
+    // The earlier snapshot still reports the log it measured: seed + boundary.
+    expect(before.logRevision).toBe(original.events.length + 1)
    expect(before.surfaceDeltaTokens).toBeGreaterThan(0)
  })

@@ -677,13 +678,15 @@ describe('malformed replay and listener lifecycle', () => {
      content: [{ type: 'text', text: 'one' }],
      source: { kind: 'user' },
    }), { surfaceOp: 'append' })
-    expect(revisions).toEqual([2])
-    expect(activeMeter.measure(session).logRevision).toBe(2)
+    // Seed, end-seed, then one live append. Only the last event published:
+    // end-seed predates store attachment, like the seed.
+    expect(revisions).toEqual([3])
+    expect(activeMeter.measure(session).logRevision).toBe(3)

    await firstFiber.dispose()
    const secondFiber = await ctx.plugin(TokenMeterService)
    activeMeter = ctx.tokenMeter
-    expect(activeMeter.measure(session).logRevision).toBe(2)
+    expect(activeMeter.measure(session).logRevision).toBe(3)
    await secondFiber.dispose()
  })
 })
--- a/packages/session-persistence/session-persistence-jsonl/tests/jsonl.spec.ts
+++ b/packages/session-persistence/session-persistence-jsonl/tests/jsonl.spec.ts
@@ -378,7 +378,9 @@ describe('SessionPersistenceJsonl: durability and crash semantics', () => {
    await ctx.sessions.flush(child)
    const loaded = await ctx.sessionPersistence.load(child.id)

-    expect(loaded.events).toEqual(source.events)
+    // The constructor seed reaches disk verbatim, then the child's end-seed.
+    expect(loaded.events.slice(0, source.events.length)).toEqual(source.events)
+    expect(loaded.events.at(-1)).toMatchObject({ type: 'session/end-seed', seq: source.events.length })
    expect(loaded.meta).toMatchObject({
      id: SessionId('persist-child'),
      cwd: '/workspace',
--- a/packages/session-persistence/session-persistence/tests/coordinator-contract.ts
+++ b/packages/session-persistence/session-persistence/tests/coordinator-contract.ts
@@ -218,7 +218,9 @@ export function runCoordinatorContract(name: string, makeFixture: () => Promise<
        live.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
        await ctx.sessions.flush(live)
        const loaded = await ctx.sessionPersistence.load(id)
-        expect(loaded.events.map(event => event.type)).toEqual(['turn/start', 'turn/end'])
+        // The constructor's end-seed event persisted between the stored
+        // turn/start and the turn/end appended live.
+        expect(loaded.events.map(event => event.type)).toEqual(['turn/start', 'session/end-seed', 'turn/end'])
        expect(loaded.events.at(-1)).toMatchObject({
          type: 'turn/end',
          data: { reason: { kind: 'completed' } },
@@ -477,11 +479,14 @@ export function runCoordinatorContract(name: string, makeFixture: () => Promise<
        const forked = ctx.sessions.create(SessionId('forked'), { seed, meta: { cwd: WORK } })
        await ctx.sessions.flush(forked) // onCreated persisted the seed
        const loaded = await ctx.sessionPersistence.load(SessionId('forked'))
-        expect(loaded.events).toEqual(seed)
+        // Fork is where the marker earns its keep: the inherited prefix may
+        // carry a bracket the still-running parent owns.
+        expect(loaded.events.slice(0, seed.length)).toEqual(seed)
+        expect(loaded.events.at(-1)).toMatchObject({ type: 'session/end-seed', seq: seed.length })
        // A flush with no NEW events must not double-write.
        await ctx.sessions.flush(forked)
        const reloaded = await ctx.sessionPersistence.load(SessionId('forked'))
-        expect(reloaded.events).toEqual(seed)
+        expect(reloaded.events).toEqual(loaded.events)
      } finally {
        await fiber.dispose()
        await fix.cleanup()
@@ -510,7 +515,9 @@ export function runCoordinatorContract(name: string, makeFixture: () => Promise<
        await second.ctx.sessions.flush(s2)

        const reloaded = await second.ctx.sessionPersistence.load(SessionId('resumed'))
-        expect(reloaded.events.map(e => e.seq)).toEqual([0, 1, 2, 3, 4, 5, 6, 7])
+        // 0-5 the resumed seed, 6 end-seed, 7-8 the new turn.
+        expect(reloaded.events.map(e => e.seq)).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8])
+        expect(reloaded.events[6]).toMatchObject({ type: 'session/end-seed' })
      } finally {
        await second.fiber.dispose()
        await fix.cleanup()
@@ -791,7 +798,9 @@ export function runCoordinatorContract(name: string, makeFixture: () => Promise<
        const live = ctx.sessions.create(SessionId('lazy-claim'), { seed: oneTurnLog(), meta: { cwd: WORK } })
        await expect(ctx.sessions.flush(live)).resolves.toBeUndefined()
        const loaded = await ctx.sessionPersistence.load(SessionId('lazy-claim'))
-        expect(loaded.events.map(e => e.seq)).toEqual([0, 1, 2, 3, 4, 5])
+        // Seeded 0-5 plus the constructor's end-seed event at 6.
+        expect(loaded.events.map(e => e.seq)).toEqual([0, 1, 2, 3, 4, 5, 6])
+        expect(loaded.events.at(-1)).toMatchObject({ type: 'session/end-seed' })
      } finally {
        await fiber.dispose()
        await fix.cleanup()
@@ -844,7 +853,9 @@ export function runCoordinatorContract(name: string, makeFixture: () => Promise<
        }, { inject: ['sessions'] }))
        await ctx.sessions.flush(cont)
        const loaded = await ctx.sessionPersistence.load(SessionId('claim'))
-        expect(loaded.events.map(e => e.seq)).toEqual([0, 1, 2, 3, 4, 5, 6, 7])
+        // 6-7 the claimed suffix; 8 end-seed after the whole seed.
+        expect(loaded.events.map(e => e.seq)).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8])
+        expect(loaded.events.at(-1)).toMatchObject({ type: 'session/end-seed' })
        expect(loaded.meta).toEqual(durableMeta)
        expect(loaded.meta.createdAt).toBe(1000)

--- a/packages/session-query/session-query-sqlite/tests/sqlite.spec.ts
+++ b/packages/session-query/session-query-sqlite/tests/sqlite.spec.ts
@@ -1077,8 +1077,9 @@ describe('SQLite reconciliation and source lifecycle', () => {
    await expect(ctx.sessionQuery.searchEvents({ sessionId: live.id, query: 'needle' }))
      .rejects.toThrow(expectCode('SESSION_QUERY_INDEX_FAILED'))
    db.exec('PRAGMA query_only = OFF')
+    // seq 2: one-event seed, end-seed, then the live message.
    await expect(ctx.sessionQuery.searchEvents({ sessionId: live.id, query: 'needle' }))
-      .resolves.toMatchObject({ items: [{ seq: 1 }] })
+      .resolves.toMatchObject({ items: [{ seq: 2 }] })
  })
 })

--- a/packages/session-title/session-title/tests/service-contracts.spec.ts
+++ b/packages/session-title/session-title/tests/service-contracts.spec.ts
@@ -185,6 +185,8 @@ describe('SessionTitleService configuration and refresh boundaries', () => {
      'turn/start',
      'user/message',
      'turn/end',
+      // The seeded constructor's end-seed marker.
+      'session/end-seed',
      'session/title',
    ])
    expect(ctx.sessionTitle.get(session)?.messageSeqs).toEqual([source.seq])
--- a/packages/subagent/subagent-inprocess/tests/inheritance.spec.ts
+++ b/packages/subagent/subagent-inprocess/tests/inheritance.spec.ts
@@ -126,9 +126,10 @@ describe('in-process policy inheritance', () => {

      expect(child.session.header.seedLength).toBe(1)
      expect(child.session.firstLiveSeq).toBe(seed.length)
+      // seq 1 is the constructor's end-seed marker.
      expect(child.session.events.filter(event => event.type === 'sandbox/mode')).toMatchObject([
        { seq: 0, data: { mode: 'workspace-write' } },
-        { seq: 1, data: { mode: 'read-only', source: 'delegation' } },
+        { seq: 2, data: { mode: 'read-only', source: 'delegation' } },
      ])
      await expect(readFile(blocked, 'utf8')).rejects.toMatchObject({ code: 'ENOENT' })
      expect(ctx.sandboxPolicy.overrideOf(child.session)).toBe('read-only')
--- a/packages/telemetry/session-telemetry/tests/telemetry.spec.ts
+++ b/packages/telemetry/session-telemetry/tests/telemetry.spec.ts
@@ -186,10 +186,12 @@ describe('TelemetryCoordinator adoption', () => {

    const seqs = backend.ledger().map(r => [r.attributes['session.id'], r.attributes['event.seq']])
    expect(seqs).toEqual(expect.arrayContaining([['seed-parent', 0], ['seed-parent', 1]]))
-    expect(seqs.filter(([id]) => id === 'seeded')).toEqual([['seeded', 2]])
+    // 2 end-seed, 3 turn/end: both this lifecycle's own writes, while
+    // inherited 0-1 stay with the parent stream.
+    expect(seqs.filter(([id]) => id === 'seeded')).toEqual([['seeded', 2], ['seeded', 3]])
  })

-  it('resume shape: a full-log seed exports nothing yet still rebuilds the chunk projection', async () => {
+  it('resume shape: a full-log seed exports only its own end-seed and rebuilds the chunk projection', async () => {
    const backend = new FakeBackend()
    const ctx = new Context()
    await ctx.plugin(SessionStore)
@@ -205,14 +207,16 @@ describe('TelemetryCoordinator adoption', () => {
    const ofResumed = () => backend.ledger()
      .filter(r => r.attributes['session.id'] === 'resumed')
      .map(r => r.attributes['event.seq'])
-    expect(ofResumed()).toEqual([])
+    // Nothing inherited is re-exported; seq 2 is this session's own first
+    // write — the end-seed event its constructor appended after the seed.
+    expect(ofResumed()).toEqual([2])
    // The seed fed the projection: the (turn 1, step 1) first chunk already
    // shipped from the original process, so its continuation is re-dropped…
    resumed.append('assistant/chunk', { turn: 1, step: 1, chunk: { type: 'text-delta', index: 0, text: 'continuation' } })
-    expect(ofResumed()).toEqual([])
+    expect(ofResumed()).toEqual([2])
    // …while a new step's first chunk exports normally.
    resumed.append('assistant/chunk', { turn: 1, step: 2, chunk: { type: 'text-delta', index: 0, text: 'next step' } })
-    expect(ofResumed()).toEqual([3])
+    expect(ofResumed()).toEqual([2, 4])
  })

  it('stamps session.seed_length from the header so receivers can stitch fork streams', async () => {
--- a/packages/ui/tui/src/components/dialogs.ts
+++ b/packages/ui/tui/src/components/dialogs.ts
@@ -23,6 +23,7 @@ import {
  type AgentLlmTarget,
 } from '@deepseek-ai/dsh-agent'
 import type { LlmModelInfo, LlmModelReasoningInfo, ReasoningEffortId } from '@deepseek-ai/dsh-llm'
+import { lastActivityTime } from '@deepseek-ai/dsh-session'
 import type { SessionId } from '@deepseek-ai/dsh-session'
 import { foldGoal, type GoalPhase } from '@deepseek-ai/dsh-goal'
 import { foldSessionTitle } from '@deepseek-ai/dsh-session-title'
@@ -512,7 +513,8 @@ export function summarizeResumeCandidate(
  return {
    record,
    title,
-    lastActivityAt: snapshot.events.at(-1)?.time ?? snapshot.session.createdAt,
+    // Excludes a prior pickup's boundary, or every browsed session floats up.
+    lastActivityAt: lastActivityTime(snapshot.events) ?? snapshot.session.createdAt,
    lastTurn: resumeTurnLabel(snapshot),
    currentWorkspace: record.header.cwd === cwd,
    workspaceLabel: formatWorkspace(record.header.cwd),
--- a/packages/ui/tui/src/index.ts
+++ b/packages/ui/tui/src/index.ts
@@ -36,6 +36,7 @@ import type {} from '@deepseek-ai/dsh-llm-retry'
 import { renderPrompt } from '@deepseek-ai/dsh-system-prompt'
 import {
  isReplacementSurfaceEvent,
+  lastActivityTime,
  SessionId,
  type SessionEvent,
  type UserMessage,
@@ -1008,7 +1009,7 @@ export function createTuiChat(
    const systemPrompt = displayText(renderPrompt(assembly)) || '(empty)'
    const registeredTools = assembly.tools.map(tool => displayText(tool.name)).join(', ') || '(none)'
    const events = agent.session.events
-    const latestActivity = events.at(-1)?.time ?? agent.session.header.createdAt
+    const latestActivity = lastActivityTime(events) ?? agent.session.header.createdAt
    const usedContext = Math.max(0, Math.round(ctx.tokenMeter.measure(agent.session).totalTokens))
    let context = `${formatDiagnosticNumber(usedContext)} used · capacity unknown`
    const contextWindow = modelController.contextWindow()
--- a/packages/ui/tui/tests/snapshots/status-diagnostics-narrow.expected.txt
+++ b/packages/ui/tui/tests/snapshots/status-diagnostics-narrow.expected.txt
@@ -48,7 +48,7 @@ buffer
 17| "│                                                      │"
  style 0-0 dim
  style 55-55 dim
-18| "│  Agent:      idle · 7 events · 1 turn · 1 step · 1   │"
+18| "│  Agent:      idle · 8 events · 1 turn · 1 step · 1   │"
  style 0-0 dim
  style 3-12 dim
  style 55-55 dim
--- a/packages/ui/tui/tests/snapshots/status-diagnostics.expected.txt
+++ b/packages/ui/tui/tests/snapshots/status-diagnostics.expected.txt
@@ -45,7 +45,7 @@ buffer
 16| "│                                                                                │"
  style 0-0 dim
  style 81-81 dim
-17| "│  Agent:      idle · 7 events · 1 turn · 1 step · 1 tool call                   │"
+17| "│  Agent:      idle · 8 events · 1 turn · 1 step · 1 tool call                   │"
  style 0-0 dim
  style 3-12 dim
  style 81-81 dim
--- a/packages/ui/tui/tests/tui.snapshot.ts
+++ b/packages/ui/tui/tests/tui.snapshot.ts
@@ -878,6 +878,9 @@ describe('TUI terminal-state snapshots', () => {
        { type: 'step/end', seq: 5, time: Date.parse(`${day}T00:00:06Z`), data: { turn: 1, step: 1 } },
        { type: 'turn/end', seq: 6, time: Date.parse(`${day}T00:00:07Z`), data: { turn: 1, reason: { kind: 'completed' } } },
        { type: 'session/title', seq: 7, time: Date.parse(`${day}T00:00:08Z`), data: { title, messageSeqs: [1], source: { kind: 'fallback' } } },
+        // A prior pickup, dated well after the work: the picker must still
+        // show the work's date, not the pickup's.
+        { type: 'session/end-seed', seq: 8, time: Date.parse('2026-07-23T07:59:00.000Z'), data: {} },
      ],
    })
    const harness = await setupSnapshot({
@@ -947,6 +950,12 @@ describe('TUI terminal-state snapshots', () => {
          messageSeqs: [1],
          source: { kind: 'fallback' },
        })
+        // Renders over a boundary-bearing log. It cannot pin the exclusion:
+        // `/status` appends its own `command/run` first, so the boundary is
+        // never the tail here. The other two call sites pin it.
+        dateNow.mockReturnValue(Date.parse('2026-07-22T10:10:11.000Z'))
+        session.append('session/end-seed', {})
+        dateNow.mockReturnValue(Date.parse('2026-07-22T09:10:11.000Z'))
      },
    }, { columns: 92, rows: 32 })
    await renderAfter(harness, () => {