Merge remote-tracking branch 'origin/master' into xtr/identified-immutable-messages

# Conflicts:
#	.agents/notes/implemented/architecture/2026-07-24-separate-context-injection-from-turn-execution.i18n.yaml
#	docs/cordis-catalog/services.md
#	docs/core-data-structures/core.i18n.yaml
#	docs/core-data-structures/session.i18n.yaml
#	docs/event-producer-consumer.md
#	docs/persistence-catalog.md
#	packages/core/session/README.i18n.yaml
#	packages/session-title/session-title/tests/persistence.spec.ts

packages/core/tools/src/code-mode.ts

@@ -43,7 +43,7 @@ declare module '@deepseek-ai/dsh-session' {
      * Log-only: `deriveMessages()` ignores it, so sub-calls never re-enter
      * model context; persistence and UIs get every call. Appended inside the
      * parent `run_code`'s execution (the bridge drains in-flight dispatches
-     * before returning), so the turn-enclosure invariant holds by
+     * before returning), so its execution-enclosure relation holds by
      * construction.
      */
     'tool/code-dispatch': { parentCallId: CallId; subCallId: CallId; name: string; arguments: unknown; isError: boolean; content: ContentBlock[] }

packages/core/tools/src/invariant.ts

@@ -1,6 +1,7 @@
 /** Package-owned tool-pipeline invariants. @module @deepseek-ai/dsh-tools/invariant */
 
 import type { Context } from 'cordis'
+import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
 import type { InvariantFailure, InvariantInstaller } from '@deepseek-ai/dsh-invariants'
 import type { ToolExecution, ToolExecutionResult } from './index.ts'
 
@@ -28,10 +29,40 @@ function validateResult(
   }
 }
 
-/** Install monotonic pipeline and final-snapshot checks. */
-const install: InvariantInstaller = (ctx, fail) => {
+/** Install monotonic pipeline, final-snapshot, and code-dispatch enclosure checks. */
+const install: InvariantInstaller = Object.assign((ctx: Context, fail: InvariantFailure) => {
   const stages = new WeakMap<object, ToolStage>()
+  const openTurns = new WeakMap<Session, number | null>()
+  const seed = (session: Session): number | null => {
+    let openTurn: number | null = null
+    for (const event of session.events) {
+      if (event.type === 'turn/start') openTurn = event.data.turn
+      else if (event.type === 'turn/end') openTurn = null
+      else if ((event.type === 'tool/code-dispatch-start' || event.type === 'tool/code-dispatch')
+        && openTurn === null) {
+        fail(`${event.type} appended outside any open turn`)
+      }
+    }
+    openTurns.set(session, openTurn)
+    return openTurn
+  }
+  const openTurnFor = (session: Session): number | null => openTurns.get(session) ?? seed(session)
+
+  for (const session of ctx.sessions.list()) seed(session)
+  ctx.on('session/created', (session) => { seed(session) }, { global: true })
+  ctx.on('session/event', (session, event) => {
+    if (event.type === 'turn/start') openTurns.set(session, event.data.turn)
+    else if (event.type === 'turn/end') openTurns.set(session, null)
+  }, { global: true })
   ctx.on('internal/dispatch', (_mode, eventName, args) => {
+    if (eventName === 'session/event') {
+      const [session, event] = args as [Session, SessionEvent]
+      if ((event.type === 'tool/code-dispatch-start' || event.type === 'tool/code-dispatch')
+        && openTurnFor(session) === null) {
+        fail(`${event.type} appended outside any open turn`)
+      }
+      return
+    }
     if (eventName === 'tools/pre-execute') {
       const exec = args[0] as ToolExecution
       if (stages.has(exec)) fail('tools/pre-execute repeated for one execution')
@@ -58,7 +89,7 @@ const install: InvariantInstaller = (ctx, fail) => {
     validateResult(exec, result, fail)
     stages.delete(exec)
   }, { global: true })
-}
+}, { inject: ['sessions'] })
 
 /**
  * Register the tools invariant companion.

packages/core/tools/tests/invariant.spec.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
 import { scopeTarget } from '@deepseek-ai/dsh-scope'
 import { CallId } from '@deepseek-ai/dsh-llm'
+import SessionStore from '@deepseek-ai/dsh-session'
 import type { ToolExecution, ToolExecutionResult, ToolExecutionToken } from '@deepseek-ai/dsh-tools'
 import * as ToolsInvariant from '@deepseek-ai/dsh-tools/invariant'
 import InvariantService from '@deepseek-ai/dsh-invariants'
@@ -10,6 +11,7 @@ const testToolSignal = new AbortController().signal
 
 async function setup(): Promise<Context> {
   const ctx = new Context()
+  await ctx.plugin(SessionStore)
   await ctx.plugin(InvariantService)
   await ctx.plugin(ToolsInvariant)
   return ctx
@@ -85,4 +87,50 @@ describe('tool-pipeline invariants', () => {
     const anonymous = Object.freeze(execution({ name: '' }))
     expect(() => { emitResult(ctx, anonymous, outcome()) }).toThrow(/non-empty name and callId/)
   })
+
+  it('requires code-dispatch records to be turn-enclosed', async () => {
+    const ctx = await setup()
+    const session = ctx.sessions.create()
+    const data = {
+      parentCallId: CallId('parent'),
+      subCallId: CallId('child'),
+      name: 'echo',
+      arguments: {},
+    }
+    expect(() => session.append('tool/code-dispatch-start', data)).toThrow(/outside any open turn/)
+    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    expect(() => session.append('tool/code-dispatch-start', data)).not.toThrow()
+    session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
+  })
+
+  it('replays enclosed code-dispatch records on late registration', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SessionStore)
+    const session = ctx.sessions.create()
+    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('tool/code-dispatch', {
+      parentCallId: CallId('parent'),
+      subCallId: CallId('child'),
+      name: 'echo',
+      arguments: {},
+      isError: false,
+      content: [{ type: 'text', text: 'ok' }],
+    })
+    session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
+    await ctx.plugin(InvariantService)
+    await expect(ctx.plugin(ToolsInvariant).then(() => undefined)).resolves.toBeUndefined()
+  })
+
+  it('rejects an unenclosed code-dispatch record on late registration', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SessionStore)
+    ctx.sessions.create().append('tool/code-dispatch-start', {
+      parentCallId: CallId('parent'),
+      subCallId: CallId('child'),
+      name: 'echo',
+      arguments: {},
+    })
+    await ctx.plugin(InvariantService)
+    await expect(ctx.plugin(ToolsInvariant).then(() => undefined)).rejects.toThrow(/outside any open turn/)
+  })
 })