@deepseek-ai/dsh-llm-replay 0.1.3-alpha.2 → 0.1.5-alpha.2

package/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/test-support/llm-replay/README.md
-README.md: e8a257c2ee9f95f1e7d20197e6db67b2b4c7b45c
-README.zh.md: 5d085959982bcaa090a893089c0295426141bed2
+README.md: 5877db20babb07523e870d6f3041e1c35f076130
+README.zh.md: 17a0815591051ea9dc6a4d1aa847d970bbb87c16

package/README.md

@@ -9,7 +9,7 @@ English | [中文](README.zh.md)
 
 ## Summary
 
-`dsh-llm-replay` makes snapshot tests run without an API key: it installs a replay LLM adapter that serves model streams reconstructed from a recorded session JSONL fixture, so a test boots the real agent against a fixed transcript. The fixture is a projection of the persisted session log — each `assistant/message` or `assistant/attempt` embeds one model-call stream, and an explicitly marked local compaction call replays as one canonical stream. A `replay.override.json` sidecar covers what a settlement cannot reconstruct: a throw before any chunk, a cancel/hang, or an injected retry. Live sessions bind to recorded scripts by first-call order, so parent-and-subagent scenarios each get their own script. It is the model source behind the ACP and headless snapshot suites and the Web browser e2e lane.
+`dsh-llm-replay` lets snapshot tests run the real agent without an API key by replaying model streams from recorded Session JSONL fixtures. Each parent and subagent session receives its recorded script in first-call order, while calls within a session advance independently. A `replay.override.json` sidecar represents pre-chunk failures, cancellation, hangs, and injected retries that durable settlements cannot reconstruct. Use it for deterministic ACP, headless, and Web browser scenarios that need real loop behavior with fixed model output.
 
 ## Table of Contents
 
@@ -58,14 +58,14 @@ With `providers` configured, the plugin registers a replay-only adapter whose ca
 | `file` | `$DSH_SNAPSHOT_FILE` | Path to the selected primary fixture: `session.jsonl` for v0 or `session.vN.jsonl` for a positive generation; required (config or env) |
 | `overrideFile` | `$DSH_SNAPSHOT_OVERRIDE` | Optional `ReplayOverrideDoc` sidecar for the primary session |
 | `childFiles` | `$DSH_SNAPSHOT_CHILD_FILES` | Recorded subagent child-session logs for a nested scenario |
-| `providers` | — | Optional replay-only provider and model catalog; a model may declare `contextWindow`, text/image modalities, and positive `imageRequestTokens` when image-capable; invalid values fail at load and routes never perform provider I/O |
+| `providers` | — | Optional replay-only provider and model catalog; a model may declare `contextWindow`, text/image modalities, positive `imageRequestTokens` when image-capable, and `systemPromptUpdate: in-history` so a keyless scenario exercises in-history system prompt replacement; invalid values fail at load (`llm-replay: provider "…" model "…" systemPromptUpdate must be "in-history" when present`) and routes never perform provider I/O |
 | `paceMs` | — (burst) | Optional per-chunk delay in ms for genuinely incremental delivery |
 
 The generated [configuration catalog](../../../docs/config-catalog.md#deepseek-aidsh-llm-replay) is the exhaustive source for every accepted field and its JSDoc.
 
 ### How the fixture works
 
-The fixture is a projection of one selected persisted Session generation produced by running the real agent once — this plugin does not record. The snapshot harness supplies the numerically highest canonical parent path (`<scenario>/session.jsonl` for v0 or `<scenario>/session.vN.jsonl` for a positive generation), and validates filename/header agreement before replay. The fixture keeps the header and every event payload but omits body `seq`/`time` envelopes (`seq0`/`time0` for historical packed rows). Replay supplies contiguous sequences and deterministic timestamps, restores typed values replaced by snapshot tokens, rejects partial or mixed envelopes, decodes the complete physical artifact through the build-static Session format catalog, and migrates historical input in memory before it exposes events or the inherited cut; current input takes direct restoration. For a projected v0 header only, an absent `delegationDepth` denotes `0`. The parser never rewrites or renames the fixture. Runtime persistence continues to write complete logs. Replay expands the compact stream on each current-view `assistant/message` or `assistant/attempt`, so a recorded fixture replays the same logical stream the live model produced. A fixture may carry its `request/header` content tokenized to `{{system}}`/`{{tools}}`; replay materializes validation-only values, while derivation reads only Assistant settlements, marked summary events, and Session metadata. Every replay and comparison fixture must pass the same content-only catalog validation; replay never repairs a refused artifact.
+The fixture is a projection of one selected persisted Session generation produced by running the real agent once — this plugin does not record. The snapshot harness supplies the numerically highest canonical parent path (`<scenario>/session.jsonl` for v0 or `<scenario>/session.vN.jsonl` for a positive generation), and validates filename/header agreement before replay. The fixture keeps the header and every event payload but omits body `seq`/`time` envelopes (`seq0`/`time0` for historical packed rows). Replay supplies contiguous sequences and deterministic timestamps, restores typed values replaced by snapshot tokens, rejects partial or mixed envelopes, decodes the complete physical artifact through the build-static Session format catalog, and migrates historical input in memory before it exposes events or the inherited cut; current input takes direct restoration. For a projected v0 header only, an absent `delegationDepth` denotes `0`. The parser never rewrites or renames the fixture. Runtime persistence continues to write complete logs. Replay expands the compact stream on each current-view `assistant/message` or `assistant/attempt`, so a recorded fixture replays the same logical stream the live model produced. A fixture may carry its `request/header` content tokenized to `{{system}}`/`{{tools}}`; replay materializes validation-only values, while derivation reads only Assistant settlements, marked summary events, and Session metadata. Every replay and comparison fixture must pass the same content-only catalog validation; replay never repairs a refused artifact. Comparison encoding preserves accepted catalog output, including extension request-header fields; current `header.system` is rejected. Wire-notification expected outputs compare directly with current-writer output, retaining event order, inserted system messages, wrapper fields, and opaque delivery and captured-generation values; only complete Session artifacts use the format migration catalog.
 
 ### Nested agents
 
@@ -97,14 +97,14 @@ This section explains the design of the replay plugin; the observable behavior i
 
 Replay treats the selected projected Session generation as the fixture. One parser completes projected envelopes, validates and migrates the whole artifact through `sessionFormatCatalog`, and returns the current header, inherited cut, and event list as one result. `deriveReplayScript` expands each `assistant/message` or `assistant/attempt` stream in log order, so each durable settlement becomes one `chunks` entry; a non-empty stream without a `finish` chunk is the fingerprint of a thrown `stream()` and must be expressed through an override sidecar. A `compaction/summary` carrying `llmStreamCall: true` and a complete `rawOutput` replays as one canonical successful stream at that event's position. Scripted strings may embed `{{fromRequest:<regex>}}`; at stream time each placeholder resolves against the live request's string leaves, taking the pattern's last match and its first capture group (or the whole match) in place.
 
-The committed-corpus test discovers every versioned `session*.jsonl` under `snapshots/`, `packages/`, and `scripts/snapshots/python-sdk-single-exe/`. Every artifact must restore to the current view through the real catalog. Any refusal fails with the artifact path, so the fixture owner must correct the invalid relationship before replay or comparison.
+The [committed-corpus test](tests/session-format-corpus.spec.ts) restores each versioned `session*.jsonl` under `snapshots/`, `packages/`, and `scripts/snapshots/python-sdk-single-exe/` through the real catalog without changing source bytes. Its [inventory](tests/session-format-corpus-inventory.ts) pins deliberate historical refusals by path, source generation, error type, and exact reason; a refusal that disappears or changes fails. Current-generation artifacts cannot receive an exception. Headerless snapshot-harness protocol examples have a separate explicit exemption. All other restoration errors fail with the artifact path; historical files remain unchanged, and native current fixtures require owner correction.
 
 ### Source map
 
 | File | Role |
 |---|---|
 | [`src/index.ts`](src/index.ts) | Types, fixture derivation, override validation, placeholder resolution, session binding, `installLlmReplay`, and the plugin export |
-| [`tests/session-format-corpus.spec.ts`](tests/session-format-corpus.spec.ts) | Complete committed-generation restoration burn-in; every refusal is a failure |
+| [`tests/session-format-corpus.spec.ts`](tests/session-format-corpus.spec.ts) | Committed-generation restoration and exact historical refusal checks |
 | — | No runtime invariant companion is published; this test-only adapter consumes a fixed replay script; its stream grammar is checked by the LLM companion and fixture derivation tests. |
 
 ### Binding and stream flow

package/README.zh.md

@@ -9,7 +9,7 @@ kind: "package-reference"
 
 ## 概述
 
-`dsh-llm-replay` 让快照测试无需 API 密钥即可运行：它安装一个回放 LLM（大语言模型）适配器，从已记录的会话 JSONL fixture（测试前置数据）重建模型流，使测试针对固定 transcript（文本记录）启动真实 agent（智能体）。fixture 是持久化会话日志的投影——每个 `assistant/message` 或 `assistant/attempt` 都嵌入一次模型调用的 stream，显式标记的本地压缩（compaction）调用则回放为一条规范流。`replay.override.json` 伴随文件覆盖 settlement 无法重建的情况：任何分片之前就抛出、取消/挂起，或注入重试。实时会话按首次调用顺序绑定到已记录脚本，因此父会话与 subagent 场景各自获得自己的脚本。它是 ACP 与 headless 快照套件以及 Web 浏览器 e2e 流水线的模型来源。
+`dsh-llm-replay` 从已记录的 Session JSONL fixture（测试前置数据）回放模型流，让快照测试无需 API 密钥即可运行真实 agent（智能体）。每个 parent 与 subagent 会话按首次调用顺序取得各自的已记录脚本，而同一会话内的调用会独立推进。`replay.override.json` 伴随文件表示持久 settlement 无法重建的分片前失败、取消、挂起与注入重试。需要以固定模型输出确定性测试真实 loop 行为时，可在 ACP、headless 与 Web 浏览器场景中使用本包。
 
 ## 目录
 
@@ -58,14 +58,14 @@ kind: "package-reference"
 | `file` | `$DSH_SNAPSHOT_FILE` | 选定 primary fixture 路径：v0 为 `session.jsonl`，正 generation 为 `session.vN.jsonl`；必需（config 或 env） |
 | `overrideFile` | `$DSH_SNAPSHOT_OVERRIDE` | 主会话的可选 `ReplayOverrideDoc` 伴随文件 |
 | `childFiles` | `$DSH_SNAPSHOT_CHILD_FILES` | 嵌套场景中已记录的 subagent 子会话日志 |
-| `providers` | 无 | 可选的仅回放提供方与模型目录；模型可声明 `contextWindow`、文本／图片模态，以及图片模型使用的正整数 `imageRequestTokens`；非法值会在加载时失败，路由绝不执行提供方 I/O |
+| `providers` | 无 | 可选的仅回放提供方与模型目录；模型可声明 `contextWindow`、文本／图片模态、图片模型使用的正整数 `imageRequestTokens`，以及让无密钥场景演练历史内系统提示词替换的 `systemPromptUpdate: in-history`；非法值会在加载时失败（`llm-replay: provider "…" model "…" systemPromptUpdate must be "in-history" when present`），路由绝不执行提供方 I/O |
 | `paceMs` | 无（突发） | 可选的每分片延迟（毫秒），用于真正的增量投递 |
 
 生成的[配置目录](../../../docs/config-catalog.zh.md#deepseek-aidsh-llm-replay)是每个受支持字段及其 JSDoc 的穷尽式真源。
 
 ### fixture 的工作方式
 
-fixture 是运行一次真实 agent 所产生的一份选定持久化 Session generation 投影，本插件不录制。snapshot harness 会提供数值最高的规范 parent 路径（v0 为 `<scenario>/session.jsonl`，正 generation 为 `<scenario>/session.vN.jsonl`），并在 replay 前校验文件名与 header 一致。fixture 保留 header 与每个事件 payload，但省略正文的 `seq`/`time` envelope（历史 packed row 使用 `seq0`/`time0`）。replay 补充连续序号与确定性 timestamp，恢复被 snapshot token 替换的类型化值，拒绝不完整或混合 envelope，通过构建期静态 Session 格式 catalog 解码完整物理产物，并在公开事件或继承 cut 前于内存中迁移历史输入；当前输入直接 restore。仅对投影 v0 header，缺失的 `delegationDepth` 表示 `0`。parser 从不重写或重命名 fixture。runtime persistence 继续写入完整日志。replay 会展开当前视图中每个 `assistant/message` 或 `assistant/attempt` 的紧凑 stream，因此已记录 fixture 会 replay 与在线模型产生的相同逻辑流。fixture 的 `request/header` 内容可能 token 化为 `{{system}}`/`{{tools}}`；replay 会物化仅用于校验的值，而派生只读取 Assistant settlement、带标记的 summary 事件与 Session metadata。每个 replay 与 comparison fixture 都必须通过同一个只基于内容的 catalog 校验；replay 绝不修复被拒绝的产物。
+fixture 是运行一次真实 agent 所产生的一份选定持久化 Session generation 投影，本插件不录制。snapshot harness 会提供数值最高的规范 parent 路径（v0 为 `<scenario>/session.jsonl`，正 generation 为 `<scenario>/session.vN.jsonl`），并在 replay 前校验文件名与 header 一致。fixture 保留 header 与每个事件 payload，但省略正文的 `seq`/`time` envelope（历史 packed row 使用 `seq0`/`time0`）。replay 补充连续序号与确定性 timestamp，恢复被 snapshot token 替换的类型化值，拒绝不完整或混合 envelope，通过构建期静态 Session 格式 catalog 解码完整物理产物，并在公开事件或继承 cut 前于内存中迁移历史输入；当前输入直接 restore。仅对投影 v0 header，缺失的 `delegationDepth` 表示 `0`。parser 从不重写或重命名 fixture。runtime persistence 继续写入完整日志。replay 会展开当前视图中每个 `assistant/message` 或 `assistant/attempt` 的紧凑 stream，因此已记录 fixture 会 replay 与在线模型产生的相同逻辑流。fixture 的 `request/header` 内容可能 token 化为 `{{system}}`/`{{tools}}`；replay 会物化仅用于校验的值，而派生只读取 Assistant settlement、带标记的 summary 事件与 Session metadata。每个 replay 与 comparison fixture 都必须通过同一个只基于内容的 catalog 校验；replay 绝不修复被拒绝的产物。比较编码保留已接受的 catalog 输出，包括扩展 request-header 字段；当前版本的 `header.system` 会被拒绝。协议通知的预期输出直接与当前写入器输出比较，保留事件顺序、插入的 system 消息、封装字段，以及不透明的交付和捕获代际值；只有完整 Session 产物使用格式迁移 catalog。
 
 ### 嵌套 agent
 
@@ -97,15 +97,15 @@ parent agent 委托给进程内 subagent 的场景会为每个 Session 记录一
 
 replay 把选定的投影 Session generation 视为 fixture。一个 parser 补全投影 envelope，通过 `sessionFormatCatalog` 校验并迁移完整产物，再以一个结果返回当前 header、继承 cut 与事件列表。`deriveReplayScript` 按日志顺序展开每个 `assistant/message` 或 `assistant/attempt` stream，因此每个持久 settlement 都成为一条 `chunks` entry；非空 stream 缺少 `finish` chunk 是 `stream()` 抛出异常的 fingerprint，必须通过 override sidecar 表达。携带 `llmStreamCall: true` 与完整 `rawOutput` 的 `compaction/summary` 会在该事件位置 replay 为一条规范成功 stream。脚本字符串可以内嵌 `{{fromRequest:<regex>}}`；stream 输出时每个 placeholder 针对 live request 的 string leaf 解析，取该 pattern 的最后一次 match，用其第一个 capture group（无 capture group 时用整个 match）原位替换。
 
-已提交语料测试会发现 `snapshots/`、`packages/` 与 `scripts/snapshots/python-sdk-single-exe/` 下每个带版本的 `session*.jsonl`。每个产物都必须通过真实 catalog 还原为当前视图。任何拒绝都会携带产物路径并使测试失败，因此 fixture owner 必须在 replay 或比较前修正无效关系。
+[已提交语料测试](tests/session-format-corpus.spec.ts) 通过真实 catalog 还原 `snapshots/`、`packages/` 与 `scripts/snapshots/python-sdk-single-exe/` 下每个带版本的 `session*.jsonl`，且不改变源字节。其[清单](tests/session-format-corpus-inventory.ts) 按路径、源代际、错误类型与精确原因固定有意拒绝的历史转换；拒绝消失或变化都会使测试失败。当前代际产物不能获得例外。没有版本 header 的快照框架协议示例具有独立的显式豁免。其他所有还原错误都携带产物路径并使测试失败；历史文件保持不变，原生当前 fixture 则由 owner 修正。
 
 ### 源码地图
 
 | 文件 | 职责 |
 |---|---|
 | [`src/index.ts`](src/index.ts) | 类型、fixture 派生、override 校验、占位符解析、会话绑定、`installLlmReplay` 与插件导出 |
-| [`tests/session-format-corpus.spec.ts`](tests/session-format-corpus.spec.ts) | 完整已提交 generation restore burn-in；任何拒绝都是失败 |
-| — | 不发布运行时不变式伴生入口；流语法由 LLM 伴生插件与派生测试检验。 |
+| [`tests/session-format-corpus.spec.ts`](tests/session-format-corpus.spec.ts) | 已提交代际还原与精确历史拒绝检查 |
+| — | 不发布运行时不变式伴生入口；该仅测试适配器消费固定的回放脚本；其流语法由 LLM 伴生插件与 fixture 派生测试检验。 |
 
 ### 绑定与流式流程
 

package/lib/index.js

@@ -7,7 +7,7 @@ import { assertNever } from "@deepseek-ai/dsh-util-values";
 //#region lib/types/index.js
 /**
 * Keyless snapshot-test LLM replay. It derives one model-call script per
-* recorded session from v2 embedded Assistant streams and explicitly marked local
+* recorded session from v3 embedded Assistant streams and explicitly marked local
 * compaction calls, then binds fresh live sessions to parent/child scripts by
 * first-call order. Throw and hang cases require an explicit override because
 * a session log cannot reconstruct them alone.
@@ -107,46 +107,15 @@ function parsedSessionFixture(artifact, sourceHeader) {
 }
 /**
 * Convert one persisted or projected snapshot fixture to the current physical format in memory for expected-output comparison.
-* Projected cwd tokens remain tokens so the ordinary snapshot normalizer can compare them with a fresh run.
+* Projected cwd and request-tool tokens remain tokens for comparison with a fresh run.
 * @param text - one complete Session fixture.
 * @returns current-format JSONL with complete event envelopes; the input string and source file remain unchanged.
 */
 function prepareSessionSnapshotFixtureForComparison(text) {
 	return encodeCurrentSessionSnapshotFixture(text, parseSessionFixture(text));
 }
-/** Read one headless or SDK event-notification wrapper. */
-function wrappedSessionEvent(row) {
-	if (row["type"] === "session_event" && typeof row["sessionId"] === "string" && row["event"] !== null && typeof row["event"] === "object" && !Array.isArray(row["event"])) return {
-		sessionId: row["sessionId"],
-		event: row["event"],
-		replace: (event) => ({
-			...row,
-			event
-		})
-	};
-	const params = row["params"];
-	if (row["method"] !== "session.event" || params === null || typeof params !== "object" || Array.isArray(params)) return;
-	const record = params;
-	if (typeof record["sessionId"] !== "string" || record["event"] === null || typeof record["event"] !== "object" || Array.isArray(record["event"])) return;
-	return {
-		sessionId: record["sessionId"],
-		event: record["event"],
-		replace: (event) => ({
-			...row,
-			params: {
-				...record,
-				event
-			}
-		})
-	};
-}
-/** Append one migrated event to the output assigned to its v1 source row. */
-function assignMigratedEvent(assigned, rowIndex, event) {
-	assigned.set(rowIndex, [...assigned.get(rowIndex) ?? [], event]);
-}
 /** Restore fixture tokens materialized only to satisfy released-format validation. */
 function restoreProjectedRequestHeader(target, source) {
-	if (target["type"] !== "request/header" || source["type"] !== "request/header") return target;
 	const targetData = target["data"];
 	const sourceData = source["data"];
 	const targetHeader = targetData["header"];
@@ -163,118 +132,22 @@ function restoreProjectedRequestHeader(target, source) {
 		}
 	};
 }
-/** Omit delivery cursors whose numeric value depends on the source Session generation. */
-function normalizeWrappedEventProvenance(event) {
-	if (event["type"] !== "session-log-deepseek/delivery-accepted") return event;
-	const data = event["data"];
-	if (data === null || typeof data !== "object" || Array.isArray(data)) return event;
-	const normalized = { ...data };
-	delete normalized["sessionFormatVersion"];
-	delete normalized["throughSeq"];
-	return {
-		...event,
-		data: normalized
-	};
-}
-/** Migrate one session's contiguous v1 notification tail and align its surviving rows. */
-function migrateWrappedEventGroup(entries) {
-	const first = entries[0];
-	if (!entries.some((entry) => entry.event["type"] === "assistant/chunk")) return /* @__PURE__ */ new Map();
-	const firstSeq = first.event["seq"];
-	if (!Number.isSafeInteger(firstSeq) || firstSeq < 0) throw new Error("session event comparison requires a non-negative first seq");
-	for (const [index, entry] of entries.entries()) if (entry.event["seq"] !== firstSeq + index || typeof entry.event["type"] !== "string") throw new Error(`session event comparison requires a contiguous event tail for ${first.sessionId}`);
-	const prefix = Array.from({ length: firstSeq }, (_, seq) => ({
-		type: "feedback/record",
-		seq,
-		time: 0,
-		data: { text: `comparison prefix ${String(seq)}` }
-	}));
-	const restore = sessionFormatCatalog.createRestore({
-		type: "session",
-		version: 1,
-		id: first.sessionId,
-		createdAt: 0,
-		delegationDepth: 0
-	}, {
-		recovery: "strict",
-		validation: "current"
-	});
-	for (const event of prefix) restore.decodeRow(event);
-	for (const entry of entries) restore.decodeRow(normalizeProjectedRow(entry.event));
-	const migrated = restore.finish().events.slice(prefix.length);
-	const assigned = /* @__PURE__ */ new Map();
-	let migratedIndex = 0;
-	let lastChunkRow;
-	for (const entry of entries) {
-		if (entry.event["type"] === "assistant/chunk") {
-			lastChunkRow = entry.rowIndex;
-			continue;
-		}
-		while (migrated[migratedIndex]?.["type"] === "assistant/attempt") {
-			assignMigratedEvent(assigned, lastChunkRow, migrated[migratedIndex]);
-			migratedIndex += 1;
-		}
-		const next = migrated[migratedIndex];
-		assignMigratedEvent(assigned, entry.rowIndex, restoreProjectedRequestHeader(next, entry.event));
-		migratedIndex += 1;
-	}
-	while (migrated[migratedIndex]?.["type"] === "assistant/attempt") {
-		assignMigratedEvent(assigned, lastChunkRow, migrated[migratedIndex]);
-		migratedIndex += 1;
-	}
-	return assigned;
-}
-/**
-* Project v1 session-event notifications to current settlement cardinality in memory.
-* Non-event protocol rows retain their exact positions, and current v2 input passes through.
-* @param text - headless `session_event` or SDK `session.event` JSONL.
-* @returns comparison JSONL using current Session events without modifying its source file.
-*/
-function prepareSessionEventNotificationsForComparison(text) {
-	const trailingNewline = text.endsWith("\n");
-	const rows = text.split("\n").filter((line) => line.trim().length > 0).map((line, index) => {
-		const value = JSON.parse(line);
-		if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`session event comparison line ${String(index + 1)} must be an object`);
-		return value;
-	});
-	const entries = rows.flatMap((row, rowIndex) => {
-		const wrapped = wrappedSessionEvent(row);
-		return wrapped === void 0 ? [] : [{
-			...wrapped,
-			rowIndex
-		}];
-	});
-	const groups = [];
-	for (const entry of entries) {
-		const nextSeq = entry.event["seq"];
-		const group = groups.findLast((candidate) => {
-			const previous = candidate.at(-1);
-			const previousSeq = previous?.event["seq"];
-			return previous?.sessionId === entry.sessionId && Number.isSafeInteger(previousSeq) && Number.isSafeInteger(nextSeq) && nextSeq === previousSeq + 1;
-		});
-		if (group === void 0) groups.push([entry]);
-		else group.push(entry);
-	}
-	const assigned = /* @__PURE__ */ new Map();
-	for (const group of groups) for (const [rowIndex, events] of migrateWrappedEventGroup(group)) assigned.set(rowIndex, events);
-	const output = rows.flatMap((row, rowIndex) => {
-		const wrapped = wrappedSessionEvent(row);
-		if (wrapped === void 0) return [row];
-		const migrated = assigned.get(rowIndex);
-		if (migrated === void 0) return wrapped.event["type"] === "assistant/chunk" ? [] : [wrapped.replace(normalizeWrappedEventProvenance(wrapped.event))];
-		return migrated.map((event) => wrapped.replace(normalizeWrappedEventProvenance(event)));
-	}).map((row) => JSON.stringify(row)).join("\n");
-	return trailingNewline ? `${output}\n` : output;
-}
-/** Encode one migrated fixture while retaining a projected cwd token. */
+/** Encode one migrated fixture while retaining projected cwd and request-tool tokens. */
 function encodeCurrentSessionSnapshotFixture(text, parsed) {
 	const header = { ...sessionFormatCatalog.encodeCurrentHeader(parsed.artifact.header, parsed.artifact.inheritedEventCount) };
 	const sourceCwd = parsed.sourceHeader["cwd"];
 	if (typeof sourceCwd === "string" && /^\{\{cwd\}\}(?:\/|$)/.test(sourceCwd)) header["cwd"] = sourceCwd;
-	const output = [JSON.stringify(header), ...parsed.artifact.events.map((event) => JSON.stringify(sessionFormatCatalog.encodeCurrentEvent(event)))].join("\n");
+	const sourceRequests = text.split(/\r?\n/).filter((line) => line.trim().length > 0).slice(1).map((line) => JSON.parse(line)).filter((row) => row["type"] === "request/header");
+	let requestIndex = 0;
+	const output = [JSON.stringify(header), ...parsed.artifact.events.map((event) => {
+		const encoded = sessionFormatCatalog.encodeCurrentEvent(event);
+		if (event.type !== "request/header") return JSON.stringify(encoded);
+		const source = sourceRequests[requestIndex++];
+		return JSON.stringify(restoreProjectedRequestHeader(encoded, source));
+	})].join("\n");
 	return text.endsWith("\n") ? `${output}\n` : output;
 }
-/** Restore typed request-header values replaced by snapshot sidecar tokens. */
+/** Omit exact request-tool sidecar tokens and materialize projected tool names for validation. */
 function normalizeProjectedRow(source) {
 	const record = { ...source };
 	if (record["type"] !== "request/header") return record;
@@ -283,9 +156,9 @@ function normalizeProjectedRow(source) {
 	const header = data["header"];
 	if (header === null || typeof header !== "object" || Array.isArray(header)) return record;
 	const tools = header["tools"];
-	let materializedTools;
-	if (tools === "{{tools}}") materializedTools = [];
-	else if (Array.isArray(tools) && tools.every((tool) => typeof tool === "string" && tool.length > 0)) materializedTools = tools.map((name) => ({
+	const normalizedHeader = { ...header };
+	if (tools === "{{tools}}") delete normalizedHeader["tools"];
+	else if (Array.isArray(tools) && tools.length > 0 && tools.every((tool) => typeof tool === "string" && tool.length > 0)) normalizedHeader["tools"] = tools.map((name) => ({
 		name,
 		description: "",
 		parameters: {}
@@ -293,10 +166,7 @@ function normalizeProjectedRow(source) {
 	else return record;
 	record["data"] = {
 		...data,
-		header: {
-			...header,
-			tools: materializedTools
-		}
+		header: normalizedHeader
 	};
 	return record;
 }
@@ -725,6 +595,7 @@ var ReplayAdapter = class extends LlmAdapter {
 			...configuredModel?.inputModalities === void 0 ? {} : { inputModalities: [...configuredModel.inputModalities] },
 			...configuredModel?.contextWindow === void 0 ? {} : { context: { contextWindow: configuredModel.contextWindow } },
 			...configuredModel?.defaultMaxTokens === void 0 ? {} : { defaultMaxTokens: configuredModel.defaultMaxTokens },
+			...configuredModel?.systemPromptUpdate === void 0 ? {} : { systemPromptUpdate: configuredModel.systemPromptUpdate },
 			...configuredModel?.reasoningEfforts === void 0 ? {} : { reasoning: {
 				efforts: configuredModel.reasoningEfforts.map((id) => ({
 					id: ReasoningEffortId(id),
@@ -900,6 +771,8 @@ function validateConfiguredModels(providers) {
 		const imageRequestTokens = model.imageRequestTokens;
 		if (imageRequestTokens !== void 0 && (!Number.isSafeInteger(imageRequestTokens) || imageRequestTokens <= 0)) throw new Error(`llm-replay: provider "${provider.id}" model "${model.id}" imageRequestTokens must be a positive safe integer`);
 		if (imageRequestTokens !== void 0 && model.inputModalities?.includes("image") !== true) throw new Error(`llm-replay: provider "${provider.id}" model "${model.id}" imageRequestTokens requires inputModalities to include "image"`);
+		const systemPromptUpdate = model.systemPromptUpdate;
+		if (systemPromptUpdate !== void 0 && systemPromptUpdate !== "in-history") throw new Error(`llm-replay: provider "${provider.id}" model "${model.id}" systemPromptUpdate must be "in-history" when present`);
 	}
 }
 function apply(ctx, config = {}) {
@@ -918,4 +791,4 @@ function apply(ctx, config = {}) {
 	});
 }
 //#endregion
-export { apply, deriveReplayScript, inject, installLlmReplay, loadReplayScript, loadSessionScripts, name, parseSessionHeader, parseSessionLog, prepareSessionEventNotificationsForComparison, prepareSessionSnapshotFixtureForComparison, resolveScriptedEntry };
+export { apply, deriveReplayScript, inject, installLlmReplay, loadReplayScript, loadSessionScripts, name, parseSessionHeader, parseSessionLog, prepareSessionSnapshotFixtureForComparison, resolveScriptedEntry };

package/lib/types/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Keyless snapshot-test LLM replay. It derives one model-call script per
- * recorded session from v2 embedded Assistant streams and explicitly marked local
+ * recorded session from v3 embedded Assistant streams and explicitly marked local
  * compaction calls, then binds fresh live sessions to parent/child scripts by
  * first-call order. Throw and hang cases require an explicit override because
  * a session log cannot reconstruct them alone.
@@ -9,7 +9,7 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { type SessionEvent } from '@deepseek-ai/dsh-session';
 import type { SessionLogOffset as SessionLogOffsetType } from '@deepseek-ai/dsh-session';
-import type { GenerateOptions, ModelModality, RetryPolicyConfig, StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { GenerateOptions, ModelModality, RetryPolicyConfig, StreamChunk, SystemPromptUpdate } from '@deepseek-ai/dsh-llm';
 /**
  * One recorded model call. `throw` may replay prefix chunks before failing;
  * `hang` models cancellation. Derived chunk entries come from ordinary model
@@ -63,6 +63,8 @@ export interface ReplayModelConfig {
      * {@link reasoningEfforts} or call resolution rejects the route.
      */
     defaultReasoningEffort?: string;
+    /** Optional in-history system prompt replacement for a keyless replay route. */
+    systemPromptUpdate?: SystemPromptUpdate;
 }
 /** One provider route exposed by the replay adapter. */
 export interface ReplayProviderConfig {
@@ -160,18 +162,11 @@ export interface SessionScript {
 export declare function parseSessionLog(text: string): SessionEvent[];
 /**
  * Convert one persisted or projected snapshot fixture to the current physical format in memory for expected-output comparison.
- * Projected cwd tokens remain tokens so the ordinary snapshot normalizer can compare them with a fresh run.
+ * Projected cwd and request-tool tokens remain tokens for comparison with a fresh run.
  * @param text - one complete Session fixture.
  * @returns current-format JSONL with complete event envelopes; the input string and source file remain unchanged.
  */
 export declare function prepareSessionSnapshotFixtureForComparison(text: string): string;
-/**
- * Project v1 session-event notifications to current settlement cardinality in memory.
- * Non-event protocol rows retain their exact positions, and current v2 input passes through.
- * @param text - headless `session_event` or SDK `session.event` JSONL.
- * @returns comparison JSONL using current Session events without modifying its source file.
- */
-export declare function prepareSessionEventNotificationsForComparison(text: string): string;
 /**
  * Read replay identity, ordering, and fork-seed facts from the JSONL header.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-llm-replay",
   "description": "Replay LLM plugin: short-circuits llm/stream with model chunks reconstructed from a recorded session JSONL (keyless snapshot tests)",
-  "version": "0.1.3-alpha.2",
+  "version": "0.1.5-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -28,10 +28,10 @@
   "license": "MIT",
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-compaction": "^0.1.3-alpha.2",
-    "@deepseek-ai/dsh-deepseek-llm-api-extensions": "^0.1.3-alpha.2",
-    "@deepseek-ai/dsh-llm": "^0.1.3-alpha.2",
-    "@deepseek-ai/dsh-session": "^0.1.3-alpha.2"
+    "@deepseek-ai/dsh-compaction": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-deepseek-llm-api-extensions": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-llm": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-session": "^0.1.5-alpha.2"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-deepseek-llm-api-extensions": {
@@ -39,14 +39,14 @@
     }
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-compaction": "^0.1.3-alpha.2",
-    "@deepseek-ai/dsh-deepseek-llm-api-extensions": "^0.1.3-alpha.2",
-    "@deepseek-ai/dsh-llm": "^0.1.3-alpha.2",
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-session": "^0.1.3-alpha.2"
+    "@deepseek-ai/dsh-compaction": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-deepseek-llm-api-extensions": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-llm": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-session": "^0.1.5-alpha.2"
   },
   "dependencies": {
-    "@deepseek-ai/dsh-session-format-catalog": "^0.1.3-alpha.2",
-    "@deepseek-ai/dsh-util-values": "^0.1.3-alpha.2"
+    "@deepseek-ai/dsh-session-format-catalog": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-util-values": "^0.1.5-alpha.2"
   }
 }