fix(invariants): replay histories and pack companions

packages/context/time-context/package.json

@@ -32,6 +32,7 @@
   "peerDependencies": {
     "@deepseek-ai/dsh-agent": "^0.0.1",
     "@deepseek-ai/dsh-invariants": "^0.0.1",
+    "@deepseek-ai/dsh-session": "^0.0.1",
     "cordis": "^4.0.0-rc.7"
   },
   "devDependencies": {

packages/context/time-context/src/invariant.ts

@@ -19,10 +19,10 @@ export const name = 'time-context-invariant'
 export const inject = ['invariants']
 
 /** Derive the pre-step position at which a time-context reading may append. */
-function preparationPosition(session: Session, fail: InvariantFailure): { turn: number; step: number } {
+function preparationPosition(history: readonly SessionEvent[], fail: InvariantFailure): { turn: number; step: number } {
   const currentTurnEvents: SessionEvent[] = []
   let openTurn: number | undefined
-  for (const event of session.events.slice().reverse()) {
+  for (const event of history.slice().reverse()) {
     if (event.type === 'turn/end') {
       fail('time-context reading must be appended inside an open turn')
     }
@@ -47,7 +47,7 @@ function preparationPosition(session: Session, fail: InvariantFailure): { turn:
 
 /** Validate one plugin-attributed time reading against its session position and timestamp. */
 function validateReading(
-  session: Session,
+  history: readonly SessionEvent[],
   event: SessionEvent<'context/message'>,
   fail: InvariantFailure,
 ): void {
@@ -62,7 +62,7 @@ function validateReading(
   if (!Number.isSafeInteger(turn) || turn < 1 || !Number.isSafeInteger(step) || step < 1) {
     fail('time-context turn and step must be positive safe integers')
   }
-  const expected = preparationPosition(session, fail)
+  const expected = preparationPosition(history, fail)
   if (turn !== expected.turn || step !== expected.step) {
     fail(`time-context reading names turn ${turn}/step ${step}, expected turn ${expected.turn}/step ${expected.step}`)
   }
@@ -80,17 +80,30 @@ function validateReading(
   }
 }
 
-/** Install validation for plugin-attributed context readings. */
-const install: InvariantInstaller = (ctx, fail) => {
+/* jscpd:ignore-start -- package companions share replay and dispatch plumbing */
+/** Validate all package-owned readings already present in one session. */
+function validateSession(session: Session, fail: InvariantFailure): void {
+  for (const [index, event] of session.events.entries()) {
+    if (event.type !== 'context/message'
+      || event.data.source.kind !== 'plugin'
+      || event.data.source.plugin !== SOURCE_NAME) continue
+    validateReading(session.events.slice(0, index), event, fail)
+  }
+}
+
+/** Install validation for loaded and newly appended context readings. */
+const install: InvariantInstaller = Object.assign((ctx: Context, fail: InvariantFailure) => {
+  for (const session of ctx.sessions.list()) validateSession(session, fail)
   ctx.on('internal/dispatch', (_mode, eventName, args) => {
     if (eventName !== 'session/event') return
     const [session, event] = args as [Session, SessionEvent]
     if (event.type !== 'context/message'
       || event.data.source.kind !== 'plugin'
       || event.data.source.plugin !== SOURCE_NAME) return
-    validateReading(session, event, fail)
+    validateReading(session.events, event, fail)
   }, { global: true })
-}
+}, { inject: ['sessions'] })
+/* jscpd:ignore-end */
 
 /**
  * Register the time-context invariant companion.

packages/context/time-context/tests/invariant.spec.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
 import type { ContentBlock } from '@deepseek-ai/dsh-llm'
-import { Session, SessionId, type SessionEvent } from '@deepseek-ai/dsh-session'
+import SessionStore, { Session, SessionId, type SessionEvent } from '@deepseek-ai/dsh-session'
 import * as TimeInvariant from '@deepseek-ai/dsh-time-context/invariant'
 import InvariantService from '@deepseek-ai/dsh-invariants'
 
@@ -9,7 +9,8 @@ const SECOND = Date.parse('2026-07-14T00:00:00Z')
 
 async function setup(): Promise<Context> {
   const ctx = new Context()
-  await ctx.plugin(InvariantService)
+  await ctx.plugin(SessionStore)
+  await ctx.plugin(InvariantService, { enabled: true })
   await ctx.plugin(TimeInvariant)
   return ctx
 }
@@ -54,6 +55,13 @@ function preparing(turn: number, step: number): Session {
   return session
 }
 
+function appendReading(session: Session, text: string): void {
+  session.append('context/message', {
+    content: [{ type: 'text', text }],
+    source: { kind: 'plugin', plugin: 'time-context' },
+  }, { surfaceOp: 'append' })
+}
+
 describe('time-context invariants', () => {
   it('accepts a reading whose turn, step, baseline, and timestamp agree', async () => {
     const ctx = await setup()
@@ -69,6 +77,37 @@ describe('time-context invariants', () => {
     }).not.toThrow()
   })
 
+  it('validates each existing reading against its preceding durable prefix', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SessionStore)
+    const session = ctx.sessions.create(SessionId('time-invariant-late-valid'))
+    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('user/message', {
+      content: [{ type: 'text', text: 'prepare' }],
+      source: { kind: 'user' },
+    }, { surfaceOp: 'append' })
+    appendReading(session, reading())
+    session.append('step/start', { turn: 1, step: 1 })
+
+    await ctx.plugin(InvariantService, { enabled: true })
+    await expect(ctx.plugin(TimeInvariant)).resolves.toBeDefined()
+  })
+
+  it('rejects an invalid existing reading on late registration', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SessionStore)
+    const session = ctx.sessions.create(SessionId('time-invariant-late-invalid'))
+    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('user/message', {
+      content: [{ type: 'text', text: 'prepare' }],
+      source: { kind: 'user' },
+    }, { surfaceOp: 'append' })
+    appendReading(session, reading('1', '2', 'step context'))
+
+    await ctx.plugin(InvariantService, { enabled: true })
+    await expect(ctx.plugin(TimeInvariant).then(() => undefined)).rejects.toThrow(/expected turn 1\/step 1/)
+  })
+
   it.each([
     [reading('1', '3', 'step context'), /expected turn 2\/step 3/],
     [reading('2', '2', 'step context'), /expected turn 2\/step 3/],

packages/context/time-context/tsconfig.json

@@ -32,6 +32,9 @@
     },
     {
       "path": "../../support/invariants"
+    },
+    {
+      "path": "../../core/session"
     }
   ]
 }

packages/goal/goal-session/tsdown.config.ts

@@ -0,0 +1,25 @@
+import { defineConfig } from 'tsdown'
+
+/** Build the package root and invariant companion as independent bundles. */
+export default defineConfig([
+  {
+    entry: ['lib/types/index.js'],
+    outDir: 'lib',
+    format: ['esm'],
+    platform: 'node',
+    target: 'es2024',
+    fixedExtension: false,
+    dts: false,
+    clean: false,
+  },
+  {
+    entry: ['lib/types/invariant.js'],
+    outDir: 'lib',
+    format: ['esm'],
+    platform: 'node',
+    target: 'es2024',
+    fixedExtension: false,
+    dts: false,
+    clean: false,
+  },
+])

packages/goal/goal/tsdown.config.ts

@@ -0,0 +1,25 @@
+import { defineConfig } from 'tsdown'
+
+/** Build the package root and invariant companion as independent bundles. */
+export default defineConfig([
+  {
+    entry: ['lib/types/index.js'],
+    outDir: 'lib',
+    format: ['esm'],
+    platform: 'node',
+    target: 'es2024',
+    fixedExtension: false,
+    dts: false,
+    clean: false,
+  },
+  {
+    entry: ['lib/types/invariant.js'],
+    outDir: 'lib',
+    format: ['esm'],
+    platform: 'node',
+    target: 'es2024',
+    fixedExtension: false,
+    dts: false,
+    clean: false,
+  },
+])

packages/sandbox/sandbox-policy/src/invariant.ts

@@ -2,7 +2,7 @@
 
 import type { Context } from 'cordis'
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
-import type { InvariantInstaller } from '@deepseek-ai/dsh-invariants'
+import type { InvariantFailure, InvariantInstaller } from '@deepseek-ai/dsh-invariants'
 import { SANDBOX_MODES } from './session-mode.ts'
 
 const PACKAGE_NAME = '@deepseek-ai/dsh-sandbox-policy'
@@ -12,16 +12,26 @@ export const name = 'sandbox-policy-invariant'
 /** Service required before the companion can reserve package ownership. */
 export const inject = ['invariants']
 
-/** Install validation for the durable sandbox-mode vocabulary. */
-const install: InvariantInstaller = (ctx, fail) => {
+/* jscpd:ignore-start -- package companions share replay and dispatch plumbing */
+/** Validate the package-owned event shape and ignore unrelated events. */
+function validateEvent(event: SessionEvent, fail: InvariantFailure): void {
+  if (event.type === 'sandbox/mode' && !SANDBOX_MODES.includes(event.data.mode)) {
+    fail(`sandbox/mode carries unknown mode ${JSON.stringify(event.data.mode)}`)
+  }
+}
+
+/** Install validation for loaded and newly appended sandbox modes. */
+const install: InvariantInstaller = Object.assign((ctx: Context, fail: InvariantFailure) => {
+  for (const session of ctx.sessions.list()) {
+    for (const event of session.events) validateEvent(event, fail)
+  }
   ctx.on('internal/dispatch', (_mode, eventName, args) => {
     if (eventName !== 'session/event') return
     const event = (args as [Session, SessionEvent])[1]
-    if (event.type === 'sandbox/mode' && !SANDBOX_MODES.includes(event.data.mode)) {
-      fail(`sandbox/mode carries unknown mode ${JSON.stringify(event.data.mode)}`)
-    }
+    validateEvent(event, fail)
   }, { global: true })
-}
+}, { inject: ['sessions'] })
+/* jscpd:ignore-end */
 
 /**
  * Register this package's invariant companion.

packages/sandbox/sandbox-policy/tests/invariant.spec.ts

@@ -1,12 +1,13 @@
 import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
-import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
+import SessionStore, { type Session, type SessionEvent } from '@deepseek-ai/dsh-session'
 import InvariantService, { InvariantError } from '@deepseek-ai/dsh-invariants'
 import * as SandboxPolicyInvariant from '@deepseek-ai/dsh-sandbox-policy/invariant'
 
 async function setup(): Promise<Context> {
   const ctx = new Context()
-  await ctx.plugin(InvariantService)
+  await ctx.plugin(SessionStore)
+  await ctx.plugin(InvariantService, { enabled: true })
   await ctx.plugin(SandboxPolicyInvariant)
   return ctx
 }
@@ -37,4 +38,16 @@ describe('sandbox-policy invariants', () => {
     expect(() => { ctx.emit('session/event', {} as Session, modeEvent('host-root')) })
       .toThrow(new InvariantError('@deepseek-ai/dsh-sandbox-policy', 'sandbox/mode carries unknown mode "host-root"'))
   })
+
+  it('rejects an unknown mode already present on late registration', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SessionStore)
+    ctx.sessions.create().append('sandbox/mode', { mode: 'host-root' as never })
+    await ctx.plugin(InvariantService, { enabled: true })
+
+    await expect(ctx.plugin(SandboxPolicyInvariant).then(() => undefined)).rejects.toMatchObject({
+      code: 'INVARIANT',
+      packageName: '@deepseek-ai/dsh-sandbox-policy',
+    })
+  })
 })

packages/sandbox/sandbox-policy/tsdown.config.ts

@@ -0,0 +1,25 @@
+import { defineConfig } from 'tsdown'
+
+/** Build the package root and invariant companion as independent bundles. */
+export default defineConfig([
+  {
+    entry: ['lib/types/index.js'],
+    outDir: 'lib',
+    format: ['esm'],
+    platform: 'node',
+    target: 'es2024',
+    fixedExtension: false,
+    dts: false,
+    clean: false,
+  },
+  {
+    entry: ['lib/types/invariant.js'],
+    outDir: 'lib',
+    format: ['esm'],
+    platform: 'node',
+    target: 'es2024',
+    fixedExtension: false,
+    dts: false,
+    clean: false,
+  },
+])

packages/todo/tool-todo/src/invariant.ts

@@ -33,14 +33,24 @@ function validateTodos(value: unknown, fail: InvariantFailure): void {
   if (active > 1) fail(`todo/write contains ${active} in-progress entries; at most one is allowed`)
 }
 
-/** Install validation for durable whole-list todo snapshots. */
-const install: InvariantInstaller = (ctx, fail) => {
+/* jscpd:ignore-start -- package companions share replay and dispatch plumbing */
+/** Validate the package-owned event shape and ignore unrelated events. */
+function validateEvent(event: SessionEvent, fail: InvariantFailure): void {
+  if (event.type === 'todo/write') validateTodos(event.data.todos, fail)
+}
+
+/** Install validation for loaded and newly appended whole-list todo snapshots. */
+const install: InvariantInstaller = Object.assign((ctx: Context, fail: InvariantFailure) => {
+  for (const session of ctx.sessions.list()) {
+    for (const event of session.events) validateEvent(event, fail)
+  }
   ctx.on('internal/dispatch', (_mode, eventName, args) => {
     if (eventName !== 'session/event') return
     const event = (args as [Session, SessionEvent])[1]
-    if (event.type === 'todo/write') validateTodos(event.data.todos, fail)
+    validateEvent(event, fail)
   }, { global: true })
-}
+}, { inject: ['sessions'] })
+/* jscpd:ignore-end */
 
 /**
  * Register the todo invariant companion.

packages/todo/tool-todo/tests/invariant.spec.ts

@@ -1,12 +1,13 @@
 import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
-import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
+import SessionStore, { type Session, type SessionEvent } from '@deepseek-ai/dsh-session'
 import * as TodoInvariant from '@deepseek-ai/dsh-tool-todo/invariant'
 import InvariantService from '@deepseek-ai/dsh-invariants'
 
 async function setup(): Promise<Context> {
   const ctx = new Context()
-  await ctx.plugin(InvariantService)
+  await ctx.plugin(SessionStore)
+  await ctx.plugin(InvariantService, { enabled: true })
   await ctx.plugin(TodoInvariant)
   return ctx
 }
@@ -50,4 +51,18 @@ describe('todo snapshot invariants', () => {
       })
     }).not.toThrow()
   })
+
+  it('rejects an invalid existing snapshot on late registration', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SessionStore)
+    ctx.sessions.create().append('todo/write', {
+      todos: [
+        { content: 'duplicate', status: 'pending' },
+        { content: 'duplicate', status: 'completed' },
+      ],
+    })
+    await ctx.plugin(InvariantService, { enabled: true })
+
+    await expect(ctx.plugin(TodoInvariant).then(() => undefined)).rejects.toThrow(/repeats content "duplicate"/)
+  })
 })

packages/ui/permission/src/invariant.ts

@@ -2,7 +2,7 @@
 
 import type { Context } from 'cordis'
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
-import type { InvariantInstaller } from '@deepseek-ai/dsh-invariants'
+import type { InvariantFailure, InvariantInstaller } from '@deepseek-ai/dsh-invariants'
 
 const PACKAGE_NAME = '@deepseek-ai/dsh-permission'
 
@@ -11,16 +11,24 @@ export const name = 'permission-invariant'
 /** Service required before the companion can reserve package ownership. */
 export const inject = ['invariants']
 
-/** Install validation that durable preset events remain resolvable. */
-const install: InvariantInstaller = Object.assign((ctx: Context, fail: (message: string) => never) => {
+/** Validate the package-owned event shape and ignore unrelated events. */
+function validateEvent(ctx: Context, event: SessionEvent, fail: InvariantFailure): void {
+  if (event.type === 'permission/preset' && !ctx.permission.names.includes(event.data.preset)) {
+    fail(`permission/preset names unknown preset ${JSON.stringify(event.data.preset)}`)
+  }
+}
+
+/** Install validation that loaded and newly appended preset events remain resolvable. */
+const install: InvariantInstaller = Object.assign((ctx: Context, fail: InvariantFailure) => {
+  for (const session of ctx.sessions.list()) {
+    for (const event of session.events) validateEvent(ctx, event, fail)
+  }
   ctx.on('internal/dispatch', (_mode, eventName, args) => {
     if (eventName !== 'session/event') return
     const event = (args as [Session, SessionEvent])[1]
-    if (event.type === 'permission/preset' && !ctx.permission.names.includes(event.data.preset)) {
-      fail(`permission/preset names unknown preset ${JSON.stringify(event.data.preset)}`)
-    }
+    validateEvent(ctx, event, fail)
   }, { global: true })
-}, { inject: ['permission'] })
+}, { inject: ['permission', 'sessions'] })
 
 /**
  * Register the permission invariant companion.

packages/ui/permission/tests/invariant.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { Context, Service } from 'cordis'
-import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
+import SessionStore, { type Session, type SessionEvent } from '@deepseek-ai/dsh-session'
 import * as PermissionInvariant from '@deepseek-ai/dsh-permission/invariant'
 import InvariantService from '@deepseek-ai/dsh-invariants'
 
@@ -14,8 +14,9 @@ class PermissionProbe extends Service {
 
 async function setup(): Promise<Context> {
   const ctx = new Context()
+  await ctx.plugin(SessionStore)
   await ctx.plugin(PermissionProbe)
-  await ctx.plugin(InvariantService)
+  await ctx.plugin(InvariantService, { enabled: true })
   await ctx.plugin(PermissionInvariant)
   return ctx
 }
@@ -39,4 +40,14 @@ describe('permission invariants', () => {
     expect(() => { ctx.emit('session/event', {} as Session, presetEvent('missing')) })
       .toThrow(/unknown preset "missing"/)
   })
+
+  it('rejects an unknown preset already present on late registration', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SessionStore)
+    await ctx.plugin(PermissionProbe)
+    ctx.sessions.create().append('permission/preset', { preset: 'missing' })
+    await ctx.plugin(InvariantService, { enabled: true })
+
+    await expect(ctx.plugin(PermissionInvariant).then(() => undefined)).rejects.toThrow(/unknown preset "missing"/)
+  })
 })