@x1a0f3n9/dsh-session-persistence-jsonl 0.1.7-rc.2 → 0.1.7-rc.3

package/lib/index.js

@@ -7,10 +7,10 @@ import { performance } from "node:perf_hooks";
 import { scheduler } from "node:timers/promises";
 import { createHash, randomBytes } from "node:crypto";
 import { SessionAlreadyExistsError, SessionAlreadyOwnedError, SessionFormatUnsupportedError, SessionHandleClosedError, SessionPersistence, SessionPersistenceCorruptionError, SessionPersistenceNotFoundError, SessionPersistenceRevision, SessionReadOnlyError, assertContiguous, assertStoredId, materializeAppendBatch, materializeCreateHeader, sessionFormatVersionRefusal, validateStoredEvents } from "@x1a0f3n9/dsh-session-persistence";
-import { AssistantStreamAccumulator, BlockAssembler, errorChain, expandAssistantStream } from "@x1a0f3n9/dsh-llm";
+import { BlockAssembler, errorChain, expandAssistantStream } from "@x1a0f3n9/dsh-llm";
 import { tryLockExclusive } from "@deepseek-ai/node-addon-system/flock";
 import { KNOWN_SESSION_EVENT_TYPES, SESSION_FORMAT_VERSION, Session, SessionId, SessionLogOffset, SessionSeq, decodeSeqRanges, interruptedTurnClosers, isAppendSurfaceEvent } from "@x1a0f3n9/dsh-session";
-import { SessionFormatError, SessionFormatUnsupportedMigrationError as SessionFormatUnsupportedMigrationError$1, defineSessionFormatMigration, isSessionFormatJsonObject, parseSessionFormatLogFilename, sessionFormatCount, sessionFormatLogFilename, sessionFormatSafeInteger, snapshotSessionFormatJson } from "@x1a0f3n9/dsh-session-format";
+import { SessionFormatError, SessionFormatUnsupportedMigrationError as SessionFormatUnsupportedMigrationError$1, parseSessionFormatLogFilename, sessionFormatLogFilename } from "@x1a0f3n9/dsh-session-format";
 import { assertReleasedV4Relationships, assertV4RowAdmission, historicalChildCatalogSource } from "@x1a0f3n9/dsh-session-format-v3-to-v4";
 import { constants, createZstdCompress, createZstdDecompress, zstdCompress, zstdDecompress, zstdDecompressSync } from "node:zlib";
 import { isDeepStrictEqual, promisify } from "node:util";
@@ -1514,3877 +1514,6 @@ async function scanZstdFramesFromReader(fileSize, readRange, signal) {
 	return { frames };
 }
 //#endregion
-//#region ../../util/values/src/index.ts
-/** Whether a realm-owned intrinsic prototype is backed by its native constructor. */
-function hasIntrinsicConstructor(prototype, name) {
-	const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
-	if (typeof constructor !== "function") return false;
-	try {
-		return constructor.name === name && constructor.prototype === prototype && Function.prototype.toString.call(constructor) === `function ${name}() { [native code] }`;
-	} catch {
-		return false;
-	}
-}
-/** Whether a candidate is one realm's intrinsic `Object.prototype`. */
-function isIntrinsicObjectPrototype(value) {
-	return Object.getPrototypeOf(value) === null && hasIntrinsicConstructor(value, "Object");
-}
-/** Whether an array uses one realm's intrinsic `Array.prototype`, not a subclass or forged prototype. */
-function hasPlainArrayPrototype(value) {
-	const prototype = Object.getPrototypeOf(value);
-	if (!Array.isArray(prototype) || !hasIntrinsicConstructor(prototype, "Array")) return false;
-	const objectPrototype = Object.getPrototypeOf(prototype);
-	return typeof objectPrototype === "object" && objectPrototype !== null && isIntrinsicObjectPrototype(objectPrototype);
-}
-/** Whether an object is a plain or null-prototype record from any JavaScript realm. */
-function hasPlainObjectPrototype(value) {
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || typeof prototype === "object" && isIntrinsicObjectPrototype(prototype);
-}
-/** Return every JSON-visible object key, or reject own data JSON would discard. */
-function enumerableStringKeys(value) {
-	const keys = Reflect.ownKeys(value);
-	if (keys.some((key) => typeof key !== "string" || !Object.prototype.propertyIsEnumerable.call(value, key))) return void 0;
-	return keys;
-}
-/** Validate lossless JSON iteratively, optionally materializing a detached snapshot. */
-function walkJsonValue(value, detach) {
-	const ancestors = /* @__PURE__ */ new Set();
-	let root;
-	const assign = (destination, item) => {
-		if (destination === void 0) return;
-		if (destination.kind === "root") root = item;
-		else if (destination.kind === "array") destination.target[destination.index] = item;
-		else Object.defineProperty(destination.target, destination.key, {
-			value: item,
-			enumerable: true,
-			configurable: true,
-			writable: true
-		});
-	};
-	const tasks = [{
-		kind: "visit",
-		value,
-		...detach ? { destination: { kind: "root" } } : {}
-	}];
-	for (let task = tasks.pop(); task !== void 0; task = tasks.pop()) {
-		if (task.kind === "leave") {
-			ancestors.delete(task.source);
-			continue;
-		}
-		if (task.kind === "array-item") {
-			if (!Object.prototype.hasOwnProperty.call(task.source, task.index)) return void 0;
-			tasks.push({
-				kind: "visit",
-				value: task.source[task.index],
-				...task.target === void 0 ? {} : { destination: {
-					kind: "array",
-					target: task.target,
-					index: task.index
-				} }
-			});
-			continue;
-		}
-		if (task.kind === "object-property") {
-			tasks.push({
-				kind: "visit",
-				value: task.source[task.key],
-				...task.target === void 0 ? {} : { destination: {
-					kind: "object",
-					target: task.target,
-					key: task.key
-				} }
-			});
-			continue;
-		}
-		const current = task.value;
-		if (current === null) {
-			assign(task.destination, null);
-			continue;
-		}
-		if (typeof current === "boolean" || typeof current === "string") {
-			assign(task.destination, current);
-			continue;
-		}
-		if (typeof current === "number") {
-			if (!Number.isFinite(current) || Object.is(current, -0)) return void 0;
-			assign(task.destination, current);
-			continue;
-		}
-		if (typeof current !== "object") return void 0;
-		if (ancestors.has(current)) return void 0;
-		if (Array.isArray(current)) {
-			if (!hasPlainArrayPrototype(current)) return void 0;
-			const length = current.length;
-			if (Reflect.ownKeys(current).length !== length + 1) return void 0;
-			const target = detach ? [] : void 0;
-			if (target !== void 0) assign(task.destination, target);
-			ancestors.add(current);
-			tasks.push({
-				kind: "leave",
-				source: current
-			});
-			for (let index = length - 1; index >= 0; index--) tasks.push({
-				kind: "array-item",
-				source: current,
-				index,
-				...target === void 0 ? {} : { target }
-			});
-			continue;
-		}
-		if (!hasPlainObjectPrototype(current)) return void 0;
-		const keys = enumerableStringKeys(current);
-		if (keys === void 0) return void 0;
-		const target = detach ? {} : void 0;
-		if (target !== void 0) assign(task.destination, target);
-		ancestors.add(current);
-		tasks.push({
-			kind: "leave",
-			source: current
-		});
-		for (let index = keys.length - 1; index >= 0; index--) {
-			const key = keys[index];
-			/* v8 ignore next -- the loop is bounded by the captured key count. */
-			if (key === void 0) return void 0;
-			tasks.push({
-				kind: "object-property",
-				source: current,
-				key,
-				...target === void 0 ? {} : { target }
-			});
-		}
-	}
-	return detach ? root : true;
-}
-/**
-* Test the same lossless JSON rules as {@link snapshotJsonValue} without detaching the value.
-* @param value - candidate value to test.
-* @returns whether the value survives a JSON round trip without loss.
-*/
-function isJsonValue(value) {
-	return walkJsonValue(value, false) === true;
-}
-/**
-* Compare JSON-compatible values structurally.
-* @param a - one JSON-compatible value.
-* @param b - the other JSON-compatible value.
-* @returns whether both values contain the same JSON data.
-*/
-function deepEqualJson(a, b) {
-	if (a === b) return true;
-	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
-	if (Array.isArray(a) || Array.isArray(b)) {
-		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
-		return a.every((entry, index) => deepEqualJson(entry, b[index]));
-	}
-	const left = a;
-	const right = b;
-	const keys = Object.keys(left);
-	if (keys.length !== Object.keys(right).length) return false;
-	return keys.every((key) => key in right && deepEqualJson(left[key], right[key]));
-}
-//#endregion
-//#region ../session-format-v0-to-v1/src/dispositions.ts
-/**
-* Freeze one exact released payload-member disposition for adjacent format validators.
-* @param required - members that must be present.
-* @param optional - additional admitted members.
-* @param opaque - members retained as lossless JSON without nested semantic inspection.
-* @returns the detached frozen disposition.
-*/
-function defineReleasedPayloadDisposition(required, optional = [], opaque = []) {
-	return Object.freeze({
-		required: Object.freeze([...required]),
-		optional: Object.freeze([...optional]),
-		opaque: Object.freeze([...opaque])
-	});
-}
-const disposition = defineReleasedPayloadDisposition;
-/**
-* Frozen released-v0 event and payload-member inventory.
-* Every listed member is preserved by the identity edge. Members in `opaque`
-* remain lossless JSON without nested Session-sequence interpretation. Nested
-* merge-extensible discriminants validate known variants and preserve
-* unknown variants as owner-opaque JSON.
-*/
-const RELEASED_V0_EVENT_DISPOSITIONS = Object.freeze({
-	"agent-preset/selected": disposition(["agentPreset"]),
-	"agent/inbox/spliced": disposition([
-		"target",
-		"start",
-		"inserted"
-	], ["removedCount", "outcome"]),
-	"approval/asked": disposition(["id", "toolName"], ["callId", "reason"]),
-	"approval/decided": disposition(["id", "outcome"]),
-	"approval/policy": disposition(["policy"], ["source"]),
-	"assistant/chunk": disposition([
-		"turn",
-		"step",
-		"chunk"
-	]),
-	"assistant/message": disposition([
-		"turn",
-		"step",
-		"message"
-	], ["usage", "interrupted"]),
-	"command/done": disposition(["commandId", "kind"], ["text", "sourceEventSeq"]),
-	"command/run": disposition([
-		"commandId",
-		"name",
-		"source"
-	], ["args"]),
-	"compaction/end": disposition(["compactionId", "turn"], ["sourceCommandId", "error"]),
-	"compaction/prune": disposition([
-		"shadowedRange",
-		"shadowedSeqs",
-		"shadowedTokenCount"
-	]),
-	"compaction/start": disposition(["compactionId", "turn"], ["sourceCommandId"]),
-	"compaction/summary": disposition([
-		"compactionId",
-		"summary",
-		"shadowedRange",
-		"shadowedSeqs",
-		"shadowedTokenCount",
-		"provider",
-		"model"
-	], [
-		"sourceCommandId",
-		"maxTokens",
-		"usage",
-		"rawOutput",
-		"llmStreamCall"
-	]),
-	"feedback/record": disposition(["text"]),
-	"goal/change": disposition([
-		"kind",
-		"version",
-		"operation"
-	], [
-		"goal",
-		"roundsStarted",
-		"createdAt",
-		"updatedAt",
-		"cleared",
-		"clearedAt"
-	]),
-	"hook/invoked": disposition([
-		"turn",
-		"point",
-		"dialect",
-		"handlerId"
-	], ["matcher"]),
-	"hook/result": disposition([
-		"turn",
-		"point",
-		"handlerId",
-		"decision",
-		"durationMs"
-	], ["exitCode", "stderrSummary"]),
-	"llm/retry": disposition([
-		"retryId",
-		"turn",
-		"step",
-		"provider",
-		"mode",
-		"policyKey",
-		"retry",
-		"delayMs",
-		"failure"
-	], ["maxRetries"]),
-	"llm/retry-started": disposition([
-		"retryId",
-		"turn",
-		"step",
-		"retry"
-	]),
-	"model/selection": disposition(["provider", "model"], ["reasoningEffort"]),
-	"permission/preset": disposition(["preset"]),
-	"plan/mode": disposition(["active"]),
-	"request/context": disposition(["provider", "model"], ["contextWindow"]),
-	"request/header": disposition(["header", "reason"], ["startsSeries"]),
-	"sandbox/mode": disposition(["mode"], ["source"]),
-	"schedule/change": disposition(["version", "operation"], [
-		"schedule",
-		"id",
-		"acceptedAt"
-	]),
-	"session-log-deepseek/delivery-accepted": disposition(["sessionId", "throughSeq"]),
-	"session/end-seed": disposition([]),
-	"session/title": disposition([
-		"title",
-		"messageSeqs",
-		"source"
-	]),
-	"session/title-llm-request": disposition([
-		"titleProvider",
-		"messageSeqs",
-		"route",
-		"system",
-		"messages",
-		"maxTokens"
-	]),
-	"step/end": disposition(["turn", "step"]),
-	"step/start": disposition(["turn", "step"]),
-	"subagent/descriptor": disposition([
-		"mode",
-		"version",
-		"provider"
-	], [
-		"label",
-		"agentProvider",
-		"agentModel",
-		"agentReasoningEffort",
-		"persona",
-		"toolFilter"
-	]),
-	"subagent/model-selection-policy": disposition(["allowedModels"]),
-	"team/member": disposition([
-		"version",
-		"teamId",
-		"member"
-	]),
-	"team/message/delivered": disposition([
-		"version",
-		"teamId",
-		"messageId",
-		"targetId"
-	]),
-	"team/message/queued": disposition([
-		"version",
-		"teamId",
-		"message"
-	]),
-	"team/task": disposition([
-		"version",
-		"teamId",
-		"task"
-	]),
-	"todo/write": disposition(["todos"]),
-	"tool-workflow/agent-end": disposition([
-		"runId",
-		"seq",
-		"outcome"
-	]),
-	"tool-workflow/agent-start": disposition([
-		"runId",
-		"seq",
-		"label",
-		"childId"
-	], ["phase"]),
-	"tool-workflow/run-end": disposition(["runId", "stopReason"]),
-	"tool-workflow/run-start": disposition(["runId", "name"]),
-	"tool/call": disposition([
-		"turn",
-		"step",
-		"callId",
-		"name",
-		"arguments"
-	]),
-	"tool/code-dispatch": disposition([
-		"rootCallId",
-		"parentCallId",
-		"subCallId",
-		"name",
-		"arguments",
-		"isError",
-		"content"
-	], [], ["arguments"]),
-	"tool/code-dispatch-start": disposition([
-		"rootCallId",
-		"parentCallId",
-		"subCallId",
-		"name",
-		"arguments"
-	], [], ["arguments"]),
-	"tool/result": disposition([
-		"turn",
-		"step",
-		"message"
-	], ["error", "meta"], ["meta"]),
-	"turn/end": disposition(["turn", "reason"]),
-	"turn/start": disposition(["turn"]),
-	"user/message": disposition([
-		"role",
-		"id",
-		"content",
-		"source"
-	]),
-	"web/deepseek-search-llm-request": disposition([
-		"endpoint",
-		"apiVersion",
-		"body"
-	])
-});
-Object.freeze(Object.keys(RELEASED_V0_EVENT_DISPOSITIONS).sort((left, right) => left.localeCompare(right, "en")));
-//#endregion
-//#region ../session-format-v0-to-v1/src/validation-helpers.ts
-/**
-* Require one plain JSON object.
-* @param value - candidate JSON value.
-* @param label - diagnostic subject.
-* @returns validated object record.
-*/
-function releasedV0Record(value, label) {
-	if (!isSessionFormatJsonObject(value)) throw new SessionFormatError(`${label} must be a JSON object`);
-	return value;
-}
-/**
-* Require every named member and no member outside the optional list.
-* @param record - candidate object.
-* @param required - members that must exist.
-* @param optional - additional admitted members.
-* @param label - diagnostic subject.
-*/
-function assertReleasedV0Keys(record, required, optional = [], label) {
-	const allowed = new Set([...required, ...optional]);
-	const unexpected = Object.keys(record).find((key) => !allowed.has(key));
-	if (unexpected !== void 0) throw new SessionFormatError(`${label} has unexpected member ${JSON.stringify(unexpected)}`);
-	const missing = required.find((key) => !Object.hasOwn(record, key));
-	if (missing !== void 0) throw new SessionFormatError(`${label} lacks required member ${JSON.stringify(missing)}`);
-}
-//#endregion
-//#region ../session-format-v0-to-v1/src/payload-validation.ts
-/**
-* Validate nested released payload semantics for one known event.
-* @param event - known event with exact top-level members.
-* @param version - source or current payload generation.
-*/
-function assertReleasedPayloadSemantics(event, version) {
-	const data = releasedV0Record(event.data, `${event.type} ${event.seq} data`);
-	const label = `${event.type} ${event.seq}`;
-	switch (event.type) {
-		case "agent-preset/selected":
-			stringValue(data["agentPreset"], `${label} agentPreset`);
-			return;
-		case "agent/inbox/spliced":
-			literalValue(data["target"], ["next-turn", "next-step"], `${label} target`);
-			countValue(data["start"], `${label} start`);
-			if (data["removedCount"] !== void 0) countValue(data["removedCount"], `${label} removedCount`);
-			arrayValue(data["inserted"], `${label} inserted`, (value) => {
-				messageValue(value, `${label} inserted message`, version, "user");
-			});
-			if (data["outcome"] !== void 0) literalValue(data["outcome"], ["canceled"], `${label} outcome`);
-			return;
-		case "approval/asked":
-			nonEmptyString(data["id"], `${label} id`);
-			nonEmptyString(data["toolName"], `${label} toolName`);
-			if (data["callId"] !== void 0) nonEmptyString(data["callId"], `${label} callId`);
-			if (data["reason"] !== void 0) stringValue(data["reason"], `${label} reason`);
-			return;
-		case "approval/decided":
-			nonEmptyString(data["id"], `${label} id`);
-			literalValue(data["outcome"], [
-				"allowed-once",
-				"rejected",
-				"cancelled",
-				"unavailable"
-			], `${label} outcome`);
-			return;
-		case "approval/policy":
-			literalValue(data["policy"], ["ask", "never"], `${label} policy`);
-			if (data["source"] !== void 0) literalValue(data["source"], ["delegation"], `${label} source`);
-			return;
-		case "assistant/chunk":
-			coordinatePair(data, label);
-			streamChunkValue(data["chunk"], `${label} chunk`);
-			return;
-		case "assistant/message":
-			coordinatePair(data, label);
-			messageValue(data["message"], `${label} message`, version, "assistant");
-			if (data["usage"] !== void 0) tokenUsageValue(data["usage"], `${label} usage`);
-			if (data["interrupted"] !== void 0) literalValue(data["interrupted"], [true], `${label} interrupted`);
-			return;
-		case "command/done":
-			nonEmptyString(data["commandId"], `${label} commandId`);
-			literalValue(data["kind"], ["success", "error"], `${label} kind`);
-			if (data["text"] !== void 0) stringValue(data["text"], `${label} text`);
-			if (data["sourceEventSeq"] !== void 0) earlierSeq(data["sourceEventSeq"], event.seq, `${label} sourceEventSeq`);
-			return;
-		case "command/run":
-			nonEmptyString(data["commandId"], `${label} commandId`);
-			nonEmptyString(data["name"], `${label} name`);
-			if (data["args"] !== void 0) stringValue(data["args"], `${label} args`);
-			literalValue(exactRecord(data["source"], `${label} source`, ["kind"])["kind"], ["user"], `${label} source kind`);
-			return;
-		case "compaction/start":
-		case "compaction/end":
-			nonEmptyString(data["compactionId"], `${label} compactionId`);
-			if (data["sourceCommandId"] !== void 0) nonEmptyString(data["sourceCommandId"], `${label} sourceCommandId`);
-			nullableValue(data["turn"], `${label} turn`, countValue);
-			if (data["error"] !== void 0) stringValue(data["error"], `${label} error`);
-			return;
-		case "compaction/prune":
-			shadowedValue(data, event.seq, label);
-			return;
-		case "compaction/summary":
-			if (data["llmStreamCall"] === true && data["rawOutput"] === void 0) throw new SessionFormatError(`${label} llmStreamCall requires rawOutput`);
-			nonEmptyString(data["compactionId"], `${label} compactionId`);
-			if (data["sourceCommandId"] !== void 0) nonEmptyString(data["sourceCommandId"], `${label} sourceCommandId`);
-			contentBlocksValue(data["summary"], `${label} summary`, version);
-			shadowedValue(data, event.seq, label);
-			nonEmptyString(data["provider"], `${label} provider`);
-			nonEmptyString(data["model"], `${label} model`);
-			if (data["maxTokens"] !== void 0) countValue(data["maxTokens"], `${label} maxTokens`);
-			if (data["usage"] !== void 0) tokenUsageValue(data["usage"], `${label} usage`);
-			if (data["rawOutput"] !== void 0) contentBlocksValue(data["rawOutput"], `${label} rawOutput`, version);
-			if (data["llmStreamCall"] !== void 0) literalValue(data["llmStreamCall"], [true], `${label} llmStreamCall`);
-			return;
-		case "feedback/record":
-			nonEmptyString(data["text"], `${label} text`);
-			return;
-		case "goal/change":
-			goalChangeValue(data, label);
-			return;
-		case "hook/invoked":
-			countValue(data["turn"], `${label} turn`);
-			nonEmptyString(data["point"], `${label} point`);
-			literalValue(data["dialect"], ["claude-code", "codex"], `${label} dialect`);
-			if (data["matcher"] !== void 0) stringValue(data["matcher"], `${label} matcher`);
-			nonEmptyString(data["handlerId"], `${label} handlerId`);
-			return;
-		case "hook/result":
-			countValue(data["turn"], `${label} turn`);
-			nonEmptyString(data["point"], `${label} point`);
-			nonEmptyString(data["handlerId"], `${label} handlerId`);
-			nonEmptyString(data["decision"], `${label} decision`);
-			if (data["exitCode"] !== void 0) safeIntegerValue(data["exitCode"], `${label} exitCode`);
-			if (data["stderrSummary"] !== void 0) stringValue(data["stderrSummary"], `${label} stderrSummary`);
-			if (finiteNumberValue(data["durationMs"], `${label} durationMs`) < 0) throw new SessionFormatError(`${label} durationMs must be non-negative`);
-			return;
-		case "llm/retry":
-			nonEmptyString(data["retryId"], `${label} retryId`);
-			coordinatePair(data, label);
-			nonEmptyString(data["provider"], `${label} provider`);
-			literalValue(data["mode"], ["normal", "always"], `${label} mode`);
-			nonEmptyString(data["policyKey"], `${label} policyKey`);
-			positiveIntegerValue(data["retry"], `${label} retry`);
-			if (data["mode"] === "normal") {
-				const maxRetries = positiveIntegerValue(data["maxRetries"], `${label} maxRetries`);
-				if (data["retry"] > maxRetries) throw new SessionFormatError(`${label} retry exceeds maxRetries`);
-			} else if (data["maxRetries"] !== void 0) throw new SessionFormatError(`${label} always mode must omit maxRetries`);
-			const delayMs = finiteNumberValue(data["delayMs"], `${label} delayMs`);
-			if (delayMs < 0) throw new SessionFormatError(`${label} delayMs must be non-negative`);
-			if (delayMs > 2147483647) throw new SessionFormatError(`${label} delayMs exceeds the timer range`);
-			llmFailureValue(data["failure"], `${label} failure`);
-			return;
-		case "llm/retry-started":
-			nonEmptyString(data["retryId"], `${label} retryId`);
-			coordinatePair(data, label);
-			positiveIntegerValue(data["retry"], `${label} retry`);
-			return;
-		case "model/selection":
-			nonEmptyString(data["provider"], `${label} provider`);
-			nonEmptyString(data["model"], `${label} model`);
-			if (data["reasoningEffort"] !== void 0) nonEmptyString(data["reasoningEffort"], `${label} reasoningEffort`);
-			return;
-		case "permission/preset":
-			nonEmptyString(data["preset"], `${label} preset`);
-			return;
-		case "plan/mode":
-			booleanValue(data["active"], `${label} active`);
-			return;
-		case "request/context":
-			nonEmptyString(data["provider"], `${label} provider`);
-			nonEmptyString(data["model"], `${label} model`);
-			if (data["contextWindow"] !== void 0) positiveIntegerValue(data["contextWindow"], `${label} contextWindow`);
-			return;
-		case "request/header":
-			requestHeaderValue(data["header"], `${label} header`);
-			literalValue(data["reason"], [
-				"initial",
-				"resume",
-				"change",
-				"series"
-			], `${label} reason`);
-			if (data["startsSeries"] !== void 0) literalValue(data["startsSeries"], [true], `${label} startsSeries`);
-			return;
-		case "sandbox/mode":
-			literalValue(data["mode"], [
-				"read-only",
-				"workspace-write",
-				"danger-full-access"
-			], `${label} mode`);
-			if (data["source"] !== void 0) literalValue(data["source"], ["delegation"], `${label} source`);
-			return;
-		case "schedule/change":
-			scheduleChangeValue(data, label);
-			return;
-		case "session-log-deepseek/delivery-accepted":
-			if ((data["sessionFormatVersion"] === void 0 ? 0 : countValue(data["sessionFormatVersion"], `${label} sessionFormatVersion`)) !== version) return;
-			nonEmptyString(data["sessionId"], `${label} sessionId`);
-			earlierSeq(data["throughSeq"], event.seq, `${label} throughSeq`);
-			return;
-		case "session/end-seed": return;
-		case "session/title":
-			nonEmptyString(data["title"], `${label} title`);
-			seqArray(data["messageSeqs"], event.seq, `${label} messageSeqs`, false);
-			titleSourceValue(data["source"], `${label} source`);
-			return;
-		case "session/title-llm-request":
-			nonEmptyString(data["titleProvider"], `${label} titleProvider`);
-			seqArray(data["messageSeqs"], event.seq, `${label} messageSeqs`, true);
-			modelRouteValue(data["route"], `${label} route`);
-			stringValue(data["system"], `${label} system`);
-			arrayValue(data["messages"], `${label} messages`, (value) => {
-				messageValue(value, `${label} message`, version);
-			});
-			positiveIntegerValue(data["maxTokens"], `${label} maxTokens`);
-			return;
-		case "step/end":
-		case "step/start":
-			coordinatePair(data, label);
-			return;
-		case "subagent/descriptor":
-			subagentDescriptorValue(data, label);
-			return;
-		case "subagent/model-selection-policy":
-			allowedModelsValue(data["allowedModels"], `${label} allowedModels`);
-			return;
-		case "team/member":
-			teamSelector(data, label);
-			teamMemberValue(data["member"], `${label} member`);
-			return;
-		case "team/message/delivered":
-			teamSelector(data, label);
-			nonEmptyString(data["messageId"], `${label} messageId`);
-			nonEmptyString(data["targetId"], `${label} targetId`);
-			return;
-		case "team/message/queued":
-			teamSelector(data, label);
-			teamMessageValue(data["message"], `${label} message`, version);
-			return;
-		case "team/task":
-			teamSelector(data, label);
-			teamTaskValue(data["task"], `${label} task`);
-			return;
-		case "todo/write":
-			arrayValue(data["todos"], `${label} todos`, (value, itemLabel) => {
-				const item = exactRecord(value, itemLabel, ["content", "status"]);
-				stringValue(item["content"], `${itemLabel} content`);
-				literalValue(item["status"], [
-					"pending",
-					"in_progress",
-					"completed"
-				], `${itemLabel} status`);
-			});
-			return;
-		case "tool-workflow/agent-end":
-			workflowIdentity(data, label);
-			literalValue(data["outcome"], [
-				"completed",
-				"failed",
-				"cancelled"
-			], `${label} outcome`);
-			return;
-		case "tool-workflow/agent-start":
-			workflowIdentity(data, label);
-			stringValue(data["label"], `${label} label`);
-			if (data["phase"] !== void 0) stringValue(data["phase"], `${label} phase`);
-			nonEmptyString(data["childId"], `${label} childId`);
-			return;
-		case "tool-workflow/run-end":
-			nonEmptyString(data["runId"], `${label} runId`);
-			literalValue(data["stopReason"], [
-				"completed",
-				"cancelled",
-				"error"
-			], `${label} stopReason`);
-			return;
-		case "tool-workflow/run-start":
-			nonEmptyString(data["runId"], `${label} runId`);
-			nonEmptyString(data["name"], `${label} name`);
-			return;
-		case "tool/call":
-			coordinatePair(data, label);
-			nonEmptyString(data["callId"], `${label} callId`);
-			nonEmptyString(data["name"], `${label} name`);
-			stringValue(data["arguments"], `${label} arguments`);
-			return;
-		case "tool/code-dispatch":
-		case "tool/code-dispatch-start":
-			nonEmptyString(data["rootCallId"], `${label} rootCallId`);
-			nonEmptyString(data["parentCallId"], `${label} parentCallId`);
-			nonEmptyString(data["subCallId"], `${label} subCallId`);
-			nonEmptyString(data["name"], `${label} name`);
-			if (event.type === "tool/code-dispatch") {
-				booleanValue(data["isError"], `${label} isError`);
-				contentBlocksValue(data["content"], `${label} content`, version);
-			}
-			return;
-		case "tool/result":
-			coordinatePair(data, label);
-			messageValue(data["message"], `${label} message`, version, "tool");
-			if (data["error"] !== void 0) {
-				const error = exactRecord(data["error"], `${label} error`, ["name", "code"]);
-				nonEmptyString(error["name"], `${label} error name`);
-				nonEmptyString(error["code"], `${label} error code`);
-			}
-			return;
-		case "turn/end":
-			countValue(data["turn"], `${label} turn`);
-			turnEndReasonValue(data["reason"], `${label} reason`);
-			return;
-		case "turn/start":
-			countValue(data["turn"], `${label} turn`);
-			return;
-		case "user/message":
-			messageValue(data, label, version, "user");
-			return;
-		case "web/deepseek-search-llm-request":
-			nonEmptyString(data["endpoint"], `${label} endpoint`);
-			nonEmptyString(data["apiVersion"], `${label} apiVersion`);
-			deepSeekSearchBodyValue(data["body"], `${label} body`);
-			return;
-		/* v8 ignore next -- the frozen disposition rejects unknown types before semantic dispatch. */
-		default: throw new SessionFormatError(`released payload validator is missing event ${JSON.stringify(event.type)}`);
-	}
-}
-function exactRecord(value, label, required, optional = []) {
-	const record = releasedV0Record(value, label);
-	assertReleasedV0Keys(record, required, optional, label);
-	return record;
-}
-function stringValue(value, label) {
-	if (typeof value !== "string") throw new SessionFormatError(`${label} must be a string`);
-}
-function nonEmptyString(value, label) {
-	if (typeof value !== "string" || value.length === 0) throw new SessionFormatError(`${label} must be a non-empty string`);
-}
-function booleanValue(value, label) {
-	if (typeof value !== "boolean") throw new SessionFormatError(`${label} must be a boolean`);
-}
-function safeIntegerValue(value, label) {
-	return sessionFormatSafeInteger(value, label);
-}
-function countValue(value, label) {
-	return sessionFormatCount(value, label);
-}
-function positiveIntegerValue(value, label) {
-	const result = countValue(value, label);
-	if (result === 0) throw new SessionFormatError(`${label} must be positive`);
-	return result;
-}
-function finiteNumberValue(value, label) {
-	if (typeof value !== "number" || !Number.isFinite(value) || Object.is(value, -0)) throw new SessionFormatError(`${label} must be a finite number`);
-	return value;
-}
-function literalValue(value, allowed, label) {
-	if (!allowed.some((candidate) => candidate === value)) throw new SessionFormatError(`${label} must be one of ${allowed.map(String).join(", ")}`);
-}
-function nullableValue(value, label, validate) {
-	if (value !== null) validate(value, label);
-}
-function arrayValue(value, label, validate) {
-	if (!Array.isArray(value)) throw new SessionFormatError(`${label} must be an array`);
-	const members = value;
-	members.forEach((member, index) => {
-		validate(member, `${label}[${index}]`);
-	});
-	return members;
-}
-function coordinatePair(data, label) {
-	countValue(data["turn"], `${label} turn`);
-	countValue(data["step"], `${label} step`);
-}
-function earlierSeq(value, eventSeq, label) {
-	const seq = countValue(value, label);
-	if (seq >= eventSeq) throw new SessionFormatError(`${label} must identify an earlier event`);
-	return seq;
-}
-function seqArray(value, eventSeq, label, requireNonEmpty) {
-	const seen = /* @__PURE__ */ new Set();
-	const values = arrayValue(value, label, (member, memberLabel) => {
-		const seq = earlierSeq(member, eventSeq, memberLabel);
-		if (seen.has(seq)) throw new SessionFormatError(`${label} repeats seq ${seq}`);
-		seen.add(seq);
-	});
-	if (requireNonEmpty && values.length === 0) throw new SessionFormatError(`${label} must be non-empty`);
-	return values;
-}
-function llmFailureValue(value, label) {
-	const failure = exactRecord(value, label, ["message", "code"], [
-		"status",
-		"providerRetryAfterMs",
-		"requestId"
-	]);
-	nonEmptyString(failure["message"], `${label} message`);
-	nonEmptyString(failure["code"], `${label} code`);
-	if (failure["status"] !== void 0) {
-		const status = safeIntegerValue(failure["status"], `${label} status`);
-		if (status < 100 || status > 599) throw new SessionFormatError(`${label} status must be 100 through 599`);
-	}
-	if (failure["providerRetryAfterMs"] !== void 0 && finiteNumberValue(failure["providerRetryAfterMs"], `${label} providerRetryAfterMs`) <= 0) throw new SessionFormatError(`${label} providerRetryAfterMs must be positive`);
-	if (failure["requestId"] !== void 0) nonEmptyString(failure["requestId"], `${label} requestId`);
-}
-function tokenUsageValue(value, label) {
-	const usage = exactRecord(value, label, ["inputTokens", "outputTokens"], [
-		"totalTokens",
-		"cacheReadTokens",
-		"cacheWriteTokens",
-		"reasoningTokens"
-	]);
-	for (const key of Object.keys(usage)) countValue(usage[key], `${label} ${key}`);
-}
-function contentBlocksValue(value, label, version) {
-	arrayValue(value, label, (member, memberLabel) => {
-		contentBlockValue(member, memberLabel, version);
-	});
-}
-function contentBlockValue(value, label, version) {
-	const block = releasedV0Record(value, label);
-	switch (block["type"]) {
-		case "text":
-		case "reasoning":
-			assertReleasedV0Keys(block, ["type", "text"], [], label);
-			stringValue(block["text"], `${label} text`);
-			return;
-		case "image":
-			assertReleasedV0Keys(block, ["type", "attachment"], [], label);
-			imageAttachmentValue(block["attachment"], `${label} attachment`);
-			return;
-		case "tool-call":
-			assertReleasedV0Keys(block, [
-				"type",
-				"id",
-				"name",
-				"arguments"
-			], [], label);
-			nonEmptyString(block["id"], `${label} id`);
-			nonEmptyString(block["name"], `${label} name`);
-			stringValue(block["arguments"], `${label} arguments`);
-			return;
-		case "tool-result":
-			assertReleasedV0Keys(block, [
-				"type",
-				"toolCallId",
-				"content"
-			], ["isError"], label);
-			nonEmptyString(block["toolCallId"], `${label} toolCallId`);
-			contentBlocksValue(block["content"], `${label} content`, version);
-			if (block["isError"] !== void 0) booleanValue(block["isError"], `${label} isError`);
-			return;
-		default:
-			nonEmptyString(block["type"], `${label} type`);
-			return;
-	}
-}
-function imageAttachmentValue(value, label) {
-	const attachment = exactRecord(value, label, [
-		"attachmentId",
-		"mediaType",
-		"bytes",
-		"width",
-		"height"
-	], ["name", "originalDimensions"]);
-	nonEmptyString(attachment["attachmentId"], `${label} attachmentId`);
-	literalValue(attachment["mediaType"], [
-		"image/png",
-		"image/jpeg",
-		"image/webp",
-		"image/gif"
-	], `${label} mediaType`);
-	countValue(attachment["bytes"], `${label} bytes`);
-	positiveIntegerValue(attachment["width"], `${label} width`);
-	positiveIntegerValue(attachment["height"], `${label} height`);
-	if (attachment["name"] !== void 0) stringValue(attachment["name"], `${label} name`);
-	if (attachment["originalDimensions"] !== void 0) {
-		const dimensions = exactRecord(attachment["originalDimensions"], `${label} originalDimensions`, ["width", "height"]);
-		positiveIntegerValue(dimensions["width"], `${label} original width`);
-		positiveIntegerValue(dimensions["height"], `${label} original height`);
-	}
-}
-function messageValue(value, label, version, expected) {
-	const message = exactRecord(value, label, [
-		"id",
-		"role",
-		"content",
-		"source"
-	]);
-	nonEmptyString(message["id"], `${label} id`);
-	const role = expected === "assistant" ? "assistant" : expected === "user" || expected === "tool" ? "user" : void 0;
-	if (role === void 0) literalValue(message["role"], [
-		"system",
-		"user",
-		"assistant"
-	], `${label} role`);
-	else literalValue(message["role"], [role], `${label} role`);
-	contentBlocksValue(message["content"], `${label} content`, version);
-	const source = releasedV0Record(message["source"], `${label} source`);
-	if (version < 2 && expected === "user" && source["kind"] === "goal" && source["change"] !== void 0) legacyGoalMessageValue(message, source, label);
-	else messageSourceValue(source, `${label} source`, version, expected);
-	if (expected === "tool") {
-		const content = message["content"];
-		const block = Array.isArray(content) && content.length === 1 ? releasedV0Record(content[0], `${label} tool result`) : void 0;
-		const source = releasedV0Record(message["source"], `${label} source`);
-		if (block?.["type"] !== "tool-result" || block["toolCallId"] !== source["callId"]) throw new SessionFormatError(`${label} must contain exactly one tool-result block`);
-	}
-}
-function legacyGoalMessageValue(message, source, label) {
-	assertReleasedV0Keys(source, [
-		"kind",
-		"goalId",
-		"revision",
-		"round",
-		"change"
-	], [], `${label} source`);
-	nonEmptyString(source["goalId"], `${label} source goalId`);
-	positiveIntegerValue(source["revision"], `${label} source revision`);
-	if (source["round"] !== 0) throw new SessionFormatError(`${label} legacy goal source round must be 0`);
-	const change = releasedV0Record(source["change"], `${label} source change`);
-	goalChangeValue(change, `${label} source change`);
-	const ref = releasedV0Record(change["operation"] === "clear" ? change["cleared"] : change["goal"], `${label} source change ref`);
-	if (source["goalId"] !== ref["id"] || source["revision"] !== ref["revision"]) throw new SessionFormatError(`${label} legacy goal source does not match its change`);
-	const payload = change["operation"] === "clear" ? {
-		cleared: change["cleared"],
-		clearedAt: change["clearedAt"]
-	} : {
-		goal: change["goal"],
-		roundsStarted: change["roundsStarted"],
-		createdAt: change["createdAt"],
-		updatedAt: change["updatedAt"]
-	};
-	const expected = [{
-		type: "text",
-		text: `<goal_state>${JSON.stringify(payload)}</goal_state>`
-	}];
-	if (!deepEqualJson(message["content"], expected)) throw new SessionFormatError(`${label} legacy goal content does not match its change`);
-}
-function messageSourceValue(value, label, version, expected) {
-	const source = releasedV0Record(value, label);
-	if (expected === "assistant" && source["kind"] !== "model") throw new SessionFormatError(`${label} must be model source`);
-	if (expected === "tool" && source["kind"] !== "tool") throw new SessionFormatError(`${label} must be tool source`);
-	switch (source["kind"]) {
-		case "user":
-			assertReleasedV0Keys(source, ["kind"], ["rpcId", "clientTimeZone"], label);
-			if (source["rpcId"] !== void 0) nonEmptyString(source["rpcId"], `${label} rpcId`);
-			if (source["clientTimeZone"] !== void 0) nonEmptyString(source["clientTimeZone"], `${label} clientTimeZone`);
-			return;
-		case "plugin":
-			pluginSourceValue(source, label);
-			return;
-		case "model":
-			assertReleasedV0Keys(source, [
-				"kind",
-				"provider",
-				"model"
-			], ["replayState"], label);
-			nonEmptyString(source["provider"], `${label} provider`);
-			nonEmptyString(source["model"], `${label} model`);
-			return;
-		case "tool":
-			assertReleasedV0Keys(source, ["kind", "callId"], [], label);
-			nonEmptyString(source["callId"], `${label} callId`);
-			return;
-		case "agent-instructions":
-			assertReleasedV0Keys(source, [
-				"kind",
-				"form",
-				"changes"
-			], ["baseline", "baselineIdentity"], label);
-			literalValue(source["form"], ["instructions"], `${label} form`);
-			if (source["baseline"] !== void 0) literalValue(source["baseline"], [true], `${label} baseline`);
-			if (source["baselineIdentity"] !== void 0) nonEmptyString(source["baselineIdentity"], `${label} baselineIdentity`);
-			arrayValue(source["changes"], `${label} changes`, (member, memberLabel) => {
-				const change = exactRecord(member, memberLabel, [
-					"action",
-					"scope",
-					"path"
-				], ["digest"]);
-				literalValue(change["action"], [
-					"set",
-					"replace",
-					"remove"
-				], `${memberLabel} action`);
-				stringValue(change["scope"], `${memberLabel} scope`);
-				stringValue(change["path"], `${memberLabel} path`);
-				if (change["digest"] !== void 0) stringValue(change["digest"], `${memberLabel} digest`);
-			});
-			return;
-		case "session-reference":
-			sessionReferenceSourceValue(source, label, version);
-			return;
-		case "team-message":
-			assertReleasedV0Keys(source, [
-				"kind",
-				"teamId",
-				"messageId",
-				"senderId",
-				"senderName"
-			], [], label);
-			for (const key of [
-				"teamId",
-				"messageId",
-				"senderId"
-			]) nonEmptyString(source[key], `${label} ${key}`);
-			stringValue(source["senderName"], `${label} senderName`);
-			return;
-		case "goal":
-			assertReleasedV0Keys(source, [
-				"kind",
-				"goalId",
-				"revision",
-				"round"
-			], [], label);
-			nonEmptyString(source["goalId"], `${label} goalId`);
-			positiveIntegerValue(source["revision"], `${label} revision`);
-			positiveIntegerValue(source["round"], `${label} round`);
-			return;
-		case "skill-invocation":
-			assertReleasedV0Keys(source, [
-				"kind",
-				"name",
-				"form"
-			], [], label);
-			nonEmptyString(source["name"], `${label} name`);
-			literalValue(source["form"], ["instructions"], `${label} form`);
-			return;
-		case "skill-catalog":
-			assertReleasedV0Keys(source, [
-				"kind",
-				"form",
-				"entries"
-			], ["update"], label);
-			literalValue(source["form"], ["catalog"], `${label} form`);
-			if (source["update"] !== void 0) literalValue(source["update"], [true], `${label} update`);
-			arrayValue(source["entries"], `${label} entries`, (member, memberLabel) => {
-				const entry = exactRecord(member, memberLabel, ["name", "description"]);
-				nonEmptyString(entry["name"], `${memberLabel} name`);
-				stringValue(entry["description"], `${memberLabel} description`);
-			});
-			return;
-		case "coordinator":
-		case "subagent-report":
-			assertReleasedV0Keys(source, [
-				"kind",
-				"form",
-				"senderSessionId"
-			], [], label);
-			literalValue(source["form"], ["relay"], `${label} form`);
-			nonEmptyString(source["senderSessionId"], `${label} senderSessionId`);
-			return;
-		case "subagent-settled":
-			assertReleasedV0Keys(source, [
-				"kind",
-				"form",
-				"summary",
-				"senderSessionId"
-			], [], label);
-			literalValue(source["form"], ["notice"], `${label} form`);
-			stringValue(source["summary"], `${label} summary`);
-			nonEmptyString(source["senderSessionId"], `${label} senderSessionId`);
-			return;
-		case "webhook":
-			assertReleasedV0Keys(source, [
-				"kind",
-				"provider",
-				"source",
-				"deliveryId",
-				"ruleId",
-				"form",
-				"summary"
-			], [], label);
-			for (const key of [
-				"provider",
-				"source",
-				"deliveryId",
-				"ruleId"
-			]) nonEmptyString(source[key], `${label} ${key}`);
-			literalValue(source["form"], ["notice"], `${label} form`);
-			stringValue(source["summary"], `${label} summary`);
-			return;
-		default:
-			nonEmptyString(source["kind"], `${label} kind`);
-			return;
-	}
-}
-function pluginSourceValue(source, label) {
-	const optional = [
-		"form",
-		"sections",
-		"summary"
-	];
-	if (source["plugin"] === "compact") optional.push("compactionId", "sourceCommandId");
-	assertReleasedV0Keys(source, ["kind", "plugin"], optional, label);
-	nonEmptyString(source["plugin"], `${label} plugin`);
-	if (source["plugin"] === "compact") {
-		nonEmptyString(source["compactionId"], `${label} compactionId`);
-		if (source["sourceCommandId"] !== void 0) nonEmptyString(source["sourceCommandId"], `${label} sourceCommandId`);
-	}
-	const form = source["form"];
-	if (form === void 0) return;
-	literalValue(form, [
-		"instructions",
-		"catalog",
-		"snapshot",
-		"notice",
-		"relay",
-		"recall"
-	], `${label} form`);
-	if (form === "snapshot") arrayValue(source["sections"], `${label} sections`, (member, memberLabel) => {
-		const section = exactRecord(member, memberLabel, ["name", "text"]);
-		nonEmptyString(section["name"], `${memberLabel} name`);
-		stringValue(section["text"], `${memberLabel} text`);
-	});
-	else if (source["sections"] !== void 0) throw new SessionFormatError(`${label} sections require snapshot form`);
-	if (form === "notice") stringValue(source["summary"], `${label} summary`);
-	else if (source["summary"] !== void 0) throw new SessionFormatError(`${label} summary requires notice form`);
-}
-function sessionReferenceSourceValue(source, label, version) {
-	assertReleasedV0Keys(source, [
-		"kind",
-		"form",
-		"version",
-		"references"
-	], [], label);
-	literalValue(source["form"], ["recall"], `${label} form`);
-	literalValue(source["version"], [1], `${label} version`);
-	let expectedInputIndex = 0;
-	const sessionIds = /* @__PURE__ */ new Set();
-	if (arrayValue(source["references"], `${label} references`, (member, memberLabel) => {
-		const reference = exactRecord(member, memberLabel, [
-			"sessionId",
-			"label",
-			"capturedThroughSeq",
-			"compacted",
-			"originalMessages",
-			"retainedMessages",
-			"omittedMessages",
-			"omittedBytes",
-			"truncated",
-			"inputIndex"
-		], version >= 1 ? ["capturedFormatVersion"] : []);
-		nonEmptyString(reference["sessionId"], `${memberLabel} sessionId`);
-		stringValue(reference["label"], `${memberLabel} label`);
-		if (reference["capturedThroughSeq"] !== null) countValue(reference["capturedThroughSeq"], `${memberLabel} capturedThroughSeq`);
-		if (reference["capturedFormatVersion"] !== void 0) {
-			const capturedVersion = countValue(reference["capturedFormatVersion"], `${memberLabel} capturedFormatVersion`);
-			if (capturedVersion < 1 || capturedVersion > version) throw new SessionFormatError(`${memberLabel} capturedFormatVersion must be between 1 and ${version}`);
-		}
-		booleanValue(reference["compacted"], `${memberLabel} compacted`);
-		const original = countValue(reference["originalMessages"], `${memberLabel} originalMessages`);
-		const retained = countValue(reference["retainedMessages"], `${memberLabel} retainedMessages`);
-		const omitted = countValue(reference["omittedMessages"], `${memberLabel} omittedMessages`);
-		const omittedBytes = countValue(reference["omittedBytes"], `${memberLabel} omittedBytes`);
-		const inputIndex = countValue(reference["inputIndex"], `${memberLabel} inputIndex`);
-		const truncated = reference["truncated"];
-		booleanValue(truncated, `${memberLabel} truncated`);
-		if (retained > original || omitted !== original - retained) throw new SessionFormatError(`${memberLabel} message counts are inconsistent`);
-		if (truncated !== (omitted > 0 || omittedBytes > 0)) throw new SessionFormatError(`${memberLabel} truncated disagrees with omitted content`);
-		if (inputIndex !== expectedInputIndex) throw new SessionFormatError(`${label} inputIndex must match reference position`);
-		expectedInputIndex += 1;
-		const sessionId = reference["sessionId"];
-		if (sessionIds.has(sessionId)) throw new SessionFormatError(`${label} repeats sessionId ${sessionId}`);
-		sessionIds.add(sessionId);
-	}).length === 0) throw new SessionFormatError(`${label} references must be non-empty`);
-}
-function streamChunkValue(value, label) {
-	const chunk = releasedV0Record(value, label);
-	switch (chunk["type"]) {
-		case "block-start":
-			assertReleasedV0Keys(chunk, [
-				"type",
-				"index",
-				"blockType"
-			], [], label);
-			countValue(chunk["index"], `${label} index`);
-			nonEmptyString(chunk["blockType"], `${label} blockType`);
-			return;
-		case "text-delta":
-		case "reasoning-delta":
-			assertReleasedV0Keys(chunk, [
-				"type",
-				"index",
-				"text"
-			], [], label);
-			countValue(chunk["index"], `${label} index`);
-			stringValue(chunk["text"], `${label} text`);
-			return;
-		case "tool-call-delta":
-			assertReleasedV0Keys(chunk, [
-				"type",
-				"index",
-				"id",
-				"argumentsDelta"
-			], ["name"], label);
-			countValue(chunk["index"], `${label} index`);
-			nonEmptyString(chunk["id"], `${label} id`);
-			if (chunk["name"] !== void 0) stringValue(chunk["name"], `${label} name`);
-			stringValue(chunk["argumentsDelta"], `${label} argumentsDelta`);
-			return;
-		case "block-end":
-			assertReleasedV0Keys(chunk, [
-				"type",
-				"index",
-				"block"
-			], [], label);
-			countValue(chunk["index"], `${label} index`);
-			contentBlockValue(chunk["block"], `${label} block`, 1);
-			return;
-		case "usage":
-			assertReleasedV0Keys(chunk, ["type", "usage"], [], label);
-			tokenUsageValue(chunk["usage"], `${label} usage`);
-			return;
-		case "finish":
-			assertReleasedV0Keys(chunk, ["type", "reason"], ["replayState"], label);
-			finishReasonValue(chunk["reason"], `${label} reason`);
-			if (chunk["replayState"] !== void 0) replayEnvelopeValue(chunk["replayState"], `${label} replayState`);
-			return;
-		default: throw new SessionFormatError(`${label} has unknown stream chunk type ${JSON.stringify(chunk["type"])}`);
-	}
-}
-function finishReasonValue(value, label) {
-	const reason = releasedV0Record(value, label);
-	if (reason["kind"] === "aborted" || reason["kind"] === "error") {
-		assertReleasedV0Keys(reason, ["kind", "failure"], [], label);
-		llmFailureValue(reason["failure"], `${label} failure`);
-		return;
-	}
-	if (reason["kind"] === "stop" || reason["kind"] === "tool-calls" || reason["kind"] === "max-tokens") assertReleasedV0Keys(reason, ["kind"], [], label);
-	nonEmptyString(reason["kind"], `${label} kind`);
-}
-function replayEnvelopeValue(value, label) {
-	const replay = exactRecord(value, label, ["response"], ["blocks"]);
-	if (replay["blocks"] !== void 0 && !Array.isArray(replay["blocks"])) throw new SessionFormatError(`${label} blocks must be an array`);
-}
-function turnEndReasonValue(value, label) {
-	const reason = releasedV0Record(value, label);
-	switch (reason["kind"]) {
-		case "completed":
-		case "blocked":
-		case "max-tokens":
-		case "interrupted":
-			assertReleasedV0Keys(reason, ["kind"], [], label);
-			return;
-		case "aborted": {
-			assertReleasedV0Keys(reason, ["kind", "reason"], [], label);
-			const cause = releasedV0Record(reason["reason"], `${label} abort cause`);
-			if (cause["kind"] === "hook") {
-				assertReleasedV0Keys(cause, ["kind", "reason"], [], `${label} abort cause`);
-				stringValue(cause["reason"], `${label} abort reason`);
-			} else {
-				assertReleasedV0Keys(cause, ["kind"], [], `${label} abort cause`);
-				literalValue(cause["kind"], [
-					"user",
-					"parent",
-					"disposed",
-					"legacy"
-				], `${label} abort kind`);
-			}
-			return;
-		}
-		case "error":
-			assertReleasedV0Keys(reason, ["kind", "error"], [], label);
-			llmFailureValue(reason["error"], `${label} error`);
-			return;
-		default:
-			nonEmptyString(reason["kind"], `${label} kind`);
-			return;
-	}
-}
-function requestHeaderValue(value, label) {
-	const header = exactRecord(value, label, ["config"], [
-		"adapterDefaults",
-		"system",
-		"tools"
-	]);
-	const config = exactRecord(header["config"], `${label} config`, ["provider", "model"], [
-		"reasoningEffort",
-		"temperature",
-		"maxTokens",
-		"stop"
-	]);
-	nonEmptyString(config["provider"], `${label} provider`);
-	nonEmptyString(config["model"], `${label} model`);
-	if (config["reasoningEffort"] !== void 0) nonEmptyString(config["reasoningEffort"], `${label} reasoningEffort`);
-	if (config["temperature"] !== void 0) finiteNumberValue(config["temperature"], `${label} temperature`);
-	if (config["maxTokens"] !== void 0) positiveIntegerValue(config["maxTokens"], `${label} maxTokens`);
-	if (config["stop"] !== void 0) arrayValue(config["stop"], `${label} stop`, stringValue);
-	if (header["adapterDefaults"] !== void 0) {
-		const defaults = exactRecord(header["adapterDefaults"], `${label} adapterDefaults`, [], ["reasoningEffort", "maxTokens"]);
-		for (const [key, marker] of Object.entries(defaults)) {
-			literalValue(marker, [true], `${label} adapterDefaults ${key}`);
-			if (!Object.hasOwn(config, key)) throw new SessionFormatError(`${label} adapter default ${key} lacks config value`);
-		}
-	}
-	if (header["system"] !== void 0) stringValue(header["system"], `${label} system`);
-	if (header["tools"] !== void 0) arrayValue(header["tools"], `${label} tools`, toolSchemaValue);
-}
-function toolSchemaValue(value, label) {
-	const schema = exactRecord(value, label, [
-		"name",
-		"description",
-		"parameters"
-	]);
-	nonEmptyString(schema["name"], `${label} name`);
-	stringValue(schema["description"], `${label} description`);
-	releasedV0Record(schema["parameters"], `${label} parameters`);
-}
-function shadowedValue(data, eventSeq, label) {
-	const range = exactRecord(data["shadowedRange"], `${label} shadowedRange`, ["start", "end"]);
-	const start = earlierSeq(range["start"], eventSeq, `${label} shadowedRange start`);
-	const end = earlierSeq(range["end"], eventSeq, `${label} shadowedRange end`);
-	const seqs = seqArray(data["shadowedSeqs"], eventSeq, `${label} shadowedSeqs`, true);
-	if (seqs[0] !== start || seqs.at(-1) !== end) throw new SessionFormatError(`${label} shadowedRange must match shadowedSeqs endpoints`);
-	countValue(data["shadowedTokenCount"], `${label} shadowedTokenCount`);
-}
-function goalChangeValue(data, label) {
-	literalValue(data["kind"], ["goal/change"], `${label} kind`);
-	literalValue(data["version"], [1], `${label} version`);
-	if (data["operation"] === "clear") {
-		assertReleasedV0Keys(data, [
-			"kind",
-			"version",
-			"operation",
-			"cleared",
-			"clearedAt"
-		], [], `${label} data`);
-		goalRefValue(data["cleared"], `${label} cleared`);
-		countValue(data["clearedAt"], `${label} clearedAt`);
-		return;
-	}
-	assertReleasedV0Keys(data, [
-		"kind",
-		"version",
-		"operation",
-		"goal",
-		"roundsStarted",
-		"createdAt",
-		"updatedAt"
-	], [], `${label} data`);
-	literalValue(data["operation"], [
-		"create",
-		"edit",
-		"pause",
-		"resume",
-		"complete",
-		"block"
-	], `${label} operation`);
-	goalSnapshotValue(data["goal"], `${label} goal`);
-	countValue(data["roundsStarted"], `${label} roundsStarted`);
-	countValue(data["createdAt"], `${label} createdAt`);
-	countValue(data["updatedAt"], `${label} updatedAt`);
-}
-function goalRefValue(value, label) {
-	const ref = exactRecord(value, label, ["id", "revision"]);
-	nonEmptyString(ref["id"], `${label} id`);
-	positiveIntegerValue(ref["revision"], `${label} revision`);
-}
-function goalSnapshotValue(value, label) {
-	const goal = exactRecord(value, label, [
-		"id",
-		"revision",
-		"objective",
-		"phase",
-		"maxGoalRounds"
-	], ["blockedReason"]);
-	nonEmptyString(goal["id"], `${label} id`);
-	positiveIntegerValue(goal["revision"], `${label} revision`);
-	nonEmptyString(goal["objective"], `${label} objective`);
-	literalValue(goal["phase"], [
-		"active",
-		"paused",
-		"blocked",
-		"complete"
-	], `${label} phase`);
-	positiveIntegerValue(goal["maxGoalRounds"], `${label} maxGoalRounds`);
-	if (goal["phase"] === "blocked") {
-		const reason = exactRecord(goal["blockedReason"], `${label} blockedReason`, ["code", "message"]);
-		nonEmptyString(reason["code"], `${label} blocked code`);
-		nonEmptyString(reason["message"], `${label} blocked message`);
-	} else if (goal["blockedReason"] !== void 0) throw new SessionFormatError(`${label} blockedReason requires blocked phase`);
-}
-function scheduleChangeValue(data, label) {
-	literalValue(data["version"], [1], `${label} version`);
-	if (data["operation"] === "create") {
-		assertReleasedV0Keys(data, [
-			"version",
-			"operation",
-			"schedule"
-		], [], `${label} data`);
-		scheduleRecordValue(data["schedule"], `${label} schedule`);
-		return;
-	}
-	assertReleasedV0Keys(data, [
-		"version",
-		"operation",
-		"id"
-	], data["operation"] === "dispatch" ? ["acceptedAt"] : [], `${label} data`);
-	literalValue(data["operation"], ["delete", "dispatch"], `${label} operation`);
-	scheduleIdValue(data["id"], `${label} id`);
-	if (data["acceptedAt"] !== void 0) instantValue(data["acceptedAt"], `${label} acceptedAt`);
-}
-function scheduleRecordValue(value, label) {
-	const record = releasedV0Record(value, label);
-	if (record["kind"] === "after") {
-		assertReleasedV0Keys(record, [
-			"id",
-			"kind",
-			"prompt",
-			"afterSeconds",
-			"scheduledAt"
-		], [], label);
-		positiveIntegerValue(record["afterSeconds"], `${label} afterSeconds`);
-	} else if (record["kind"] === "at") assertReleasedV0Keys(record, [
-		"id",
-		"kind",
-		"prompt",
-		"scheduledAt"
-	], [], label);
-	else if (record["kind"] === "every") {
-		assertReleasedV0Keys(record, [
-			"id",
-			"kind",
-			"prompt",
-			"everySeconds",
-			"scheduledAt"
-		], [], label);
-		if (positiveIntegerValue(record["everySeconds"], `${label} everySeconds`) < 300) throw new SessionFormatError(`${label} everySeconds must be at least 300`);
-	} else throw new SessionFormatError(`${label} has unknown schedule kind`);
-	scheduleIdValue(record["id"], `${label} id`);
-	nonEmptyString(record["prompt"], `${label} prompt`);
-	instantValue(record["scheduledAt"], `${label} scheduledAt`);
-}
-function scheduleIdValue(value, label) {
-	nonEmptyString(value, label);
-	if (value.trim() !== value) throw new SessionFormatError(`${label} must not have surrounding whitespace`);
-}
-function instantValue(value, label) {
-	if (typeof value !== "string" || !/^(?!0000)\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d\.\d{3}Z$/u.test(value) || !Number.isFinite(Date.parse(value)) || new Date(Date.parse(value)).toISOString() !== value) throw new SessionFormatError(`${label} must be a canonical UTC instant`);
-}
-function titleSourceValue(value, label) {
-	const source = releasedV0Record(value, label);
-	if (source["kind"] === "provider") {
-		assertReleasedV0Keys(source, ["kind", "provider"], ["model"], label);
-		nonEmptyString(source["provider"], `${label} provider`);
-		if (source["model"] !== void 0) modelRouteValue(source["model"], `${label} model`);
-		return;
-	}
-	assertReleasedV0Keys(source, ["kind"], [], label);
-	literalValue(source["kind"], ["fallback", "user"], `${label} kind`);
-}
-function modelRouteValue(value, label) {
-	const route = exactRecord(value, label, ["provider", "model"]);
-	nonEmptyString(route["provider"], `${label} provider`);
-	nonEmptyString(route["model"], `${label} model`);
-}
-function subagentDescriptorValue(data, label) {
-	literalValue(data["version"], [3], `${label} version`);
-	nonEmptyString(data["provider"], `${label} provider`);
-	if (data["mode"] === "one-shot") {
-		assertReleasedV0Keys(data, [
-			"mode",
-			"version",
-			"provider"
-		], ["label"], `${label} data`);
-		if (data["label"] !== void 0) stringValue(data["label"], `${label} label`);
-		return;
-	}
-	literalValue(data["mode"], ["continuable"], `${label} mode`);
-	nonEmptyString(data["label"], `${label} label`);
-	for (const key of [
-		"agentProvider",
-		"agentModel",
-		"agentReasoningEffort",
-		"persona"
-	]) if (data[key] !== void 0) nonEmptyString(data[key], `${label} ${key}`);
-	if (data["agentProvider"] === void 0 !== (data["agentModel"] === void 0)) throw new SessionFormatError(`${label} agentProvider and agentModel must be paired`);
-	if (data["toolFilter"] !== void 0) {
-		const filter = exactRecord(data["toolFilter"], `${label} toolFilter`, [], ["allow", "deny"]);
-		if (filter["allow"] === void 0 && filter["deny"] === void 0) throw new SessionFormatError(`${label} toolFilter requires allow or deny`);
-		if (filter["allow"] !== void 0) arrayValue(filter["allow"], `${label} allow`, nonEmptyString);
-		if (filter["deny"] !== void 0) arrayValue(filter["deny"], `${label} deny`, nonEmptyString);
-	}
-}
-function allowedModelsValue(value, label) {
-	const seen = /* @__PURE__ */ new Set();
-	if (arrayValue(value, label, (member, memberLabel) => {
-		const route = exactRecord(member, memberLabel, ["provider", "model"]);
-		nonEmptyString(route["provider"], `${memberLabel} provider`);
-		nonEmptyString(route["model"], `${memberLabel} model`);
-		const key = `${route["provider"]}\0${route["model"]}`;
-		if (seen.has(key)) throw new SessionFormatError(`${label} repeats route ${key}`);
-		seen.add(key);
-	}).length === 0) throw new SessionFormatError(`${label} must be non-empty`);
-}
-function teamSelector(data, label) {
-	literalValue(data["version"], [1], `${label} version`);
-	nonEmptyString(data["teamId"], `${label} teamId`);
-}
-function teamMemberValue(value, label) {
-	const member = exactRecord(value, label, [
-		"id",
-		"name",
-		"description",
-		"provider",
-		"context",
-		"phase"
-	], ["error"]);
-	nonEmptyString(member["id"], `${label} id`);
-	stringValue(member["name"], `${label} name`);
-	stringValue(member["description"], `${label} description`);
-	stringValue(member["provider"], `${label} provider`);
-	literalValue(member["context"], ["fresh", "fork"], `${label} context`);
-	literalValue(member["phase"], [
-		"provisioning",
-		"active",
-		"failed"
-	], `${label} phase`);
-	if (member["error"] !== void 0) stringValue(member["error"], `${label} error`);
-}
-function teamTaskValue(value, label) {
-	const task = exactRecord(value, label, [
-		"id",
-		"revision",
-		"subject",
-		"description",
-		"status",
-		"blockedBy",
-		"writeScopes"
-	], ["ownerId"]);
-	nonEmptyString(task["id"], `${label} id`);
-	positiveIntegerValue(task["revision"], `${label} revision`);
-	stringValue(task["subject"], `${label} subject`);
-	stringValue(task["description"], `${label} description`);
-	literalValue(task["status"], [
-		"pending",
-		"in_progress",
-		"completed",
-		"deleted"
-	], `${label} status`);
-	if (task["ownerId"] !== void 0) nonEmptyString(task["ownerId"], `${label} ownerId`);
-	arrayValue(task["blockedBy"], `${label} blockedBy`, nonEmptyString);
-	arrayValue(task["writeScopes"], `${label} writeScopes`, stringValue);
-}
-function teamMessageValue(value, label, version) {
-	const message = exactRecord(value, label, [
-		"id",
-		"senderId",
-		"senderName",
-		"targetId",
-		"delivery",
-		"content"
-	]);
-	for (const key of [
-		"id",
-		"senderId",
-		"targetId"
-	]) nonEmptyString(message[key], `${label} ${key}`);
-	stringValue(message["senderName"], `${label} senderName`);
-	literalValue(message["delivery"], ["quiet", "wakeup"], `${label} delivery`);
-	contentBlocksValue(message["content"], `${label} content`, version);
-}
-function workflowIdentity(data, label) {
-	nonEmptyString(data["runId"], `${label} runId`);
-	positiveIntegerValue(data["seq"], `${label} seq`);
-}
-function deepSeekSearchBodyValue(value, label) {
-	const body = exactRecord(value, label, [
-		"model",
-		"max_tokens",
-		"messages",
-		"tools"
-	]);
-	nonEmptyString(body["model"], `${label} model`);
-	positiveIntegerValue(body["max_tokens"], `${label} max_tokens`);
-	if (arrayValue(body["messages"], `${label} messages`, (member, memberLabel) => {
-		const message = exactRecord(member, memberLabel, ["role", "content"]);
-		literalValue(message["role"], ["user"], `${memberLabel} role`);
-		if (arrayValue(message["content"], `${memberLabel} content`, (block, blockLabel) => {
-			const text = exactRecord(block, blockLabel, ["type", "text"]);
-			literalValue(text["type"], ["text"], `${blockLabel} type`);
-			stringValue(text["text"], `${blockLabel} text`);
-		}).length !== 1) throw new SessionFormatError(`${memberLabel} content must contain one text block`);
-	}).length !== 1) throw new SessionFormatError(`${label} messages must contain one user message`);
-	if (arrayValue(body["tools"], `${label} tools`, (member, memberLabel) => {
-		const tool = exactRecord(member, memberLabel, [
-			"type",
-			"name",
-			"max_uses"
-		]);
-		literalValue(tool["type"], ["web_search_20250305"], `${memberLabel} type`);
-		literalValue(tool["name"], ["web_search"], `${memberLabel} name`);
-		positiveIntegerValue(tool["max_uses"], `${memberLabel} max_uses`);
-	}).length !== 1) throw new SessionFormatError(`${label} tools must contain one web search tool`);
-}
-//#endregion
-//#region ../session-format-v0-to-v1/src/validation.ts
-const HEADER_REQUIRED$2 = [
-	"version",
-	"id",
-	"createdAt",
-	"isSeeded",
-	"delegationDepth"
-];
-const HEADER_OPTIONAL$2 = [
-	"cwd",
-	"parentSession",
-	"origin",
-	"agentPreset"
-];
-/**
-* Validate the logical header shared by released v0 and v1.
-* @param header - detached logical header.
-* @param version - exact expected generation.
-*/
-function assertReleasedSessionFormatHeader(header, version) {
-	const record = releasedV0Record(header, `format v${version} header`);
-	assertReleasedV0Keys(record, HEADER_REQUIRED$2, HEADER_OPTIONAL$2, `format v${version} header`);
-	if (record["version"] !== version) throw new SessionFormatError(`expected format v${version} header`);
-	if (typeof record["id"] !== "string") throw new SessionFormatError(`format v${version} header id must be a string`);
-	sessionFormatCount(record["createdAt"], `format v${version} header createdAt`);
-	if (typeof record["isSeeded"] !== "boolean") throw new SessionFormatError(`format v${version} header isSeeded must be a boolean`);
-	sessionFormatCount(record["delegationDepth"], `format v${version} header delegationDepth`);
-	for (const key of [
-		"cwd",
-		"parentSession",
-		"agentPreset"
-	]) if (record[key] !== void 0 && typeof record[key] !== "string") throw new SessionFormatError(`format v${version} header ${key} must be a string`);
-	if (typeof record["cwd"] === "string" && !isAbsolute(record["cwd"])) throw new SessionFormatError(`format v${version} header cwd must be absolute`);
-	if (record["origin"] !== void 0 && record["origin"] !== "subagent") throw new SessionFormatError(`format v${version} header origin must be "subagent"`);
-}
-/**
-* Validate one released-v1 logical header.
-* @param header - detached logical header.
-*/
-function assertReleasedV1Header(header) {
-	assertReleasedSessionFormatHeader(header, 1);
-}
-/**
-* Validate shared-layout surface references for one released generation.
-* @param record - exact event envelope.
-* @param seq - event position used for earlier-reference checks.
-* @param type - surface event type used in diagnostics.
-* @param assistantSources - whether this generation admits empty Assistant chunk references.
-*/
-function assertReleasedSurfaceMetadata(record, seq, type, assistantSources) {
-	const sources = record["sourceEventSeqs"];
-	if (type === "assistant/message" && sources !== void 0 && assistantSources === "forbid-assistant") throw new SessionFormatError(`assistant/message ${seq} retains obsolete chunk references`);
-	if (sources !== void 0) {
-		if (!Array.isArray(sources)) throw new SessionFormatError(`${type} ${seq} sourceEventSeqs must be an array`);
-		const seen = /* @__PURE__ */ new Set();
-		for (const source of sources) {
-			const current = sessionFormatCount(source, `${type} ${seq} sourceEventSeqs member`);
-			if (current >= seq || seen.has(current)) throw new SessionFormatError(`${type} ${seq} sourceEventSeqs must be unique earlier seqs`);
-			seen.add(current);
-		}
-		if (sources.length === 0 && type !== "assistant/message") throw new SessionFormatError(`${type} ${seq} sourceEventSeqs must be non-empty`);
-	}
-	const operation = record["surfaceOp"];
-	if (operation === void 0 || operation === "append") return;
-	const replacement = releasedV0Record(operation, `${type} ${seq} surfaceOp`);
-	assertReleasedV0Keys(replacement, [
-		"op",
-		"start",
-		"end"
-	], [], `${type} ${seq} surfaceOp`);
-	if (replacement["op"] !== "replace") throw new SessionFormatError(`${type} ${seq} surfaceOp must replace`);
-	const start = sessionFormatCount(replacement["start"], `${type} ${seq} surface start`);
-	const end = sessionFormatCount(replacement["end"], `${type} ${seq} surface end`);
-	if (start >= seq || end >= seq) throw new SessionFormatError(`${type} ${seq} has an invalid surface replacement`);
-}
-/**
-* Validate one exact known payload after legacy normalization.
-* @param event - known event to validate.
-* @param version - payload generation controlling versioned members.
-*/
-function assertReleasedEventPayload(event, version) {
-	const disposition = RELEASED_V0_EVENT_DISPOSITIONS[event.type];
-	/* v8 ignore next -- artifact coordinate validation admits only the frozen inventory before payload validation. */
-	if (disposition === void 0) throw new SessionFormatUnsupportedMigrationError$1(`format v0 contains unknown historical event type ${JSON.stringify(event.type)} at seq ${event.seq}; migration refuses unknown historical events even when ignorable`);
-	const data = releasedV0Record(event.data, `${event.type} ${event.seq} data`);
-	if (event.type === "subagent/descriptor" && data["version"] !== 3) {
-		const descriptorVersion = sessionFormatCount(data["version"], `${event.type} ${event.seq} version`);
-		if (version === 0) throw new SessionFormatUnsupportedMigrationError$1(`${event.type} ${event.seq} uses unsupported descriptor version ${descriptorVersion}`);
-		return;
-	}
-	const versionOptional = version === 1 && event.type === "session-log-deepseek/delivery-accepted" ? [...disposition.optional, "sessionFormatVersion"] : disposition.optional;
-	assertReleasedV0Keys(data, disposition.required, versionOptional, `${event.type} ${event.seq} data`);
-	for (const key of disposition.opaque) if (Object.hasOwn(data, key) && !isJsonValue(data[key])) throw new SessionFormatError(`${event.type} ${event.seq} opaque ${key} is not lossless JSON`);
-	assertReleasedPayloadSemantics(event, version);
-}
-//#endregion
-//#region ../session-format-v0-to-v1/src/codec.ts
-const PHYSICAL_HEADER_REQUIRED = [
-	"type",
-	"version",
-	"id",
-	"createdAt",
-	"delegationDepth"
-];
-const PHYSICAL_HEADER_OPTIONAL = [
-	"cwd",
-	"parentSession",
-	"seedLength",
-	"origin",
-	"agentPreset"
-];
-const PACKED_TAGS = new Set([
-	"text-chunks",
-	"reasoning-chunks",
-	"tool-call-chunks"
-]);
-/**
-* Test whether a compact migration item is a released packed Assistant row.
-* @param run - compact migration item to classify.
-* @returns whether the item carries the released Assistant chunk representation.
-*/
-function isReleasedAssistantChunkRun(run) {
-	return run.runType === "released-assistant-chunks";
-}
-createReleasedCodec(0);
-createReleasedCodec(1);
-function createReleasedCodec(version) {
-	return Object.freeze({
-		version,
-		decodeHeader: (value) => decodeHeader(value, version),
-		createDecoder(headerValue, recovery) {
-			const physical = decodePhysicalHeader$1(headerValue, version);
-			const scanner = scanRows(recovery === "recoverable");
-			return {
-				header: physical.header,
-				headerInheritedEventCount: physical.inheritedEventCount,
-				decodeRow: (rowValue, context) => {
-					scanner.decodeRow(rowValue, context);
-				},
-				finish(_context) {
-					scanner.finish(physical.inheritedEventCount);
-					return physical.inheritedEventCount;
-				}
-			};
-		}
-	});
-}
-function scanRows(recoverable) {
-	let rowIndex = 0;
-	let eventCount = 0;
-	let issue;
-	return {
-		decodeRow(rowValue, context) {
-			const currentRow = rowIndex;
-			rowIndex += 1;
-			let packed = false;
-			let decoded;
-			try {
-				const record = releasedV0Record(rowValue, `released Session row ${currentRow}`);
-				const type = record["type"];
-				if (typeof type === "string" && PACKED_TAGS.has(type)) {
-					packed = true;
-					decoded = decodePackedRun(record, type, currentRow);
-				} else decoded = decodeEvent$1(record, currentRow);
-			} catch (error) {
-				const current = error instanceof SessionFormatError ? error : new SessionFormatError(`released Session row ${currentRow} is malformed`, { cause: error });
-				if (!recoverable) throw current;
-				issue ??= current;
-				return;
-			}
-			if (issue !== void 0) {
-				if (!packed && decoded.type === "turn/end") throw issue;
-				return;
-			}
-			const seq = packed ? decoded.firstSeq : decoded.seq;
-			if (seq !== eventCount) {
-				const gap = new SessionFormatError(`released Session row ${currentRow} has seq gap (expected ${eventCount}, got ${seq})`);
-				if (!recoverable) throw gap;
-				issue = gap;
-				if (!packed && decoded.type === "turn/end") throw gap;
-				return;
-			}
-			if (packed) {
-				const run = decoded;
-				eventCount += run.eventCount;
-				context.emitRun(run);
-			} else {
-				eventCount += 1;
-				context.emitEvent(decoded);
-			}
-		},
-		finish(inheritedEventCount) {
-			if (inheritedEventCount > eventCount) throw new SessionFormatError("Session inheritedEventCount exceeds its event count");
-		}
-	};
-}
-function decodeHeader(value, version) {
-	return decodePhysicalHeader$1(value, version).header;
-}
-function decodePhysicalHeader$1(value, version) {
-	const record = releasedV0Record(snapshotSessionFormatJson(value, `released v${version} physical header`), `released v${version} physical header`);
-	assertReleasedV0Keys(record, PHYSICAL_HEADER_REQUIRED, PHYSICAL_HEADER_OPTIONAL, `released v${version} physical header`);
-	if (record["type"] !== "session" || record["version"] !== version) throw new SessionFormatError(`expected released v${version} physical Session header`);
-	if (typeof record["id"] !== "string") throw new SessionFormatError(`released v${version} header id must be a string`);
-	const createdAt = sessionFormatCount(record["createdAt"], `released v${version} header createdAt`);
-	const delegationDepth = sessionFormatCount(record["delegationDepth"], `released v${version} header delegationDepth`);
-	const seedLength = record["seedLength"] === void 0 ? 0 : sessionFormatCount(record["seedLength"], `released v${version} header seedLength`);
-	for (const key of [
-		"cwd",
-		"parentSession",
-		"agentPreset"
-	]) if (record[key] !== void 0 && typeof record[key] !== "string") throw new SessionFormatError(`released v${version} header ${key} must be a string`);
-	if (record["origin"] !== void 0 && record["origin"] !== "subagent") throw new SessionFormatError(`released v${version} header origin must be "subagent"`);
-	const header = {
-		version,
-		id: record["id"],
-		createdAt,
-		...record["cwd"] === void 0 ? {} : { cwd: record["cwd"] },
-		...record["parentSession"] === void 0 ? {} : { parentSession: record["parentSession"] },
-		isSeeded: record["seedLength"] !== void 0,
-		...record["origin"] === void 0 ? {} : { origin: record["origin"] },
-		delegationDepth,
-		...record["agentPreset"] === void 0 ? {} : { agentPreset: record["agentPreset"] }
-	};
-	assertReleasedSessionFormatHeader(header, version);
-	return {
-		header,
-		inheritedEventCount: seedLength
-	};
-}
-function decodeEvent$1(record, rowIndex) {
-	if (record["sourceEventSeqs"] !== void 0) {
-		const seq = sessionFormatCount(record["seq"], `released Session row ${rowIndex} seq`);
-		return {
-			...record,
-			sourceEventSeqs: decodeSeqRanges$2(record["sourceEventSeqs"], seq)
-		};
-	}
-	return record;
-}
-function decodePackedRun(row, type, rowIndex) {
-	const label = `released ${type} row ${rowIndex}`;
-	assertReleasedV0Keys(row, [
-		"type",
-		"seq0",
-		"time0",
-		"data"
-	], [], label);
-	const seq0 = sessionFormatCount(row["seq0"], `${label} seq0`);
-	const time0 = sessionFormatSafeInteger(row["time0"], `${label} time0`);
-	const data = releasedV0Record(row["data"], `${label} data`);
-	const isTool = type === "tool-call-chunks";
-	assertReleasedV0Keys(data, isTool ? [
-		"turn",
-		"step",
-		"index",
-		"id",
-		"dt",
-		"args"
-	] : [
-		"turn",
-		"step",
-		"index",
-		"dt",
-		"texts"
-	], isTool ? ["name"] : [], `${label} data`);
-	const payload = data[isTool ? "args" : "texts"];
-	if (!Array.isArray(payload) || payload.length === 0 || payload.some((member) => typeof member !== "string")) throw new SessionFormatError(`${label} payload must be a non-empty string array`);
-	const gaps = data["dt"];
-	if (!Array.isArray(gaps) || gaps.length !== payload.length - 1) throw new SessionFormatError(`${label} dt length must match its payload`);
-	let lastTime = time0;
-	for (const gap of gaps) {
-		const validGap = sessionFormatSafeInteger(gap, `${label} dt member`);
-		lastTime = sessionFormatSafeInteger(lastTime + validGap, `${label} member time`);
-	}
-	const turn = sessionFormatCount(data["turn"], `${label} turn`);
-	const step = sessionFormatCount(data["step"], `${label} step`);
-	const chunkIndex = sessionFormatCount(data["index"], `${label} index`);
-	if (isTool && (typeof data["id"] !== "string" || data["id"].length === 0 || data["name"] !== void 0 && typeof data["name"] !== "string")) throw new SessionFormatError(`${label} id and optional name must be strings`);
-	const lastSeq = sessionFormatCount(seq0 + payload.length - 1, `${label} final seq`);
-	const stream = type === "tool-call-chunks" ? {
-		type,
-		time0,
-		index: chunkIndex,
-		dt: gaps,
-		id: data["id"],
-		...data["name"] === void 0 ? {} : { name: data["name"] },
-		args: payload
-	} : {
-		type,
-		time0,
-		index: chunkIndex,
-		dt: gaps,
-		texts: payload
-	};
-	const run = {
-		runType: "released-assistant-chunks",
-		firstSeq: seq0,
-		eventCount: payload.length,
-		turn,
-		step,
-		lastSeq,
-		lastTime,
-		stream,
-		expand: () => expandAssistantChunkRun(run)
-	};
-	return run;
-}
-function* expandAssistantChunkRun(run) {
-	const stream = run.stream;
-	const gaps = stream["dt"];
-	const members = stream["type"] === "tool-call-chunks" ? stream["args"] : stream["texts"];
-	let time = run.stream["time0"];
-	for (let index = 0; index < members.length; index += 1) {
-		if (index > 0) time += gaps[index - 1];
-		const member = members[index];
-		const chunk = stream["type"] === "text-chunks" ? {
-			type: "text-delta",
-			index: stream["index"],
-			text: member
-		} : stream["type"] === "reasoning-chunks" ? {
-			type: "reasoning-delta",
-			index: stream["index"],
-			text: member
-		} : {
-			type: "tool-call-delta",
-			index: stream["index"],
-			id: stream["id"],
-			...stream["name"] === void 0 ? {} : { name: stream["name"] },
-			argumentsDelta: member
-		};
-		yield {
-			type: "assistant/chunk",
-			seq: run.firstSeq + index,
-			time,
-			data: {
-				turn: run.turn,
-				step: run.step,
-				chunk
-			}
-		};
-	}
-}
-function decodeSeqRanges$2(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 (typeof entry === "number") {
-			if (output.length >= maxEntries) throw new SessionFormatError("sourceEventSeqs exceeds its event seq");
-			output.push(sessionFormatCount(entry, "sourceEventSeqs member"));
-			continue;
-		}
-		if (!Array.isArray(entry) || 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 (end < start || end - start + 1 > maxEntries - output.length) throw new SessionFormatError("sourceEventSeqs range exceeds its event seq");
-		for (let seq = start; seq <= end; seq += 1) output.push(seq);
-		hasRange = true;
-	}
-	if (hasRange && output.some((member, index) => index > 0 && member <= output[index - 1])) throw new SessionFormatError("sourceEventSeqs ranges must be strictly increasing");
-	return output;
-}
-//#endregion
-//#region ../session-format-v0-to-v1/src/migration.ts
-const LEGACY_ASSISTANT_SOURCE_KEY = ["pro", "venance"].join("");
-defineSessionFormatMigration({
-	name: "@x1a0f3n9/dsh-session-format-v0-to-v1",
-	fromVersion: 0,
-	toVersion: 1,
-	migrateHeader(header) {
-		assertHeaderVersion(header, 0);
-		return {
-			...header,
-			version: 1
-		};
-	},
-	createStage(input) {
-		return new ReleasedV0ToV1Stage(input);
-	},
-	validateTargetHeader: assertReleasedV1Header
-});
-var ReleasedV0ToV1Stage = class {
-	input;
-	headerInheritedEventCount;
-	state = {
-		messageIds: /* @__PURE__ */ new Map(),
-		retryIds: /* @__PURE__ */ new Map()
-	};
-	constructor(input) {
-		this.input = input;
-		assertHeaderVersion(input.sourceHeader, 0);
-		this.headerInheritedEventCount = sessionFormatCount(input.sourceInheritedEventCount, "format v0 inherited event count");
-	}
-	transformEvent(event, context) {
-		const normalized = normalizeReleasedV0Event(event, this.input.sourceHeader.id, this.state);
-		assertSourceDeliveryMarker$1(normalized, this.input);
-		context.emitEvent(normalized);
-	}
-	transformRun(run, context) {
-		if (isReleasedAssistantChunkRun(run)) {
-			context.emitRun(run);
-			return;
-		}
-		for (const event of run.expand()) this.transformEvent(event, context);
-	}
-	finish(_context) {
-		return this.headerInheritedEventCount;
-	}
-};
-function assertHeaderVersion(header, version) {
-	if (header.version !== version) throw new SessionFormatError(`expected format v${version} header`);
-}
-function normalizeReleasedV0Event(event, sessionId, state) {
-	const named = normalizeLegacyCompactionType(event);
-	assertSupportedLegacyType(named, sessionId);
-	const descriptor = normalizeLegacySubagentDescriptor(normalizeLegacyMessage(normalizeLegacyCompaction(normalizeLegacyRetry(normalizeLegacySteering(normalizeLegacyRequestHeader(normalizeLegacyTurnEnd(normalizeLegacyTurnStart(named, sessionId), sessionId), sessionId), sessionId), sessionId, state.retryIds), sessionId, state), sessionId, state.messageIds));
-	if (descriptor.type !== "assistant/chunk") assertReleasedEventPayload(descriptor, 0);
-	const messageId = eventMessageId(descriptor);
-	if (messageId !== void 0) state.messageIds.set(descriptor.seq, messageId);
-	return descriptor;
-}
-function normalizeLegacySubagentDescriptor(event) {
-	if (event.type !== "subagent/descriptor") return event;
-	const data = releasedV0Record(event.data, `${event.type} ${event.seq} data`);
-	if (data["version"] !== 2) return event;
-	return {
-		...event,
-		data: {
-			...data,
-			version: 3
-		}
-	};
-}
-function normalizeLegacyCompactionType(event) {
-	switch (event.type) {
-		case "compact/start": return {
-			...event,
-			type: "compaction/start"
-		};
-		case "compact/summary": return {
-			...event,
-			type: "compaction/summary"
-		};
-		case "compact/end": return {
-			...event,
-			type: "compaction/end"
-		};
-		case "compact/prune": return {
-			...event,
-			type: "compaction/prune"
-		};
-		default: return event;
-	}
-}
-function assertSourceDeliveryMarker$1(event, input) {
-	if (event.type !== "session-log-deepseek/delivery-accepted") return;
-	const data = releasedV0Record(event.data, `${event.type} ${event.seq} data`);
-	const acceptedVersion = data["sessionFormatVersion"] ?? 0;
-	const inherited = input.sourceHeader.parentSession !== void 0 && event.seq < sessionFormatCount(input.sourceInheritedEventCount, "format v0 inherited event count");
-	if (acceptedVersion === 0 && !inherited && data["sessionId"] !== input.sourceHeader.id) throw new SessionFormatError("current-generation delivery marker names the wrong Session");
-}
-function normalizeLegacyRetry(event, sessionId, retryIds) {
-	if (event.type !== "llm/retry") return event;
-	const data = releasedV0Record(event.data, `llm/retry ${event.seq} data`);
-	const chain = [
-		data["turn"],
-		data["step"],
-		data["provider"],
-		data["policyKey"]
-	].map((value) => JSON.stringify(value)).join("\0");
-	const retryId = data["retryId"];
-	if (typeof retryId === "string" && retryId.length > 0) {
-		retryIds.set(chain, retryId);
-		return event;
-	}
-	if (Object.hasOwn(data, "retryId")) return event;
-	const migratedRetryId = retryIds.get(chain) ?? `legacy-retry:${sessionId}:${event.seq}`;
-	retryIds.set(chain, migratedRetryId);
-	return {
-		...event,
-		data: {
-			...data,
-			retryId: migratedRetryId
-		}
-	};
-}
-function normalizeLegacyCompaction(event, sessionId, state) {
-	if (event.type === "session/end-seed") {
-		delete state.compactionId;
-		return event;
-	}
-	if (event.type === "compaction/start") {
-		const data = releasedV0Record(event.data, `compaction/start ${event.seq} data`);
-		const existing = data["compactionId"];
-		if (typeof existing === "string" && existing.length > 0) {
-			state.compactionId = existing;
-			return event;
-		}
-		if (Object.hasOwn(data, "compactionId")) return event;
-		const id = `legacy-compaction:${sessionId}:${event.seq}`;
-		state.compactionId = id;
-		return {
-			...event,
-			data: {
-				...data,
-				compactionId: id
-			}
-		};
-	}
-	const compactionId = state.compactionId;
-	if (compactionId === void 0) return event;
-	if (event.type === "compaction/summary" || event.type === "compaction/end") {
-		const normalized = addLegacyCompactionId(event, compactionId);
-		if (event.type === "compaction/end") delete state.compactionId;
-		return normalized;
-	}
-	if (event.type !== "user/message") return event;
-	const data = releasedV0Record(event.data, `user/message ${event.seq} data`);
-	const source = data["source"];
-	if (!releasedIsRecord(source) || source["kind"] !== "plugin" || source["plugin"] !== "compact" || Object.hasOwn(source, "compactionId")) return event;
-	return {
-		...event,
-		data: {
-			...data,
-			source: {
-				...source,
-				compactionId
-			}
-		}
-	};
-}
-function addLegacyCompactionId(event, compactionId) {
-	const data = releasedV0Record(event.data, `${event.type} ${event.seq} data`);
-	if (Object.hasOwn(data, "compactionId")) return event;
-	return {
-		...event,
-		data: {
-			...data,
-			compactionId
-		}
-	};
-}
-function normalizeLegacyRequestHeader(event, sessionId) {
-	if (event.type !== "request/header") return event;
-	const data = releasedV0Record(event.data, `request/header ${event.seq} data`);
-	const header = releasedV0Record(data["header"], `request/header ${event.seq} header`);
-	if (!Object.hasOwn(header, "messagePrefix")) return event;
-	if (!Array.isArray(header["messagePrefix"])) throw new SessionFormatError(`session ${JSON.stringify(sessionId)} contains malformed request/header messagePrefix at seq ${event.seq}`);
-	const { messagePrefix: _messagePrefix, ...currentHeader } = header;
-	return {
-		...event,
-		data: {
-			...data,
-			header: currentHeader
-		}
-	};
-}
-function assertSupportedLegacyType(event, sessionId) {
-	if (event.type === "request/header-delta" || event.type === "mode/set") throw new SessionFormatUnsupportedMigrationError$1(`session ${JSON.stringify(sessionId)} contains unsupported legacy ${event.type} event at seq ${event.seq}`);
-	if (event.type === "request/header") {
-		if (releasedV0Record(event.data, `request/header ${event.seq} data`)["reason"] === "fallback") throw new SessionFormatUnsupportedMigrationError$1(`session ${JSON.stringify(sessionId)} contains unsupported request/header reason "fallback" at seq ${event.seq}`);
-	}
-}
-function normalizeLegacySteering(event, sessionId) {
-	if (event.type !== "steering/message") return event;
-	const data = releasedV0Record(event.data, `steering/message ${event.seq} data`);
-	const wrapped = data["message"];
-	if (wrapped !== void 0) {
-		assertReleasedV0Keys(data, ["turn", "message"], [], `steering/message ${event.seq} data`);
-		sessionFormatCount(data["turn"], `steering/message ${event.seq} turn`);
-		return {
-			...event,
-			type: "user/message",
-			data: wrapped
-		};
-	}
-	assertReleasedV0Keys(data, [
-		"turn",
-		"content",
-		"source"
-	], [], `steering/message ${event.seq} data`);
-	sessionFormatCount(data["turn"], `steering/message ${event.seq} turn`);
-	const { turn: _turn, ...message } = data;
-	return {
-		...event,
-		type: "user/message",
-		data: {
-			...message,
-			id: legacyMessageId(sessionId, event.seq),
-			role: "user"
-		}
-	};
-}
-function normalizeLegacyTurnStart(event, sessionId) {
-	if (event.type !== "turn/start") return event;
-	const data = releasedV0Record(event.data, `turn/start ${event.seq} data`);
-	if (!Object.hasOwn(data, "trigger")) return event;
-	assertReleasedV0Keys(data, ["turn", "trigger"], [], `turn/start ${event.seq} data`);
-	const turn = sessionFormatCount(data["turn"], `turn/start ${event.seq} turn`);
-	const trigger = releasedV0Record(data["trigger"], `turn/start ${event.seq} trigger`);
-	if (turn < 1 || typeof trigger["kind"] !== "string" || trigger["kind"].length === 0) throw malformedLegacy(sessionId, "turn/start", event.seq);
-	return {
-		...event,
-		data: { turn }
-	};
-}
-function normalizeLegacyTurnEnd(event, sessionId) {
-	if (event.type !== "turn/end") return event;
-	const data = releasedV0Record(event.data, `turn/end ${event.seq} data`);
-	assertReleasedV0Keys(data, ["turn", "reason"], [], `turn/end ${event.seq} data`);
-	if (sessionFormatCount(data["turn"], `turn/end ${event.seq} turn`) < 1) throw malformedLegacy(sessionId, "turn/end", event.seq);
-	const reason = releasedV0Record(data["reason"], `turn/end ${event.seq} reason`);
-	if (typeof reason["kind"] !== "string") throw malformedLegacy(sessionId, "turn/end", event.seq);
-	let current;
-	switch (reason["kind"]) {
-		case "completed":
-		case "blocked":
-		case "max-tokens":
-		case "interrupted":
-			assertReleasedV0Keys(reason, ["kind"], [], `turn/end ${event.seq} reason`);
-			return event;
-		case "aborted":
-			if (Object.hasOwn(reason, "reason")) return event;
-			assertReleasedV0Keys(reason, ["kind"], [], `turn/end ${event.seq} reason`);
-			current = {
-				kind: "aborted",
-				reason: { kind: "legacy" }
-			};
-			break;
-		case "disposed":
-			assertReleasedV0Keys(reason, ["kind"], [], `turn/end ${event.seq} reason`);
-			current = {
-				kind: "aborted",
-				reason: { kind: "disposed" }
-			};
-			break;
-		case "error":
-			if (Object.hasOwn(reason, "error")) return event;
-			current = normalizeLegacyErrorReason(reason, event.seq, sessionId);
-			break;
-		default: return event;
-	}
-	return {
-		...event,
-		data: {
-			...data,
-			reason: current
-		}
-	};
-}
-function normalizeLegacyErrorReason(reason, seq, sessionId) {
-	sessionFormatCount(reason["step"], `turn/end ${seq} error step`);
-	const failure = reason["failure"];
-	if (failure !== void 0) {
-		assertReleasedV0Keys(reason, [
-			"kind",
-			"step",
-			"failure"
-		], [], `turn/end ${seq} reason`);
-		const record = releasedV0Record(failure, `turn/end ${seq} failure`);
-		assertReleasedV0Keys(record, ["message", "code"], [
-			"status",
-			"providerRetryAfterMs",
-			"requestId"
-		], `turn/end ${seq} failure`);
-		if (typeof record["message"] !== "string" || typeof record["code"] !== "string") throw malformedLegacy(sessionId, "turn/end", seq);
-		return {
-			kind: "error",
-			error: record
-		};
-	}
-	assertReleasedV0Keys(reason, [
-		"kind",
-		"step",
-		"message"
-	], ["code"], `turn/end ${seq} reason`);
-	if (typeof reason["message"] !== "string" || reason["code"] !== void 0 && typeof reason["code"] !== "string") throw malformedLegacy(sessionId, "turn/end", seq);
-	return {
-		kind: "error",
-		error: {
-			message: reason["message"],
-			code: typeof reason["code"] === "string" ? reason["code"] : "UNKNOWN"
-		}
-	};
-}
-function normalizeLegacyMessage(event, sessionId, messageIds) {
-	const data = releasedV0Record(event.data, `${event.type} ${event.seq} data`);
-	switch (event.type) {
-		case "user/message":
-			if (Object.hasOwn(data, "id") || Object.hasOwn(data, "role") || Object.hasOwn(data, "message") || !Object.hasOwn(data, "content") || !Object.hasOwn(data, "source")) return event;
-			return {
-				...event,
-				data: {
-					...data,
-					id: legacyMessageId(sessionId, event.seq),
-					role: "user"
-				}
-			};
-		case "assistant/message": {
-			if (Object.hasOwn(data, "message") || !Object.hasOwn(data, "content") || !Object.hasOwn(data, LEGACY_ASSISTANT_SOURCE_KEY)) return event;
-			const content = data["content"];
-			const eventData = { ...data };
-			delete eventData["content"];
-			const source = releasedV0Record(eventData[LEGACY_ASSISTANT_SOURCE_KEY], `assistant/message ${event.seq} legacy source`);
-			Reflect.deleteProperty(eventData, LEGACY_ASSISTANT_SOURCE_KEY);
-			return {
-				...event,
-				data: {
-					...eventData,
-					message: {
-						id: legacyMessageId(sessionId, event.seq),
-						role: "assistant",
-						content,
-						source: {
-							...source,
-							kind: "model"
-						}
-					}
-				}
-			};
-		}
-		case "tool/result": {
-			if (Object.hasOwn(data, "message") || !Object.hasOwn(data, "callId") || !Object.hasOwn(data, "content") || !Object.hasOwn(data, "isError")) return event;
-			const { callId, content, isError, ...eventData } = data;
-			if (typeof callId !== "string" || typeof isError !== "boolean" || content === void 0) return event;
-			const inheritedId = replacementStart(event);
-			const messageId = inheritedId === void 0 ? legacyMessageId(sessionId, event.seq) : messageIds.get(inheritedId);
-			if (messageId === void 0) throw new SessionFormatError(`tool/result ${event.seq} replacement cites a message without identity`);
-			return {
-				...event,
-				data: {
-					...eventData,
-					message: {
-						id: messageId,
-						role: "user",
-						content: [{
-							type: "tool-result",
-							toolCallId: callId,
-							content,
-							isError
-						}],
-						source: {
-							kind: "tool",
-							callId
-						}
-					}
-				}
-			};
-		}
-		default: return event;
-	}
-}
-function replacementStart(event) {
-	const operation = event["surfaceOp"];
-	if (operation === void 0 || !releasedIsRecord(operation) || operation["op"] !== "replace") return void 0;
-	return operation["start"];
-}
-function eventMessageId(event) {
-	const data = releasedV0Record(event.data, `${event.type} ${event.seq} data`);
-	const message = event.type === "user/message" ? data : releasedIsRecord(data["message"]) ? data["message"] : void 0;
-	return typeof message?.["id"] === "string" ? message["id"] : void 0;
-}
-function releasedIsRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function legacyMessageId(sessionId, seq) {
-	return `legacy-message:${sessionId}:${seq}`;
-}
-function malformedLegacy(sessionId, type, seq) {
-	return new SessionFormatError(`session ${JSON.stringify(sessionId)} contains malformed pre-react-loop ${type} at seq ${seq}`);
-}
-//#endregion
-//#region ../session-format-v1-to-v2/src/dispositions.ts
-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"])
-});
-Object.freeze(Object.keys(RELEASED_V2_EVENT_DISPOSITIONS).sort((left, right) => left.localeCompare(right, "en")));
-//#endregion
-//#region ../session-format-v1-to-v2/src/validation.ts
-const HEADER_REQUIRED$1 = [
-	"version",
-	"id",
-	"createdAt",
-	"isSeeded",
-	"delegationDepth"
-];
-const HEADER_OPTIONAL$1 = [
-	"cwd",
-	"parentSession",
-	"origin",
-	"agentPreset"
-];
-/**
-* 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 = releasedV2Record(header, "format v2 header");
-	assertReleasedV2Keys(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\"");
-}
-/**
-* Require one released-v2 value to be a JSON object.
-* @param value - value to narrow.
-* @param label - diagnostic subject.
-* @returns the narrowed object.
-*/
-function releasedV2Record(value, label) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new SessionFormatError(`${label} must be an object`);
-	return value;
-}
-/**
-* Require one released-v2 object to contain exactly the admitted keys.
-* @param value - object to inspect.
-* @param required - keys that must be present.
-* @param optional - additional keys that may be present.
-* @param label - diagnostic subject.
-*/
-function assertReleasedV2Keys(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}`);
-}
-//#endregion
-//#region ../session-format-v1-to-v2/src/codec.ts
-const HEADER_REQUIRED = [
-	"type",
-	"version",
-	"id",
-	"createdAt",
-	"isSeeded",
-	"delegationDepth"
-];
-const HEADER_OPTIONAL = [
-	"cwd",
-	"parentSession",
-	"origin",
-	"agentPreset"
-];
-const EVENT_REQUIRED = [
-	"type",
-	"seq",
-	"time",
-	"data"
-];
-const EVENT_OPTIONAL = [
-	"ignorable",
-	"sourceEventSeqs",
-	"surfaceOp"
-];
-const EVENT_KEYS = new Set([...EVENT_REQUIRED, ...EVENT_OPTIONAL]);
-/** Frozen physical JSON codec for released v2. */
-const releasedV2SessionFormatCodec = Object.freeze({
-	version: 2,
-	decodeHeader(value) {
-		return decodePhysicalHeader(value);
-	},
-	createDecoder(headerValue, recovery) {
-		return createDecoder(headerValue, recovery);
-	},
-	encodeHeader(header, inheritedEventCount) {
-		return encodeHeader(header, inheritedEventCount);
-	},
-	encodeEvent(event) {
-		return encodeSourceEventRanges(event);
-	}
-});
-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 createDecoder(headerValue, recovery) {
-	const header = decodePhysicalHeader(headerValue);
-	let rowIndex = 0;
-	let eventCount = 0;
-	let inheritedEventCount;
-	let issue;
-	return {
-		header,
-		decodeRow(value, context) {
-			const currentRow = rowIndex;
-			rowIndex += 1;
-			let event;
-			try {
-				event = decodeEvent(value, currentRow);
-			} catch (error) {
-				const current = error instanceof SessionFormatError ? error : new SessionFormatError(`released v2 row ${currentRow} is malformed`, { cause: error });
-				if (recovery === "strict") throw current;
-				issue ??= current;
-				return;
-			}
-			if (issue !== void 0) {
-				if (event.type === "turn/end") throw issue;
-				return;
-			}
-			if (event.seq !== eventCount) {
-				const gap = new SessionFormatError(`released v2 row ${currentRow} has seq gap (expected ${eventCount}, got ${event.seq})`);
-				if (recovery === "strict") throw gap;
-				issue = gap;
-				if (event.type === "turn/end") throw issue;
-				return;
-			}
-			eventCount += 1;
-			if (event.type === "session/end-seed") {
-				if (jsonRecord(event.data, `session/end-seed ${event.seq} data`)["inherited"] === true) inheritedEventCount = event.seq;
-			}
-			context.emitEvent(event);
-		},
-		finish(_context) {
-			if (header.isSeeded && inheritedEventCount === void 0) throw new SessionFormatError("released v2 seeded Session lacks an inherited end-seed marker");
-			if (!header.isSeeded && inheritedEventCount !== void 0) throw new SessionFormatError("released v2 unseeded Session contains an inherited end-seed marker");
-			return inheritedEventCount ?? 0;
-		}
-	};
-}
-function decodeEvent(value, rowIndex) {
-	const record = jsonRecord(value, `released v2 row ${rowIndex}`);
-	const missing = EVENT_REQUIRED.find((key) => !Object.hasOwn(record, key));
-	if (missing !== void 0) throw new SessionFormatError(`released v2 row ${rowIndex} lacks required field ${missing}`);
-	const unexpected = Object.keys(record).find((key) => !EVENT_KEYS.has(key));
-	if (unexpected !== void 0) throw new SessionFormatError(`released v2 row ${rowIndex} has unexpected field ${unexpected}`);
-	if (typeof record["type"] !== "string") throw new SessionFormatError(`released v2 row ${rowIndex} type must be a string`);
-	sessionFormatSafeInteger(record["time"], `released v2 row ${rowIndex} time`);
-	if (record["ignorable"] !== void 0 && record["ignorable"] !== true) throw new SessionFormatError(`released v2 row ${rowIndex} ignorable must be true when present`);
-	if (record["sourceEventSeqs"] === void 0) return record;
-	const seq = sessionFormatCount(record["seq"], `released v2 row ${rowIndex} seq`);
-	return {
-		...record,
-		sourceEventSeqs: decodeSeqRanges$1(record["sourceEventSeqs"], seq)
-	};
-}
-function encodeHeader(header, inheritedEventCount) {
-	assertReleasedV2Header(header);
-	const cut = sessionFormatCount(inheritedEventCount, "format v2 inherited event count");
-	if (!header.isSeeded && cut !== 0) throw new SessionFormatError("unseeded format v2 Session has inherited events");
-	return {
-		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 }
-	};
-}
-function encodeSourceEventRanges(event) {
-	if (event.sourceEventSeqs === void 0) return event;
-	return {
-		...event,
-		sourceEventSeqs: encodeSeqRanges(event.sourceEventSeqs)
-	};
-}
-function decodeSeqRanges$1(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 ../session-format-v1-to-v2/src/migration.ts
-const CHUNK_EVENT_REQUIRED = [
-	"type",
-	"seq",
-	"time",
-	"data"
-];
-const CHUNK_EVENT_OPTIONAL = [
-	"ignorable",
-	"sourceEventSeqs",
-	"surfaceOp"
-];
-const CHUNK_EVENT_KEYS = new Set([...CHUNK_EVENT_REQUIRED, ...CHUNK_EVENT_OPTIONAL]);
-defineSessionFormatMigration({
-	name: "@x1a0f3n9/dsh-session-format-v1-to-v2",
-	fromVersion: 1,
-	toVersion: 2,
-	migrateHeader(header) {
-		assertReleasedV1Header(header);
-		return {
-			...header,
-			version: 2
-		};
-	},
-	createStage(input) {
-		return input.sourceKind === "decoded" ? new DecodedReleasedV1ToV2Stage(input) : new TransformedReleasedV1ToV2Stage(input);
-	},
-	validateTargetHeader: assertReleasedV2Header
-});
-var TransformedReleasedV1ToV2Stage = class {
-	state;
-	constructor(input) {
-		assertReleasedV1Header(input.sourceHeader);
-		this.state = {
-			sourceHeader: input.sourceHeader,
-			sourceCut: sessionFormatCount(input.sourceInheritedEventCount, "format v1 inherited event count"),
-			mapping: /* @__PURE__ */ new Map(),
-			legacyTurns: legacyTurnState(),
-			pending: void 0,
-			targetSeq: 0,
-			targetCut: input.sourceHeader.isSeeded ? void 0 : 0,
-			lastTime: input.sourceHeader.createdAt
-		};
-	}
-	transformEvent(event, context) {
-		transformReleasedEvent(this.state, event, context);
-	}
-	transformRun(run, context) {
-		transformReleasedRun(this.state, run, context);
-	}
-	finish(context) {
-		return finishMigration(this.state, context);
-	}
-};
-var DecodedReleasedV1ToV2Stage = class extends TransformedReleasedV1ToV2Stage {
-	transformEvent(event, context) {
-		if (event.type !== "assistant/chunk" && RELEASED_V0_EVENT_DISPOSITIONS[event.type] !== void 0) assertReleasedEventPayload(event, 1);
-		super.transformEvent(event, context);
-	}
-};
-function transformReleasedEvent(state, event, context) {
-	if (event.type === "assistant/chunk") assertChunkEnvelope(event);
-	if (RELEASED_V0_EVENT_DISPOSITIONS[event.type] === void 0) throw refusal(`format v1 contains unknown event type ${JSON.stringify(event.type)} at seq ${event.seq}`);
-	const interrupted = legacyInterruptedTurn(state.legacyTurns, event);
-	if (event.type === "turn/start" && state.legacyTurns.openTurn !== null && interrupted === void 0) throw refusal(`turn/start ${JSON.stringify(record$1(event.data)["turn"])} does not close the prior turn`);
-	assertSourceDeliveryMarker(state, event);
-	observeLegacyTurn(state.legacyTurns, event);
-	state.lastTime = event.time;
-	if (interrupted !== void 0) {
-		finishAttempt(state, context);
-		emitGenerated(state, event.seq, interrupted, context);
-	}
-	const legacyGoal = splitLegacyGoalChange(event);
-	if (legacyGoal !== void 0) {
-		emitGenerated(state, event.seq, legacyGoal.change, context);
-		emitSource(state, legacyGoal.message, context);
-		return;
-	}
-	if (event.type === "assistant/chunk") {
-		transformChunk(state, event, context);
-		return;
-	}
-	if (event.type === "assistant/message") {
-		transformMessage(state, event, context);
-		return;
-	}
-	if (closesAttempt(event)) {
-		finishAttempt(state, context);
-		emitSource(state, event, context);
-		return;
-	}
-	if (state.pending !== void 0) {
-		state.pending.afterLastChunk.push(event);
-		return;
-	}
-	emitSource(state, event, context);
-}
-function assertChunkEnvelope(event) {
-	const unexpected = Object.keys(event).find((key) => !CHUNK_EVENT_KEYS.has(key));
-	if (unexpected !== void 0) throw refusal(`assistant/chunk ${event.seq} has unexpected member ${unexpected}`);
-	const missing = CHUNK_EVENT_REQUIRED.find((key) => !Object.hasOwn(event, key));
-	if (missing !== void 0) throw refusal(`assistant/chunk ${event.seq} lacks required member ${missing}`);
-	if (event.ignorable !== void 0 && event.ignorable !== true) throw refusal(`assistant/chunk ${event.seq} ignorable must be true when present`);
-}
-function assertSourceDeliveryMarker(state, event) {
-	if (event.type !== "session-log-deepseek/delivery-accepted") return;
-	const data = record$1(event.data);
-	const inherited = state.sourceHeader.parentSession !== void 0 && event.seq < state.sourceCut;
-	if (data["sessionFormatVersion"] === 1 && !inherited && data["sessionId"] !== state.sourceHeader.id) throw refusal("current-generation delivery marker names the wrong Session");
-}
-function transformReleasedRun(state, run, context) {
-	if (!isReleasedAssistantChunkRun(run)) {
-		for (const event of run.expand()) transformReleasedEvent(state, event, context);
-		return;
-	}
-	state.legacyTurns.previous = void 0;
-	state.lastTime = run.lastTime;
-	if (state.pending !== void 0 && (state.pending.group.terminal || state.pending.group.turn !== run.turn || state.pending.group.step !== run.step)) finishAttempt(state, context);
-	else if (state.pending !== void 0) flushBuffered(state, state.pending, context);
-	state.pending ??= {
-		group: attemptGroup(run.turn, run.step),
-		afterLastChunk: []
-	};
-	assertAttemptRange(state, run.firstSeq, run.lastSeq);
-	flushAccumulator(state.pending.group);
-	appendStreamRecord(state.pending.group, run.stream, run.lastTime);
-	recordChunkSpan(state.pending.group, run.firstSeq, run.eventCount, run.lastTime);
-}
-function finishMigration(state, context) {
-	finishAttempt(state, context);
-	if (state.sourceHeader.isSeeded && state.targetCut === void 0) {
-		state.targetCut = state.targetSeq;
-		context.emitEvent({
-			type: "session/end-seed",
-			seq: state.targetSeq,
-			time: state.lastTime,
-			data: { inherited: true }
-		});
-		state.targetSeq += 1;
-	}
-	return state.targetCut;
-}
-function transformChunk(state, event, context) {
-	const data = record$1(event.data);
-	const turn = coordinate(data["turn"]);
-	const step = coordinate(data["step"]);
-	const chunk = record$1(data["chunk"]);
-	if (state.pending !== void 0 && (state.pending.group.terminal || state.pending.group.turn !== turn || state.pending.group.step !== step)) finishAttempt(state, context);
-	else if (state.pending !== void 0) flushBuffered(state, state.pending, context);
-	state.pending ??= {
-		group: attemptGroup(turn, step),
-		afterLastChunk: []
-	};
-	assertAttemptCut(state, state.pending.group, event.seq);
-	state.pending.group.accumulator ??= new AssistantStreamAccumulator();
-	state.pending.group.accumulator.push({
-		time: event.time,
-		chunk: data["chunk"]
-	});
-	recordChunkSpan(state.pending.group, event.seq, 1, event.time);
-	if (chunk["type"] === "finish") state.pending.group.terminal = true;
-}
-function transformMessage(state, event, context) {
-	const data = record$1(event.data);
-	const turn = coordinate(data["turn"]);
-	const step = coordinate(data["step"]);
-	const sources = event.sourceEventSeqs;
-	const pending = state.pending;
-	if (pending !== void 0 && (pending.group.turn !== turn || pending.group.step !== step)) {
-		finishAttempt(state, context);
-		emitSource(state, messageEvent(event, attemptGroup(turn, step)), context);
-		return;
-	}
-	if (!Array.isArray(sources)) {
-		if (pending !== void 0) throw refusal(`assistant/message ${event.seq} does not cite its complete v1 chunk attempt`);
-		emitSource(state, messageEvent(event, attemptGroup(turn, step)), context);
-		return;
-	}
-	if (sources.length === 0) {
-		finishAttempt(state, context);
-		emitSource(state, messageEvent(event, attemptGroup(turn, step)), context);
-		return;
-	}
-	if (pending === void 0 || !matchesChunkSources(pending.group, sources)) throw refusal(`assistant/message ${event.seq} chunk references are not one complete ordered attempt`);
-	assertAttemptCut(state, pending.group, event.seq);
-	pending.group.terminal = true;
-	flushBuffered(state, pending, context);
-	emitSource(state, messageEvent(event, pending.group), context);
-	state.pending = void 0;
-}
-function finishAttempt(state, context) {
-	const pending = state.pending;
-	if (pending === void 0) return;
-	emitGenerated(state, pending.group.lastChunkSeq, attemptEvent(pending.group), context);
-	flushBuffered(state, pending, context);
-	state.pending = void 0;
-}
-function flushBuffered(state, pending, context) {
-	for (const event of pending.afterLastChunk) emitSource(state, event, context);
-	pending.afterLastChunk.length = 0;
-}
-function emitSource(state, event, context) {
-	let source = event;
-	if (state.sourceHeader.isSeeded && event.seq === state.sourceCut && event.type === "session/end-seed") source = {
-		...event,
-		data: { inherited: true }
-	};
-	ensureTargetCut(state, event.seq, event.time, source.type, context);
-	state.mapping.set(event.seq, state.targetSeq);
-	context.emitEvent(remapReferences(source, state.targetSeq, state.mapping));
-	state.targetSeq += 1;
-}
-function emitGenerated(state, origin, event, context) {
-	ensureTargetCut(state, origin, event.time, event.type, context);
-	context.emitEvent(remapReferences(event, state.targetSeq, state.mapping));
-	state.targetSeq += 1;
-}
-function ensureTargetCut(state, origin, time, type, context) {
-	if (!state.sourceHeader.isSeeded || state.targetCut !== void 0 || origin < state.sourceCut) return;
-	state.targetCut = state.targetSeq;
-	if (origin === state.sourceCut && type === "session/end-seed") return;
-	context.emitEvent({
-		type: "session/end-seed",
-		seq: state.targetSeq,
-		time,
-		data: { inherited: true }
-	});
-	state.targetSeq += 1;
-}
-function assertAttemptCut(state, group, member) {
-	if ((group.spans[0]?.firstSeq ?? member) < state.sourceCut !== member < state.sourceCut) throw refusal(`inherited Session cut ${state.sourceCut} splits one Assistant attempt`);
-}
-function assertAttemptRange(state, first, last) {
-	if (first < state.sourceCut !== last < state.sourceCut) throw refusal(`inherited Session cut ${state.sourceCut} splits one Assistant attempt`);
-}
-function legacyTurnState() {
-	return {
-		openTurn: null,
-		openStep: null,
-		previous: void 0
-	};
-}
-function legacyInterruptedTurn(state, event) {
-	if (event.type !== "turn/start" || state.openTurn === null || state.openStep !== null || coordinate(record$1(event.data)["turn"]) !== state.openTurn + 1 || state.previous?.type !== "agent/inbox/spliced") return void 0;
-	const splice = record$1(state.previous.data);
-	if (splice["target"] !== "next-turn" || !Array.isArray(splice["inserted"]) || splice["inserted"].length === 0) return;
-	return {
-		type: "turn/end",
-		seq: event.seq,
-		time: event.time,
-		data: {
-			turn: state.openTurn,
-			reason: { kind: "interrupted" }
-		}
-	};
-}
-function observeLegacyTurn(state, event) {
-	const data = record$1(event.data);
-	if (event.type === "turn/start") {
-		state.openTurn = coordinate(data["turn"]);
-		state.openStep = null;
-	} else if (event.type === "turn/end") {
-		state.openTurn = null;
-		state.openStep = null;
-	} else if (event.type === "step/start") state.openStep = coordinate(data["step"]);
-	else if (event.type === "step/end") state.openStep = null;
-	state.previous = event;
-}
-function splitLegacyGoalChange(event) {
-	if (event.type !== "user/message") return void 0;
-	const data = record$1(event.data);
-	const source = record$1(data["source"]);
-	if (source["kind"] !== "goal" || source["change"] === void 0) return void 0;
-	return {
-		change: {
-			type: "goal/change",
-			seq: event.seq,
-			time: event.time,
-			data: source["change"]
-		},
-		message: {
-			...event,
-			data: {
-				...data,
-				source: {
-					kind: "plugin",
-					plugin: "goal"
-				}
-			}
-		}
-	};
-}
-function closesAttempt(event) {
-	return event.type === "turn/end" || event.type === "step/end" || event.type === "llm/retry" || event.type === "llm/retry-started";
-}
-function attemptGroup(turn, step) {
-	return {
-		turn,
-		step,
-		spans: [],
-		stream: [],
-		chunkCount: 0,
-		terminal: false
-	};
-}
-function recordChunkSpan(group, firstSeq, eventCount, lastTime) {
-	const previous = group.spans.at(-1);
-	if (previous !== void 0 && previous.firstSeq + previous.eventCount === firstSeq) previous.eventCount += eventCount;
-	else group.spans.push({
-		firstSeq,
-		eventCount
-	});
-	group.chunkCount += eventCount;
-	group.lastChunkSeq = firstSeq + eventCount - 1;
-	group.lastChunkTime = lastTime;
-}
-function matchesChunkSources(group, sources) {
-	if (sources.length !== group.chunkCount) return false;
-	let index = 0;
-	for (const span of group.spans) for (let offset = 0; offset < span.eventCount; offset += 1) {
-		if (sources[index] !== span.firstSeq + offset) return false;
-		index += 1;
-	}
-	return true;
-}
-function recordLastTime(record) {
-	if (record.type === "chunk") return record.time;
-	return record.dt.reduce((time, gap) => time + gap, record.time0);
-}
-function mutableRecord(record) {
-	if (record.type === "chunk") return record;
-	if (record.type === "tool-call-chunks") return {
-		...record,
-		dt: [...record.dt],
-		args: [...record.args]
-	};
-	return {
-		...record,
-		dt: [...record.dt],
-		texts: [...record.texts]
-	};
-}
-function appendStreamRecord(group, source, lastTime, owned = true) {
-	const previous = group.stream.at(-1);
-	if (previous === void 0 || source.type === "chunk" || previous.record.type !== source.type) {
-		group.stream.push({
-			record: owned ? source : mutableRecord(source),
-			lastTime
-		});
-		return;
-	}
-	const gap = source.time0 - previous.lastTime;
-	if (previous.record.index !== source.index || !Number.isSafeInteger(gap)) {
-		group.stream.push({
-			record: owned ? source : mutableRecord(source),
-			lastTime
-		});
-		return;
-	}
-	if (source.type === "tool-call-chunks") {
-		const target = previous.record;
-		if (target.id !== source.id || target.name !== source.name) {
-			group.stream.push({
-				record: owned ? source : mutableRecord(source),
-				lastTime
-			});
-			return;
-		}
-		target.dt.push(gap);
-		for (const value of source.dt) target.dt.push(value);
-		for (const value of source.args) target.args.push(value);
-	} else {
-		const target = previous.record;
-		target.dt.push(gap);
-		for (const value of source.dt) target.dt.push(value);
-		for (const value of source.texts) target.texts.push(value);
-	}
-	previous.lastTime = lastTime;
-}
-function flushAccumulator(group) {
-	const accumulator = group.accumulator;
-	if (accumulator === void 0) return;
-	for (const record of accumulator.snapshot()) appendStreamRecord(group, record, recordLastTime(record), false);
-	delete group.accumulator;
-}
-function streamOf(group) {
-	flushAccumulator(group);
-	return group.stream.map(({ record }) => record);
-}
-function messageEvent(source, group) {
-	const data = record$1(source.data);
-	const { sourceEventSeqs: _sourceEventSeqs, ...event } = source;
-	return {
-		...event,
-		data: {
-			...data,
-			stream: streamOf(group)
-		}
-	};
-}
-function attemptEvent(group) {
-	return {
-		type: "assistant/attempt",
-		seq: group.lastChunkSeq,
-		time: group.lastChunkTime,
-		data: {
-			turn: group.turn,
-			step: group.step,
-			stream: streamOf(group)
-		}
-	};
-}
-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$1(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$1(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$1(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$1(value) {
-	return value;
-}
-function numberArray(value) {
-	return value;
-}
-function coordinate(value) {
-	return value;
-}
-function refusal(message) {
-	return new SessionFormatUnsupportedMigrationError$1(message);
-}
-//#endregion
-//#region ../session-format-v2-to-v3/src/payload.ts
-/** Audited V2 migration admission and V3 payload validation, independent of installed core Session types. */
-/** Audited surface event names; all other admitted events are log-only. */
-const SURFACE_TYPES = new Set([
-	"system/message",
-	"user/message",
-	"assistant/message",
-	"tool/result"
-]);
-const SOURCE_KINDS = new Set([
-	"user",
-	"plugin",
-	"model",
-	"tool",
-	"agent-instructions",
-	"session-reference",
-	"team-message",
-	"goal",
-	"skill-invocation",
-	"skill-catalog",
-	"coordinator",
-	"subagent-report",
-	"subagent-settled",
-	"webhook",
-	"agent-message"
-]);
-/**
-* Require a JSON object at the durable input boundary.
-* @param value - decoded value.
-* @param label - diagnostic subject.
-* @returns the narrowed object.
-*/
-function record(value, label) {
-	if (!isSessionFormatJsonObject(value)) throw new SessionFormatError(label + " must be an object");
-	return value;
-}
-/**
-* Reject missing and unaudited members rather than guessing whether they contain coordinates.
-* @param value - decoded record.
-* @param required - required member names.
-* @param optional - additional admitted names.
-* @param label - diagnostic subject.
-*/
-function keys(value, required, optional, label) {
-	const missing = required.find((key) => !Object.hasOwn(value, key));
-	const unexpected = Object.keys(value).find((key) => !required.includes(key) && !optional.includes(key));
-	if (missing !== void 0) throw new SessionFormatError(label + " lacks required field " + missing);
-	if (unexpected !== void 0) throw new SessionFormatError(label + " has unexpected field " + unexpected);
-}
-/**
-* Validate classified payloads before migration, or native V3 system/header payloads.
-* @param event - decoded logical event.
-* @param version - source or target generation.
-*/
-function assertEvent(event, version) {
-	if (version === 3) {
-		assertV3Event(event);
-		return;
-	}
-	const disposition = RELEASED_V2_EVENT_DISPOSITIONS[event.type];
-	const feedback = event.type === "feedback/message-put" || event.type === "feedback/message-delete";
-	if (disposition === void 0 && !feedback) throw new SessionFormatUnsupportedMigrationError$1("format v2 to v3 cannot safely transform unclassified event " + event.type);
-	const surface = SURFACE_TYPES.has(event.type);
-	keys(event, [
-		"type",
-		"seq",
-		"time",
-		"data"
-	], surface ? [
-		"ignorable",
-		"sourceEventSeqs",
-		"surfaceOp"
-	] : ["ignorable"], event.type);
-	sessionFormatCount(event.seq, "event seq");
-	sessionFormatSafeInteger(event.time, "event time");
-	if (event["ignorable"] !== void 0 && event["ignorable"] !== true) throw new SessionFormatError("ignorable must be true");
-	if (surface) {
-		assertReleasedSurfaceMetadata(event, event.seq, event.type, "forbid-assistant");
-		if (event["surfaceOp"] === void 0) throw new SessionFormatError(event.type + " requires surfaceOp");
-	}
-	const data = record(event.data, event.type + " data");
-	if (feedback) {
-		assertFeedback(event.type, data);
-		return;
-	}
-	const admitted = disposition;
-	keys(data, admitted.required, admitted.optional, event.type + " data");
-	assertOwnedContent(event, data);
-	if (event.type !== "assistant/attempt") assertReleasedPayloadSemantics(event, version);
-	if (event.type === "assistant/message" || event.type === "assistant/attempt") {
-		for (const coordinate of ["turn", "step"]) if (sessionFormatCount(data[coordinate], coordinate) === 0) throw new SessionFormatError(coordinate + " must be positive");
-	}
-	if (event.type === "session/end-seed" && data["inherited"] !== void 0 && data["inherited"] !== true) throw new SessionFormatError("session/end-seed inherited must be true");
-	if (event.type === "user/message") assertSource(data);
-	if (event.type === "assistant/message" || event.type === "tool/result") assertSource(record(data["message"], "message"));
-	if (event.type === "tool/result" && isSessionFormatJsonObject(data["error"]) && data["error"]["code"] === "TOOL_NOT_STARTED") {
-		const message = record(data["message"], "tool result message");
-		const source = record(message["source"], "tool result source");
-		if (!isRepairIdentity(message["id"], source["callId"])) throw new SessionFormatError("TOOL_NOT_STARTED repair requires its canonical historical message id");
-	}
-	if (event.type === "agent/inbox/spliced" || event.type === "session/title-llm-request") {
-		const messages = data[event.type === "agent/inbox/spliced" ? "inserted" : "messages"];
-		for (const message of messages) assertSource(message);
-	}
-}
-/**
-* Recognize stable generated repair IDs without interpreting their historical suffix as a current coordinate.
-* @param id - durable message identity.
-* @param callId - advertised tool identity.
-* @returns whether the identity has the canonical historical repair form.
-*/
-function isRepairIdentity(id, callId) {
-	if (typeof callId !== "string") return false;
-	const prefix = "interrupted-tool-result-" + callId + "-";
-	if (typeof id !== "string" || !id.startsWith(prefix)) return false;
-	const suffix = id.slice(prefix.length);
-	return /^(0|[1-9]\d*)$/.test(suffix) && Number.isSafeInteger(Number(suffix));
-}
-function assertSource(message) {
-	const source = record(message["source"], "message source");
-	if (typeof source["kind"] !== "string" || !SOURCE_KINDS.has(source["kind"])) throw new SessionFormatUnsupportedMigrationError$1("cannot safely transform unclassified message source");
-	if (source["kind"] === "agent-message") {
-		keys(source, [
-			"kind",
-			"form",
-			"senderSessionId"
-		], [], "agent-message source");
-		if (source["form"] !== "relay" || typeof source["senderSessionId"] !== "string" || source["senderSessionId"].length === 0) throw new SessionFormatError("agent-message source requires relay form and senderSessionId");
-	}
-}
-const CONTENT_KINDS = new Set([
-	"text",
-	"reasoning",
-	"image",
-	"file",
-	"tool-call",
-	"tool-result"
-]);
-function contentArray(value, label) {
-	if (!Array.isArray(value)) throw new SessionFormatError(label + ": content must be an array");
-	return value;
-}
-function assertOwnedContent(event, data) {
-	const label = "format v2 " + event.type + " at seq " + String(event.seq) + " data";
-	switch (event.type) {
-		case "user/message":
-		case "tool/code-dispatch":
-			assertContentKinds(data["content"], label + ".content");
-			break;
-		case "assistant/message":
-		case "tool/result":
-		case "team/message/queued":
-			assertContentKinds(record(data["message"], label + ".message")["content"], label + ".message.content");
-			break;
-		case "agent/inbox/spliced":
-		case "session/title-llm-request": {
-			const field = event.type === "agent/inbox/spliced" ? "inserted" : "messages";
-			for (const [index, value] of contentArray(data[field], label + "." + field).entries()) {
-				const path = label + "." + field + "[" + String(index) + "]";
-				assertContentKinds(record(value, path)["content"], path + ".content");
-			}
-			break;
-		}
-		case "compaction/summary":
-			assertContentKinds(data["summary"], label + ".summary");
-			if (data["rawOutput"] !== void 0) assertContentKinds(data["rawOutput"], label + ".rawOutput");
-			break;
-	}
-	if (event.type === "assistant/message" || event.type === "assistant/attempt") for (const [index, value] of contentArray(data["stream"], label + ".stream").entries()) {
-		const path = label + ".stream[" + String(index) + "]";
-		const entry = record(value, path);
-		if (entry["type"] !== "chunk") continue;
-		const chunk = record(entry["chunk"], path + ".chunk");
-		if (chunk["type"] === "block-end") assertContentBlock(chunk["block"], path + ".chunk.block");
-		if (chunk["type"] === "block-start") assertContentKind(chunk["blockType"], path + ".chunk.blockType");
-	}
-}
-function assertContentKind(kind, label) {
-	if (typeof kind !== "string" || !CONTENT_KINDS.has(kind)) throw new SessionFormatUnsupportedMigrationError$1(label + ": cannot safely transform unclassified message content kind " + JSON.stringify(kind));
-}
-function assertContentKinds(content, label) {
-	for (const [index, value] of contentArray(content, label).entries()) assertContentBlock(value, label + "[" + String(index) + "]");
-}
-function assertContentBlock(value, label) {
-	const block = record(value, label);
-	assertContentKind(block["type"], label);
-	if (block["type"] === "tool-result") {
-		if (!Array.isArray(block["content"])) throw new SessionFormatError(label + ".content: invalid message content kind \"tool-result\": content must be an array");
-		assertContentKinds(block["content"], label + ".content");
-	}
-	if (block["type"] === "file") {
-		keys(block, ["type", "attachment"], [], label + " kind \"file\"");
-		const attachment = record(block["attachment"], label + " kind \"file\" attachment");
-		keys(attachment, [
-			"attachmentId",
-			"name",
-			"bytes"
-		], [], label + " kind \"file\" attachment");
-		if (typeof attachment["attachmentId"] !== "string" || attachment["attachmentId"].length === 0 || typeof attachment["name"] !== "string") throw new SessionFormatError(label + " kind \"file\": file attachment requires attachmentId and name");
-		sessionFormatCount(attachment["bytes"], label + " kind \"file\" attachment bytes");
-		return;
-	}
-	const probe = {
-		type: "user/message",
-		seq: 0,
-		time: 0,
-		data: {
-			id: "content-admission",
-			role: "user",
-			source: { kind: "user" },
-			content: [block["type"] === "tool-result" ? {
-				...block,
-				content: []
-			} : block]
-		}
-	};
-	try {
-		assertReleasedPayloadSemantics(probe, 2);
-	} catch (error) {
-		throw new SessionFormatError(label + ": invalid message content kind " + JSON.stringify(block["type"]) + ": " + String(error));
-	}
-}
-/**
-* Reject V3 structural payload violations even beyond a recoverable physical-row failure.
-* @param value - raw physical row; ordinary rows retain the frozen decoder's recovery policy.
-*/
-function assertV3StructuralRow(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return;
-	const row = value;
-	if (row["type"] === "request/header") {
-		const data = record(row["data"], "request/header data");
-		if (Object.hasOwn(record(data["header"], "request header"), "system")) throw new SessionFormatUnsupportedMigrationError$1("format v3 request/header rejects retired header.system");
-	} else if (row["type"] === "system/message") {
-		const data = record(row["data"], "system/message data");
-		assertSystem({
-			type: "system/message",
-			seq: 0,
-			time: 0,
-			data
-		}, data);
-	}
-}
-function assertSystem(event, data) {
-	keys(data, [
-		"turn",
-		"step",
-		"message"
-	], [], "system/message data");
-	for (const coordinate of ["turn", "step"]) if (sessionFormatCount(data[coordinate], coordinate) === 0) throw new SessionFormatError(coordinate + " must be positive");
-	const message = record(data["message"], "system message");
-	keys(message, [
-		"id",
-		"role",
-		"source",
-		"content"
-	], [], "system message");
-	if (typeof message["id"] !== "string" || message["id"].length === 0 || message["role"] !== "system") throw new SessionFormatError("system message requires an id and system role");
-	const source = record(message["source"], "system source");
-	if (source["kind"] !== "plugin" || typeof source["plugin"] !== "string" || source["plugin"].length === 0) throw new SessionFormatError("system message requires plugin source");
-	assertReleasedPayloadSemantics({
-		...event,
-		type: "user/message",
-		data: {
-			...message,
-			role: "user"
-		}
-	}, 3);
-}
-function assertFeedback(type, data) {
-	keys(data, type === "feedback/message-put" ? ["sessionId", "item"] : ["sessionId", "messageId"], [], type);
-	if (typeof data["sessionId"] !== "string") throw new SessionFormatError("feedback sessionId must be a string");
-	if (type === "feedback/message-delete") {
-		if (typeof data["messageId"] !== "string") throw new SessionFormatError("feedback messageId must be a string");
-		return;
-	}
-	const item = record(data["item"], "feedback item");
-	keys(item, [
-		"messageId",
-		"rating",
-		"version",
-		"createdAt",
-		"updatedAt"
-	], ["note"], "feedback item");
-	for (const key of ["messageId", "version"]) if (typeof item[key] !== "string") throw new SessionFormatError("feedback " + key + " must be a string");
-	if (item["rating"] !== "positive" && item["rating"] !== "negative") throw new SessionFormatError("invalid feedback rating");
-	if (item["note"] !== void 0 && typeof item["note"] !== "string") throw new SessionFormatError("feedback note must be a string");
-	sessionFormatCount(item["createdAt"], "feedback createdAt");
-	sessionFormatCount(item["updatedAt"], "feedback updatedAt");
-}
-/**
-* Validate one canonical V3 event without interpreting plugin-owned payloads or log relationships.
-* Unclassified metadata is deferred to vocabulary-aware restoration; unknown required types must not become recoverable corruption.
-* @param event - decoded logical event.
-* @param knownEventTypes - additional installed event types whose envelopes are interpreted.
-*/
-function assertV3Event(event, knownEventTypes) {
-	const value = record(event, "format v3 event");
-	const subject = `format v3 ${event.type} at seq ${event.seq}`;
-	const opaque = !(!(event.type === "tool/code-dispatch-start" || event.type === "tool/code-dispatch") && (SURFACE_TYPES.has(event.type) || RELEASED_V2_EVENT_DISPOSITIONS[event.type] !== void 0 || event.type === "tool/ptc-dispatch-start" || event.type === "tool/ptc-dispatch" || event.type === "feedback/message-put" || event.type === "feedback/message-delete" || knownEventTypes?.has(event.type) === true));
-	keys(value, [
-		"type",
-		"seq",
-		"time",
-		"data"
-	], SURFACE_TYPES.has(event.type) || opaque ? [
-		"ignorable",
-		"surfaceOp",
-		"sourceEventSeqs"
-	] : ["ignorable"], subject);
-	if (typeof event.type !== "string") throw new SessionFormatError(`${subject} type must be a string`);
-	sessionFormatCount(event.seq, `${subject} seq`);
-	sessionFormatSafeInteger(event.time, `${subject} time`);
-	if (Object.hasOwn(value, "ignorable") && value["ignorable"] !== true) throw new SessionFormatError(`${subject} ignorable must be true when present`);
-	if (SURFACE_TYPES.has(event.type)) {
-		const operation = value["surfaceOp"];
-		if (operation === void 0) throw new SessionFormatError(`${subject} requires a surfaceOp marker`);
-		if (operation !== "append") {
-			const replace = record(operation, `${subject} surfaceOp`);
-			if (Object.keys(replace).length !== 3 || replace["op"] !== "replace" || !Object.hasOwn(replace, "startSeq") || !Object.hasOwn(replace, "endSeq")) throw new SessionFormatError(`${subject} requires exact replace fields op/startSeq/endSeq`);
-			for (const key of ["startSeq", "endSeq"]) if (sessionFormatCount(replace[key], `${subject} surfaceOp ${key}`) >= event.seq) throw new SessionFormatError(`${subject} replacement endpoints must reference earlier events`);
-		}
-		const sources = value["sourceEventSeqs"];
-		if (event.type === "assistant/message" && sources !== void 0) throw new SessionFormatError(`${subject} embeds its stream and cannot carry sourceEventSeqs`);
-		if (sources !== void 0) {
-			if (!Array.isArray(sources) || sources.length === 0) throw new SessionFormatError(`${subject} sourceEventSeqs must be a non-empty array`);
-			const seen = /* @__PURE__ */ new Set();
-			for (const source of sources) {
-				const seq = sessionFormatCount(source, `${subject} sourceEventSeqs member`);
-				if (seq >= event.seq || seen.has(seq)) throw new SessionFormatError(`${subject} sourceEventSeqs must be unique earlier seqs`);
-				seen.add(seq);
-			}
-		}
-	}
-	assertV3StructuralRow(event);
-	assertCanonicalPayload(event);
-}
-function assertCanonicalPayload(event) {
-	const subject = `format v3 ${event.type} at seq ${event.seq}`;
-	if (event.type === "request/header") {
-		const header = record(record(event.data, `${subject} data`)["header"], `${subject} header`);
-		if (Array.isArray(header["tools"]) && header["tools"].length === 0 || isSessionFormatJsonObject(header["adapterDefaults"]) && Object.keys(header["adapterDefaults"]).length === 0) throw new SessionFormatError(`${subject} empty optional header fields must be omitted`);
-	}
-	if (event.type !== "tool/result") return;
-	const data = record(event.data, `${subject} data`);
-	if (data["error"] === void 0) return;
-	const content = record(data["message"], `${subject} message`)["content"];
-	if (!Array.isArray(content) || content.length !== 1 || !isSessionFormatJsonObject(content[0]) || content[0]["type"] !== "tool-result" || content[0]["isError"] !== true) throw new SessionFormatError(`${subject} carries error metadata for a non-error tool result`);
-}
-/**
-* Canonicalize structurally transformed events without changing their target coordinates.
-* @param event - transformed event using released replacement names and target coordinates.
-* @returns a V3 event sharing all unchanged payloads and reference values.
-*/
-function canonicalizeTransformedEvent(event) {
-	let target = event;
-	const operation = event["surfaceOp"];
-	if (operation !== void 0 && operation !== "append") {
-		const replace = record(operation, `format v2 ${event.type} at seq ${event.seq} surfaceOp`);
-		if (Object.keys(replace).length !== 3 || replace["op"] !== "replace" || !Object.hasOwn(replace, "start") || !Object.hasOwn(replace, "end")) throw new SessionFormatError(`format v2 ${event.type} at seq ${event.seq} requires exact replace fields op/start/end`);
-		target = {
-			...event,
-			surfaceOp: {
-				op: "replace",
-				startSeq: sessionFormatCount(replace["start"], `format v2 ${event.type} at seq ${event.seq} replace start`),
-				endSeq: sessionFormatCount(replace["end"], `format v2 ${event.type} at seq ${event.seq} replace end`)
-			}
-		};
-	}
-	if (event.type === "request/header") {
-		const data = record(event.data, `format v2 request/header at seq ${event.seq} data`);
-		const header = record(data["header"], `format v2 request/header at seq ${event.seq} header`);
-		const empty = Object.keys(header).filter((key) => key === "tools" && Array.isArray(header[key]) && header[key].length === 0 || key === "adapterDefaults" && isSessionFormatJsonObject(header[key]) && Object.keys(header[key]).length === 0);
-		if (empty.length > 0) {
-			const canonical = Object.fromEntries(Object.entries(header).filter(([key]) => !empty.includes(key)));
-			target = {
-				...target,
-				data: {
-					...data,
-					header: canonical
-				}
-			};
-		}
-	}
-	assertV3Event(target);
-	return target;
-}
-//#endregion
-//#region ../session-format-v2-to-v3/src/validation.ts
-/** Native V3 system-head validation with a private view for frozen non-system relationships. */
-/**
-* Validate v3 logical metadata with the released-v2 fields.
-* @param header - decoded v3 Session header.
-*/
-function assertReleasedV3Header(header) {
-	if (header.version !== 3) throw new SessionFormatError("expected format v3 header");
-	assertReleasedV2Header({
-		...header,
-		version: 2
-	});
-}
-/**
-* Refuse required predecessor PTC tags without interpreting native extension payloads.
-* @param event - event envelope whose type and ignorable admission markers are available.
-*/
-function assertV3EventAdmission(event) {
-	if ((event.type === "tool/code-dispatch-start" || event.type === "tool/code-dispatch") && event["ignorable"] !== true) throw new SessionFormatUnsupportedMigrationError$1("format v3 contains unknown event type " + JSON.stringify(event.type) + " at seq " + String(event.seq));
-}
-Object.freeze({
-	version: 3,
-	decodeHeader(value) {
-		return {
-			...releasedV2SessionFormatCodec.decodeHeader(v2PhysicalHeader(value)),
-			version: 3
-		};
-	},
-	createDecoder(value, recovery) {
-		const decoder = releasedV2SessionFormatCodec.createDecoder(v2PhysicalHeader(value), recovery);
-		let issue;
-		let acceptedInheritedCut;
-		return {
-			header: {
-				...decoder.header,
-				version: 3
-			},
-			decodeRow(row, context) {
-				assertV3RowAdmission(row);
-				decoder.decodeRow(row, {
-					emitRun: context.emitRun.bind(context),
-					emitEvent(event) {
-						assertV3EventAdmission(event);
-						if (issue === void 0) try {
-							assertV3Event(event);
-						} catch (error) {
-							const invalid = error;
-							if (recovery === "strict") throw invalid;
-							issue = invalid;
-						}
-						if (issue !== void 0) {
-							if (event.type === "turn/end") throw issue;
-							return;
-						}
-						if (event.type === "session/end-seed" && isSessionFormatJsonObject(event.data) && event.data["inherited"] === true) acceptedInheritedCut = event.seq;
-						context.emitEvent(event);
-					}
-				});
-			},
-			finish(context) {
-				if (issue === void 0) return decoder.finish(context);
-				if (decoder.header.isSeeded && acceptedInheritedCut === void 0) throw new SessionFormatError("format v3 seeded Session lacks an accepted inherited end-seed marker");
-				if (!decoder.header.isSeeded && acceptedInheritedCut !== void 0) throw new SessionFormatError("format v3 unseeded Session contains an inherited end-seed marker");
-				return acceptedInheritedCut ?? 0;
-			}
-		};
-	},
-	encodeHeader(header, inheritedEventCount) {
-		assertReleasedV3Header(header);
-		return {
-			...releasedV2SessionFormatCodec.encodeHeader({
-				...header,
-				version: 2
-			}, inheritedEventCount),
-			version: 3
-		};
-	},
-	encodeEvent(event) {
-		assertV3EventAdmission(event);
-		assertV3Event(event);
-		return releasedV2SessionFormatCodec.encodeEvent(event);
-	}
-});
-/**
-* Validate owned V3 admission rules before a scanner or codec can discard a recoverable tail.
-* This checks only identified structural payloads; physical source-event ranges still belong to decoding.
-* @param row - parsed physical row, before envelope or compressed-range decoding.
-*/
-function assertV3RowAdmission(row) {
-	assertV3StructuralRow(row);
-	if (typeof row === "object" && row !== null && !Array.isArray(row)) assertV3EventAdmission(row);
-}
-function v2PhysicalHeader(value) {
-	const header = snapshotSessionFormatJson(value, "format v3 physical header");
-	if (!isSessionFormatJsonObject(header) || header["version"] !== 3) throw new SessionFormatError("expected format v3 physical Session header");
-	return {
-		...header,
-		version: 2
-	};
-}
-//#endregion
-//#region ../session-format-v2-to-v3/src/references.ts
-/** Explicit local-coordinate remapping; captured generations and owner-local counters remain opaque. */
-/**
-* Remap only audited same-artifact references, preserving IDs and embedded model input.
-* @param event - validated source event.
-* @param seq - output event position.
-* @param mapping - earlier source positions mapped to output positions.
-* @returns the event in target coordinates.
-*/
-function remapEvent(event, seq, mapping) {
-	const one = (value) => {
-		const source = sessionFormatCount(value, "source event reference");
-		const target = mapping[source];
-		if (source >= event.seq || target === void 0) throw new SessionFormatError("reference must name an earlier source event");
-		return target;
-	};
-	const list = (value) => {
-		if (!Array.isArray(value)) throw new SessionFormatError("sequence references must be an array");
-		return value.map(one);
-	};
-	const range = (value) => {
-		const source = record(value, "sequence range");
-		return {
-			...source,
-			start: one(source["start"]),
-			end: one(source["end"])
-		};
-	};
-	let data = record(event.data, event.type);
-	switch (event.type) {
-		case "command/done":
-			if (data["sourceEventSeq"] !== void 0) data = {
-				...data,
-				sourceEventSeq: one(data["sourceEventSeq"])
-			};
-			break;
-		case "compaction/summary":
-		case "compaction/prune":
-			data = {
-				...data,
-				shadowedRange: range(data["shadowedRange"]),
-				shadowedSeqs: list(data["shadowedSeqs"])
-			};
-			break;
-		case "session/title":
-		case "session/title-llm-request":
-			data = {
-				...data,
-				messageSeqs: list(data["messageSeqs"])
-			};
-			break;
-	}
-	return {
-		...event,
-		seq,
-		data,
-		...event["sourceEventSeqs"] === void 0 ? {} : { sourceEventSeqs: list(event["sourceEventSeqs"]) },
-		...event["surfaceOp"] === void 0 || event["surfaceOp"] === "append" ? {} : { surfaceOp: range(event["surfaceOp"]) }
-	};
-}
-defineSessionFormatMigration({
-	name: "@x1a0f3n9/dsh-session-format-v2-to-v3",
-	fromVersion: 2,
-	toVersion: 3,
-	migrateHeader(header) {
-		assertReleasedV2Header(header);
-		return {
-			...header,
-			version: 3,
-			...header.agentPreset === "code" ? { agentPreset: "ptc" } : {}
-		};
-	},
-	createStage(input) {
-		return new ReleasedV2ToV3Stage(input);
-	},
-	validateTargetHeader: assertReleasedV3Header
-});
-var ReleasedV2ToV3Stage = class {
-	input;
-	headerInheritedEventCount;
-	mapping = [];
-	originalIds = /* @__PURE__ */ new Set();
-	generatedIds = /* @__PURE__ */ new Set();
-	targetSeq = 0;
-	sourceCut;
-	targetCut;
-	lastForeignDeliverySeq;
-	step;
-	head;
-	prompt = "";
-	constructor(input) {
-		this.input = input;
-		assertReleasedV2Header(input.sourceHeader);
-		this.sourceCut = input.sourceHeader.isSeeded ? void 0 : 0;
-		this.targetCut = input.sourceHeader.isSeeded ? void 0 : 0;
-		if (!input.sourceHeader.isSeeded) this.headerInheritedEventCount = 0;
-	}
-	transformEvent(event, context) {
-		if (event.seq !== this.mapping.length) throw new SessionFormatError("format v2 source events must be dense");
-		assertEvent(event, 2);
-		this.observeMessageIds(event);
-		let source = event;
-		const data = record(event.data, event.type);
-		if (event.type === "request/header") {
-			const { system, ...header } = record(data["header"], "request header");
-			const prompt = typeof system === "string" ? system : "";
-			if (prompt !== this.prompt) this.emitSystem(prompt, event, context);
-			source = {
-				...event,
-				data: {
-					...data,
-					header
-				}
-			};
-		}
-		if (SURFACE_TYPES.has(event.type) && this.head === void 0) throw new SessionFormatUnsupportedMigrationError$1("format v2 surface before first step cannot acquire a system head without changing chronology");
-		if (event.type === "session/end-seed" && data["inherited"] === true) {
-			if (!this.input.sourceHeader.isSeeded) throw new SessionFormatError("format v2 unseeded Session contains an inherited end-seed marker");
-			this.sourceCut = event.seq;
-			this.targetCut = this.targetSeq;
-		}
-		if (event.type === "session-log-deepseek/delivery-accepted") {
-			if (data["sessionFormatVersion"] === 3) throw new SessionFormatError("format v2 delivery marker claims target format v3");
-			if (data["sessionFormatVersion"] === 2 && data["sessionId"] !== this.input.sourceHeader.id) this.lastForeignDeliverySeq = event.seq;
-		}
-		const target = remapEvent(source, this.targetSeq, this.mapping);
-		this.mapping.push(this.targetSeq++);
-		context.emitEvent(canonicalizeTransformedEvent(renamePtcEvent(target)));
-		if (event.type === "step/start") {
-			this.step = {
-				turn: data["turn"],
-				step: data["step"]
-			};
-			if (this.head === void 0) this.emitSystem("", event, context);
-		} else if (event.type === "step/end" || event.type === "turn/end") this.step = void 0;
-	}
-	transformRun(run, context) {
-		for (const event of run.expand()) this.transformEvent(event, context);
-	}
-	finish(_context) {
-		const cut = sessionFormatCount(this.sourceCut, "format v2 inherited end-seed marker");
-		if (this.input.sourceInheritedEventCount !== void 0 && this.input.sourceInheritedEventCount !== cut) throw new SessionFormatError("format v2 inherited end-seed marker disagrees with its source cut");
-		if (this.lastForeignDeliverySeq !== void 0 && (this.input.sourceHeader.parentSession === void 0 || this.lastForeignDeliverySeq >= cut)) throw new SessionFormatError("current-generation delivery marker names the wrong Session");
-		return sessionFormatCount(this.targetCut, "format v3 inherited event count");
-	}
-	observeMessageIds(event) {
-		const data = record(event.data, event.type);
-		const messages = event.type === "user/message" ? [data] : event.type === "assistant/message" || event.type === "tool/result" ? [record(data["message"], "message")] : event.type === "agent/inbox/spliced" ? data["inserted"] : event.type === "session/title-llm-request" ? data["messages"] : [];
-		for (const message of messages) {
-			const id = message["id"];
-			if (this.generatedIds.has(id)) throw new SessionFormatUnsupportedMigrationError$1("source message id collides with a generated system message id");
-			this.originalIds.add(id);
-		}
-	}
-	emitSystem(prompt, anchor, context) {
-		if (this.step === void 0) throw new SessionFormatUnsupportedMigrationError$1("format v2 changed request prompt outside an open step cannot retain source chronology");
-		const identity = JSON.stringify([
-			"session-format-v2-to-v3",
-			this.input.sourceHeader.id,
-			anchor.seq,
-			anchor.type
-		]);
-		const id = "v2-to-v3-system-" + createHash("sha256").update(identity).digest("hex");
-		if (this.originalIds.has(id) || this.generatedIds.has(id)) throw new SessionFormatUnsupportedMigrationError$1("generated system message id collides with an existing message id");
-		this.generatedIds.add(id);
-		const seq = this.targetSeq++;
-		context.emitEvent(canonicalizeTransformedEvent({
-			type: "system/message",
-			seq,
-			time: anchor.time,
-			data: {
-				...this.step,
-				message: {
-					id,
-					role: "system",
-					source: {
-						kind: "plugin",
-						plugin: "@x1a0f3n9/dsh-system-prompt"
-					},
-					content: prompt === "" ? [] : [{
-						type: "text",
-						text: prompt
-					}]
-				}
-			},
-			...this.head === void 0 ? { surfaceOp: "append" } : {
-				surfaceOp: {
-					op: "replace",
-					start: this.head,
-					end: this.head
-				},
-				sourceEventSeqs: [this.head]
-			}
-		}));
-		this.head = seq;
-		this.prompt = prompt;
-	}
-};
-/** Source admission precedes renaming, so these payloads have exact audited fields. */
-function renamePtcEvent(event) {
-	switch (event.type) {
-		case "agent-preset/selected": return event.data["agentPreset"] === "code" ? {
-			...event,
-			data: {
-				...event.data,
-				agentPreset: "ptc"
-			}
-		} : event;
-		case "tool/code-dispatch-start": return {
-			...event,
-			type: "tool/ptc-dispatch-start"
-		};
-		case "tool/code-dispatch": return {
-			...event,
-			type: "tool/ptc-dispatch"
-		};
-		case "user/message": {
-			const data = renameMessageSource(event.data);
-			return data === event.data ? event : {
-				...event,
-				data
-			};
-		}
-		case "agent/inbox/spliced":
-		case "session/title-llm-request": {
-			const data = event.data;
-			const key = event.type === "agent/inbox/spliced" ? "inserted" : "messages";
-			const messages = data[key];
-			const renamed = messages.map(renameMessageSource);
-			return renamed.every((message, index) => message === messages[index]) ? event : {
-				...event,
-				data: {
-					...data,
-					[key]: renamed
-				}
-			};
-		}
-		default: return event;
-	}
-}
-function renameMessageSource(message) {
-	const source = message["source"];
-	if (source["kind"] !== "plugin" || source["plugin"] !== "tools-code-mode") return message;
-	return {
-		...message,
-		source: {
-			...source,
-			plugin: "tools-ptc"
-		}
-	};
-}
-//#endregion
 //#region lib/types/history-suffix.js
 /**
 * Tail-page decoder for JSONL session logs. It scans cheap Zstandard frame
@@ -5700,7 +1829,7 @@ function parseEventRecords(plaintext) {
 * @returns the logical event used for pagination.
 */
 function decodeSuffixEvent(parsed) {
-	assertV3RowAdmission(parsed);
+	assertV4RowAdmission(parsed, KNOWN_SESSION_EVENT_TYPES);
 	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("corrupt session log: event row is not a JSON object");
 	const record = parsed;
 	if (record["sourceEventSeqs"] === void 0) return record;