Merge remote-tracking branch 'origin/master' into worktree/provider-routed-llm-adapters

# Conflicts: # docs/cordis-catalog/events.md # docs/cordis-catalog/services.md # docs/event-producer-consumer.md # docs/module-graph.md # packages/context/time-context/tests/time-context.spec.ts # packages/cordis/tool-cordis/src/api-catalog.ts # packages/core/session/README.md # packages/core/session/src/types.ts # packages/core/session/tests/surface.spec.ts # packages/examples/acp-demo/tests/acp-agent.spec.ts # packages/examples/stdio-demo/tests/stdio-agent.spec.ts # packages/hooks/hooks-claude/tests/coverage.spec.ts # packages/hooks/hooks-codex/tests/coverage.spec.ts # packages/session-query/session-query/tests/session-query.spec.ts # packages/support/invariants/tests/invariants.spec.ts # packages/ui/acp/tests/harness.ts
2026-07-17 21:56:10 +08:00
parent 182c622eab cc6cdc9c08
commit 53680ee6bc
358 changed files with 18578 additions and 2877 deletions
--- a/packages/context/time-context/tests/fixtures/cordis.yml
+++ b/packages/context/time-context/tests/fixtures/cordis.yml
@@ -16,3 +16,4 @@
    persona: 'Test the time-context plugin.'
    welcome: 'time-context e2e ready.'
    persistenceRoot: './.sessions'
+    workspaceContext: false
--- a/packages/context/time-context/tests/time-context.e2e.ts
+++ b/packages/context/time-context/tests/time-context.e2e.ts
@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { afterEach, describe, expect, it } from 'vitest'
-import { foldRequestHeader, type SessionEvent } from '@deepseek-ai/dsh-session'
+import type { SessionEvent } from '@deepseek-ai/dsh-session'

 const binScript = fileURLToPath(new URL('../../../examples/stdio-demo/src/bin.ts', import.meta.url))
 const configPath = fileURLToPath(new URL('./fixtures/cordis.yml', import.meta.url))
@@ -12,7 +12,8 @@ const repoTsconfig = fileURLToPath(new URL('../../../../tsconfig.json', import.m
 const tsxLoader = fileURLToPath(import.meta.resolve('tsx'))
 const PROCESS_TIMEOUT_MS = 30_000
 const TEST_TIMEOUT_MS = PROCESS_TIMEOUT_MS + 15_000
-const FIRST_REPLY = 'You said: "first". Try "echo <something>" to see a tool call.'
+const FIRST_REPLY = '[main turn 1] You said: "Time sampled while preparing turn 1, step 1:'
+const SECOND_REPLY = '[main turn 2] You said: "Time sampled while preparing turn 2, step 1:'

 let child: ChildProcessWithoutNullStreams | undefined
 let workdir: string | undefined
@@ -60,7 +61,7 @@ async function runTwoTurns(): Promise<{ stdout: string; stderr: string }> {
    proc.stdout.setEncoding('utf8')
    proc.stdout.on('data', (chunk: string) => {
      stdout += chunk
-      if (!sentSecond && stdout.includes(`${FIRST_REPLY}\n> `)) {
+      if (!sentSecond && stdout.includes(FIRST_REPLY) && stdout.includes('Try "echo <something>" to see a tool call.\n> ')) {
        sentSecond = true
        proc.stdin.end('second\n')
      }
@@ -84,12 +85,12 @@ async function runTwoTurns(): Promise<{ stdout: string; stderr: string }> {
 }

 describe('time-context through a real cordis.yml and stdio process', () => {
-  it('uses the process zone and persists both first-turn and elapsed-time request context', async () => {
+  it('uses the process zone and persists one ordered context event per request', async () => {
    const { stdout, stderr } = await runTwoTurns()
    expect(stderr).not.toContain('UNHANDLED')
    expect(stdout).toContain('time-context e2e ready.')
    expect(stdout).toContain(FIRST_REPLY)
-    expect(stdout).toContain('You said: "second".')
+    expect(stdout).toContain(SECOND_REPLY)

    const logs = await jsonlFiles(join(workdir as string, '.sessions'))
    expect(logs).toHaveLength(1)
@@ -97,19 +98,29 @@ describe('time-context through a real cordis.yml and stdio process', () => {
    const events = lines.slice(1).map(line => JSON.parse(line) as SessionEvent)
    expect(events.filter(event => event.type === 'turn/end')).toHaveLength(2)

-    const firstHeader = events.find(event => event.type === 'request/header')
-    if (firstHeader?.type !== 'request/header') throw new Error('missing initial request/header event')
-    expect(firstHeader.data.header.system).toMatch(
-      /Current time: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+08:00\[Asia\/Shanghai\]/,
+    const contexts = events.filter(event => event.type === 'context/message')
+    const starts = events.filter(event => event.type === 'step/start')
+    expect(contexts).toHaveLength(2)
+    expect(starts).toHaveLength(2)
+    for (let index = 0; index < contexts.length; index += 1) {
+      expect(contexts[index]!.seq).toBeLessThan(starts[index]!.seq)
+      expect(contexts[index]!.surfaceOp).toBe('append')
+      expect(contexts[index]!.data.source).toEqual({ kind: 'plugin', plugin: 'time-context' })
+    }
+    const contextText = contexts.map(event => event.data.content
+      .filter(block => block.type === 'text')
+      .map(block => block.text)
+      .join('\n'))
+    expect(contextText[0]).toMatch(
+      /Time sampled while preparing turn 1, step 1: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+08:00\[Asia\/Shanghai\]/,
    )
-    expect(firstHeader.data.header.system).toContain(
-      'Time since previous message: unavailable (no earlier message in this session).',
+    expect(contextText[0]).toMatch(
+      /Elapsed since the preceding model-visible message: (?:\d+d )?(?:\d+h )?(?:\d+m )?\d+s\./,
    )
+    expect(contextText[1]).toMatch(/Time sampled while preparing turn 2, step 1:/)

-    const finalSystem = foldRequestHeader(events)?.system
-    expect(finalSystem).toContain('[Asia/Shanghai]')
-    expect(finalSystem).toMatch(
-      /Time since previous message: (?:\d+d )?(?:\d+h )?(?:\d+m )?\d+s\./,
-    )
+    const headers = events.filter(event => event.type === 'request/header'
+      || event.type === 'request/header-delta')
+    expect(JSON.stringify(headers)).not.toContain('Time sampled while preparing')
  }, TEST_TIMEOUT_MS)
 })
--- a/packages/context/time-context/tests/time-context.spec.ts
+++ b/packages/context/time-context/tests/time-context.spec.ts
@@ -1,19 +1,20 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
 import Loader from '@cordisjs/plugin-loader'
-import LlmService, { CallId, LlmAdapter } from '@deepseek-ai/dsh-llm'
+import { CallId, LlmAdapter } from '@deepseek-ai/dsh-llm'
 import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm'
-import SessionStore, { Session, SessionId, foldRequestHeader } from '@deepseek-ai/dsh-session'
-import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
+import { Session, SessionId } from '@deepseek-ai/dsh-session'
 import AgentRegistry, { AgentId } from '@deepseek-ai/dsh-agent'
 import type { Agent } from '@deepseek-ai/dsh-agent'
-import ToolRegistry, { defineTool } from '@deepseek-ai/dsh-tools'
+import { defineTool } from '@deepseek-ai/dsh-tools'
 import AgentLoop from '@deepseek-ai/dsh-agent-loop'
+import { mountAgentLoopTestDependencies } from '@deepseek-ai/dsh-agent-loop-testkit'
 import * as timeContext from '@deepseek-ai/dsh-time-context'
 import type { Config } from '@deepseek-ai/dsh-time-context'

 const BASE = Date.parse('2026-07-14T00:00:00.000Z')
 const ORIGINAL_TIME_ZONE = process.env['TZ']
+const SIGNAL = new AbortController().signal

 beforeEach(() => {
  process.env['TZ'] = 'UTC'
@@ -30,18 +31,29 @@ afterEach(() => {

 async function mount(config: Config = {}) {
  const ctx = new Context()
-  await ctx.plugin(SystemPrompt)
+  await ctx.plugin(AgentRegistry)
  const fiber = await ctx.plugin(timeContext, config)
  return { ctx, fiber }
 }

 function sessionAgent(session: Session, id = 'agent'): Agent {
-  return { id: AgentId(id), session } as unknown as Agent
-}
-
-async function sectionText(ctx: Context, agent?: Agent): Promise<string | undefined> {
-  const assembly = await ctx.systemPrompt.assemble(agent === undefined ? {} : { agent })
-  return assembly.sections.find(section => section.name === 'context:time')?.text
+  return {
+    id: AgentId(id),
+    options: {},
+    session,
+    status: 'running',
+    ctx: new Context(),
+    send() {},
+    steer() {},
+    inject(content, options) {
+      session.append('context/message', {
+        content,
+        source: options?.source ?? { kind: 'user' },
+      }, { surfaceOp: 'append' })
+    },
+    cancel() {},
+    whenIdle: () => Promise.resolve(),
+  }
 }

 function openMessageTurn(session: Session, turn: number): void {
@@ -52,6 +64,28 @@ function openMessageTurn(session: Session, turn: number): void {
  }, { surfaceOp: 'append' })
 }

+function contextTexts(session: Session): string[] {
+  const texts: string[] = []
+  for (const event of session.events) {
+    if (event.type === 'context/message'
+      && event.data.source.kind === 'plugin'
+      && event.data.source.plugin === 'time-context') {
+      texts.push(event.data.content.find(block => block.type === 'text')?.text ?? '')
+    }
+  }
+  return texts
+}
+
+async function fire(
+  ctx: Context,
+  agent: Agent,
+  turn: number,
+  step: number,
+  signal: AbortSignal = SIGNAL,
+): Promise<void> {
+  await ctx.serial('agent/pre-step', agent, turn, step, '', [], signal)
+}
+
 function textResponse(text: string): StreamChunk[] {
  return [
    { type: 'block-start', index: 0, blockType: 'text' },
@@ -89,187 +123,186 @@ class ScriptedAdapter extends LlmAdapter {

 async function loopHarness(adapter: ScriptedAdapter, config: Config = {}): Promise<Context> {
  const ctx = new Context()
-  await ctx.plugin(LlmService)
-  await ctx.plugin(SessionStore)
-  await ctx.plugin(SystemPrompt)
-  await ctx.plugin(ToolRegistry)
-  await ctx.plugin(AgentRegistry)
+  await mountAgentLoopTestDependencies(ctx)
  await ctx.plugin(AgentLoop, { agents: [] })
  await ctx.plugin(timeContext, config)
  ctx.llm.registerAdapter(['mock'], adapter)
  return ctx
 }

-describe('temporal section rendering', () => {
-  it('renders the first turn in UTC with the explicit no-previous-message fallback', async () => {
-    const { ctx } = await mount()
+function requestText(request: GenerateOptions): string {
+  return request.messages
+    .flatMap(message => message.content)
+    .filter(block => block.type === 'text')
+    .map(block => block.text)
+    .join('\n')
+}
+
+describe('durable step context', () => {
+  it('records turn, step, zoned time, and the preceding model-visible message baseline', async () => {
+    const { ctx } = await mount({ timeZone: 'Asia/Shanghai' })
    const session = new Session(SessionId('first'))
    openMessageTurn(session, 1)
-
-    expect(await sectionText(ctx, sessionAgent(session))).toBe(
-      'Current time: 2026-07-14T00:00:00+00:00[UTC]\n'
-      + 'Time since previous message: unavailable (no earlier message in this session).',
-    )
-  })
-
-  it('renders a non-UTC numeric offset and all compact duration units', async () => {
-    const { ctx } = await mount({ timeZone: 'Asia/Shanghai' })
-    const session = new Session(SessionId('offset'))
-    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
-    session.append('assistant/message', {
-      provenance: { provider: 'mock', model: 'mock' },
-      turn: 1,
-      step: 1,
-      content: [{ type: 'text', text: 'previous' }],
-    }, { surfaceOp: 'append' })
-    session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
    vi.setSystemTime(BASE + 90_061_000)
-    openMessageTurn(session, 2)

-    expect(await sectionText(ctx, sessionAgent(session))).toBe(
-      'Current time: 2026-07-15T09:01:01+08:00[Asia/Shanghai]\n'
-      + 'Time since previous message: 1d 1h 1m 1s.',
+    await fire(ctx, sessionAgent(session), 1, 1)
+
+    expect(contextTexts(session)).toEqual([
+      'Time sampled while preparing turn 1, step 1: 2026-07-15T09:01:01+08:00[Asia/Shanghai]\n'
+      + 'Elapsed since the preceding model-visible message: 1d 1h 1m 1s.',
+    ])
+    const event = session.events.at(-1)
+    expect(event?.type).toBe('context/message')
+    if (event?.type !== 'context/message') throw new Error('missing time context')
+    expect(event.data.source).toEqual({ kind: 'plugin', plugin: 'time-context' })
+    expect(event.surfaceOp).toBe('append')
+  })
+
+  it('reports an unavailable first-step baseline when no model-visible message precedes it', async () => {
+    const { ctx } = await mount()
+    const session = new Session(SessionId('unavailable'))
+    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+
+    await fire(ctx, sessionAgent(session), 1, 1)
+
+    expect(contextTexts(session)[0]).toContain(
+      'Elapsed since the preceding model-visible message: unavailable.',
    )
  })

-  it('clamps a backward wall-clock adjustment to a zero duration', async () => {
+  it.each([
+    ['omitted interval', {}],
+    ['zero interval', { refreshIntervalMs: 0 }],
+  ] as const)('uses the preceding durable step-context timestamp after step one with %s', async (_label, config) => {
+    const { ctx } = await mount(config)
+    const session = new Session(SessionId('later-step'))
+    const agent = sessionAgent(session)
+    openMessageTurn(session, 3)
+    await fire(ctx, agent, 3, 1)
+    vi.setSystemTime(BASE + 61_000)
+
+    await fire(ctx, agent, 3, 2)
+
+    expect(contextTexts(session)[1]).toBe(
+      'Time sampled while preparing turn 3, step 2: 2026-07-14T00:01:01+00:00[UTC]\n'
+      + 'Elapsed since the preceding step context: 1m 1s.',
+    )
+  })
+
+  it('reports an unavailable later-step baseline at the matching turn boundary', async () => {
    const { ctx } = await mount()
-    const session = new Session(SessionId('backward-duration'))
-    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
-    session.append('assistant/message', {
-      provenance: { provider: 'mock', model: 'mock' },
-      turn: 1,
-      step: 1,
-      content: [{ type: 'text', text: 'future by adjusted clock' }],
-    }, { surfaceOp: 'append' })
-    session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
+    const session = new Session(SessionId('later-step-boundary'))
+    openMessageTurn(session, 4)
+
+    await fire(ctx, sessionAgent(session), 4, 2)
+
+    expect(contextTexts(session)[0]).toContain(
+      'Elapsed since the preceding step context: unavailable.',
+    )
+  })
+
+  it('reports an unavailable later-step baseline when event lookup is exhausted', async () => {
+    const { ctx } = await mount()
+    const session = new Session(SessionId('later-step-exhausted'))
+
+    await fire(ctx, sessionAgent(session), 1, 2)
+
+    expect(contextTexts(session)[0]).toContain(
+      'Elapsed since the preceding step context: unavailable.',
+    )
+  })
+
+  it('injects after backward wall-clock movement and clamps elapsed time to zero', async () => {
+    const { ctx } = await mount({ refreshIntervalMs: 60_000 })
+    const session = new Session(SessionId('backward'))
+    const agent = sessionAgent(session)
+    openMessageTurn(session, 1)
+    await fire(ctx, agent, 1, 1)
    vi.setSystemTime(BASE - 5_000)
-    openMessageTurn(session, 2)

-    expect(await sectionText(ctx, sessionAgent(session))).toContain('Time since previous message: 0s.')
+    await fire(ctx, agent, 1, 2)
+
+    expect(contextTexts(session)).toHaveLength(2)
+    expect(contextTexts(session)[1]).toContain('Elapsed since the preceding step context: 0s.')
  })

-  const previousMessageCases = [
-    ['user/message', (session: Session): void => {
-      session.append('user/message', { content: [{ type: 'text', text: 'u' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
-    }],
-    ['assistant/message', (session: Session): void => {
-      session.append('assistant/message', { provenance: { provider: 'mock', model: 'mock' }, turn: 1, step: 1, content: [{ type: 'text', text: 'a' }] }, { surfaceOp: 'append' })
-    }],
-    ['tool/result', (session: Session): void => {
-      session.append('tool/result', {
-        turn: 1,
-        step: 1,
-        callId: CallId('previous'),
-        content: [{ type: 'text', text: 'r' }],
-        isError: false,
-      }, { surfaceOp: 'append' })
-    }],
-    ['context/message', (session: Session): void => {
-      session.append('context/message', {
-        content: [{ type: 'text', text: 'c' }],
-        source: { kind: 'plugin', plugin: 'test' },
-      }, { surfaceOp: 'append' })
-    }],
-    ['steering/message', (session: Session): void => {
-      session.append('steering/message', {
-        turn: 1,
-        content: [{ type: 'text', text: 's' }],
-        source: { kind: 'user' },
-      }, { surfaceOp: 'append' })
-    }],
-  ] as const
+  it('uses a shadowed durable injection after resume and injects at the exact threshold', async () => {
+    const { ctx } = await mount({ refreshIntervalMs: 1_000 })
+    const original = new Session(SessionId('seed-source'))
+    openMessageTurn(original, 1)
+    await fire(ctx, sessionAgent(original), 1, 1)
+    const user = original.events.find(event => event.type === 'user/message')
+    const reading = original.events.find(event => event.type === 'context/message')
+    if (user === undefined || reading === undefined) throw new Error('missing source surface events')
+    original.append('context/message', {
+      content: [{ type: 'text', text: 'compacted history' }],
+      source: { kind: 'plugin', plugin: 'compact-basic' },
+    }, {
+      surfaceOp: { op: 'replace', start: user.seq, end: reading.seq },
+      sourceEventSeqs: [user.seq, reading.seq],
+    })
+    original.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
+    expect(JSON.stringify(original.deriveMessages())).not.toContain('Time sampled while preparing')

-  it.each(previousMessageCases)('uses a prior %s as the duration baseline', async (_name, appendPrevious) => {
-    const { ctx } = await mount()
-    const session = new Session(SessionId(`previous-${_name}`))
-    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
-    appendPrevious(session)
-    session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
-    vi.setSystemTime(BASE + 5_000)
-    openMessageTurn(session, 2)
+    const resumed = new Session(SessionId('resumed'), [...original.events])
+    const resumedAgent = sessionAgent(resumed)
+    vi.setSystemTime(BASE + 999)
+    openMessageTurn(resumed, 2)
+    const beforeSkip = resumed.events.length

-    expect(await sectionText(ctx, sessionAgent(session))).toContain('Time since previous message: 5s.')
-  })
+    await fire(ctx, resumedAgent, 2, 1)

-  it('contributes empty text without an active agent turn', async () => {
-    const { ctx } = await mount()
-    expect(await sectionText(ctx)).toBe('')
+    expect(resumed.events).toHaveLength(beforeSkip)
+    expect(contextTexts(resumed)).toHaveLength(1)

-    const empty = sessionAgent(new Session(SessionId('empty')))
-    expect(await sectionText(ctx, empty)).toBe('')
-
-    const closedSession = new Session(SessionId('closed'))
-    openMessageTurn(closedSession, 1)
-    closedSession.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
-    expect(await sectionText(ctx, sessionAgent(closedSession))).toBe('')
-  })
-})
-
-describe('refresh policy', () => {
-  it('reuses within the interval, refreshes at expiry, and refreshes after a backward clock jump', async () => {
-    const { ctx } = await mount({ refreshIntervalMs: 60_000 })
-    const session = new Session(SessionId('interval'))
-    const agent = sessionAgent(session)
-    openMessageTurn(session, 1)
-
-    const first = await sectionText(ctx, agent)
-    vi.setSystemTime(BASE + 30_000)
-    expect(await sectionText(ctx, agent)).toBe(first)
-    vi.setSystemTime(BASE + 60_000)
-    const expired = await sectionText(ctx, agent)
-    expect(expired).toContain('2026-07-14T00:01:00+00:00[UTC]')
-    vi.setSystemTime(BASE + 59_000)
-    expect(await sectionText(ctx, agent)).toContain('2026-07-14T00:00:59+00:00[UTC]')
-  })
-
-  it('refreshes every assembly when refreshIntervalMs is zero', async () => {
-    const { ctx } = await mount({ refreshIntervalMs: 0 })
-    const session = new Session(SessionId('every-step'))
-    const agent = sessionAgent(session)
-    openMessageTurn(session, 1)
-    const first = await sectionText(ctx, agent)
    vi.setSystemTime(BASE + 1_000)
-    expect(await sectionText(ctx, agent)).not.toBe(first)
+    await fire(ctx, resumedAgent, 2, 2)
+
+    expect(contextTexts(resumed)).toHaveLength(2)
+    expect(contextTexts(resumed)[1]).toContain(
+      'Elapsed since the preceding step context: unavailable.',
+    )
  })

-  it('always refreshes for a new turn and keeps the preceding message baseline', async () => {
-    const { ctx } = await mount({ refreshIntervalMs: 60_000 })
-    const session = new Session(SessionId('turn-refresh'))
+  it('applies a positive interval across turns without sharing state between sessions', async () => {
+    const { ctx } = await mount({ refreshIntervalMs: 1_000 })
+    const first = new Session(SessionId('interval-first'))
+    const firstAgent = sessionAgent(first, 'first-agent')
+    openMessageTurn(first, 1)
+    await fire(ctx, firstAgent, 1, 1)
+    first.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
+
+    vi.setSystemTime(BASE + 500)
+    openMessageTurn(first, 2)
+    const beforeSkip = first.events.length
+    await fire(ctx, firstAgent, 2, 1)
+
+    const independent = new Session(SessionId('interval-independent'))
+    openMessageTurn(independent, 1)
+    await fire(ctx, sessionAgent(independent, 'independent-agent'), 1, 1)
+
+    expect(first.events).toHaveLength(beforeSkip)
+    expect(contextTexts(first)).toHaveLength(1)
+    expect(contextTexts(independent)).toHaveLength(1)
+  })
+
+  it('runs before ordinary pre-step listeners and skips an already-aborted step', async () => {
+    const { ctx } = await mount()
+    const session = new Session(SessionId('ordering'))
    const agent = sessionAgent(session)
    openMessageTurn(session, 1)
-    const first = await sectionText(ctx, agent)
-    vi.setSystemTime(BASE + 1_000)
-    session.append('assistant/message', {
-      provenance: { provider: 'mock', model: 'mock' },
-      turn: 1,
-      step: 1,
-      content: [{ type: 'text', text: 'done' }],
-    }, { surfaceOp: 'append' })
-    session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
-    vi.setSystemTime(BASE + 2_000)
-    openMessageTurn(session, 2)
+    let ordinarySawContext = false
+    ctx.on('agent/pre-step', (subject) => {
+      ordinarySawContext = subject.session.events.some(event => event.type === 'context/message')
+    })

-    const second = await sectionText(ctx, agent)
-    expect(second).not.toBe(first)
-    expect(second).toContain('Time since previous message: 1s.')
-  })
+    await fire(ctx, agent, 1, 1)
+    const abort = new AbortController()
+    abort.abort()
+    await fire(ctx, agent, 1, 2, abort.signal)

-  it('keeps refresh caches independent per agent', async () => {
-    const { ctx } = await mount({ refreshIntervalMs: 60_000 })
-    const sessionA = new Session(SessionId('agent-a'))
-    const sessionB = new Session(SessionId('agent-b'))
-    const agentA = sessionAgent(sessionA, 'a')
-    const agentB = sessionAgent(sessionB, 'b')
-    openMessageTurn(sessionA, 1)
-    openMessageTurn(sessionB, 1)
-    const aFirst = await sectionText(ctx, agentA)
-    vi.setSystemTime(BASE + 30_000)
-    const bFirst = await sectionText(ctx, agentB)
-    vi.setSystemTime(BASE + 40_000)
-
-    expect(await sectionText(ctx, agentA)).toBe(aFirst)
-    expect(bFirst).toContain('2026-07-14T00:00:30+00:00[UTC]')
+    expect(ordinarySawContext).toBe(true)
+    expect(contextTexts(session)).toHaveLength(1)
  })
 })

@@ -281,49 +314,79 @@ describe('configuration and lifecycle', () => {
    const session = new Session(SessionId('system-zone'))
    openMessageTurn(session, 1)

-    expect(await sectionText(ctx, sessionAgent(session))).toContain(
-      'Current time: 2026-07-14T08:00:00+08:00[Asia/Shanghai]',
+    await fire(ctx, sessionAgent(session), 1, 1)
+
+    expect(contextTexts(session)[0]).toContain('2026-07-14T08:00:00+08:00[Asia/Shanghai]')
+  })
+
+  it('fails loud for an invalid explicit zone or an unavailable process zone', async () => {
+    const invalid = new Context()
+    await invalid.plugin(AgentRegistry)
+    await expect(invalid.plugin(timeContext, { timeZone: 'Not/A_Real_Zone' })).rejects.toThrow(
+      /invalid IANA timeZone/,
    )
-  })

-  it('fails loud for negative, fractional, unsafe, and invalid-zone config', async () => {
-    for (const refreshIntervalMs of [-1, 1.5, Number.MAX_SAFE_INTEGER + 1]) {
-      const ctx = new Context()
-      await ctx.plugin(SystemPrompt)
-      await expect(ctx.plugin(timeContext, { refreshIntervalMs })).rejects.toThrow(/non-negative safe integer/)
-    }
-
-    const ctx = new Context()
-    await ctx.plugin(SystemPrompt)
-    await expect(ctx.plugin(timeContext, { timeZone: 'Not/A_Real_Zone' })).rejects.toThrow(/invalid IANA timeZone/)
-  })
-
-  it('fails loud when the process system zone cannot be resolved', async () => {
    vi.spyOn(Intl, 'DateTimeFormat').mockImplementationOnce(() => {
      throw new RangeError('system zone unavailable')
    })
-    const ctx = new Context()
-    await ctx.plugin(SystemPrompt)
-
-    await expect(ctx.plugin(timeContext, {})).rejects.toThrow(/failed to resolve the system time zone/)
+    const unresolved = new Context()
+    await unresolved.plugin(AgentRegistry)
+    await expect(unresolved.plugin(timeContext, {})).rejects.toThrow(/failed to resolve the system time zone/)
  })

-  it('removes its section when the plugin fiber disposes', async () => {
+  it('rejects invalid refresh intervals at plugin load with one diagnostic', async () => {
+    const invalid = [-1, 0.5, Number.MAX_SAFE_INTEGER + 1, Number.POSITIVE_INFINITY, Number.NaN]
+    for (const refreshIntervalMs of invalid) {
+      await expect(mount({ refreshIntervalMs })).rejects.toThrow(
+        'time-context: refreshIntervalMs must be a non-negative safe integer',
+      )
+    }
+  })
+
+  it('removes its listener when the plugin fiber disposes', async () => {
    const { ctx, fiber } = await mount()
    const session = new Session(SessionId('dispose'))
    const agent = sessionAgent(session)
    openMessageTurn(session, 1)
-    expect(await sectionText(ctx, agent)).toContain('Current time:')
+    await fire(ctx, agent, 1, 1)

    await fiber.dispose()
-    expect(await sectionText(ctx, agent)).toBeUndefined()
+    await fire(ctx, agent, 1, 2)
+
+    expect(contextTexts(session)).toHaveLength(1)
  })
 })

-describe('real agent-loop request logging', () => {
-  it('refreshes a long turn in the system prompt and records the header delta without context history', async () => {
-    const adapter = new ScriptedAdapter([toolCallResponse(), textResponse('done'), textResponse('next turn')])
-    const ctx = await loopHarness(adapter, { refreshIntervalMs: 60_000 })
+describe('real agent-loop request history', () => {
+  it.each([
+    ['throws', 'error'],
+    ['cancels', 'aborted'],
+  ] as const)('retains the preparation reading when a later pre-step listener %s', async (mode, reasonKind) => {
+    const adapter = new ScriptedAdapter([textResponse('unused')])
+    const ctx = await loopHarness(adapter)
+    let laterSawReading = false
+    ctx.on('agent/pre-step', (subject) => {
+      laterSawReading = contextTexts(subject.session).length === 1
+      if (mode === 'throws') throw new Error('later pre-step failure')
+      subject.cancel('later pre-step cancellation')
+    })
+    const agent = ctx.agentLoop.create(AgentId(`late-${mode}`), { provider: 'mock', model: 'mock' })
+
+    agent.send([{ type: 'text', text: 'start' }])
+    await agent.whenIdle()
+
+    expect(laterSawReading).toBe(true)
+    expect(contextTexts(agent.session)).toHaveLength(1)
+    expect(adapter.requests).toHaveLength(0)
+    expect(agent.session.events.some(event => event.type === 'step/start')).toBe(false)
+    const turnEnd = agent.session.events.findLast(event => event.type === 'turn/end')
+    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason.kind).toBe(reasonKind)
+    await ctx.fiber.dispose()
+  })
+
+  it('persists one ordered context per request, accumulates readings, and leaves system headers unchanged', async () => {
+    const adapter = new ScriptedAdapter([toolCallResponse(), textResponse('done')])
+    const ctx = await loopHarness(adapter)
    ctx.tools.register(defineTool({
      name: 'tick',
      description: 'advance fake time',
@@ -337,38 +400,55 @@ describe('real agent-loop request logging', () => {

    agent.send([{ type: 'text', text: 'start' }])
    await agent.whenIdle()
-    expect(adapter.requests).toHaveLength(2)
-    expect(adapter.requests[0]!.system).toContain('2026-07-14T00:00:00+00:00[UTC]')
-    expect(adapter.requests[1]!.system).toContain('2026-07-14T00:01:01+00:00[UTC]')
-    expect(agent.session.events.some(event => event.type === 'context/message')).toBe(false)
-    expect(agent.session.events.filter(event => event.type === 'request/header-delta')).toHaveLength(1)
-    expect(foldRequestHeader(agent.session.events)?.system).toBe(adapter.requests[1]!.system)

-    vi.setSystemTime(BASE + 361_000)
-    agent.send([{ type: 'text', text: 'again' }])
-    await agent.whenIdle()
-    expect(adapter.requests[2]!.system).toContain('Time since previous message: 5m 0s.')
+    expect(adapter.requests).toHaveLength(2)
+    const contexts = agent.session.events.filter(event => event.type === 'context/message')
+    const starts = agent.session.events.filter(event => event.type === 'step/start')
+    expect(contexts).toHaveLength(adapter.requests.length)
+    expect(starts).toHaveLength(adapter.requests.length)
+    for (let index = 0; index < contexts.length; index += 1) {
+      expect(contexts[index]!.seq).toBeLessThan(starts[index]!.seq)
+    }
+    expect(contexts.every(event => event.data.source.kind === 'plugin'
+      && event.data.source.plugin === 'time-context'
+      && event.surfaceOp === 'append')).toBe(true)
+
+    const firstRequestText = requestText(adapter.requests[0]!)
+    const secondRequestText = requestText(adapter.requests[1]!)
+    expect(firstRequestText).toContain('Time sampled while preparing turn 1, step 1:')
+    expect(firstRequestText).toContain('Elapsed since the preceding model-visible message: 0s.')
+    expect(firstRequestText).not.toContain('Time sampled while preparing turn 1, step 2:')
+    expect(secondRequestText).toContain('Time sampled while preparing turn 1, step 1:')
+    expect(secondRequestText).toContain('Time sampled while preparing turn 1, step 2:')
+    expect(secondRequestText).toContain('Elapsed since the preceding step context: 1m 1s.')
+
+    for (const request of adapter.requests) expect(request.system).not.toContain('Time sampled while preparing')
+    const headers = agent.session.events.filter(event => event.type === 'request/header'
+      || event.type === 'request/header-delta')
+    expect(JSON.stringify(headers)).not.toContain('Time sampled while preparing')
+    expect(agent.session.events.filter(event => event.type === 'request/header-delta')).toHaveLength(0)
    await ctx.fiber.dispose()
  })
 })

 describe('real Loader export path', () => {
-  it('keeps the namespace metadata and boots through unwrapExports', async () => {
+  it('keeps namespace metadata and boots the agent listener through unwrapExports', async () => {
    expect('default' in timeContext).toBe(false)
    const loader = Object.create(Loader.prototype) as Loader
    const unwrapped = loader.unwrapExports(timeContext) as Record<string, unknown>
    expect(unwrapped).toBe(timeContext)
    expect(unwrapped.name).toBe('time-context')
-    expect(unwrapped.inject).toEqual(['systemPrompt'])
+    expect(unwrapped.inject).toEqual(['agents'])
    expect(unwrapped.Config).toBeDefined()
    expect(typeof unwrapped.apply).toBe('function')

    const ctx = new Context()
-    await ctx.plugin(SystemPrompt)
+    await ctx.plugin(AgentRegistry)
    const plugin = loader.unwrapExports(timeContext) as Parameters<Context['plugin']>[0]
    await ctx.plugin(plugin)
    const session = new Session(SessionId('loader'))
    openMessageTurn(session, 1)
-    expect(await sectionText(ctx, sessionAgent(session))).toContain('Current time:')
+    await fire(ctx, sessionAgent(session), 1, 1)
+    expect(contextTexts(session)[0]).toContain('Time sampled while preparing turn 1, step 1:')
  })
 })