kiokuko-dsh 0.2.7 → 0.2.9

package/dist/dsh/legacy-session-codecs.js

@@ -142,7 +142,7 @@ var PartialArguments = class PartialArguments2 {
   * @returns top-level keys seen so far, in first-appearance order.
   */
   keys() {
-    return this.remember("keys", "", () => this.keysNow(), (keys) => keys.length);
+    return this.remember("keys", "", () => this.keysNow(), (keys2) => keys2.length);
   }
   /**
   * Check whether a top-level field has appeared.
@@ -642,9 +642,9 @@ function hasPlainObjectPrototype(value) {
   return prototype === null || typeof prototype === "object" && isIntrinsicObjectPrototype(prototype);
 }
 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;
+  const keys2 = Reflect.ownKeys(value);
+  if (keys2.some((key) => typeof key !== "string" || !Object.prototype.propertyIsEnumerable.call(value, key))) return void 0;
+  return keys2;
 }
 function walkJsonValue(value, detach) {
   const ancestors = /* @__PURE__ */ new Set();
@@ -731,8 +731,8 @@ function walkJsonValue(value, detach) {
       continue;
     }
     if (!hasPlainObjectPrototype(current)) return void 0;
-    const keys = enumerableStringKeys(current);
-    if (keys === void 0) return void 0;
+    const keys2 = enumerableStringKeys(current);
+    if (keys2 === void 0) return void 0;
     const target = detach ? {} : void 0;
     if (target !== void 0) assign(task.destination, target);
     ancestors.add(current);
@@ -740,8 +740,8 @@ function walkJsonValue(value, detach) {
       kind: "leave",
       source: current
     });
-    for (let index = keys.length - 1; index >= 0; index--) {
-      const key = keys[index];
+    for (let index = keys2.length - 1; index >= 0; index--) {
+      const key = keys2[index];
       if (key === void 0) return void 0;
       tasks.push({
         kind: "object-property",
@@ -768,9 +768,9 @@ function deepEqualJson(a, b) {
   }
   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]));
+  const keys2 = Object.keys(left);
+  if (keys2.length !== Object.keys(right).length) return false;
+  return keys2.every((key) => key in right && deepEqualJson(left[key], right[key]));
 }
 function deepFreeze(value) {
   const seen = /* @__PURE__ */ new WeakSet();
@@ -794,9 +794,9 @@ function deepFreeze(value) {
     if (seen.has(node)) continue;
     seen.add(node);
     Object.freeze(node);
-    const keys = Object.keys(node);
-    for (let index = keys.length - 1; index >= 0; index--) {
-      const key = keys[index];
+    const keys2 = Object.keys(node);
+    for (let index = keys2.length - 1; index >= 0; index--) {
+      const key = keys2[index];
       if (key === void 0) continue;
       pending.push({
         kind: "property",
@@ -1065,11 +1065,11 @@ function releasedV0Record(value, label) {
   if (!isSessionFormatJsonObject(value)) throw new SessionFormatError(`${label} must be a JSON object`);
   return value;
 }
-function assertReleasedV0Keys(record2, required, optional = [], label) {
+function assertReleasedV0Keys(record3, required, optional = [], label) {
   const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
-  const unexpected = Object.keys(record2).find((key) => !allowed.has(key));
+  const unexpected = Object.keys(record3).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(record2, key));
+  const missing = required.find((key) => !Object.hasOwn(record3, key));
   if (missing !== void 0) throw new SessionFormatError(`${label} lacks required member ${JSON.stringify(missing)}`);
 }
 function assertReleasedPayloadSemantics(event, version) {
@@ -1365,9 +1365,9 @@ function assertReleasedPayloadSemantics(event, version) {
   }
 }
 function exactRecord(value, label, required, optional = []) {
-  const record2 = releasedV0Record(value, label);
-  assertReleasedV0Keys(record2, required, optional, label);
-  return record2;
+  const record3 = releasedV0Record(value, label);
+  assertReleasedV0Keys(record3, required, optional, label);
+  return record3;
 }
 function stringValue(value, label) {
   if (typeof value !== "string") throw new SessionFormatError(`${label} must be a string`);
@@ -2040,35 +2040,35 @@ function scheduleChangeValue(data, label) {
   if (data["acceptedAt"] !== void 0) instantValue(data["acceptedAt"], `${label} acceptedAt`);
 }
 function scheduleRecordValue(value, label) {
-  const record2 = releasedV0Record(value, label);
-  if (record2["kind"] === "after") {
-    assertReleasedV0Keys(record2, [
+  const record3 = releasedV0Record(value, label);
+  if (record3["kind"] === "after") {
+    assertReleasedV0Keys(record3, [
       "id",
       "kind",
       "prompt",
       "afterSeconds",
       "scheduledAt"
     ], [], label);
-    positiveIntegerValue(record2["afterSeconds"], `${label} afterSeconds`);
-  } else if (record2["kind"] === "at") assertReleasedV0Keys(record2, [
+    positiveIntegerValue(record3["afterSeconds"], `${label} afterSeconds`);
+  } else if (record3["kind"] === "at") assertReleasedV0Keys(record3, [
     "id",
     "kind",
     "prompt",
     "scheduledAt"
   ], [], label);
-  else if (record2["kind"] === "every") {
-    assertReleasedV0Keys(record2, [
+  else if (record3["kind"] === "every") {
+    assertReleasedV0Keys(record3, [
       "id",
       "kind",
       "prompt",
       "everySeconds",
       "scheduledAt"
     ], [], label);
-    if (positiveIntegerValue(record2["everySeconds"], `${label} everySeconds`) < 300) throw new SessionFormatError(`${label} everySeconds must be at least 300`);
+    if (positiveIntegerValue(record3["everySeconds"], `${label} everySeconds`) < 300) throw new SessionFormatError(`${label} everySeconds must be at least 300`);
   } else throw new SessionFormatError(`${label} has unknown schedule kind`);
-  scheduleIdValue(record2["id"], `${label} id`);
-  nonEmptyString(record2["prompt"], `${label} prompt`);
-  instantValue(record2["scheduledAt"], `${label} scheduledAt`);
+  scheduleIdValue(record3["id"], `${label} id`);
+  nonEmptyString(record3["prompt"], `${label} prompt`);
+  instantValue(record3["scheduledAt"], `${label} scheduledAt`);
 }
 function scheduleIdValue(value, label) {
   nonEmptyString(value, label);
@@ -2246,24 +2246,50 @@ var HEADER_OPTIONAL = [
   "agentPreset"
 ];
 function assertReleasedSessionFormatHeader(header, version) {
-  const record2 = releasedV0Record(header, `format v${version} header`);
-  assertReleasedV0Keys(record2, HEADER_REQUIRED, HEADER_OPTIONAL, `format v${version} header`);
-  if (record2["version"] !== version) throw new SessionFormatError(`expected format v${version} header`);
-  if (typeof record2["id"] !== "string") throw new SessionFormatError(`format v${version} header id must be a string`);
-  sessionFormatCount(record2["createdAt"], `format v${version} header createdAt`);
-  if (typeof record2["isSeeded"] !== "boolean") throw new SessionFormatError(`format v${version} header isSeeded must be a boolean`);
-  sessionFormatCount(record2["delegationDepth"], `format v${version} header delegationDepth`);
+  const record3 = releasedV0Record(header, `format v${version} header`);
+  assertReleasedV0Keys(record3, HEADER_REQUIRED, HEADER_OPTIONAL, `format v${version} header`);
+  if (record3["version"] !== version) throw new SessionFormatError(`expected format v${version} header`);
+  if (typeof record3["id"] !== "string") throw new SessionFormatError(`format v${version} header id must be a string`);
+  sessionFormatCount(record3["createdAt"], `format v${version} header createdAt`);
+  if (typeof record3["isSeeded"] !== "boolean") throw new SessionFormatError(`format v${version} header isSeeded must be a boolean`);
+  sessionFormatCount(record3["delegationDepth"], `format v${version} header delegationDepth`);
   for (const key of [
     "cwd",
     "parentSession",
     "agentPreset"
-  ]) if (record2[key] !== void 0 && typeof record2[key] !== "string") throw new SessionFormatError(`format v${version} header ${key} must be a string`);
-  if (typeof record2["cwd"] === "string" && !isAbsolute(record2["cwd"])) throw new SessionFormatError(`format v${version} header cwd must be absolute`);
-  if (record2["origin"] !== void 0 && record2["origin"] !== "subagent") throw new SessionFormatError(`format v${version} header origin must be "subagent"`);
+  ]) if (record3[key] !== void 0 && typeof record3[key] !== "string") throw new SessionFormatError(`format v${version} header ${key} must be a string`);
+  if (typeof record3["cwd"] === "string" && !isAbsolute(record3["cwd"])) throw new SessionFormatError(`format v${version} header cwd must be absolute`);
+  if (record3["origin"] !== void 0 && record3["origin"] !== "subagent") throw new SessionFormatError(`format v${version} header origin must be "subagent"`);
 }
 function assertReleasedV1Header(header) {
   assertReleasedSessionFormatHeader(header, 1);
 }
+function assertReleasedSurfaceMetadata(record3, seq, type, assistantSources) {
+  const sources = record3["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 = record3["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`);
+}
 function assertReleasedEventPayload(event, version) {
   const disposition2 = RELEASED_V0_EVENT_DISPOSITIONS[event.type];
   if (disposition2 === void 0) throw new SessionFormatUnsupportedMigrationError(`format v0 contains unknown historical event type ${JSON.stringify(event.type)} at seq ${event.seq}; migration refuses unknown historical events even when ignorable`);
@@ -2334,12 +2360,12 @@ function scanRows(recoverable) {
       let packed = false;
       let decoded;
       try {
-        const record2 = releasedV0Record(rowValue, `released Session row ${currentRow}`);
-        const type = record2["type"];
+        const record3 = releasedV0Record(rowValue, `released Session row ${currentRow}`);
+        const type = record3["type"];
         if (typeof type === "string" && PACKED_TAGS.has(type)) {
           packed = true;
-          decoded = decodePackedRun(record2, type, currentRow);
-        } else decoded = decodeEvent(record2, currentRow);
+          decoded = decodePackedRun(record3, type, currentRow);
+        } else decoded = decodeEvent(record3, currentRow);
       } catch (error) {
         const current = error instanceof SessionFormatError ? error : new SessionFormatError(`released Session row ${currentRow} is malformed`, { cause: error });
         if (!recoverable) throw current;
@@ -2376,29 +2402,29 @@ function decodeHeader(value, version) {
   return decodePhysicalHeader(value, version).header;
 }
 function decodePhysicalHeader(value, version) {
-  const record2 = releasedV0Record(snapshotSessionFormatJson(value, `released v${version} physical header`), `released v${version} physical header`);
-  assertReleasedV0Keys(record2, PHYSICAL_HEADER_REQUIRED, PHYSICAL_HEADER_OPTIONAL, `released v${version} physical header`);
-  if (record2["type"] !== "session" || record2["version"] !== version) throw new SessionFormatError(`expected released v${version} physical Session header`);
-  if (typeof record2["id"] !== "string") throw new SessionFormatError(`released v${version} header id must be a string`);
-  const createdAt = sessionFormatCount(record2["createdAt"], `released v${version} header createdAt`);
-  const delegationDepth = sessionFormatCount(record2["delegationDepth"], `released v${version} header delegationDepth`);
-  const seedLength = record2["seedLength"] === void 0 ? 0 : sessionFormatCount(record2["seedLength"], `released v${version} header seedLength`);
+  const record3 = releasedV0Record(snapshotSessionFormatJson(value, `released v${version} physical header`), `released v${version} physical header`);
+  assertReleasedV0Keys(record3, PHYSICAL_HEADER_REQUIRED, PHYSICAL_HEADER_OPTIONAL, `released v${version} physical header`);
+  if (record3["type"] !== "session" || record3["version"] !== version) throw new SessionFormatError(`expected released v${version} physical Session header`);
+  if (typeof record3["id"] !== "string") throw new SessionFormatError(`released v${version} header id must be a string`);
+  const createdAt = sessionFormatCount(record3["createdAt"], `released v${version} header createdAt`);
+  const delegationDepth = sessionFormatCount(record3["delegationDepth"], `released v${version} header delegationDepth`);
+  const seedLength = record3["seedLength"] === void 0 ? 0 : sessionFormatCount(record3["seedLength"], `released v${version} header seedLength`);
   for (const key of [
     "cwd",
     "parentSession",
     "agentPreset"
-  ]) if (record2[key] !== void 0 && typeof record2[key] !== "string") throw new SessionFormatError(`released v${version} header ${key} must be a string`);
-  if (record2["origin"] !== void 0 && record2["origin"] !== "subagent") throw new SessionFormatError(`released v${version} header origin must be "subagent"`);
+  ]) if (record3[key] !== void 0 && typeof record3[key] !== "string") throw new SessionFormatError(`released v${version} header ${key} must be a string`);
+  if (record3["origin"] !== void 0 && record3["origin"] !== "subagent") throw new SessionFormatError(`released v${version} header origin must be "subagent"`);
   const header = {
     version,
-    id: record2["id"],
+    id: record3["id"],
     createdAt,
-    ...record2["cwd"] === void 0 ? {} : { cwd: record2["cwd"] },
-    ...record2["parentSession"] === void 0 ? {} : { parentSession: record2["parentSession"] },
-    isSeeded: record2["seedLength"] !== void 0,
-    ...record2["origin"] === void 0 ? {} : { origin: record2["origin"] },
+    ...record3["cwd"] === void 0 ? {} : { cwd: record3["cwd"] },
+    ...record3["parentSession"] === void 0 ? {} : { parentSession: record3["parentSession"] },
+    isSeeded: record3["seedLength"] !== void 0,
+    ...record3["origin"] === void 0 ? {} : { origin: record3["origin"] },
     delegationDepth,
-    ...record2["agentPreset"] === void 0 ? {} : { agentPreset: record2["agentPreset"] }
+    ...record3["agentPreset"] === void 0 ? {} : { agentPreset: record3["agentPreset"] }
   };
   assertReleasedSessionFormatHeader(header, version);
   return {
@@ -2406,15 +2432,15 @@ function decodePhysicalHeader(value, version) {
     inheritedEventCount: seedLength
   };
 }
-function decodeEvent(record2, rowIndex) {
-  if (record2["sourceEventSeqs"] !== void 0) {
-    const seq = sessionFormatCount(record2["seq"], `released Session row ${rowIndex} seq`);
+function decodeEvent(record3, rowIndex) {
+  if (record3["sourceEventSeqs"] !== void 0) {
+    const seq = sessionFormatCount(record3["seq"], `released Session row ${rowIndex} seq`);
     return {
-      ...record2,
-      sourceEventSeqs: decodeSeqRanges(record2["sourceEventSeqs"], seq)
+      ...record3,
+      sourceEventSeqs: decodeSeqRanges(record3["sourceEventSeqs"], seq)
     };
   }
-  return record2;
+  return record3;
 }
 function decodePackedRun(row, type, rowIndex) {
   const label = `released ${type} row ${rowIndex}`;
@@ -2828,16 +2854,16 @@ function normalizeLegacyErrorReason(reason, seq, sessionId) {
       "step",
       "failure"
     ], [], `turn/end ${seq} reason`);
-    const record2 = releasedV0Record(failure, `turn/end ${seq} failure`);
-    assertReleasedV0Keys(record2, ["message", "code"], [
+    const record3 = releasedV0Record(failure, `turn/end ${seq} failure`);
+    assertReleasedV0Keys(record3, ["message", "code"], [
       "status",
       "providerRetryAfterMs",
       "requestId"
     ], `turn/end ${seq} failure`);
-    if (typeof record2["message"] !== "string" || typeof record2["code"] !== "string") throw malformedLegacy(sessionId, "turn/end", seq);
+    if (typeof record3["message"] !== "string" || typeof record3["code"] !== "string") throw malformedLegacy(sessionId, "turn/end", seq);
     return {
       kind: "error",
-      error: record2
+      error: record3
     };
   }
   assertReleasedV0Keys(reason, [
@@ -3045,10 +3071,10 @@ var AssistantStreamAccumulator = class {
    * @returns a detached immutable record list suitable for a durable event.
    */
   snapshot() {
-    const records = this.records.map((record2) => {
-      if (record2.type === "chunk")
-        return { ...record2 };
-      const { lastTime: _lastTime, ...durable } = record2;
+    const records = this.records.map((record3) => {
+      if (record3.type === "chunk")
+        return { ...record3 };
+      const { lastTime: _lastTime, ...durable } = record3;
       if (durable.type === "tool-call-chunks") {
         return { ...durable, dt: [...durable.dt], args: [...durable.args] };
       }
@@ -3091,16 +3117,16 @@ var HEADER_OPTIONAL$1 = [
   "agentPreset"
 ];
 function assertReleasedV2Header(header) {
-  const record2 = releasedV2Record(header, "format v2 header");
-  assertReleasedV2Keys(record2, HEADER_REQUIRED$1, HEADER_OPTIONAL$1, "format v2 header");
-  if (record2["version"] !== 2) throw new SessionFormatError("expected format v2 header");
-  if (typeof record2["id"] !== "string") throw new SessionFormatError("format v2 header id must be a string");
-  sessionFormatCount(record2["createdAt"], "format v2 header createdAt");
-  sessionFormatCount(record2["delegationDepth"], "format v2 header delegationDepth");
-  if (typeof record2["isSeeded"] !== "boolean") throw new SessionFormatError("format v2 header isSeeded must be boolean");
-  if (record2["cwd"] !== void 0 && (typeof record2["cwd"] !== "string" || !isAbsolute2(record2["cwd"]))) throw new SessionFormatError("format v2 header cwd must be absolute");
-  for (const key of ["parentSession", "agentPreset"]) if (record2[key] !== void 0 && typeof record2[key] !== "string") throw new SessionFormatError(`format v2 header ${key} must be a string`);
-  if (record2["origin"] !== void 0 && record2["origin"] !== "subagent") throw new SessionFormatError('format v2 header origin must be "subagent"');
+  const record3 = releasedV2Record(header, "format v2 header");
+  assertReleasedV2Keys(record3, HEADER_REQUIRED$1, HEADER_OPTIONAL$1, "format v2 header");
+  if (record3["version"] !== 2) throw new SessionFormatError("expected format v2 header");
+  if (typeof record3["id"] !== "string") throw new SessionFormatError("format v2 header id must be a string");
+  sessionFormatCount(record3["createdAt"], "format v2 header createdAt");
+  sessionFormatCount(record3["delegationDepth"], "format v2 header delegationDepth");
+  if (typeof record3["isSeeded"] !== "boolean") throw new SessionFormatError("format v2 header isSeeded must be boolean");
+  if (record3["cwd"] !== void 0 && (typeof record3["cwd"] !== "string" || !isAbsolute2(record3["cwd"]))) throw new SessionFormatError("format v2 header cwd must be absolute");
+  for (const key of ["parentSession", "agentPreset"]) if (record3[key] !== void 0 && typeof record3[key] !== "string") throw new SessionFormatError(`format v2 header ${key} must be a string`);
+  if (record3["origin"] !== void 0 && record3["origin"] !== "subagent") throw new SessionFormatError('format v2 header origin must be "subagent"');
 }
 function releasedV2Record(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) throw new SessionFormatError(`${label} must be an object`);
@@ -3155,29 +3181,29 @@ var releasedV2SessionFormatCodec = Object.freeze({
   }
 });
 function decodePhysicalHeader2(value) {
-  const record2 = jsonRecord(snapshotSessionFormatJson(value, "released v2 physical header"), "released v2 physical header");
-  exactKeys(record2, HEADER_REQUIRED2, HEADER_OPTIONAL2, "released v2 physical header");
-  if (record2["type"] !== "session" || record2["version"] !== 2) throw new SessionFormatError("expected released v2 physical Session header");
-  if (typeof record2["id"] !== "string") throw new SessionFormatError("released v2 header id must be a string");
-  const createdAt = sessionFormatCount(record2["createdAt"], "released v2 header createdAt");
-  const delegationDepth = sessionFormatCount(record2["delegationDepth"], "released v2 header delegationDepth");
-  if (typeof record2["isSeeded"] !== "boolean") throw new SessionFormatError("released v2 header isSeeded must be boolean");
+  const record3 = jsonRecord(snapshotSessionFormatJson(value, "released v2 physical header"), "released v2 physical header");
+  exactKeys(record3, HEADER_REQUIRED2, HEADER_OPTIONAL2, "released v2 physical header");
+  if (record3["type"] !== "session" || record3["version"] !== 2) throw new SessionFormatError("expected released v2 physical Session header");
+  if (typeof record3["id"] !== "string") throw new SessionFormatError("released v2 header id must be a string");
+  const createdAt = sessionFormatCount(record3["createdAt"], "released v2 header createdAt");
+  const delegationDepth = sessionFormatCount(record3["delegationDepth"], "released v2 header delegationDepth");
+  if (typeof record3["isSeeded"] !== "boolean") throw new SessionFormatError("released v2 header isSeeded must be boolean");
   for (const key of [
     "cwd",
     "parentSession",
     "agentPreset"
-  ]) if (record2[key] !== void 0 && typeof record2[key] !== "string") throw new SessionFormatError(`released v2 header ${key} must be a string`);
-  if (record2["origin"] !== void 0 && record2["origin"] !== "subagent") throw new SessionFormatError('released v2 header origin must be "subagent"');
+  ]) if (record3[key] !== void 0 && typeof record3[key] !== "string") throw new SessionFormatError(`released v2 header ${key} must be a string`);
+  if (record3["origin"] !== void 0 && record3["origin"] !== "subagent") throw new SessionFormatError('released v2 header origin must be "subagent"');
   const header = snapshotSessionFormatJson({
     version: 2,
-    id: record2["id"],
+    id: record3["id"],
     createdAt,
-    ...record2["cwd"] === void 0 ? {} : { cwd: record2["cwd"] },
-    ...record2["parentSession"] === void 0 ? {} : { parentSession: record2["parentSession"] },
-    isSeeded: record2["isSeeded"],
-    ...record2["origin"] === void 0 ? {} : { origin: record2["origin"] },
+    ...record3["cwd"] === void 0 ? {} : { cwd: record3["cwd"] },
+    ...record3["parentSession"] === void 0 ? {} : { parentSession: record3["parentSession"] },
+    isSeeded: record3["isSeeded"],
+    ...record3["origin"] === void 0 ? {} : { origin: record3["origin"] },
     delegationDepth,
-    ...record2["agentPreset"] === void 0 ? {} : { agentPreset: record2["agentPreset"] }
+    ...record3["agentPreset"] === void 0 ? {} : { agentPreset: record3["agentPreset"] }
   }, "released v2 logical header");
   assertReleasedV2Header(header);
   return header;
@@ -3227,19 +3253,19 @@ function createDecoder(headerValue, recovery) {
   };
 }
 function decodeEvent2(value, rowIndex) {
-  const record2 = jsonRecord(value, `released v2 row ${rowIndex}`);
-  const missing = EVENT_REQUIRED.find((key) => !Object.hasOwn(record2, key));
+  const record3 = jsonRecord(value, `released v2 row ${rowIndex}`);
+  const missing = EVENT_REQUIRED.find((key) => !Object.hasOwn(record3, key));
   if (missing !== void 0) throw new SessionFormatError(`released v2 row ${rowIndex} lacks required field ${missing}`);
-  const unexpected = Object.keys(record2).find((key) => !EVENT_KEYS.has(key));
+  const unexpected = Object.keys(record3).find((key) => !EVENT_KEYS.has(key));
   if (unexpected !== void 0) throw new SessionFormatError(`released v2 row ${rowIndex} has unexpected field ${unexpected}`);
-  if (typeof record2["type"] !== "string") throw new SessionFormatError(`released v2 row ${rowIndex} type must be a string`);
-  sessionFormatSafeInteger(record2["time"], `released v2 row ${rowIndex} time`);
-  if (record2["ignorable"] !== void 0 && record2["ignorable"] !== true) throw new SessionFormatError(`released v2 row ${rowIndex} ignorable must be true when present`);
-  if (record2["sourceEventSeqs"] === void 0) return record2;
-  const seq = sessionFormatCount(record2["seq"], `released v2 row ${rowIndex} seq`);
+  if (typeof record3["type"] !== "string") throw new SessionFormatError(`released v2 row ${rowIndex} type must be a string`);
+  sessionFormatSafeInteger(record3["time"], `released v2 row ${rowIndex} time`);
+  if (record3["ignorable"] !== void 0 && record3["ignorable"] !== true) throw new SessionFormatError(`released v2 row ${rowIndex} ignorable must be true when present`);
+  if (record3["sourceEventSeqs"] === void 0) return record3;
+  const seq = sessionFormatCount(record3["seq"], `released v2 row ${rowIndex} seq`);
   return {
-    ...record2,
-    sourceEventSeqs: decodeSeqRanges2(record2["sourceEventSeqs"], seq)
+    ...record3,
+    sourceEventSeqs: decodeSeqRanges2(record3["sourceEventSeqs"], seq)
   };
 }
 function encodeHeader(header, inheritedEventCount) {
@@ -3310,11 +3336,11 @@ 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(record2, required, optional, label) {
+function exactKeys(record3, required, optional, label) {
   const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
-  const missing = required.find((key) => !Object.hasOwn(record2, key));
+  const missing = required.find((key) => !Object.hasOwn(record3, key));
   if (missing !== void 0) throw new SessionFormatError(`${label} lacks ${missing}`);
-  const unexpected = Object.keys(record2).find((key) => !allowed.has(key));
+  const unexpected = Object.keys(record3).find((key) => !allowed.has(key));
   if (unexpected !== void 0) throw new SessionFormatError(`${label} has unexpected field ${unexpected}`);
 }
 var CHUNK_EVENT_REQUIRED = [
@@ -3641,21 +3667,21 @@ function matchesChunkSources(group, sources) {
   }
   return true;
 }
-function recordLastTime(record2) {
-  if (record2.type === "chunk") return record2.time;
-  return record2.dt.reduce((time, gap) => time + gap, record2.time0);
+function recordLastTime(record3) {
+  if (record3.type === "chunk") return record3.time;
+  return record3.dt.reduce((time, gap) => time + gap, record3.time0);
 }
-function mutableRecord(record2) {
-  if (record2.type === "chunk") return record2;
-  if (record2.type === "tool-call-chunks") return {
-    ...record2,
-    dt: [...record2.dt],
-    args: [...record2.args]
+function mutableRecord(record3) {
+  if (record3.type === "chunk") return record3;
+  if (record3.type === "tool-call-chunks") return {
+    ...record3,
+    dt: [...record3.dt],
+    args: [...record3.args]
   };
   return {
-    ...record2,
-    dt: [...record2.dt],
-    texts: [...record2.texts]
+    ...record3,
+    dt: [...record3.dt],
+    texts: [...record3.texts]
   };
 }
 function appendStreamRecord(group, source, lastTime, owned = true) {
@@ -3698,12 +3724,12 @@ function appendStreamRecord(group, source, lastTime, owned = true) {
 function flushAccumulator(group) {
   const accumulator = group.accumulator;
   if (accumulator === void 0) return;
-  for (const record2 of accumulator.snapshot()) appendStreamRecord(group, record2, recordLastTime(record2), false);
+  for (const record3 of accumulator.snapshot()) appendStreamRecord(group, record3, recordLastTime(record3), false);
   delete group.accumulator;
 }
 function streamOf(group) {
   flushAccumulator(group);
-  return group.stream.map(({ record: record2 }) => record2);
+  return group.stream.map(({ record: record3 }) => record3);
 }
 function messageEvent(source, group) {
   const data = record(source.data);
@@ -3798,9 +3824,687 @@ function coordinate(value) {
 function refusal(message) {
   return new SessionFormatUnsupportedMigrationError(message);
 }
+
+// node_modules/@deepseek-ai/dsh-session-format-v2-to-v3/lib/index.js
+import { createHash } from "node:crypto";
+var SURFACE_TYPES = /* @__PURE__ */ new Set([
+  "system/message",
+  "user/message",
+  "assistant/message",
+  "tool/result"
+]);
+var SOURCE_KINDS = /* @__PURE__ */ 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"
+]);
+function record2(value, label) {
+  if (!isSessionFormatJsonObject(value)) throw new SessionFormatError(label + " must be an object");
+  return value;
+}
+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);
+}
+function assertEvent(event, version) {
+  if (version === 3) {
+    assertV3Event(event);
+    return;
+  }
+  const disposition2 = RELEASED_V2_EVENT_DISPOSITIONS[event.type];
+  const feedback = event.type === "feedback/message-put" || event.type === "feedback/message-delete";
+  if (disposition2 === void 0 && !feedback) throw new SessionFormatUnsupportedMigrationError("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 = record2(event.data, event.type + " data");
+  if (feedback) {
+    assertFeedback(event.type, data);
+    return;
+  }
+  const admitted = disposition2;
+  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 coordinate2 of ["turn", "step"]) if (sessionFormatCount(data[coordinate2], coordinate2) === 0) throw new SessionFormatError(coordinate2 + " 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(record2(data["message"], "message"));
+  if (event.type === "tool/result" && isSessionFormatJsonObject(data["error"]) && data["error"]["code"] === "TOOL_NOT_STARTED") {
+    const message = record2(data["message"], "tool result message");
+    const source = record2(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);
+  }
+}
+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 = record2(message["source"], "message source");
+  if (typeof source["kind"] !== "string" || !SOURCE_KINDS.has(source["kind"])) throw new SessionFormatUnsupportedMigrationError("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");
+  }
+}
+var CONTENT_KINDS = /* @__PURE__ */ 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(record2(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(record2(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 = record2(value, path);
+    if (entry["type"] !== "chunk") continue;
+    const chunk = record2(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(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 = record2(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 = record2(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));
+  }
+}
+function assertV3StructuralRow(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return;
+  const row = value;
+  if (row["type"] === "request/header") {
+    const data = record2(row["data"], "request/header data");
+    if (Object.hasOwn(record2(data["header"], "request header"), "system")) throw new SessionFormatUnsupportedMigrationError("format v3 request/header rejects retired header.system");
+  } else if (row["type"] === "system/message") {
+    const data = record2(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 coordinate2 of ["turn", "step"]) if (sessionFormatCount(data[coordinate2], coordinate2) === 0) throw new SessionFormatError(coordinate2 + " must be positive");
+  const message = record2(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 = record2(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 = record2(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");
+}
+function assertV3Event(event, knownEventTypes) {
+  const value = record2(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 = record2(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 = record2(record2(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 = record2(event.data, `${subject} data`);
+  if (data["error"] === void 0) return;
+  const content = record2(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`);
+}
+function canonicalizeTransformedEvent(event) {
+  let target = event;
+  const operation = event["surfaceOp"];
+  if (operation !== void 0 && operation !== "append") {
+    const replace = record2(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 = record2(event.data, `format v2 request/header at seq ${event.seq} data`);
+    const header = record2(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;
+}
+function assertReleasedV3Header(header) {
+  if (header.version !== 3) throw new SessionFormatError("expected format v3 header");
+  assertReleasedV2Header({
+    ...header,
+    version: 2
+  });
+}
+function assertV3EventAdmission(event) {
+  if ((event.type === "tool/code-dispatch-start" || event.type === "tool/code-dispatch") && event["ignorable"] !== true) throw new SessionFormatUnsupportedMigrationError("format v3 contains unknown event type " + JSON.stringify(event.type) + " at seq " + String(event.seq));
+}
+var releasedV3SessionFormatCodec = 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);
+  }
+});
+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
+  };
+}
+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 = record2(value, "sequence range");
+    return {
+      ...source,
+      start: one(source["start"]),
+      end: one(source["end"])
+    };
+  };
+  let data = record2(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"]) }
+  };
+}
+var sessionFormatV2ToV3 = defineSessionFormatMigration({
+  name: "@deepseek-ai/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 = record2(event.data, event.type);
+    if (event.type === "request/header") {
+      const { system, ...header } = record2(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("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 = record2(event.data, event.type);
+    const messages = event.type === "user/message" ? [data] : event.type === "assistant/message" || event.type === "tool/result" ? [record2(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("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("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("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: "@deepseek-ai/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;
+  }
+};
+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"
+    }
+  };
+}
 export {
   releasedV0SessionFormatCodec,
   releasedV1SessionFormatCodec,
-  releasedV2SessionFormatCodec
+  releasedV2SessionFormatCodec,
+  releasedV3SessionFormatCodec
 };
 //# sourceMappingURL=legacy-session-codecs.js.map