@xneog/dsh-session-format-v1-to-v2 0.1.3-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# 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/session/session-format-v1-to-v2/README.md
+README.md: a4600d2d83356a99e33119adcb70d1c6065c5b15
+README.zh.md: d03054435e30d281c328df68035fb122d365f2a0

package/README.md

@@ -0,0 +1,111 @@
+---
+description: "Frozen released-v1 Session reader and cardinality-changing migration that embeds Assistant streams in released v2 events."
+kind: "package-reference"
+---
+
+# @xneog/dsh-session-format-v1-to-v2
+
+English | [中文](README.zh.md)
+
+## Summary
+
+`dsh-session-format-v1-to-v2` converts a complete released-v1 Session into the released-v2 event model. It consumes top-level `assistant/chunk` events, embeds their exact timed stream in the matching `assistant/message`, and records an `assistant/attempt` when a failed, retried, cancelled, or stream-error attempt reached settlement without a surface message. The edge densely remaps surviving events and every declared same-Session sequence reference, while the v2 codec stores one event per row and derives the inherited cut from a tagged `session/end-seed` marker.
+
+## Table of Contents
+
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## Use this package
+
+### When to use it
+
+Persistence obtains this edge through `dsh-session-format-catalog`; feature compositions do not mount it. Import it directly only when assembling or testing the static released-format catalog or inspecting the exact v1-to-v2 transformation. No runtime invariant companion is published because every codec and migration call validates its complete source or target artifact and retains no runtime state.
+
+### Entry point
+
+```text
+const decodedV1 = releasedV1SessionFormatCodec.decodeArtifact(header, rows)
+const migratedV2 = sessionFormatV1ToV2.migrate(decodedV1)
+```
+
+`releasedV1SessionFormatCodec` reads the frozen v1 physical language. `sessionFormatV1ToV2` validates that complete source, performs the cardinality-changing transformation, remaps declared references, and validates the exact v2 result. `releasedV2SessionFormatCodec` then encodes or decodes the current physical representation.
+
+A successful v1 `assistant/message` must cite its complete ordered attempt. The migration removes the cited top-level chunks and obsolete message provenance, compacts the chunks without joining token boundaries, and stores the stream on that message. An unclaimed attempt becomes one log-only `assistant/attempt` at its final chunk position. Unrelated interleaved events keep their relative order.
+
+The migration refuses a reference to a consumed chunk instead of redirecting it to a different semantic event. It remaps declared event provenance, surface replacements, command source events, compaction ranges and lists, and title message lists. The already model-visible `session/title-llm-request.messages` text remains byte-identical after source validation, so target validation does not reinterpret the old sequence numbers embedded in that prompt. A seeded source also refuses an inherited cut that splits an Assistant attempt; the target marks the exact cut with `session/end-seed { inherited: true }`.
+
+The v2 physical header requires `isSeeded` and does not store a numeric cut. The codec derives the cut from the last inherited end-seed marker, writes one event per row, range-encodes only `sourceEventSeqs`, and remains neutral to ordinary event vocabulary and payload growth. Strict migration-target validation freezes the released-v2 inventory and rejects unknown types or members. Current restoration instead admits event types known to the installed Session package plus unknown events carrying `ignorable: true`, then delegates payload and stream semantics to the installed current restorer. All paths retain strict header, event-envelope, sequence, and inherited-cut validation.
+
+-----
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+<details>
+<summary>Implementation internals — click to expand</summary>
+
+The edge first groups v1 chunks by turn, step, terminal finish, and explicit message provenance. It stages survivors in source order, substitutes one settlement for each group, computes a dense old-to-new sequence map, and rewrites only the reference fields declared by the frozen event inventory. Source and target validators bracket the transformation so a partially understood artifact is never admitted.
+
+| File | Role |
+|---|---|
+| [`src/migration.ts`](src/migration.ts) | Attempt grouping, settlement substitution, dense sequence mapping, and reference rewriting |
+| [`src/codec.ts`](src/codec.ts) | Released-v2 header, one-event-per-row encoding, provenance ranges, and recoverable prefix decoding |
+| [`src/validation.ts`](src/validation.ts) | Physical v2 envelope/cut validation, exact migration-target policy, and vocabulary-neutral current restoration |
+| [`src/dispositions.ts`](src/dispositions.ts) | Frozen released-v2 event and payload-member inventory |
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+- [Released v0 to v1 edge](../session-format-v0-to-v1/README.md) — the source codec and frozen historical vocabulary reused here.
+- [Static catalog](../session-format-catalog/README.md) — build-owned codec and migration ordering.
+- [Session persistence subsystem](../../../docs/subsystems/persistence.md) — immutable generation selection and publication.
+- [Embedded Assistant stream decision](../../../.agents/notes/implemented/architecture/2026-09-01-v2-embedded-assistant-streams.md) — rationale, alternatives, and consequences.
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+### Historical restoration
+
+#### What the model sees
+
+Successful Assistant messages retain the content, provider, model, usage, and replay state assembled from the same v1 stream. Failed or abandoned attempts remain durable diagnostics through `assistant/attempt` but do not enter `deriveMessages()`.
+
+#### Token effect
+
+The migration adds no model-visible content. It preserves the derived message history and removes only top-level chunk envelopes from the current logical event sequence.
+
+#### KV Cache effect
+
+The restored model-message sequence stays unchanged, so the migration alone does not alter request-prefix cache identity.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **Closed first-party source inventory** — an unknown v1 event refuses migration, including an event marked `ignorable: true`.
+- **Whole-artifact transformation** — the edge materializes the source, target, and sequence map in memory; it does not stream the rewrite.
+- **No publication or compatibility fallback** — persistence owns exclusive successor publication, and retained v1 generations are not automatic downgrade or restore inputs.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -0,0 +1,111 @@
+---
+description: "冻结的已发布 v1 Session 读取器，以及把 Assistant 流嵌入已发布 v2 事件的基数变化迁移。"
+kind: "package-reference"
+---
+
+# @xneog/dsh-session-format-v1-to-v2
+
+[English](README.md) | 中文
+
+## 概述
+
+`dsh-session-format-v1-to-v2` 把完整的已发布 v1 Session 转换为已发布 v2 事件模型。它会消费顶层 `assistant/chunk` 事件，把精确的带时间流嵌入匹配的 `assistant/message`，并在失败、重试、取消或 stream error attempt 已到达 settlement、但没有产生 surface message 时记录 `assistant/attempt`。该迁移边会密集重映射存活事件和每个已声明的同 Session 序号引用；v2 编解码器则让每行只存一个事件，并从带标记的 `session/end-seed` 事件推导继承切点。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+### 何时使用
+
+持久化通过 `dsh-session-format-catalog` 获取该迁移边；功能组合不会挂载它。只有在装配或测试静态已发布格式目录，或检查精确的 v1 到 v2 转换时，才直接导入本包。它不发布运行时不变式伴生入口，因为每次 codec 与迁移调用都会校验完整的源或目标 artifact，且不保留运行时状态。
+
+### 入口
+
+```text
+const decodedV1 = releasedV1SessionFormatCodec.decodeArtifact(header, rows)
+const migratedV2 = sessionFormatV1ToV2.migrate(decodedV1)
+```
+
+`releasedV1SessionFormatCodec` 读取冻结的 v1 物理语言。`sessionFormatV1ToV2` 校验完整源产物、执行基数变化转换、重映射已声明引用，并校验精确的 v2 结果。`releasedV2SessionFormatCodec` 随后编码或解码当前物理表示。
+
+成功的 v1 `assistant/message` 必须引用其完整有序 attempt。迁移会移除这些顶层 chunk 和已停用的 message provenance，在不合并 token 边界的前提下压缩 chunk，并把 stream 存到该 message 上。未被 message 认领的 attempt 会在其最后一个 chunk 的位置变成一个仅日志可见的 `assistant/attempt`。无关的交错事件保持相对顺序。
+
+如果引用指向被消费的 chunk，迁移会失败，而不会把它重定向到语义不同的事件。它会重映射已声明的事件 provenance、surface replacement、command source event、compaction range 与 list，以及 title message list。已经对模型可见的 `session/title-llm-request.messages` 文本会在源校验后保持逐字节不变，因此目标校验不会重新解释该 prompt 中嵌入的旧序号。带 seed 的源若让继承切点切开一个 Assistant attempt，也会迁移失败；目标会用 `session/end-seed { inherited: true }` 标出精确切点。
+
+v2 物理 header 要求 `isSeeded`，且不存储数值切点。编解码器从最后一个 inherited end-seed marker 推导切点，每行写入一个事件，只对 `sourceEventSeqs` 做范围编码，并对普通事件词汇与 payload 扩展保持中立。严格的迁移目标校验会冻结 released-v2 清单并拒绝未知 type 或 member。当前恢复则准入 installed Session package 已知的事件 type，以及携带 `ignorable: true` 的未知事件，再把 payload 与 stream 语义交给 installed current restorer。所有路径仍严格校验 header、event envelope、sequence 与 inherited cut。
+
+-----
+
+<a id="understand-the-implementation"></a>
+## 理解实现
+
+<details>
+<summary>实现细节——点击展开</summary>
+
+该迁移边先按 turn、step、terminal finish 和显式 message provenance 对 v1 chunk 分组。它按源顺序暂存存活事件，为每组替换一个 settlement，计算密集的旧序号到新序号映射，并且只改写冻结事件清单声明的引用字段。源与目标校验器包围整个转换，因此部分理解的产物绝不会被接纳。
+
+| 文件 | 职责 |
+|---|---|
+| [`src/migration.ts`](src/migration.ts) | Attempt 分组、settlement 替换、密集序号映射与引用重写 |
+| [`src/codec.ts`](src/codec.ts) | 已发布 v2 header、每行一个事件的编码、provenance 范围与可恢复前缀解码 |
+| [`src/validation.ts`](src/validation.ts) | v2 物理 envelope／cut 校验、精确 migration-target 策略与 vocabulary-neutral current restoration |
+| [`src/dispositions.ts`](src/dispositions.ts) | 冻结的已发布 v2 事件与 payload 成员清单 |
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+- [已发布 v0 到 v1 迁移边](../session-format-v0-to-v1/README.zh.md)——本包复用的源编解码器与冻结历史词表。
+- [静态目录](../session-format-catalog/README.zh.md)——构建拥有的编解码器与迁移顺序。
+- [Session 持久化子系统](../../../docs/subsystems/persistence.zh.md)——不可变 generation 选择与发布。
+- [嵌入式 Assistant stream 决策](../../../.agents/notes/implemented/architecture/2026-09-01-v2-embedded-assistant-streams.zh.md)——理由、替代方案与后果。
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+### 历史还原
+
+#### 模型看到什么
+
+成功的 Assistant message 会保留从同一 v1 stream 组装出的 content、provider、model、usage 与 replay state。失败或放弃的 attempt 会通过 `assistant/attempt` 保留为持久诊断事实，但不会进入 `deriveMessages()`。
+
+#### Token 影响
+
+迁移不会添加模型可见内容。它会保留派生 message history，只从当前逻辑事件序列中移除顶层 chunk 信封。
+
+#### KV Cache 影响
+
+还原后的模型 message 序列保持不变，因此迁移本身不会改变请求前缀的缓存身份。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **封闭的第一方源清单**——未知 v1 事件会使迁移失败，包括带有 `ignorable: true` 的事件。
+- **全产物转换**——该迁移边会在内存中物化源、目标和序号映射；它不会流式改写。
+- **不负责发布或兼容回退**——持久化拥有排他 successor 发布，保留的 v1 generation 不是自动 downgrade 或 restore 输入。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -0,0 +1,656 @@
+import { RELEASED_V0_EVENT_DISPOSITIONS, assertReleasedArtifactRelationships, assertReleasedPayloadSemantics, assertReleasedSurfaceMetadata, assertReleasedV1Artifact, assertReleasedV1Header, defineReleasedPayloadDisposition, releasedV1SessionFormatCodec } from "@xneog/dsh-session-format-v0-to-v1";
+import { SessionFormatError, SessionFormatUnsupportedMigrationError, defineSessionFormatMigration, sessionFormatCount, sessionFormatSafeInteger, snapshotSessionFormatArtifact, snapshotSessionFormatJson } from "@xneog/dsh-session-format";
+import { isAbsolute } from "node:path";
+import { AssistantStreamAccumulator, BlockAssembler, expandAssistantStream } from "@xneog/dsh-llm";
+import { deepEqualJson } from "@xneog/dsh-util-values";
+//#region lib/types/dispositions.js
+const retained = Object.fromEntries(Object.entries(RELEASED_V0_EVENT_DISPOSITIONS).filter(([type]) => type !== "assistant/chunk" && type !== "assistant/message" && type !== "session-log-deepseek/delivery-accepted" && type !== "session/end-seed"));
+/** Exact top-level event and payload-member inventory frozen for released v2. */
+const RELEASED_V2_EVENT_DISPOSITIONS = Object.freeze({
+	...retained,
+	"assistant/attempt": defineReleasedPayloadDisposition([
+		"turn",
+		"step",
+		"stream"
+	]),
+	"assistant/message": defineReleasedPayloadDisposition([
+		"turn",
+		"step",
+		"message",
+		"stream"
+	], ["usage", "interrupted"]),
+	"session-log-deepseek/delivery-accepted": defineReleasedPayloadDisposition(["sessionId", "throughSeq"], ["sessionFormatVersion"]),
+	"session/end-seed": defineReleasedPayloadDisposition([], ["inherited"])
+});
+/** Stable sorted released-v2 event inventory. */
+const RELEASED_V2_EVENT_TYPES = Object.freeze(Object.keys(RELEASED_V2_EVENT_DISPOSITIONS).sort((left, right) => left.localeCompare(right, "en")));
+//#endregion
+//#region lib/types/validation.js
+const HEADER_REQUIRED$1 = [
+	"version",
+	"id",
+	"createdAt",
+	"isSeeded",
+	"delegationDepth"
+];
+const HEADER_OPTIONAL$1 = [
+	"cwd",
+	"parentSession",
+	"origin",
+	"agentPreset"
+];
+const EVENT_REQUIRED = [
+	"type",
+	"seq",
+	"time",
+	"data"
+];
+const SURFACE_TYPES = new Set([
+	"user/message",
+	"assistant/message",
+	"tool/result"
+]);
+const SURFACE_OPTIONAL = [
+	"ignorable",
+	"sourceEventSeqs",
+	"surfaceOp"
+];
+const LOG_OPTIONAL = ["ignorable"];
+const RELEASED_V2_EVENT_TYPE_SET = new Set(RELEASED_V2_EVENT_TYPES);
+const RELEASED_V2_RELATIONSHIP_EXTENSIONS = {
+	stepEvents: new Set(["assistant/attempt"]),
+	preservedSourceTitleRequestText: true
+};
+/**
+* Validate the exact logical header written by released v2.
+* @param header - decoded released-v2 Session header.
+* @throws {SessionFormatError} when the header is not an exact released-v2 value.
+*/
+function assertReleasedV2Header(header) {
+	const record = jsonRecord$1(header, "format v2 header");
+	exactKeys$1(record, HEADER_REQUIRED$1, HEADER_OPTIONAL$1, "format v2 header");
+	if (record["version"] !== 2) throw new SessionFormatError("expected format v2 header");
+	if (typeof record["id"] !== "string") throw new SessionFormatError("format v2 header id must be a string");
+	sessionFormatCount(record["createdAt"], "format v2 header createdAt");
+	sessionFormatCount(record["delegationDepth"], "format v2 header delegationDepth");
+	if (typeof record["isSeeded"] !== "boolean") throw new SessionFormatError("format v2 header isSeeded must be boolean");
+	if (record["cwd"] !== void 0 && (typeof record["cwd"] !== "string" || !isAbsolute(record["cwd"]))) throw new SessionFormatError("format v2 header cwd must be absolute");
+	for (const key of ["parentSession", "agentPreset"]) if (record[key] !== void 0 && typeof record[key] !== "string") throw new SessionFormatError(`format v2 header ${key} must be a string`);
+	if (record["origin"] !== void 0 && record["origin"] !== "subagent") throw new SessionFormatError("format v2 header origin must be \"subagent\"");
+}
+/**
+* Validate the exact logical image emitted by the released v2 writer.
+* @param artifact - complete decoded released-v2 Session artifact.
+* @throws {SessionFormatError} when an envelope, payload, relationship, or inherited cut is invalid.
+* @throws {SessionFormatUnsupportedMigrationError} when the artifact contains an unknown event type.
+*/
+function assertReleasedV2Artifact(artifact) {
+	validateReleasedV2Artifact(artifact, "target", RELEASED_V2_EVENT_TYPE_SET);
+}
+/**
+* Validate only the released-v2 physical header, event envelopes, and inherited cut.
+* Event vocabulary and payload semantics belong to target or installed-current restoration.
+* @param artifact - complete physical-codec output.
+*/
+function assertReleasedV2PhysicalArtifact(artifact) {
+	validateReleasedV2Artifact(artifact, "physical");
+}
+function validateReleasedV2Artifact(artifact, mode, knownEventTypes) {
+	assertReleasedV2Header(artifact.header);
+	const cut = sessionFormatCount(artifact.inheritedEventCount, "format v2 inherited event count");
+	if (cut > artifact.events.length) throw new SessionFormatError("format v2 inherited event count exceeds its events");
+	if (!artifact.header.isSeeded && cut !== 0) throw new SessionFormatError("unseeded format v2 Session has inherited events");
+	let lastInheritedMarker;
+	for (const [index, event] of artifact.events.entries()) {
+		const record = jsonRecord$1(event, `format v2 event ${index}`);
+		const type = record["type"];
+		if (typeof type !== "string") throw new SessionFormatError(`format v2 event ${index} type must be a string`);
+		const disposition = RELEASED_V2_EVENT_DISPOSITIONS[type];
+		const installed = knownEventTypes?.has(type) === true;
+		const ignorableUnknown = disposition === void 0 && mode === "current" && record["ignorable"] === true;
+		if (mode !== "physical" && disposition === void 0 && !installed && !ignorableUnknown) throw new SessionFormatUnsupportedMigrationError(`format v2 contains unknown event type ${JSON.stringify(type)} at seq ${index}`);
+		const surface = disposition !== void 0 && SURFACE_TYPES.has(type);
+		exactKeys$1(record, EVENT_REQUIRED, mode === "physical" || disposition === void 0 ? SURFACE_OPTIONAL : surface ? SURFACE_OPTIONAL : LOG_OPTIONAL, `format v2 event ${index}`);
+		if (record["seq"] !== index) throw new SessionFormatError(`format v2 event ${index} is not dense`);
+		sessionFormatSafeInteger(record["time"], `format v2 event ${index} time`);
+		if (record["ignorable"] !== void 0 && record["ignorable"] !== true) throw new SessionFormatError(`format v2 event ${index} ignorable must be true when present`);
+		if (mode === "target" && surface) assertReleasedSurfaceMetadata(record, index, type, "forbid-assistant");
+		if (mode === "target" && disposition !== void 0) assertPayload(event, disposition);
+		if (type === "session/end-seed") {
+			if (jsonRecord$1(event.data, `session/end-seed ${index} data`)["inherited"] === true) lastInheritedMarker = index;
+		}
+	}
+	if (artifact.header.isSeeded && lastInheritedMarker !== cut) throw new SessionFormatError("format v2 seeded header disagrees with its last inherited end-seed marker");
+	if (!artifact.header.isSeeded && lastInheritedMarker !== void 0) throw new SessionFormatError("format v2 unseeded Session contains an inherited end-seed marker");
+	if (mode === "target") assertReleasedArtifactRelationships(artifact, RELEASED_V2_RELATIONSHIP_EXTENSIONS);
+}
+function assertPayload(event, disposition) {
+	const data = jsonRecord$1(event.data, `${event.type} ${event.seq} data`);
+	exactKeys$1(data, disposition.required, disposition.optional, `${event.type} ${event.seq} data`);
+	for (const key of disposition.opaque) if (Object.hasOwn(data, key)) snapshotSessionFormatJson(data[key], `${event.type} ${event.seq} opaque ${key}`);
+	if (event.type === "assistant/attempt" || event.type === "assistant/message") {
+		const turn = sessionFormatCount(data["turn"], `${event.type} ${event.seq} turn`);
+		const step = sessionFormatCount(data["step"], `${event.type} ${event.seq} step`);
+		const assembler = new BlockAssembler();
+		let timed;
+		try {
+			timed = expandAssistantStream(data["stream"]);
+			for (const member of timed) {
+				assertReleasedPayloadSemantics({
+					type: "assistant/chunk",
+					seq: event.seq,
+					time: member.time,
+					data: {
+						turn,
+						step,
+						chunk: member.chunk
+					}
+				}, 2);
+				assembler.push(member.chunk);
+			}
+		} catch (error) {
+			throw new SessionFormatError(`${event.type} ${event.seq} has an invalid embedded stream`, { cause: error });
+		}
+		if (event.type === "assistant/attempt") return;
+		assertReleasedPayloadSemantics(event, 2);
+		if (timed.length > 0) {
+			const message = jsonRecord$1(data["message"], `assistant/message ${event.seq} message`);
+			const content = data["interrupted"] === true ? assembler.interruptedBlocks() : assembler.blocks();
+			if (!deepEqualJson(message["content"], content)) throw new SessionFormatError(`assistant/message ${event.seq} message content disagrees with its embedded stream`);
+			if (!deepEqualJson(data["usage"], assembler.usage)) throw new SessionFormatError(`assistant/message ${event.seq} usage disagrees with its embedded stream`);
+			if (!deepEqualJson(jsonRecord$1(message["source"], `assistant/message ${event.seq} source`)["replayState"], assembler.replayState)) throw new SessionFormatError(`assistant/message ${event.seq} replay state disagrees with its embedded stream`);
+		}
+		return;
+	}
+	if (event.type === "session/end-seed") {
+		if (data["inherited"] !== void 0 && data["inherited"] !== true) throw new SessionFormatError(`session/end-seed ${event.seq} inherited must be true when present`);
+		return;
+	}
+	assertReleasedPayloadSemantics(event, 2);
+}
+function jsonRecord$1(value, label) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new SessionFormatError(`${label} must be an object`);
+	return value;
+}
+function exactKeys$1(value, required, optional, label) {
+	const allowed = new Set([...required, ...optional]);
+	const missing = required.find((key) => !Object.hasOwn(value, key));
+	if (missing !== void 0) throw new SessionFormatError(`${label} lacks required field ${missing}`);
+	const unexpected = Object.keys(value).find((key) => !allowed.has(key));
+	if (unexpected !== void 0) throw new SessionFormatError(`${label} has unexpected field ${unexpected}`);
+}
+/**
+* Restore and validate one decoded released-v2 artifact.
+* @param artifact - detached vocabulary-restored artifact.
+* @param knownEventTypes - event types understood by the installed current Session package.
+* @returns the same validated artifact.
+*/
+function restoreReleasedV2Artifact(artifact, knownEventTypes) {
+	validateReleasedV2Artifact(artifact, "current", knownEventTypes);
+	return artifact;
+}
+//#endregion
+//#region lib/types/codec.js
+const HEADER_REQUIRED = [
+	"type",
+	"version",
+	"id",
+	"createdAt",
+	"isSeeded",
+	"delegationDepth"
+];
+const HEADER_OPTIONAL = [
+	"cwd",
+	"parentSession",
+	"origin",
+	"agentPreset"
+];
+/** Frozen physical JSON codec for released v2. */
+const releasedV2SessionFormatCodec = Object.freeze({
+	version: 2,
+	decodeHeader(value) {
+		return decodePhysicalHeader(value);
+	},
+	decodeArtifact(headerValue, rowValues) {
+		return decodeArtifact(headerValue, rowValues, false);
+	},
+	decodeRecoverableArtifact(headerValue, rowValues) {
+		return decodeArtifact(headerValue, rowValues, true);
+	},
+	encodeArtifact(artifact) {
+		return encodeArtifact(artifact);
+	}
+});
+function decodePhysicalHeader(value) {
+	const record = jsonRecord(snapshotSessionFormatJson(value, "released v2 physical header"), "released v2 physical header");
+	exactKeys(record, HEADER_REQUIRED, HEADER_OPTIONAL, "released v2 physical header");
+	if (record["type"] !== "session" || record["version"] !== 2) throw new SessionFormatError("expected released v2 physical Session header");
+	if (typeof record["id"] !== "string") throw new SessionFormatError("released v2 header id must be a string");
+	const createdAt = sessionFormatCount(record["createdAt"], "released v2 header createdAt");
+	const delegationDepth = sessionFormatCount(record["delegationDepth"], "released v2 header delegationDepth");
+	if (typeof record["isSeeded"] !== "boolean") throw new SessionFormatError("released v2 header isSeeded must be boolean");
+	for (const key of [
+		"cwd",
+		"parentSession",
+		"agentPreset"
+	]) if (record[key] !== void 0 && typeof record[key] !== "string") throw new SessionFormatError(`released v2 header ${key} must be a string`);
+	if (record["origin"] !== void 0 && record["origin"] !== "subagent") throw new SessionFormatError("released v2 header origin must be \"subagent\"");
+	const header = snapshotSessionFormatJson({
+		version: 2,
+		id: record["id"],
+		createdAt,
+		...record["cwd"] === void 0 ? {} : { cwd: record["cwd"] },
+		...record["parentSession"] === void 0 ? {} : { parentSession: record["parentSession"] },
+		isSeeded: record["isSeeded"],
+		...record["origin"] === void 0 ? {} : { origin: record["origin"] },
+		delegationDepth,
+		...record["agentPreset"] === void 0 ? {} : { agentPreset: record["agentPreset"] }
+	}, "released v2 logical header");
+	assertReleasedV2Header(header);
+	return header;
+}
+function decodeArtifact(headerValue, rowValues, recoverable) {
+	const header = decodePhysicalHeader(headerValue);
+	const events = [];
+	let issue;
+	for (const [rowIndex, value] of rowValues.entries()) {
+		let event;
+		try {
+			event = decodeEvent(value, rowIndex);
+		} catch (error) {
+			const current = error instanceof SessionFormatError ? error : new SessionFormatError(`released v2 row ${rowIndex} is malformed`, { cause: error });
+			if (!recoverable) throw current;
+			issue ??= current;
+			continue;
+		}
+		if (issue !== void 0) {
+			if (event.type === "turn/end") throw issue;
+			continue;
+		}
+		if (event.seq !== events.length) {
+			const gap = new SessionFormatError(`released v2 row ${rowIndex} has seq gap (expected ${events.length}, got ${event.seq})`);
+			if (!recoverable) throw gap;
+			issue = gap;
+			if (event.type === "turn/end") throw issue;
+			continue;
+		}
+		events.push(event);
+	}
+	const artifact = snapshotSessionFormatArtifact({
+		header,
+		inheritedEventCount: deriveInheritedEventCount(header, events),
+		events
+	}, "released v2 artifact");
+	assertReleasedV2PhysicalArtifact(artifact);
+	return artifact;
+}
+function decodeEvent(value, rowIndex) {
+	const record = jsonRecord(snapshotSessionFormatJson(value, `released v2 row ${rowIndex}`), `released v2 row ${rowIndex}`);
+	if (record["sourceEventSeqs"] === void 0) return record;
+	const seq = sessionFormatCount(record["seq"], `released v2 row ${rowIndex} seq`);
+	return snapshotSessionFormatJson({
+		...record,
+		sourceEventSeqs: decodeSeqRanges(record["sourceEventSeqs"], seq)
+	}, `released v2 row ${rowIndex} provenance`);
+}
+function deriveInheritedEventCount(header, events) {
+	let cut;
+	for (const event of events) {
+		if (event.type !== "session/end-seed") continue;
+		if (jsonRecord(event.data, `session/end-seed ${event.seq} data`)["inherited"] === true) cut = event.seq;
+	}
+	if (header.isSeeded && cut === void 0) throw new SessionFormatError("released v2 seeded Session lacks an inherited end-seed marker");
+	if (!header.isSeeded && cut !== void 0) throw new SessionFormatError("released v2 unseeded Session contains an inherited end-seed marker");
+	return cut ?? 0;
+}
+function encodeArtifact(artifact) {
+	assertReleasedV2PhysicalArtifact(artifact);
+	const header = artifact.header;
+	const physicalHeader = snapshotSessionFormatJson({
+		type: "session",
+		version: 2,
+		id: header.id,
+		createdAt: header.createdAt,
+		...header.cwd === void 0 ? {} : { cwd: header.cwd },
+		...header.parentSession === void 0 ? {} : { parentSession: header.parentSession },
+		isSeeded: header.isSeeded,
+		...header.origin === void 0 ? {} : { origin: header.origin },
+		delegationDepth: header.delegationDepth,
+		...header.agentPreset === void 0 ? {} : { agentPreset: header.agentPreset }
+	}, "released v2 encoded header");
+	const rows = Object.freeze(artifact.events.map((event) => encodeProvenance(event)));
+	return Object.freeze({
+		header: physicalHeader,
+		rows
+	});
+}
+function encodeProvenance(event) {
+	if (event.sourceEventSeqs === void 0) return event;
+	return snapshotSessionFormatJson({
+		...event,
+		sourceEventSeqs: encodeSeqRanges(event.sourceEventSeqs)
+	}, `released v2 event ${event.seq} provenance`);
+}
+function decodeSeqRanges(value, maxEntries) {
+	if (!Array.isArray(value)) throw new SessionFormatError("sourceEventSeqs must be an array");
+	const output = [];
+	let hasRange = false;
+	for (const entry of value) {
+		if (!Array.isArray(entry)) {
+			output.push(sessionFormatCount(entry, "sourceEventSeqs member"));
+			continue;
+		}
+		if (entry.length !== 2) throw new SessionFormatError("sourceEventSeqs range must be a [start, end] pair");
+		const start = sessionFormatCount(entry[0], "sourceEventSeqs range start");
+		const end = sessionFormatCount(entry[1], "sourceEventSeqs range end");
+		if (start > end || end >= maxEntries || end - start + 1 > maxEntries - output.length) throw new SessionFormatError("sourceEventSeqs range exceeds its event seq");
+		for (let current = start; current <= end; current += 1) output.push(current);
+		hasRange = true;
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const source of output) {
+		if (source >= maxEntries || seen.has(source)) throw new SessionFormatError("sourceEventSeqs ranges must contain unique earlier seqs");
+		seen.add(source);
+	}
+	if (hasRange && output.some((source, index) => index > 0 && source <= output[index - 1])) throw new SessionFormatError("sourceEventSeqs ranges must be strictly increasing");
+	return output;
+}
+function encodeSeqRanges(values) {
+	if (values.some((value, index) => index > 0 && value <= values[index - 1])) return [...values];
+	const output = [];
+	for (let index = 0; index < values.length;) {
+		const start = values[index];
+		let end = start;
+		while (index + 1 < values.length && values[index + 1] === end + 1) {
+			index += 1;
+			end += 1;
+		}
+		output.push(end - start >= 2 ? [start, end] : start);
+		if (end - start === 1) output.push(end);
+		index += 1;
+	}
+	return output;
+}
+function jsonRecord(value, label) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new SessionFormatError(`${label} must be an object`);
+	return value;
+}
+function exactKeys(record, required, optional, label) {
+	const allowed = new Set([...required, ...optional]);
+	const missing = required.find((key) => !Object.hasOwn(record, key));
+	if (missing !== void 0) throw new SessionFormatError(`${label} lacks ${missing}`);
+	const unexpected = Object.keys(record).find((key) => !allowed.has(key));
+	if (unexpected !== void 0) throw new SessionFormatError(`${label} has unexpected field ${unexpected}`);
+}
+//#endregion
+//#region lib/types/migration.js
+/** Adjacent migration that embeds released-v1 top-level Assistant chunks into v2 attempt events. */
+const sessionFormatV1ToV2 = defineSessionFormatMigration({
+	name: "@xneog/dsh-session-format-v1-to-v2",
+	fromVersion: 1,
+	toVersion: 2,
+	migrateHeader(header) {
+		assertReleasedV1Header(header);
+		return {
+			...header,
+			version: 2
+		};
+	},
+	migrate(source) {
+		assertReleasedV1Artifact(source);
+		const unknown = source.events.find((event) => RELEASED_V0_EVENT_DISPOSITIONS[event.type] === void 0);
+		if (unknown !== void 0) throw refusal(`format v1 contains unknown event type ${JSON.stringify(unknown.type)} at seq ${unknown.seq}`);
+		const groups = collectAttemptGroups(source.events);
+		const groupByChunk = /* @__PURE__ */ new Map();
+		const groupByMessage = /* @__PURE__ */ new Map();
+		for (const group of groups) {
+			for (const chunk of group.chunks) groupByChunk.set(chunk.seq, group);
+			if (group.messageSeq !== void 0) groupByMessage.set(group.messageSeq, group);
+		}
+		const staged = [];
+		const oldToNew = /* @__PURE__ */ new Map();
+		for (const sourceEvent of source.events) {
+			const group = groupByChunk.get(sourceEvent.seq);
+			if (group !== void 0) {
+				if (group.messageSeq === void 0 && sourceEvent.seq === group.chunks.at(-1)?.seq) stage(staged, oldToNew, sourceEvent.seq, attemptEvent(group));
+				continue;
+			}
+			const messageGroup = groupByMessage.get(sourceEvent.seq);
+			if (messageGroup !== void 0) {
+				stage(staged, oldToNew, sourceEvent.seq, messageEvent(sourceEvent, messageGroup));
+				continue;
+			}
+			const event = source.header.isSeeded && sourceEvent.seq === source.inheritedEventCount && sourceEvent.type === "session/end-seed" ? {
+				...sourceEvent,
+				data: { inherited: true }
+			} : sourceEvent;
+			stage(staged, oldToNew, sourceEvent.seq, event);
+		}
+		const inheritedEventCount = remapInheritedCut(source, groups, staged);
+		if (source.header.isSeeded && source.events[source.inheritedEventCount]?.type !== "session/end-seed") {
+			const next = source.events[source.inheritedEventCount];
+			const previous = source.events[source.inheritedEventCount - 1];
+			staged.splice(inheritedEventCount, 0, {
+				origin: -1,
+				event: {
+					type: "session/end-seed",
+					seq: inheritedEventCount,
+					time: next?.time ?? previous?.time ?? source.header.createdAt,
+					data: { inherited: true }
+				}
+			});
+			oldToNew.clear();
+			for (const [seq, candidate] of staged.entries()) if (candidate.origin >= 0) oldToNew.set(candidate.origin, seq);
+		}
+		for (const group of groups) for (const chunk of group.chunks) oldToNew.delete(chunk.seq);
+		const target = snapshotSessionFormatArtifact({
+			header: {
+				...source.header,
+				version: 2
+			},
+			inheritedEventCount,
+			events: staged.map(({ event }, seq) => remapReferences(event, seq, oldToNew))
+		}, "released v1-to-v2 target");
+		assertReleasedV2Artifact(target);
+		return target;
+	},
+	validateTarget: assertReleasedV2Artifact,
+	validateTargetHeader: assertReleasedV2Header
+});
+function collectAttemptGroups(events) {
+	const groups = [];
+	const current = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		if (event.type === "assistant/chunk") {
+			const data = record(event.data);
+			const turn = coordinate(data["turn"]);
+			const step = coordinate(data["step"]);
+			const key = `${turn}:${step}`;
+			let group = current.get(key);
+			if (group === void 0 || group.terminal) {
+				group = {
+					turn,
+					step,
+					chunks: [],
+					terminal: false
+				};
+				groups.push(group);
+				current.set(key, group);
+			}
+			group.chunks.push(event);
+			if (record(data["chunk"])["type"] === "finish") group.terminal = true;
+			continue;
+		}
+		if (event.type !== "assistant/message") {
+			closeAttemptAtBoundary(event, current);
+			continue;
+		}
+		const data = record(event.data);
+		const turn = coordinate(data["turn"]);
+		const step = coordinate(data["step"]);
+		const sources = event.sourceEventSeqs;
+		if (!Array.isArray(sources)) {
+			if (groups.some((candidate) => candidate.messageSeq === void 0 && candidate.turn === turn && candidate.step === step)) throw refusal(`assistant/message ${event.seq} does not cite its complete v1 chunk attempt`);
+			groups.push({
+				turn,
+				step,
+				chunks: [],
+				terminal: true,
+				messageSeq: event.seq
+			});
+			continue;
+		}
+		if (sources.length === 0) {
+			groups.push({
+				turn,
+				step,
+				chunks: [],
+				terminal: true,
+				messageSeq: event.seq
+			});
+			continue;
+		}
+		const group = groups.find((candidate) => candidate.messageSeq === void 0 && candidate.turn === turn && candidate.step === step && sameNumbers(candidate.chunks.map((chunk) => chunk.seq), sources));
+		if (group === void 0) throw refusal(`assistant/message ${event.seq} chunk provenance is not one complete ordered attempt`);
+		group.messageSeq = event.seq;
+		group.terminal = true;
+	}
+	return groups;
+}
+function closeAttemptAtBoundary(event, current) {
+	if (event.type === "turn/end") {
+		const turn = coordinate(record(event.data)["turn"]);
+		for (const group of current.values()) if (group.turn === turn) group.terminal = true;
+		return;
+	}
+	if (event.type !== "step/end" && event.type !== "llm/retry" && event.type !== "llm/retry-started") return;
+	const data = record(event.data);
+	const turn = coordinate(data["turn"]);
+	const step = coordinate(data["step"]);
+	const group = current.get(`${turn}:${step}`);
+	if (group !== void 0) group.terminal = true;
+}
+function streamOf(group) {
+	const accumulator = new AssistantStreamAccumulator();
+	for (const event of group.chunks) {
+		const data = record(event.data);
+		accumulator.push({
+			time: event.time,
+			chunk: data["chunk"]
+		});
+	}
+	return accumulator.snapshot();
+}
+function messageEvent(source, group) {
+	const data = record(source.data);
+	const { sourceEventSeqs: _sourceEventSeqs, ...event } = source;
+	return {
+		...event,
+		data: {
+			...data,
+			stream: streamOf(group)
+		}
+	};
+}
+function attemptEvent(group) {
+	const last = group.chunks.at(-1);
+	return {
+		type: "assistant/attempt",
+		seq: last.seq,
+		time: last.time,
+		data: {
+			turn: group.turn,
+			step: group.step,
+			stream: streamOf(group)
+		}
+	};
+}
+function stage(staged, oldToNew, origin, event) {
+	oldToNew.set(origin, staged.length);
+	staged.push({
+		origin,
+		event
+	});
+}
+function remapInheritedCut(source, groups, staged) {
+	const cut = source.inheritedEventCount;
+	for (const group of groups) {
+		const members = group.messageSeq === void 0 ? group.chunks.map((chunk) => chunk.seq) : [...group.chunks.map((chunk) => chunk.seq), group.messageSeq];
+		const before = members.some((seq) => seq < cut);
+		const after = members.some((seq) => seq >= cut);
+		if (before && after) throw refusal(`inherited Session cut ${cut} splits one Assistant attempt`);
+	}
+	return staged.filter((candidate) => candidate.origin < cut).length;
+}
+function remapReferences(source, targetSeq, mapping) {
+	const { sourceEventSeqs, surfaceOp, ...event } = source;
+	const sources = sourceEventSeqs === void 0 ? {} : { sourceEventSeqs: mapList(numberArray(sourceEventSeqs), mapping, `${source.type} ${source.seq} sources`) };
+	let operation = surfaceOp;
+	if (surfaceOp !== void 0 && surfaceOp !== "append") {
+		const replacement = record(surfaceOp);
+		operation = {
+			op: "replace",
+			start: mapOne(coordinate(replacement["start"]), mapping, `${source.type} ${source.seq} surface start`),
+			end: mapOne(coordinate(replacement["end"]), mapping, `${source.type} ${source.seq} surface end`)
+		};
+	}
+	return {
+		...event,
+		seq: targetSeq,
+		data: remapPayloadReferences(source, mapping),
+		...sources,
+		...operation === void 0 ? {} : { surfaceOp: operation }
+	};
+}
+function remapPayloadReferences(event, mapping) {
+	const data = record(event.data);
+	switch (event.type) {
+		case "command/done": return data["sourceEventSeq"] === void 0 ? data : {
+			...data,
+			sourceEventSeq: mapOne(coordinate(data["sourceEventSeq"]), mapping, `command/done ${event.seq} sourceEventSeq`)
+		};
+		case "compaction/prune":
+		case "compaction/summary": {
+			const range = record(data["shadowedRange"]);
+			return {
+				...data,
+				shadowedRange: {
+					start: mapOne(coordinate(range["start"]), mapping, `${event.type} ${event.seq} shadowedRange start`),
+					end: mapOne(coordinate(range["end"]), mapping, `${event.type} ${event.seq} shadowedRange end`)
+				},
+				shadowedSeqs: mapList(numberArray(data["shadowedSeqs"]), mapping, `${event.type} ${event.seq} shadowedSeqs`)
+			};
+		}
+		case "session/title":
+		case "session/title-llm-request": return {
+			...data,
+			messageSeqs: mapList(numberArray(data["messageSeqs"]), mapping, `${event.type} ${event.seq} messageSeqs`)
+		};
+		default: return data;
+	}
+}
+function mapList(values, mapping, label) {
+	return values.map((value) => mapOne(value, mapping, label));
+}
+function mapOne(value, mapping, label) {
+	const mapped = mapping.get(value);
+	if (mapped === void 0) throw refusal(`${label} targets consumed assistant/chunk ${value}`);
+	return mapped;
+}
+function record(value) {
+	return value;
+}
+function numberArray(value) {
+	return value;
+}
+function coordinate(value) {
+	return value;
+}
+function sameNumbers(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function refusal(message) {
+	return new SessionFormatUnsupportedMigrationError(message);
+}
+//#endregion
+export { RELEASED_V2_EVENT_DISPOSITIONS, RELEASED_V2_EVENT_TYPES, assertReleasedV2Artifact, assertReleasedV2Header, assertReleasedV2PhysicalArtifact, releasedV1SessionFormatCodec, releasedV2SessionFormatCodec, restoreReleasedV2Artifact, sessionFormatV1ToV2 };

package/lib/types/codec.d.ts

@@ -0,0 +1,10 @@
+import type { EncodedSessionFormatArtifact, SessionFormatArtifact, SessionFormatHeader } from '@xneog/dsh-session-format';
+/** Frozen physical JSON codec for released v2. */
+export declare const releasedV2SessionFormatCodec: Readonly<{
+    version: number;
+    decodeHeader(value: unknown): SessionFormatHeader;
+    decodeArtifact(headerValue: unknown, rowValues: readonly unknown[]): SessionFormatArtifact;
+    decodeRecoverableArtifact(headerValue: unknown, rowValues: readonly unknown[]): SessionFormatArtifact;
+    encodeArtifact(artifact: SessionFormatArtifact): EncodedSessionFormatArtifact;
+}>;
+//# sourceMappingURL=codec.d.ts.map

package/lib/types/dispositions.d.ts

@@ -0,0 +1,6 @@
+import { type ReleasedV0PayloadDisposition } from '@xneog/dsh-session-format-v0-to-v1';
+/** Exact top-level event and payload-member inventory frozen for released v2. */
+export declare const RELEASED_V2_EVENT_DISPOSITIONS: Readonly<Record<string, ReleasedV0PayloadDisposition>>;
+/** Stable sorted released-v2 event inventory. */
+export declare const RELEASED_V2_EVENT_TYPES: readonly string[];
+//# sourceMappingURL=dispositions.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,7 @@
+/** Frozen released-v1 physical codec and assistant-stream migration into v2. */
+export { releasedV1SessionFormatCodec } from '@xneog/dsh-session-format-v0-to-v1';
+export * from './codec.ts';
+export * from './dispositions.ts';
+export * from './migration.ts';
+export * from './validation.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/migration.d.ts

@@ -0,0 +1,3 @@
+/** Adjacent migration that embeds released-v1 top-level Assistant chunks into v2 attempt events. */
+export declare const sessionFormatV1ToV2: import("@xneog/dsh-session-format").SessionFormatMigration;
+//# sourceMappingURL=migration.d.ts.map

package/lib/types/validation.d.ts

@@ -0,0 +1,28 @@
+import type { SessionFormatArtifact, SessionFormatHeader } from '@xneog/dsh-session-format';
+/**
+ * Validate the exact logical header written by released v2.
+ * @param header - decoded released-v2 Session header.
+ * @throws {SessionFormatError} when the header is not an exact released-v2 value.
+ */
+export declare function assertReleasedV2Header(header: SessionFormatHeader): void;
+/**
+ * Validate the exact logical image emitted by the released v2 writer.
+ * @param artifact - complete decoded released-v2 Session artifact.
+ * @throws {SessionFormatError} when an envelope, payload, relationship, or inherited cut is invalid.
+ * @throws {SessionFormatUnsupportedMigrationError} when the artifact contains an unknown event type.
+ */
+export declare function assertReleasedV2Artifact(artifact: SessionFormatArtifact): void;
+/**
+ * Validate only the released-v2 physical header, event envelopes, and inherited cut.
+ * Event vocabulary and payload semantics belong to target or installed-current restoration.
+ * @param artifact - complete physical-codec output.
+ */
+export declare function assertReleasedV2PhysicalArtifact(artifact: SessionFormatArtifact): void;
+/**
+ * Restore and validate one decoded released-v2 artifact.
+ * @param artifact - detached vocabulary-restored artifact.
+ * @param knownEventTypes - event types understood by the installed current Session package.
+ * @returns the same validated artifact.
+ */
+export declare function restoreReleasedV2Artifact(artifact: SessionFormatArtifact, knownEventTypes: ReadonlySet<string>): SessionFormatArtifact;
+//# sourceMappingURL=validation.d.ts.map

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@xneog/dsh-session-format-v1-to-v2",
+  "description": "Frozen released-v1 Session codec and assistant-stream migration to v2",
+  "version": "0.1.3-alpha.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gomes007-alt/xneog-harness.git",
+    "directory": "packages/session/session-format-v1-to-v2"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "dsh": {
+    "sessionFormatMigration": {
+      "from": 1,
+      "to": 2,
+      "export": ".",
+      "migration": "sessionFormatV1ToV2",
+      "sourceCodec": "releasedV1SessionFormatCodec",
+      "targetCodec": "releasedV2SessionFormatCodec",
+      "targetHeaderValidator": "assertReleasedV2Header",
+      "targetRestorer": "restoreReleasedV2Artifact"
+    }
+  },
+  "dependencies": {
+    "@xneog/dsh-llm": "^0.1.3-alpha.1",
+    "@xneog/dsh-session-format-v0-to-v1": "^0.1.3-alpha.1",
+    "@xneog/dsh-util-values": "^0.1.3-alpha.1",
+    "@xneog/dsh-session-format": "^0.1.3-alpha.1"
+  },
+  "peerDependencies": {
+    "@xneog/cordis": "^4.0.2"
+  },
+  "devDependencies": {
+    "@xneog/cordis": "^4.0.2",
+    "@xneog/dsh-session": "^0.1.3-alpha.1"
+  }
+}