dsh-context-compression-improved 0.2.1 → 0.3.1

package/scripts/{packed-components-smoke.ts → packed-components-smoke.mjs}

@@ -1,25 +1,23 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-// @ts-nocheck
-// and cordis augmented services that are not in the scripts tsconfig scope.
 import { realpath } from 'node:fs/promises'
 import { createRequire } from 'node:module'
 import { dirname, sep } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { Context } from '@deepseek-ai/cordis'
-import { agentEvents, Inbox } from '@deepseek-ai/dsh-agent'
+import { agentEvents } from '@deepseek-ai/dsh-agent'
 import AgentLoop from '@deepseek-ai/dsh-agent-loop'
 import { mountAgentLoopTestDependencies } from '@deepseek-ai/dsh-agent-loop-testkit'
 import BasicCompactionEngine from '@deepseek-ai/dsh-compaction-basic'
 import LlmRuntime, {
-  CallId,
+  ToolCallId as CallId,
   createMessage,
   createUserMessage,
   createToolResultMessage,
   LlmAdapter,
 } from '@deepseek-ai/dsh-llm'
-import SessionStore, { SessionId, canonicalHeader } from '@deepseek-ai/dsh-session'
-import { SettingsProvider, settingsNamespace } from '@deepseek-ai/dsh-settings'
+import SessionStore, { Session, SessionId, canonicalHeader } from '@deepseek-ai/dsh-session'
+import { SettingsProvider } from '@deepseek-ai/dsh-settings'
 import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
+import SessionProjectionRegistry from '@deepseek-ai/dsh-session-projection'
 import TokenMeter from '@deepseek-ai/dsh-token-meter'
 import ToolRuntime from '@deepseek-ai/dsh-tools'
 
@@ -31,9 +29,9 @@ const selectorPackage = consumerRequire.resolve('dsh-context-compression-improve
 const selectorRequire = createRequire(selectorPackage)
 const prunerEntry = selectorRequire.resolve('dsh-context-compression-improved/pruner')
 const SelectorHost = await import(pathToFileURL(consumerRequire.resolve('dsh-context-compression-improved')).href)
-const Runtime = await import(pathToFileURL(prunerEntry).href) as typeof import('../packages/selector/src/pruner')
+const Runtime = await import(pathToFileURL(prunerEntry).href)
 
-const assert = (condition: unknown, message: string): asserts condition => {
+const assert = (condition, message) => {
   if (!condition) throw new Error(`packed component smoke: ${message}`)
 }
 
@@ -45,29 +43,26 @@ for (const path of [selectorPackage, prunerEntry]) {
 
 class MemorySettings extends SettingsProvider {
   writable = true
-  stored: Record<string, unknown> = {}
+  stored = {}
 
   load() {
     return Promise.resolve(structuredClone(this.stored))
   }
 
-  persist(namespace: string, section: unknown) {
+  persist(namespace, section) {
     this.stored[namespace] = structuredClone(section)
     return Promise.resolve()
   }
 }
 
 class NativeSummaryAdapter extends LlmAdapter {
-  responses: string[]
-  contextWindow: number
-
-  constructor(responses: string[], contextWindow: number) {
+  constructor(responses, contextWindow) {
     super()
     this.responses = [...responses]
     this.contextWindow = contextWindow
   }
 
-  resolveModel(provider: string, model: string) {
+  resolveModel(provider, model) {
     return Promise.resolve({
       provider,
       id: model,
@@ -76,23 +71,23 @@ class NativeSummaryAdapter extends LlmAdapter {
     })
   }
 
-  async * stream(options: { signal?: AbortSignal }) {
+  async * stream(options) {
     options.signal?.throwIfAborted()
     const text = this.responses.shift()
     if (text === undefined) throw new Error('NativeSummaryAdapter response script exhausted')
-    yield { type: 'block-start', index: 0, blockType: 'text' } as const
-    yield { type: 'text-delta', index: 0, text } as const
-    yield { type: 'block-end', index: 0, block: { type: 'text', text } } as const
-    yield { type: 'usage', usage: { inputTokens: 10, outputTokens: text.length } } as const
-    yield { type: 'finish', reason: { kind: 'stop' } } as const
+    yield { type: 'block-start', index: 0, blockType: 'text' }
+    yield { type: 'text-delta', index: 0, text }
+    yield { type: 'block-end', index: 0, block: { type: 'text', text } }
+    yield { type: 'usage', usage: { inputTokens: 10, outputTokens: text.length } }
+    yield { type: 'finish', reason: { kind: 'stop' } }
   }
 }
 
-function captureAudit(ctx: Context) {
-  const records: Array<Record<string, unknown>> = []
+function captureAudit(ctx) {
+  const records = []
   Object.defineProperty(ctx.logger, 'info', {
     configurable: true,
-    value(message: unknown) {
+    value(message) {
       const line = String(message)
       if (line.startsWith(AUDIT_PREFIX)) records.push(JSON.parse(line.slice(AUDIT_PREFIX.length)))
       return ctx.logger
@@ -101,15 +96,7 @@ function captureAudit(ctx: Context) {
   return records
 }
 
-function appendToolTurn(
-  session: Record<string, unknown>,
-  turn: number,
-  text: string,
-  closeTurn: boolean,
-  userText?: string,
-  provider = 'deepseek',
-  model = MODEL,
-) {
+function appendToolTurn(session, turn, text, closeTurn, userText, provider = 'deepseek', model = MODEL) {
   const callId = CallId(`packed-call-${String(turn)}`)
   session.append('turn/start', { turn })
   if (session.requestHeader() === undefined) {
@@ -126,6 +113,7 @@ function appendToolTurn(
   }
   session.append('step/start', { turn, step: 1 })
   const assistant = session.append('assistant/message', {
+      stream: [],
     turn,
     step: 1,
     message: createMessage({
@@ -146,16 +134,10 @@ function appendToolTurn(
   }, { surfaceOp: 'append' })
   session.append('step/end', { turn, step: 1 })
   if (closeTurn) session.append('turn/end', { turn, reason: { kind: 'completed' } })
-  return { assistantSeq: (assistant as { seq: number }).seq, resultSeq: (result as { seq: number }).seq }
+  return { assistantSeq: assistant.seq, resultSeq: result.seq }
 }
 
-function appendToolBatchTurn(
-  session: Record<string, unknown>,
-  turn: number,
-  texts: string[],
-  closeTurn: boolean,
-  userText?: string,
-) {
+function appendToolBatchTurn(session, turn, texts, closeTurn, userText) {
   const calls = texts.map((_, index) => ({
     id: CallId(`packed-call-${String(turn)}-${String(index + 1)}`),
     name: 'bash',
@@ -175,6 +157,7 @@ function appendToolBatchTurn(
   }
   session.append('step/start', { turn, step: 1 })
   session.append('assistant/message', {
+      stream: [],
     turn,
     step: 1,
     message: createMessage({
@@ -203,12 +186,14 @@ function appendToolBatchTurn(
   if (closeTurn) session.append('turn/end', { turn, reason: { kind: 'completed' } })
 }
 
-function stubAgent(ctx: Context, session: Record<string, unknown>) {
+function stubAgent(ctx, session) {
   return {
-    id: (session as { id: string }).id,
+    id: session.id,
     options: {},
     session,
-    inbox: new Inbox(session as never, { inserted() {}, discarded() {}, claimed() {} }),
+    // 0.1.5 moved the durable Inbox behind the loop driver; the pruner only
+  // reads id/session, so an inert face is enough for the stub.
+  inbox: undefined,
     status: 'idle',
     ctx,
     send() {},
@@ -216,7 +201,7 @@ function stubAgent(ctx: Context, session: Record<string, unknown>) {
     steer: () => ({ outcome: Promise.resolve({ status: 'rejected' }) }),
     inject() {},
     cancel() {},
-    runMaintenance: (task: (signal: AbortSignal) => void) => task(new AbortController().signal),
+    runMaintenance: task => task(new AbortController().signal),
     whenIdle: () => Promise.resolve(),
   }
 }
@@ -225,11 +210,12 @@ const ctx = new Context()
 try {
   await ctx.plugin(MemorySettings).await()
   await ctx.plugin(SelectorHost).await()
-  await ctx.plugin(LlmRuntime)
-  await ctx.plugin(SessionStore)
-  await ctx.plugin(SystemPrompt)
-  await ctx.plugin(ToolRuntime)
-  await ctx.plugin(TokenMeter)
+  await ctx.plugin(LlmRuntime).await()
+  await ctx.plugin(SessionStore).await()
+  await ctx.plugin(SystemPrompt).await()
+  await ctx.plugin(ToolRuntime).await()
+  await ctx.plugin(SessionProjectionRegistry).await()
+  await ctx.plugin(TokenMeter).await()
   const audit = captureAudit(ctx)
 
   const policy = structuredClone(Runtime.DEFAULT_CUSTOM_COMPRESSION_POLICY)
@@ -238,6 +224,9 @@ try {
   policy.aggregate = { enabled: true, trigger: 1_000, target: 400 }
   policy.history = {
     enabled: true,
+    // Strict required-reclaim: the batch must pull tool tokens back under the
+    // trigger, so it sits above the large protected tail and placeholder
+    // residue while remaining below the session's tool-result total.
     trigger: 7_800,
     keepRecentToolCalls: 0,
     keepRecentTokens: 1,
@@ -245,7 +234,7 @@ try {
   }
   policy.prefixPolicy = 'pressure-break'
   policy.tailTrim = { enabled: true, trigger: 8 }
-  const namespace = settingsNamespace(Runtime.CONTEXT_COMPRESSION_SETTINGS_NAMESPACE)
+  const namespace = Runtime.CONTEXT_COMPRESSION_SETTINGS_NAMESPACE
   await ctx.settings.update(namespace, { profile: 'custom', custom: policy })
   await ctx.plugin(Runtime.default, {
     profile: 'native',
@@ -255,12 +244,12 @@ try {
     tailChars: 8,
   }).await()
 
-  const session = ctx.sessions.create(SessionId('packed-components-full-pipeline'))
-  appendToolTurn(session as never, 1, 'packed Fresh '.repeat(600), false, 'run packed Fresh')
+  const session = Session.create(SessionId('packed-components-full-pipeline'))
+  appendToolTurn(session, 1, 'packed Fresh '.repeat(600), false, 'run packed Fresh')
   ctx.toolResultPruner.pruneSession(session, { stage: 'fresh', freshTurn: 1, freshStep: 1 })
   session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
   appendToolBatchTurn(
-    session as never,
+    session,
     2,
     Array.from({ length: 30 }, (_, index) => `packed Aggregate ${String(index)} `.repeat(20)),
     false,
@@ -268,18 +257,14 @@ try {
   )
   ctx.toolResultPruner.pruneSession(session, { stage: 'fresh', freshTurn: 2, freshStep: 1 })
   session.append('turn/end', { turn: 2, reason: { kind: 'completed' } })
-  appendToolTurn(session as never, 3, 'packed History '.repeat(600), true, 'run packed History')
-  appendToolTurn(session as never, 4, 'packed recent protected working-set context '.repeat(1000), true, 'retain packed recent context')
+  appendToolTurn(session, 3, 'packed History '.repeat(600), true, 'run packed History')
+  appendToolTurn(session, 4, 'packed recent protected working-set context '.repeat(1000), true, 'retain packed recent context')
   session.append('turn/start', { turn: 5 })
   ctx.toolResultPruner.pruneSession(session, { stage: 'pressure' })
 
   const tail = audit.find(record => record.kind === 'rewrite' && record.component === 'tail-trim')
-  if (tail === undefined) {
-    console.error('TAILTRIM_DIAG', JSON.stringify(audit.filter(record =>
-      record.component === 'tail-trim' || record.kind === 'rewrite'), null, 2))
-  }
   assert(tail !== undefined, 'TailTrim did not commit from installed Runtime')
-  const ref = `session://${String((session as { id: string }).id)}/tailtrim/${String(tail.manifestSeq)}`
+  const ref = `session://${String(session.id)}/tailtrim/${String(tail.manifestSeq)}`
   const recovered = await ctx.tools.execute({
     name: 'context_compression_retrieve',
     arguments: { ref, max_lines: 20 },
@@ -289,12 +274,12 @@ try {
   })
   assert(recovered.isError === false, 'installed TailTrim recovery returned an error')
   const recoveredText = recovered.content
-    .map((block: { type: string; text?: string }) => block.type === 'text' ? block.text : '')
+    .map(block => block.type === 'text' ? block.text : '')
     .join('\n')
   assert(recoveredText.includes('kind: tailtrim-group'),
     'installed TailTrim recovery did not return a TailTrim group')
-  const tailSourcePayloads = (tail.sourceSeqs as number[])
-    .map(seq => (session as { events: Record<number, unknown> }).events[seq])
+  const tailSourcePayloads = tail.sourceSeqs
+    .map(seq => session.snapshotEvents()[seq])
     .filter(event => event !== undefined)
     .map(event => JSON.stringify(event))
   const recoveredMarker = [
@@ -322,9 +307,9 @@ try {
   capacityPolicy.tailTrim.enabled = false
   await ctx.settings.update(namespace, { profile: 'custom', custom: capacityPolicy })
 
-  const inactiveCapacity = ctx.sessions.create(SessionId('packed-history-capacity-inactive'))
-  appendToolTurn(inactiveCapacity as never, 1, 'packed capacity inactive '.repeat(600), true)
-  appendToolTurn(inactiveCapacity as never, 2, 'packed newest protected result', true)
+  const inactiveCapacity = Session.create(SessionId('packed-history-capacity-inactive'))
+  appendToolTurn(inactiveCapacity, 1, 'packed capacity inactive '.repeat(600), true)
+  appendToolTurn(inactiveCapacity, 2, 'packed newest protected result', true)
   inactiveCapacity.append('request/context', {
     provider: 'deepseek',
     model: MODEL,
@@ -333,16 +318,16 @@ try {
   inactiveCapacity.append('turn/start', { turn: 3 })
   ctx.toolResultPruner.pruneSession(inactiveCapacity, { stage: 'pressure' })
   const inactiveCapacityAudit = audit.find(record => record.kind === 'component-evaluation'
-    && record.sessionId === String((inactiveCapacity as { id: string }).id)
+    && record.sessionId === String(inactiveCapacity.id)
     && record.component === 'history')
   assert(inactiveCapacityAudit?.status === 'skipped'
     && inactiveCapacityAudit.reason === 'below-micro-deadline'
     && inactiveCapacityAudit.historyMode === 'capacity-pressure',
   'installed History did not prove the inactive capacity-pressure gate')
 
-  const activeCapacity = ctx.sessions.create(SessionId('packed-history-capacity-active'))
-  appendToolTurn(activeCapacity as never, 1, 'packed capacity active '.repeat(600), true)
-  appendToolTurn(activeCapacity as never, 2, 'packed newest protected result', true)
+  const activeCapacity = Session.create(SessionId('packed-history-capacity-active'))
+  appendToolTurn(activeCapacity, 1, 'packed capacity active '.repeat(600), true)
+  appendToolTurn(activeCapacity, 2, 'packed newest protected result', true)
   const activeCapacityWindow = Math.floor(ctx.tokenMeter.measure(activeCapacity).totalTokens / 0.75)
   activeCapacity.append('request/context', {
     provider: 'deepseek',
@@ -352,21 +337,21 @@ try {
   activeCapacity.append('turn/start', { turn: 3 })
   ctx.toolResultPruner.pruneSession(activeCapacity, { stage: 'pressure' })
   const capacityRewrite = audit.find(record => record.kind === 'rewrite'
-    && record.sessionId === String((activeCapacity as { id: string }).id)
+    && record.sessionId === String(activeCapacity.id)
     && record.component === 'history')
   assert(capacityRewrite?.historyMode === 'capacity-pressure'
     && capacityRewrite.stage === 'pressure'
     && typeof capacityRewrite.reducer === 'string'
     && Number.isSafeInteger(capacityRewrite.tokensBefore)
     && Number.isSafeInteger(capacityRewrite.tokensAfter)
-    && (capacityRewrite.tokensBefore as number) > (capacityRewrite.tokensAfter as number),
+    && capacityRewrite.tokensBefore > capacityRewrite.tokensAfter,
   'installed History did not commit exact capacity-pressure evidence')
 
   const boundaryCtx = new Context()
   try {
     await mountAgentLoopTestDependencies(boundaryCtx)
-    await boundaryCtx.plugin(AgentLoop, { agents: [] })
-    await boundaryCtx.plugin(TokenMeter)
+    await boundaryCtx.plugin(AgentLoop, { agents: [] }).await()
+    await boundaryCtx.plugin(TokenMeter).await()
     const boundaryAudit = captureAudit(boundaryCtx)
     boundaryCtx.llm.registerAdapter(
       ['deepseek'],
@@ -383,17 +368,19 @@ try {
       historyKeepRecentTokens: 1,
       historyMinReclaimTokens: 1,
     }).await()
-    const boundaryAgent = boundaryCtx.agentLoop.create(
+    const boundaryAgent = await boundaryCtx.agentLoop.create(
       SessionId('packed-history-capacity-request-boundary'),
       { provider: 'deepseek', model: MODEL },
     )
     const boundarySession = boundaryAgent.session
-    appendToolTurn(boundarySession as never, 1, 'packed old capacity-pressure evidence '.repeat(600), true)
-    appendToolTurn(boundarySession as never, 2, 'packed newest protected result', true)
+    appendToolTurn(boundarySession, 1, 'packed old capacity-pressure evidence '.repeat(600), true)
+    appendToolTurn(boundarySession, 2, 'packed newest protected result', true)
     const boundaryTotal = boundaryCtx.tokenMeter.measure(boundarySession).totalTokens
     boundarySession.append('request/context', {
       provider: 'deepseek',
       model: MODEL,
+      // Just under the frozen 80% deadline D = 0.7 * window so the gate is
+      // active while the strict reclaim target stays reachable.
       contextWindow: Math.floor(boundaryTotal / 0.72),
     })
     boundaryAgent.followup(createUserMessage({
@@ -402,21 +389,24 @@ try {
     }))
     await boundaryAgent.whenIdle()
     const boundaryRewrite = boundaryAudit.find(record => record.kind === 'rewrite'
-      && record.sessionId === String((boundarySession as { id: string }).id)
+      && record.sessionId === String(boundarySession.id)
       && record.component === 'history')
     assert(boundaryRewrite?.stage === 'pressure'
       && boundaryRewrite.historyMode === 'capacity-pressure'
-      && (boundaryRewrite.tokensBefore as number) > (boundaryRewrite.tokensAfter as number),
+      && boundaryRewrite.tokensBefore > boundaryRewrite.tokensAfter,
     'installed Cache Strict did not schedule History from the real request boundary')
   } finally {
     await boundaryCtx.fiber.dispose()
   }
 
-  // Packed vision-session gate
+  // Packed vision-session gate: the installed runtime must actually resolve
+  // the deepseek-v4-flash-vision-exp route, count text exactly with the
+  // separately bundled vision tokenizer, estimate image surfaces, and keep
+  // image-bearing results outside exact rewrite proofs.
   const VISION_MODEL = 'deepseek-v4-flash-vision-exp'
   const VISION_TOKENIZER_REPOSITORY = 'deepseek-ai/DeepSeek-V4-Flash-Vision-Exp'
   const VISION_TOKENIZER_REVISION = '6821d6ad3681a4b137b066b76094fa82ebd0a380'
-  const imageBlock = (width: number, height: number) => ({
+  const imageBlock = (width, height) => ({
     type: 'image',
     attachment: {
       attachmentId: `packed-image-${String(width)}x${String(height)}`,
@@ -430,11 +420,12 @@ try {
   try {
     await visionCtx.plugin(MemorySettings).await()
     await visionCtx.plugin(SelectorHost).await()
-    await visionCtx.plugin(LlmRuntime)
-    await visionCtx.plugin(SessionStore)
-    await visionCtx.plugin(SystemPrompt)
-    await visionCtx.plugin(ToolRuntime)
-    await visionCtx.plugin(TokenMeter)
+    await visionCtx.plugin(LlmRuntime).await()
+    await visionCtx.plugin(SessionStore).await()
+    await visionCtx.plugin(SystemPrompt).await()
+    await visionCtx.plugin(ToolRuntime).await()
+    await visionCtx.plugin(SessionProjectionRegistry).await()
+    await visionCtx.plugin(TokenMeter).await()
     const visionAudit = captureAudit(visionCtx)
     await visionCtx.plugin(Runtime.default, {
       profile: 'balanced',
@@ -448,8 +439,9 @@ try {
       historyMinReclaimTokens: 1,
     }).await()
 
-    // (a) A user image plus pure-text tool results
-    const visionText = visionCtx.sessions.create(SessionId('packed-vision-text-session'))
+    // (a) A user image plus pure-text tool results: the text rewrites must be
+    // exact and carry the vision tokenizer's repository/revision.
+    const visionText = Session.create(SessionId('packed-vision-text-session'))
     visionText.append('turn/start', { turn: 1 })
     visionText.append('request/header', {
       reason: 'initial',
@@ -484,15 +476,15 @@ try {
     }, { surfaceOp: 'append' })
     visionText.append('step/end', { turn: 1, step: 1 })
     visionText.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
-    appendToolTurn(visionText as never, 2, 'packed vision history evidence '.repeat(300), true, undefined, 'deepseek', VISION_MODEL)
-    appendToolTurn(visionText as never, 3, 'packed recent protected result', true, undefined, 'deepseek', VISION_MODEL)
+    appendToolTurn(visionText, 2, 'packed vision history evidence '.repeat(300), true, undefined, 'deepseek', VISION_MODEL)
+    appendToolTurn(visionText, 3, 'packed recent protected result', true, undefined, 'deepseek', VISION_MODEL)
     visionText.append('turn/start', { turn: 4 })
     const visionFresh = visionCtx.toolResultPruner.pruneSession(visionText, { stage: 'fresh', freshTurn: 1, freshStep: 1 })
     const visionPressure = visionCtx.toolResultPruner.pruneSession(visionText, { stage: 'pressure' })
     assert(visionFresh.pruned.length === 1 && visionPressure.pruned.length >= 1,
       'packed vision text session did not rewrite pure-text results')
     const visionRewrites = visionAudit
-      .filter(record => record.kind === 'rewrite' && record.sessionId === String((visionText as { id: string }).id))
+      .filter(record => record.kind === 'rewrite' && record.sessionId === String(visionText.id))
     assert(visionRewrites.length >= 2, 'packed vision text session lacks aggregate and history rewrites')
     for (const record of visionRewrites) {
       assert(record.tokenizerId === VISION_TOKENIZER_REPOSITORY
@@ -503,8 +495,10 @@ try {
       && visionRewrites.some(record => record.component === 'history'),
     'packed vision text session lacks an aggregate/history component rewrite')
 
-    // (b) An image-bearing tool result
-    const visionImage = visionCtx.sessions.create(SessionId('packed-vision-image-tool-result'))
+    // (b) An image-bearing tool result: its surface may be estimated, but every
+    // rewrite path still requires exact counts. The original event is untouched
+    // and the audits say why no rewrite was authorized.
+    const visionImage = Session.create(SessionId('packed-vision-image-tool-result'))
     visionImage.append('turn/start', { turn: 1 })
     visionImage.append('request/header', {
       reason: 'initial',
@@ -546,7 +540,7 @@ try {
       'packed vision image-bearing result was rewritten lossily')
     const imageMeasurement = Runtime.measureForCompaction(visionCtx, visionImage)
     const estimatedImageCount = imageMeasurement.measuredNodes
-      .find((node: { seq: number }) => node.seq === (estimatedUserImage as { seq: number }).seq)?.count
+      .find(node => node.seq === estimatedUserImage.seq)?.count
     assert(estimatedImageCount?.kind === 'tokenizer-estimate',
       `packed vision image surface is ${String(estimatedImageCount?.kind)}, expected tokenizer-estimate`)
     assert(estimatedImageCount.tokens === 340,
@@ -559,14 +553,17 @@ try {
       `packed vision image estimator revision is ${String(estimatedImageCount.estimatorRevision)}`)
     assert(imageMeasurement.currentSurface.kind === 'tokenizer-estimate',
       `packed vision current surface is ${imageMeasurement.currentSurface.kind}, expected tokenizer-estimate`)
-    const originalImage = (visionImage as { events: Record<number, unknown> }).events[(imageResult as { seq: number }).seq]
-    assert((originalImage as { type: string })?.type === 'tool/result'
+    // Tool-result events carry one envelope block whose nested content holds
+    // the original [text, image] blocks; the durable attachment reference must
+    // still be there verbatim.
+    const originalImage = visionImage.snapshotEvents()[imageResult.seq]
+    assert(originalImage?.type === 'tool/result'
       && JSON.stringify(originalImage).includes('packed-image-800x600')
       && JSON.stringify(originalImage).includes('"type":"image"'),
     'packed vision image-bearing result is no longer intact on the surface')
     for (const component of ['fresh', 'history']) {
       assert(visionAudit.some(record => record.kind === 'component-evaluation'
-        && record.sessionId === String((visionImage as { id: string }).id)
+        && record.sessionId === String(visionImage.id)
         && record.component === component
         && record.status === 'skipped'
         && record.reason === 'exact-tokenizer-unavailable'),
@@ -604,12 +601,12 @@ try {
     () => Promise.resolve({ kind: 'enter', messages: [] }),
   )
   assert(decision.kind === 'enter', 'Native pre-step did not return enter')
-  assert(session.events.some((event: { type: string }) => event.type === 'compaction/summary'),
+  assert(session.snapshotEvents().some(event => event.type === 'compaction/summary'),
     'official BasicCompactionEngine did not commit Native summary')
 
   await ctx.settings.update(namespace, { profile: 'native' })
-  const nativeSession = ctx.sessions.create(SessionId('packed-native-tool-result'))
-  appendToolTurn(nativeSession as never, 1, 'packed native tool result '.repeat(800), false)
+  const nativeSession = Session.create(SessionId('packed-native-tool-result'))
+  appendToolTurn(nativeSession, 1, 'packed native tool result '.repeat(800), false)
   const nativeResult = ctx.toolResultPruner.pruneSession(nativeSession, { stage: 'pressure' })
   assert(nativeResult.pruned.length === 1, 'installed Native tool-result profile did not rewrite')
 
@@ -619,8 +616,8 @@ try {
   firstFrozen.history.enabled = false
   firstFrozen.tailTrim.enabled = false
   await ctx.settings.update(namespace, { profile: 'custom', custom: firstFrozen })
-  const frozenA = ctx.sessions.create(SessionId('packed-policy-freeze-a'))
-  appendToolTurn(frozenA as never, 1, 'packed frozen first '.repeat(800), false)
+  const frozenA = Session.create(SessionId('packed-policy-freeze-a'))
+  appendToolTurn(frozenA, 1, 'packed frozen first '.repeat(800), false)
   assert(ctx.toolResultPruner.pruneSession(frozenA, {
     stage: 'fresh', freshTurn: 1, freshStep: 1,
   }).pruned.length === 1, 'first frozen policy did not run Fresh')
@@ -629,23 +626,23 @@ try {
   edited.history.trigger += 123
   await ctx.settings.update(namespace, { custom: edited })
   frozenA.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
-  appendToolTurn(frozenA as never, 2, 'packed frozen second '.repeat(800), false)
+  appendToolTurn(frozenA, 2, 'packed frozen second '.repeat(800), false)
   assert(ctx.toolResultPruner.pruneSession(frozenA, {
     stage: 'fresh', freshTurn: 2, freshStep: 1,
   }).pruned.length === 1, 'observed Session did not retain its complete frozen policy')
-  const frozenB = ctx.sessions.create(SessionId('packed-policy-freeze-b'))
-  appendToolTurn(frozenB as never, 1, 'packed new disabled Fresh '.repeat(800), false)
+  const frozenB = Session.create(SessionId('packed-policy-freeze-b'))
+  appendToolTurn(frozenB, 1, 'packed new disabled Fresh '.repeat(800), false)
   assert(ctx.toolResultPruner.pruneSession(frozenB, {
     stage: 'fresh', freshTurn: 1, freshStep: 1,
   }).pruned.length === 0, 'new Session did not adopt the edited complete policy')
 
   const rewrites = audit.filter(record => record.kind === 'rewrite')
-  const firstIndex = (component: string) => audit.findIndex(record => record.kind === 'rewrite'
-    && record.sessionId === String((session as { id: string }).id) && record.component === component)
+  const firstIndex = component => audit.findIndex(record => record.kind === 'rewrite'
+    && record.sessionId === String(session.id) && record.component === component)
   for (const component of ['fresh', 'aggregate', 'history', 'tail-trim']) {
     assert(firstIndex(component) >= 0, `installed pipeline lacks ${component} rewrite`)
   }
-  const routineHistory = rewrites.find(record => record.sessionId === String((session as { id: string }).id)
+  const routineHistory = rewrites.find(record => record.sessionId === String(session.id)
     && record.component === 'history')
   assert(routineHistory?.historyMode === 'routine',
     'installed full pipeline did not identify routine History')
@@ -653,23 +650,23 @@ try {
     && firstIndex('aggregate') < firstIndex('history')
     && firstIndex('history') < firstIndex('tail-trim'),
   'installed component rewrite order is wrong')
-  const pipelineRewrites = rewrites.filter(record => record.sessionId === String((session as { id: string }).id))
+  const pipelineRewrites = rewrites.filter(record => record.sessionId === String(session.id))
   assert(pipelineRewrites.every(record => Number.isSafeInteger(record.tokensBefore)
-    && Number.isSafeInteger(record.tokensAfter) && (record.tokensBefore as number) > (record.tokensAfter as number)),
+    && Number.isSafeInteger(record.tokensAfter) && record.tokensBefore > record.tokensAfter),
   'installed rewrite lacks exact decreasing token evidence')
   assert(audit.some(record => record.kind === 'native-auto-compact'
-    && record.sessionId === String((session as { id: string }).id)),
+    && record.sessionId === String(session.id)),
   'installed Runtime did not audit official Native summary')
   assert(rewrites.some(record => record.component === 'native-tool-result'
-    && record.sessionId === String((nativeSession as { id: string }).id)),
+    && record.sessionId === String(nativeSession.id)),
   'installed Runtime lacks Native tool-result audit')
   const frozenAuditA = audit.find(record => record.kind === 'policy-frozen'
-    && record.sessionId === String((frozenA as { id: string }).id))
+    && record.sessionId === String(frozenA.id))
   const frozenAuditB = audit.find(record => record.kind === 'policy-frozen'
-    && record.sessionId === String((frozenB as { id: string }).id))
-  assert((frozenAuditA?.settings as Record<string, Record<string, Record<string, unknown>>>)?.custom?.fresh?.enabled === true,
+    && record.sessionId === String(frozenB.id))
+  assert(frozenAuditA?.settings?.custom?.fresh?.enabled === true,
     'first installed policy-frozen record lacks original complete settings')
-  assert((frozenAuditB?.settings as Record<string, Record<string, Record<string, unknown>>>)?.custom?.fresh?.enabled === false,
+  assert(frozenAuditB?.settings?.custom?.fresh?.enabled === false,
     'new installed policy-frozen record lacks edited complete settings')
 
   console.info(`PACKED_COMPONENTS_E2E ${JSON.stringify({
@@ -706,7 +703,7 @@ try {
         tokensAfter: record.tokensAfter,
       }
     }),
-    customEvents: (session.events as Array<{ type: string }>).some(event => event.type === 'compaction/group-trim') ? 'present' : 'absent',
+    customEvents: session.snapshotEvents().some(event => event.type === 'compaction/group-trim') ? 'present' : 'absent',
   })}`)
 } finally {
   await ctx.fiber.dispose()