@codexhost/cli-darwin-x64 0.10.0 → 0.10.1

package/app/plugins/deepseek-harness/plugin.mjs

@@ -20861,7 +20861,8 @@ var ModernRemoteConnection = class {
     } catch (error51) {
       throw this.#transportFailure("DeepSeek Harness Web authentication failed", error51);
     }
-    if (response.status !== 303 || response.headers.get("location") !== "/") {
+    const location = response.headers.get("location");
+    if (response.status !== 303 || location !== "/" && location !== "./") {
       await cancelResponse(response);
       throw new ModernRemoteConnectionError(response.status === 401 || response.status === 403 ? "authenticationRequired" : "protocolError", "DeepSeek Harness Web rejected its bootstrap authentication exchange");
     }
@@ -21393,7 +21394,7 @@ function parseEvent(value, format = 0) {
     throw protocolError("journal event has invalid scalar fields");
   }
   assertJsonValue(value.data, "journal event data");
-  if (format === 3 && value.ignorable === true) {
+  if (format >= 3 && value.ignorable === true) {
     if (Object.hasOwn(value, "sourceEventSeqs"))
       assertJsonValue(value.sourceEventSeqs, "journal event sourceEventSeqs");
     if (Object.hasOwn(value, "surfaceOp"))
@@ -21412,8 +21413,8 @@ function parseEvent(value, format = 0) {
 function parseSurfaceOp(value, format) {
   if (value === "append")
     return value;
-  const start = format === 3 ? "startSeq" : "start";
-  const end = format === 3 ? "endSeq" : "end";
+  const start = format >= 3 ? "startSeq" : "start";
+  const end = format >= 3 ? "endSeq" : "end";
   if (!isRecord3(value) || !hasExactKeys2(value, ["op", start, end]) || value.op !== "replace" || !isSeq(value[start]) || !isSeq(value[end])) {
     throw protocolError("journal event has an invalid surfaceOp");
   }
@@ -21915,12 +21916,33 @@ function parseArguments(value) {
     return value;
   }
 }
+function contentText(value) {
+  if (!isRecord4(value) || !Array.isArray(value.content))
+    return "";
+  return value.content.filter((block) => isRecord4(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text).join("");
+}
 function projectToolResult(value, limit) {
   if (!isRecord4(value) || !isRecord4(value.source) || value.source.kind !== "tool")
     return null;
   const callId = value.source.callId;
   if (!nonBlankString(callId) || !Array.isArray(value.content))
     return null;
+  if (value.role === "tool") {
+    if (value.toolCallId !== callId || value.isError !== void 0 && typeof value.isError !== "boolean")
+      return null;
+    const text2 = contentText(value);
+    const truncated2 = text2.length > limit;
+    return {
+      callId,
+      failed: value.isError === true,
+      ...text2 ? {
+        output: {
+          content: [{ type: "text", text: truncated2 ? text2.slice(0, limit) : text2 }],
+          ...truncated2 ? { truncated: true } : {}
+        }
+      } : {}
+    };
+  }
   const resultBlocks = value.content.filter((block) => isRecord4(block) && block.type === "tool-result" && block.toolCallId === callId && Array.isArray(block.content));
   if (resultBlocks.length === 0)
     return null;
@@ -22036,6 +22058,12 @@ function projectTurnReason(value) {
       history: { status: "cancelled", reason: "Cancelled by user" }
     };
   }
+  if (value.kind === "forked") {
+    return {
+      outcome: { status: "cancelled", reason: "Forked from parent Session" },
+      history: { status: "cancelled", reason: "Forked from parent Session" }
+    };
+  }
   const error51 = {
     code: "nativeFailure",
     message: value.kind === "error" && isRecord4(value.error) && typeof value.error.message === "string" ? value.error.message : `DeepSeek Harness Turn ended with '${value.kind}'`,
@@ -22174,6 +22202,12 @@ function positiveInteger(value, label) {
 function nonNegativeInteger(value, label) {
   return boundedInteger(value, label, 0);
 }
+function nonNegativeFiniteNumber(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    fail(`${label} must be a finite number greater than or equal to 0`);
+  }
+  return value;
+}
 function nonNegativeSafeInteger2(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
@@ -22874,13 +22908,219 @@ function matchesForkTail2(expectedPrefix, childEvents) {
   return childOwned.every((event) => event.type !== "turn/start" && event.type !== "session/end-seed");
 }
 
+// dist/profiles/v017.js
+function invalid2(label) {
+  throw new ModernHistoryError("protocolError", `DSH V4 ${label} is malformed`);
+}
+function requiredFields(value, fields) {
+  if (fields.some((field) => !Object.hasOwn(value, field)))
+    invalid2("required fields");
+}
+function validateV4Content(value) {
+  if (!Array.isArray(value))
+    invalid2("content");
+  for (const block of value) {
+    if (!isRecord3(block) || block.type === "tool-result")
+      invalid2("content block");
+    if (block.type === "tool-addition" || block.type === "tool-removal") {
+      requiredString(block.toolName, "tool change toolName");
+      continue;
+    }
+    if (block.type === "image" && block.offloaded !== void 0 && block.offloaded !== true) {
+      invalid2("image offloaded marker");
+    }
+    const ordinary = Object.fromEntries(Object.entries(block).filter(([key]) => key !== "offloaded"));
+    const canonical = block.type === "text" || block.type === "reasoning" ? { type: block.type, text: block.text } : block.type === "image" || block.type === "file" ? { type: block.type, attachment: block.attachment } : block.type === "tool-call" ? { type: block.type, id: block.id, name: block.name, arguments: block.arguments } : ordinary;
+    DEEPSEEK_V015_PROFILE.validateContent([canonical]);
+  }
+}
+function validateV4Chunk(value) {
+  DEEPSEEK_V015_PROFILE.validateChunk(value);
+  if (!isRecord3(value))
+    invalid2("assistant chunk");
+  const blockType = value.type === "block-start" ? value.blockType : value.type === "block-end" && isRecord3(value.block) ? value.block.type : void 0;
+  if (blockType === "tool-result" || blockType === "tool-addition" || blockType === "tool-removal") {
+    invalid2("assistant tool-change block");
+  }
+}
+function validateV4Stream(value) {
+  for (const entry of expandV015AssistantStream(value))
+    validateV4Chunk(entry.chunk);
+}
+function validateDeveloperMessage(event) {
+  if (!isRecord3(event.data))
+    invalid2("developer/message data");
+  const data = event.data;
+  requiredFields(data, ["turn", "step", "message"]);
+  if (Object.hasOwn(data, "headerSeq") && !Number.isSafeInteger(data.headerSeq))
+    invalid2("developer/message headerSeq");
+  positiveInteger(data.turn, "developer/message turn");
+  positiveInteger(data.step, "developer/message step");
+  if (!isRecord3(data.message))
+    invalid2("developer/message message");
+  const message = data.message;
+  requiredFields(message, ["id", "role", "content", "source"]);
+  requiredString(message.id, "developer/message id");
+  if (message.role !== "developer" || !isRecord3(message.source) || typeof message.source.kind !== "string" || !message.source.kind || message.source.kind === "plugin" || !Array.isArray(message.content)) {
+    invalid2("developer/message role, source or content");
+  }
+  let additions = false;
+  for (const block of message.content) {
+    if (!isRecord3(block))
+      invalid2("developer content block");
+    if (block.type === "tool-addition" || block.type === "tool-removal") {
+      requiredString(block.toolName, "developer toolName");
+      additions ||= block.type === "tool-addition";
+    } else {
+      validateV4Content([block]);
+    }
+  }
+  if (additions !== Object.hasOwn(data, "headerSeq") || additions && (!Number.isSafeInteger(data.headerSeq) || Object.is(data.headerSeq, -0) || data.headerSeq < 0 || data.headerSeq >= event.seq)) {
+    invalid2("developer/message headerSeq");
+  }
+}
+function matchesV4ForkTail(prefix, child) {
+  if (!DEEPSEEK_V015_PROFILE.matchesForkTail(prefix, child))
+    return false;
+  const tail = child.slice(prefix.length + 1);
+  const openTurn = prefix.reduce((turn, event) => event.type === "turn/start" ? event.data.turn : event.type === "turn/end" ? null : turn, null);
+  const closer = tail.find((event) => event.type === "turn/end");
+  if (openTurn === null)
+    return closer === void 0 && !tail.some((event) => event.type === "step/end");
+  return closer !== void 0 && isRecord3(closer.data) && closer.data.turn === openTurn && isRecord3(closer.data.reason) && closer.data.reason.kind === "forked";
+}
+var DEEPSEEK_V017_PROFILE = Object.freeze({
+  ...DEEPSEEK_V015_PROFILE,
+  version: "0.1.7-rc.1",
+  checkpointPrefix: "v4-turn-end:",
+  sessionFormatVersion: 4,
+  matchesForkTail: matchesV4ForkTail,
+  parseHeader(value, expected) {
+    if (!isRecord3(value) || value.version !== 4)
+      invalid2("journal header");
+    if (value.delegationDepth !== void 0 && (!Number.isSafeInteger(value.delegationDepth) || Object.is(value.delegationDepth, -0) || value.delegationDepth < 0)) {
+      invalid2("journal header delegationDepth");
+    }
+    const delegationDepth = value.delegationDepth ?? 0;
+    DEEPSEEK_V015_PROFILE.parseHeader({ ...value, version: 3, delegationDepth }, expected);
+    return { ...value, delegationDepth };
+  },
+  parseHistoryRecord: (value, remaining) => parseV015HistoryRecord(value, remaining, (event) => parseEvent(event, 4)),
+  parseLiveItem: (value) => {
+    const item = parseV015LiveItem(value, (event) => parseEvent(event, 4));
+    if (item.type === "assistant-stream" && "frame" in item && item.frame.type === "chunk") {
+      validateV4Chunk(item.frame.chunk);
+    }
+    return item;
+  },
+  parseAssistantBaseline(value) {
+    const baseline = parseV015AssistantBaseline(value);
+    if (baseline.activeAttempt)
+      validateV4Stream(baseline.activeAttempt.stream);
+    return baseline;
+  },
+  validateContent: validateV4Content,
+  validateChunk: validateV4Chunk,
+  validateEvent(event) {
+    if (event.type === "developer/message") {
+      validateDeveloperMessage(event);
+    } else if (event.type === "system/message") {
+      if (!isRecord3(event.data) || !isRecord3(event.data.message))
+        invalid2("system/message");
+      exactKeys2(event.data, ["turn", "step", "message"]);
+      const message = event.data.message;
+      requiredFields(message, ["id", "role", "content", "source"]);
+      requiredString(message.id, "system/message id");
+      if (message.role !== "system" || !isRecord3(message.source) || message.source.kind !== "system-prompt") {
+        invalid2("system/message source");
+      }
+      validateV4Content(message.content);
+    } else if (event.type === "image/offload") {
+      if (!isRecord3(event.data))
+        invalid2("image/offload");
+      exactKeys2(event.data, ["targets"]);
+      if (!Array.isArray(event.data.targets) || event.data.targets.length === 0)
+        invalid2("image/offload targets");
+    } else if (event.type === "workspace/changes") {
+      if (!isRecord3(event.data))
+        invalid2("workspace/changes");
+      exactKeys2(event.data, ["turn"]);
+      positiveInteger(event.data.turn, "workspace/changes turn");
+    } else if (event.type === "tool/result") {
+      if (!isRecord3(event.data))
+        invalid2("tool/result");
+      const message = event.data.message;
+      if (event.data.error !== void 0 && (!isRecord3(message) || message.isError !== true)) {
+        invalid2("tool/result error marker");
+      }
+    } else if (event.type === "request/header") {
+      DEEPSEEK_V015_PROFILE.validateEvent(event);
+      if (!isRecord3(event.data) || !isRecord3(event.data.header))
+        invalid2("request/header");
+      const tools = event.data.header.tools;
+      if (tools !== void 0 && (!Array.isArray(tools) || tools.some((tool) => !isRecord3(tool) || tool.deferLoading !== void 0 && tool.deferLoading !== true))) {
+        invalid2("request/header tools");
+      }
+    } else if (event.type === "assistant/message" || event.type === "assistant/attempt") {
+      DEEPSEEK_V015_PROFILE.validateEvent(event);
+      if (!isRecord3(event.data))
+        invalid2("assistant settlement");
+      validateV4Stream(event.data.stream);
+    } else {
+      DEEPSEEK_V015_PROFILE.validateEvent(event);
+    }
+  }
+});
+
 // dist/profiles/profile.js
+var V4_MINIMUM = parseSemVer("0.1.7-rc.1");
+function parseSemVer(value) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/u.exec(value);
+  if (!match)
+    return void 0;
+  const prerelease = match[4] ? match[4].split(".").map((part) => /^\d+$/u.test(part) ? Number(part) : part) : [];
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease
+  };
+}
+function compareSemVer(left, right) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (left[key] !== right[key])
+      return left[key] > right[key] ? 1 : -1;
+  }
+  if (left.prerelease.length === 0 || right.prerelease.length === 0) {
+    return left.prerelease.length === right.prerelease.length ? 0 : left.prerelease.length === 0 ? 1 : -1;
+  }
+  const length = Math.max(left.prerelease.length, right.prerelease.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = left.prerelease[index];
+    const rightPart = right.prerelease[index];
+    if (leftPart === void 0 || rightPart === void 0) {
+      return leftPart === rightPart ? 0 : leftPart === void 0 ? -1 : 1;
+    }
+    if (leftPart === rightPart)
+      continue;
+    if (typeof leftPart === "number" && typeof rightPart === "string")
+      return -1;
+    if (typeof leftPart === "string" && typeof rightPart === "number")
+      return 1;
+    return leftPart > rightPart ? 1 : -1;
+  }
+  return 0;
+}
+function usesV4Profile(version2) {
+  const parsed = parseSemVer(version2);
+  return parsed !== void 0 && V4_MINIMUM !== void 0 && compareSemVer(parsed, V4_MINIMUM) >= 0;
+}
 function deepSeekModernProfile(version2) {
-  const base = /^0\.1\.2(?:-|\+|$)/u.test(version2) ? DEEPSEEK_V012_PROFILE : DEEPSEEK_V015_PROFILE;
+  const base = /^0\.1\.2(?:-|\+|$)/u.test(version2) ? DEEPSEEK_V012_PROFILE : usesV4Profile(version2) ? DEEPSEEK_V017_PROFILE : DEEPSEEK_V015_PROFILE;
   return base.version === version2 ? base : Object.freeze({ ...base, version: version2 });
 }
-function isDeepSeekV015(profile) {
-  return profile.sessionFormatVersion === 3;
+function hasDeepSeekModernStream(profile) {
+  return profile.sessionFormatVersion >= 3;
 }
 
 // dist/modern/commands.js
@@ -22962,7 +23202,7 @@ async function callModernCommand(remote, endpoint, args, parse3, signal, timeout
   }
 }
 function executeModernCommand(remote, agentId, line, signal, profile = DEEPSEEK_V012_PROFILE) {
-  return callModernCommand(remote, "commands/execute", isDeepSeekV015(profile) ? { agentId, line, submittedAttachments: [] } : { agentId, line, images: [] }, parseModernCommandExecution, signal, null);
+  return callModernCommand(remote, "commands/execute", profile.sessionFormatVersion !== 0 ? { agentId, line, submittedAttachments: [] } : { agentId, line, images: [] }, parseModernCommandExecution, signal, null);
 }
 
 // dist/modern/control-store.js
@@ -23234,13 +23474,15 @@ function parseSessionCollection(value, kind, sessions, maxSessions) {
     }
   }
 }
-function parseBaseline(value, maxSessions, maxKeys) {
-  if (!isRecord6(value) || !hasExactKeys4(value, ["queues", "jobs", "projections"]) || !isPlainRecord3(value.projections)) {
+function parseBaseline(value, maxSessions, maxKeys, formatVersion) {
+  if (!isRecord6(value) || !hasExactKeys4(value, formatVersion === 4 ? ["projections"] : ["queues", "jobs", "projections"]) || !isPlainRecord3(value.projections)) {
     throw storeError("protocolError", "DeepSeek Harness control stream emitted an invalid baseline");
   }
   const sessions = /* @__PURE__ */ new Set();
-  parseSessionCollection(value.queues, "queues", sessions, maxSessions);
-  parseSessionCollection(value.jobs, "jobs", sessions, maxSessions);
+  if (formatVersion !== 4) {
+    parseSessionCollection(value.queues, "queues", sessions, maxSessions);
+    parseSessionCollection(value.jobs, "jobs", sessions, maxSessions);
+  }
   const projections = /* @__PURE__ */ Object.create(null);
   for (const [sessionId, block] of Object.entries(value.projections)) {
     if (!validIdentifier(sessionId)) {
@@ -23254,12 +23496,15 @@ function parseBaseline(value, maxSessions, maxKeys) {
   }
   return { projections };
 }
-function parseControlFrame(value, maxSessions, maxKeys) {
+function parseControlFrame(value, maxSessions, maxKeys, formatVersion) {
   if (!isRecord6(value) || typeof value.type !== "string") {
     throw storeError("protocolError", "DeepSeek Harness control stream emitted an invalid frame");
   }
   if (value.type === "baseline" && hasExactKeys4(value, ["type", "value"])) {
-    return { type: "baseline", value: parseBaseline(value.value, maxSessions, maxKeys) };
+    return {
+      type: "baseline",
+      value: parseBaseline(value.value, maxSessions, maxKeys, formatVersion)
+    };
   }
   if (value.type === "projection" && hasExactKeys4(value, ["type", "sessionId", "key", "value", "seq"]) && validIdentifier(value.sessionId) && validProjectionKey(value.key) && validSeq(value.seq)) {
     const projection = measureProjection(value.key, value.value);
@@ -23272,12 +23517,12 @@ function parseControlFrame(value, maxSessions, maxKeys) {
       bytes: projection.bytes
     };
   }
-  if (value.type === "queue" && hasExactKeys4(value, ["type", "sessionId", "items"]) && validIdentifier(value.sessionId) && Array.isArray(value.items) && value.items.length <= MAX_COLLECTION_ITEMS) {
+  if (formatVersion !== 4 && value.type === "queue" && hasExactKeys4(value, ["type", "sessionId", "items"]) && validIdentifier(value.sessionId) && Array.isArray(value.items) && value.items.length <= MAX_COLLECTION_ITEMS) {
     for (const item of value.items)
       parseQueueItem(item);
     return { type: "queue", sessionId: value.sessionId };
   }
-  if (value.type === "jobs" && hasExactKeys4(value, ["type", "sessionId", "jobs"]) && validIdentifier(value.sessionId) && Array.isArray(value.jobs) && value.jobs.length <= MAX_COLLECTION_ITEMS) {
+  if (formatVersion !== 4 && value.type === "jobs" && hasExactKeys4(value, ["type", "sessionId", "jobs"]) && validIdentifier(value.sessionId) && Array.isArray(value.jobs) && value.jobs.length <= MAX_COLLECTION_ITEMS) {
     for (const job of value.jobs)
       parseJob(job);
     return { type: "jobs", sessionId: value.sessionId };
@@ -23289,6 +23534,7 @@ function parseSeed(value, maxKeys) {
 }
 var ModernControlStore = class {
   #lifetime = new AbortController();
+  #formatVersion;
   #maxKeys;
   #maxSessions;
   #maxWaiters;
@@ -23309,6 +23555,7 @@ var ModernControlStore = class {
   #readyResolve;
   constructor(source, options = {}) {
     this.#source = source;
+    this.#formatVersion = options.profile?.sessionFormatVersion ?? 3;
     this.#maxSessions = positiveInteger3(options.maxSessions ?? DEFAULT_MAX_SESSIONS, "maxSessions");
     this.#maxKeys = positiveInteger3(options.maxKeysPerSession ?? DEFAULT_MAX_KEYS_PER_SESSION, "maxKeysPerSession");
     this.#maxWaiters = positiveInteger3(options.maxWaiters ?? DEFAULT_MAX_WAITERS, "maxWaiters");
@@ -23477,7 +23724,7 @@ var ModernControlStore = class {
   replaceBaseline(frame) {
     this.#assertUsable();
     try {
-      const parsed = parseControlFrame(frame, this.#maxSessions, this.#maxKeys);
+      const parsed = parseControlFrame(frame, this.#maxSessions, this.#maxKeys, this.#formatVersion);
       if (parsed.type !== "baseline") {
         throw storeError("protocolError", "Control baseline replacement requires a baseline frame");
       }
@@ -23518,7 +23765,7 @@ var ModernControlStore = class {
               return;
             throw storeError(this.#opened ? "unavailable" : "protocolError", this.#opened ? "DeepSeek Harness control stream ended unexpectedly" : "DeepSeek Harness control stream ended before its baseline");
           }
-          const frame = parseControlFrame(next.value, this.#maxSessions, this.#maxKeys);
+          const frame = parseControlFrame(next.value, this.#maxSessions, this.#maxKeys, this.#formatVersion);
           if (!generationOpened && frame.type !== "baseline") {
             throw storeError("protocolError", "DeepSeek Harness control stream omitted its baseline");
           }
@@ -24649,7 +24896,7 @@ function validateSecrets(value) {
   }
   return value;
 }
-function parseDescribe(value) {
+function parseDescribe(value, profile) {
   assertBoundedJson2(value);
   if (!isPlainRecord4(value) || !exactKeys3(value, ["writable", "hasDocument", "namespaces"])) {
     throw permissionError("protocolError", "DeepSeek Harness returned an invalid settings response");
@@ -24663,7 +24910,7 @@ function parseDescribe(value) {
   const namespaceIds = [];
   const permissionNamespaces = [];
   for (const candidate of value.namespaces) {
-    if (!isPlainRecord4(candidate) || !exactKeys3(candidate, ["ns", "schema", "value", "applies", "secrets", "revision"], ["base", "user"]) || candidate.applies !== "live" && candidate.applies !== "restart" || !validRevision(candidate.revision)) {
+    if (!isPlainRecord4(candidate) || !exactKeys3(candidate, profile.sessionFormatVersion === 4 ? ["ns", "autoGenerate", "schema", "value", "applies", "secrets", "revision"] : ["ns", "schema", "value", "applies", "secrets", "revision"], ["base", "user"]) || profile.sessionFormatVersion === 4 && typeof candidate.autoGenerate !== "boolean" || candidate.applies !== "live" && candidate.applies !== "restart" || !validRevision(candidate.revision)) {
       throw permissionError("protocolError", "DeepSeek Harness returned an invalid settings namespace");
     }
     const ns = nonBlankString2(candidate.ns, MAX_NAMESPACE_ID_LENGTH, "settings namespace id");
@@ -24701,7 +24948,7 @@ function permissionSection(value, requireDefault, knownIds, area) {
     }
   }
 }
-function catalogFromNamespace(view) {
+function catalogFromNamespace(view, profile) {
   if (view.applies !== "live") {
     throw permissionError("protocolError", "DeepSeek Harness permission settings are not live");
   }
@@ -24720,10 +24967,14 @@ function catalogFromNamespace(view) {
   }
   const field = dictionary.defaultPreset;
   if (field.meta?.required !== true) {
+    if (profile.sessionFormatVersion === 4)
+      return null;
     throw permissionError("protocolError", "DeepSeek Harness permission default is not required");
   }
   const choices = field.type === "union" ? field.list : field.type === "const" ? [field] : void 0;
   if (!Array.isArray(choices) || choices.length === 0) {
+    if (profile.sessionFormatVersion === 4)
+      return null;
     throw permissionError("protocolError", "DeepSeek Harness permission schema has no preset choices");
   }
   if (choices.length > HARNESS_PERMISSION_MODE_CATALOG_MAX_LENGTH) {
@@ -24763,18 +25014,18 @@ function catalogFromNamespace(view) {
     throw permissionError("protocolError", "DeepSeek Harness returned an unusable permission catalog");
   }
 }
-function parseModernPermissionModeCatalog(value) {
-  const permission = parseDescribe(value);
-  return permission ? catalogFromNamespace(permission) : null;
+function parseModernPermissionModeCatalog(value, profile = DEEPSEEK_V015_PROFILE) {
+  const permission = parseDescribe(value, profile);
+  return permission ? catalogFromNamespace(permission, profile) : null;
 }
-async function loadModernPermissionModeCatalog(remote, signal) {
+async function loadModernPermissionModeCatalog(remote, signal, profile = DEEPSEEK_V015_PROFILE) {
   try {
     const result = await remote.call("settings/describe", {}, signal);
     if (!result.ok) {
       const safe = sanitizeModernRemoteFailure(result.error);
       throw permissionError("remoteError", `DeepSeek Harness settings/describe failed: ${safe.message}`, safe.code);
     }
-    return parseModernPermissionModeCatalog(result.value);
+    return parseModernPermissionModeCatalog(result.value, profile);
   } catch (error51) {
     if (error51 instanceof ModernPermissionModeError)
       throw error51;
@@ -24830,8 +25081,10 @@ function parseProjectionValue(value, catalog) {
   }
   return current.data;
 }
-function readModernPermissionModeState(row, catalog) {
+function readModernPermissionModeState(row, catalog, profile) {
   if (!catalog) {
+    if (profile?.sessionFormatVersion === 4)
+      return void 0;
     if (row) {
       throw permissionError("protocolError", "DeepSeek Harness exposed permissions without a settings catalog");
     }
@@ -24966,7 +25219,7 @@ function readModernConfigurationSnapshot(input) {
     throw configurationError("protocolError", "DeepSeek Harness control state is detached");
   }
   const model = readModernModelSelectionState(rows[MODERN_MODEL_SELECTION_PROJECTION_KEY], input.modelCatalog);
-  const permission = readModernPermissionModeState(rows[MODERN_PERMISSION_PROJECTION_KEY], input.permissionModes);
+  const permission = readModernPermissionModeState(rows[MODERN_PERMISSION_PROJECTION_KEY], input.permissionModes, input.profile);
   return {
     model,
     state: stateForSelection(input.nativeRef, model.selection, input.modelCatalog, permission?.permissionModeId),
@@ -25941,10 +26194,14 @@ function parseQuestionOption(value) {
   };
 }
 function parseQuestionIntent(value) {
-  if (!isPlainRecord6(value) || !hasExactKeys5(value, ["kind", "approve"]) || value.kind !== "plan-review" || !nonBlankString3(value.approve)) {
+  if (!isPlainRecord6(value) || !hasOnlyKeys(value, ["kind", "approve"], ["callId"]) || value.kind !== "plan-review" || !nonBlankString3(value.approve) || Object.hasOwn(value, "callId") && !nonBlankString3(value.callId)) {
     throw invalidFrame();
   }
-  return { kind: "plan-review", approve: value.approve };
+  return {
+    kind: "plan-review",
+    approve: value.approve,
+    ...typeof value.callId === "string" ? { callId: value.callId } : {}
+  };
 }
 function parseQuestionAnswer(value) {
   if (!isPlainRecord6(value) || !hasExactKeys5(value, ["answers"]) || !Array.isArray(value.answers)) {
@@ -26728,6 +26985,13 @@ var KNOWN_EVENT_TYPES = /* @__PURE__ */ new Set([
   "user/message",
   "web/deepseek-search-llm-request"
 ]);
+var V4_EVENT_TYPES = /* @__PURE__ */ new Set(["developer/message", "image/offload", "workspace/changes"]);
+function knownEvent(type, profile) {
+  return KNOWN_EVENT_TYPES.has(type) || profile.sessionFormatVersion === 4 && V4_EVENT_TYPES.has(type);
+}
+function surfaceEvent(type, profile) {
+  return SURFACE_EVENT_TYPES.has(type) || profile.sessionFormatVersion === 4 && type === "developer/message";
+}
 var SURFACE_EVENT_TYPES = /* @__PURE__ */ new Set([
   "system/message",
   "user/message",
@@ -26746,7 +27010,10 @@ var ModernEventValidator = class {
     surface: [],
     pendingCalls: /* @__PURE__ */ new Set(),
     commandStates: /* @__PURE__ */ new Map(),
-    commandEventSeqs: /* @__PURE__ */ new Set()
+    commandEventSeqs: /* @__PURE__ */ new Set(),
+    requestHeaders: /* @__PURE__ */ new Map(),
+    offloadedImages: /* @__PURE__ */ new Set(),
+    toolCalls: /* @__PURE__ */ new Map()
   };
   constructor(maxEvents = MODERN_HISTORY_MAX_EVENTS, profile = DEEPSEEK_V012_PROFILE) {
     this.#maxEvents = boundedInteger(maxEvents, "maxEvents", 1);
@@ -26759,16 +27026,16 @@ var ModernEventValidator = class {
     if (event.seq !== trace.count)
       fail("Modern history is not a contiguous zero-based prefix");
     trace.count += 1;
-    if (isDeepSeekV015(this.#profile) && !KNOWN_EVENT_TYPES.has(event.type) && event.ignorable === true)
+    if (hasDeepSeekModernStream(this.#profile) && !knownEvent(event.type, this.#profile) && event.ignorable === true)
       return;
-    if (!SURFACE_EVENT_TYPES.has(event.type)) {
+    if (!surfaceEvent(event.type, this.#profile)) {
       if (event.surfaceOp !== void 0 || event.sourceEventSeqs !== void 0) {
         fail("Modern history has surface metadata on a log-only event");
       }
     } else if (event.surfaceOp === void 0) {
       fail("Modern history surface event omitted surfaceOp");
     }
-    if (!KNOWN_EVENT_TYPES.has(event.type)) {
+    if (!knownEvent(event.type, this.#profile)) {
       if (event.ignorable === true)
         return;
       fail("Modern history contains an unknown required event");
@@ -26792,10 +27059,13 @@ var ModernEventValidator = class {
       case "turn/end": {
         exactKeys2(data, ["turn", "reason"]);
         const turn = positiveInteger(data.turn, "turn/end turn");
-        validateTurnReason(data.reason);
+        validateTurnReason(data.reason, this.#profile);
         if (trace.openTurn !== turn || trace.openStep !== null) {
           fail("Modern history has an invalid turn/end boundary");
         }
+        if (this.#profile.sessionFormatVersion === 4 && trace.toolCalls.size > 0) {
+          fail("Modern history turn/end leaves unresolved tool calls");
+        }
         trace.openTurn = null;
         trace.nextTurn += 1;
         return;
@@ -26812,6 +27082,9 @@ var ModernEventValidator = class {
       case "step/end": {
         exactKeys2(data, ["turn", "step"]);
         requireOpenStep(trace, data, "step/end");
+        if (this.#profile.sessionFormatVersion === 4 && trace.toolCalls.size > 0) {
+          fail("Modern history step/end leaves unresolved tool calls");
+        }
         trace.openStep = null;
         trace.nextStep += 1;
         trace.pendingCalls.clear();
@@ -26820,6 +27093,10 @@ var ModernEventValidator = class {
       case "user/message":
         validateUserMessage(data, this.#profile);
         return;
+      case "developer/message":
+        requireOpenStep(trace, data, "developer/message");
+        validateDeveloperHeader(event, trace);
+        return;
       case "system/message":
         requireOpenStep(trace, data, "system/message");
         return;
@@ -26831,6 +27108,8 @@ var ModernEventValidator = class {
       case "assistant/message": {
         requireOpenStep(trace, data, "assistant/message");
         validateAssistantMessage(data.message, this.#profile);
+        if (this.#profile.sessionFormatVersion === 4)
+          registerV4ToolCalls(data.message, trace);
         if (data.interrupted !== void 0 && data.interrupted !== true) {
           fail("Modern history assistant/message has invalid interrupted marker");
         }
@@ -26844,10 +27123,18 @@ var ModernEventValidator = class {
         exactKeys2(data, ["turn", "step", "callId", "name", "arguments"]);
         requireOpenStep(trace, data, "tool/call");
         const callId = requiredString(data.callId, "tool/call callId");
-        requiredString(data.name, "tool/call name");
+        const name = requiredString(data.name, "tool/call name");
         if (typeof data.arguments !== "string" || trace.pendingCalls.has(callId)) {
           fail("Modern history contains an invalid tool/call");
         }
+        if (this.#profile.sessionFormatVersion === 4) {
+          const tool = trace.toolCalls.get(callId);
+          if (!tool || tool.started || tool.name !== name || tool.arguments !== data.arguments) {
+            fail("Modern history tool/call does not match its advertised tool call");
+          }
+          tool.started = true;
+          return;
+        }
         trace.pendingCalls.add(callId);
         return;
       }
@@ -26855,10 +27142,16 @@ var ModernEventValidator = class {
         requiredOptionalKeys(data, ["turn", "step", "message"], ["error", "meta"]);
         const callId = validateToolResultMessage(data.message, this.#profile);
         if (data.error !== void 0)
-          validateToolError(data.error);
+          validateToolError(data.error, this.#profile);
         if (event.surfaceOp === "append") {
           requireOpenStep(trace, data, "tool/result");
-          if (!trace.pendingCalls.delete(callId)) {
+          if (this.#profile.sessionFormatVersion === 4) {
+            const tool = trace.toolCalls.get(callId);
+            if (!tool || !tool.started && !isV4ForkToolResult(data, event.sourceEventSeqs, event.seq)) {
+              fail("Modern history contains an unmatched tool/result");
+            }
+            trace.toolCalls.delete(callId);
+          } else if (!trace.pendingCalls.delete(callId)) {
             fail("Modern history contains an unmatched tool/result");
           }
         } else if (trace.openTurn === null) {
@@ -26870,6 +27163,7 @@ var ModernEventValidator = class {
         validateRequestHeader(data);
         if (trace.openTurn === null)
           fail("Modern history request/header is outside a Turn");
+        trace.requestHeaders.set(event.seq, data.header);
         return;
       case "request/context":
         validateRequestContext(data, this.#profile);
@@ -26881,6 +27175,11 @@ var ModernEventValidator = class {
         return;
       case "session/end-seed":
         return;
+      case "image/offload":
+        validateImageOffload(data, trace);
+        return;
+      case "workspace/changes":
+        return;
       case "agent-preset/selected":
         exactKeys2(data, ["agentPreset"]);
         requiredString(data.agentPreset, "agent-preset/selected agentPreset");
@@ -27010,20 +27309,113 @@ var ModernEventValidator = class {
     }
   }
 };
+function registerV4ToolCalls(value, trace) {
+  if (!isRecord4(value) || !Array.isArray(value.content))
+    return;
+  for (const block of value.content) {
+    if (!isRecord4(block) || block.type !== "tool-call")
+      continue;
+    const callId = requiredString(block.id, "assistant tool-call id");
+    const name = requiredString(block.name, "assistant tool-call name");
+    if (typeof block.arguments !== "string" || trace.toolCalls.has(callId)) {
+      fail("Modern history assistant/message repeats an advertised tool call");
+    }
+    trace.toolCalls.set(callId, { name, arguments: block.arguments, started: false });
+  }
+}
+function isV4ForkToolResult(data, sourceEventSeqs, seq) {
+  if (!isRecord4(data.error) || data.error.name !== "ToolNotStartedError" || data.error.code !== "TOOL_NOT_STARTED" || !isRecord4(data.message) || data.message.role !== "tool" || data.message.isError !== true || !isRecord4(data.message.source) || data.message.source.kind !== "tool" || typeof data.message.source.callId !== "string" || data.message.toolCallId !== data.message.source.callId || typeof data.message.id !== "string" || data.message.id !== `forked-tool-result-${data.message.source.callId}-${seq}` || sourceEventSeqs !== void 0 || !Array.isArray(data.message.content) || data.message.content.length !== 1) {
+    return false;
+  }
+  const content = data.message.content[0];
+  return isRecord4(content) && content.type === "text" && typeof content.text === "string" && data.message.id.endsWith(`-${seq}`);
+}
+function validateDeveloperHeader(event, trace) {
+  const data = event.data;
+  if (data.headerSeq === void 0)
+    return;
+  const header = trace.requestHeaders.get(data.headerSeq);
+  if (!header || !Array.isArray(header.tools)) {
+    fail("Modern history developer/message references an invalid request/header");
+  }
+  const message = data.message;
+  for (const block of message.content) {
+    if (!isRecord4(block) || block.type !== "tool-addition")
+      continue;
+    const matching = header.tools.filter((tool) => isRecord4(tool) && tool.name === block.toolName);
+    if (matching.length !== 1 || !isRecord4(matching[0]) || typeof matching[0].description !== "string" || !isRecord4(matching[0].parameters) || matching[0].deferLoading !== void 0 && matching[0].deferLoading !== true) {
+      fail("Modern history developer/message references an invalid tool definition");
+    }
+  }
+}
+function strictIndex(value, label) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || Object.is(value, -0)) {
+    fail(`Modern history ${label} is malformed`);
+  }
+  return value;
+}
+function validateImageOffload(data, trace) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const target of data.targets) {
+    if (!isRecord4(target))
+      fail("Modern history image/offload target is malformed");
+    exactKeys2(target, ["seq", "imageIndexes"]);
+    const seq = strictIndex(target.seq, "image/offload target seq");
+    if (seen.has(seq))
+      fail("Modern history image/offload repeats a target");
+    seen.add(seq);
+    const source = trace.surface.find((event) => event.seq === seq);
+    if (!source || source.type !== "user/message" && source.type !== "tool/result") {
+      fail("Modern history image/offload target is not a current message");
+    }
+    const sourceData = source.type === "user/message" ? source.data : source.data.message;
+    const content = isRecord4(sourceData) ? sourceData.content : void 0;
+    if (!Array.isArray(content) || !Array.isArray(target.imageIndexes) || !target.imageIndexes.length) {
+      fail("Modern history image/offload indexes are malformed");
+    }
+    const images = [];
+    const collectImages = (value) => {
+      if (!Array.isArray(value))
+        return;
+      for (const block of value) {
+        if (!isRecord4(block))
+          continue;
+        if (block.type === "image")
+          images.push(block);
+        if (Array.isArray(block.content))
+          collectImages(block.content);
+      }
+    };
+    collectImages(content);
+    let previous = -1;
+    for (const value of target.imageIndexes) {
+      const index = strictIndex(value, "image/offload index");
+      const image = images[index];
+      if (index <= previous || !isRecord4(image) || image.offloaded === true || trace.offloadedImages.has(`${seq}:${index}`)) {
+        fail("Modern history image/offload references an invalid image occurrence");
+      }
+      trace.offloadedImages.add(`${seq}:${index}`);
+      previous = index;
+    }
+  }
+}
 function acceptSurfaceEvent(trace, event, profile) {
-  if (!SURFACE_EVENT_TYPES.has(event.type))
+  if (!surfaceEvent(event.type, profile))
     return;
   const sources = event.sourceEventSeqs;
-  if (sources !== void 0 && (!Array.isArray(sources) || sources.some((seq) => !nonNegativeSafeInteger2(seq) || Object.is(seq, -0) || seq >= event.seq) || new Set(sources).size !== sources.length || sources.length === 0 && event.type !== "assistant/message")) {
+  if (sources !== void 0 && (!Array.isArray(sources) || sources.some((seq) => !nonNegativeSafeInteger2(seq) || Object.is(seq, -0) || seq >= event.seq) || new Set(sources).size !== sources.length || sources.length === 0 && (profile.sessionFormatVersion === 4 || event.type !== "assistant/message"))) {
     fail("Modern history surface event has invalid sourceEventSeqs");
   }
   const op = event.surfaceOp;
   if (op === "append") {
+    if (profile.sessionFormatVersion === 4 && event.type === "system/message" && trace.surface.length > 0 && !trace.surface.some((surface) => surface.type === "system/message")) {
+      fail("Modern history system/message must remain the protected surface head");
+    }
     trace.surface.push(event);
     return;
   }
-  const start = isDeepSeekV015(profile) ? "startSeq" : "start";
-  const end = isDeepSeekV015(profile) ? "endSeq" : "end";
+  const start = hasDeepSeekModernStream(profile) ? "startSeq" : "start";
+  const end = hasDeepSeekModernStream(profile) ? "endSeq" : "end";
   if (!isRecord4(op) || Reflect.ownKeys(op).length !== 3 || !Object.hasOwn(op, "op") || !Object.hasOwn(op, start) || !Object.hasOwn(op, end) || op.op !== "replace" || !nonNegativeSafeInteger2(op[start]) || Object.is(op[start], -0) || !nonNegativeSafeInteger2(op[end]) || Object.is(op[end], -0)) {
     fail("Modern history surface event has an invalid replacement operation");
   }
@@ -27041,17 +27433,20 @@ function acceptSurfaceEvent(trace, event, profile) {
     fail("Modern history system head may only be replaced by one system/message");
   }
   if (event.type === "tool/result") {
-    if (shadowed.length !== 1 || shadowed[0]?.type !== "tool/result" || !isDeepStrictEqual6(comparableToolResultData(shadowed[0]), comparableToolResultData(event))) {
+    if (shadowed.length !== 1 || shadowed[0]?.type !== "tool/result" || !isDeepStrictEqual6(comparableToolResultData(shadowed[0], profile), comparableToolResultData(event, profile))) {
       fail("Modern history tool/result replacement changed more than result content");
     }
   }
   trace.surface.splice(startIndex, endIndex - startIndex + 1, event);
 }
-function comparableToolResultData(event) {
+function comparableToolResultData(event, profile) {
   const data = event.data;
-  if (!isRecord4(data) || !isRecord4(data.message) || !Array.isArray(data.message.content) || !isRecord4(data.message.content[0])) {
+  if (!isRecord4(data) || !isRecord4(data.message) || !Array.isArray(data.message.content) || profile.sessionFormatVersion !== 4 && !isRecord4(data.message.content[0])) {
     fail("Modern history tool/result replacement is malformed");
   }
+  if (profile.sessionFormatVersion === 4) {
+    return { ...data, message: { ...data.message, content: null } };
+  }
   return {
     ...data,
     message: {
@@ -27074,6 +27469,8 @@ function resolveModernForkBoundary(events, checkpointId, profile = DEEPSEEK_V012
   if (atSeq === null || events[atSeq]?.seq !== atSeq || events[atSeq]?.type !== "turn/end") {
     return null;
   }
+  if (profile.sessionFormatVersion === 4)
+    return { atSeq, events: events.slice(0, atSeq + 1) };
   let cut = atSeq + 1;
   while (cut < events.length && events[cut]?.type !== "turn/start")
     cut += 1;
@@ -27122,7 +27519,7 @@ function projectModernHistory(input) {
   };
   for (const [index, event] of input.events.entries()) {
     validator.accept(event);
-    if (!KNOWN_EVENT_TYPES.has(event.type) || !isRecord4(event.data))
+    if (!knownEvent(event.type, profile) || !isRecord4(event.data))
       continue;
     const data = event.data;
     switch (event.type) {
@@ -27133,6 +27530,7 @@ function projectModernHistory(input) {
           input: [],
           items: [],
           tools: /* @__PURE__ */ new Map(),
+          advertisedTools: /* @__PURE__ */ new Map(),
           model: effectiveModel
         };
         break;
@@ -27211,7 +27609,7 @@ function projectModernHistory(input) {
     harnessId,
     nativeSessionId: input.sessionId,
     formatVersion: 1,
-    ...isDeepSeekV015(profile) ? { locator: { dshVersion: profile.version } } : {}
+    ...hasDeepSeekModernStream(profile) ? { locator: { dshVersion: profile.version } } : {}
   });
   const state = {
     nativeRef,
@@ -27243,7 +27641,7 @@ function modernCheckpointRef(harnessId, sessionId, seq, profile = DEEPSEEK_V012_
     nativeSessionId: sessionId,
     checkpointId: `${profile.checkpointPrefix}${seq}`,
     formatVersion: 1,
-    ...isDeepSeekV015(profile) ? { locator: { dshVersion: profile.version } } : {}
+    ...hasDeepSeekModernStream(profile) ? { locator: { dshVersion: profile.version } } : {}
   });
 }
 function modernItemId(sessionId, key) {
@@ -27251,6 +27649,13 @@ function modernItemId(sessionId, key) {
 }
 function projectAssistantMessage(turn, sessionId, data) {
   const message = data.message;
+  if (Array.isArray(message.content)) {
+    for (const block of message.content) {
+      if (isRecord4(block) && block.type === "tool-call" && typeof block.id === "string" && typeof block.name === "string" && typeof block.arguments === "string") {
+        turn.advertisedTools.set(block.id, { toolName: block.name, arguments: block.arguments });
+      }
+    }
+  }
   const reasoning2 = contentByType(message.content, "reasoning");
   if (reasoning2) {
     const item = {
@@ -27283,15 +27688,32 @@ function projectToolCall(turn, sessionId, data, seq) {
   const itemIndex = turn.items.length;
   turn.items.push({ item, outcome: incompleteToolOutcome(item.toolName) });
   turn.tools.set(data.callId, { itemIndex, item, toolName: item.toolName });
+  turn.advertisedTools.delete(data.callId);
 }
 function projectToolResultEvent(turn, sessionId, data, seq, limit) {
   const result = projectToolResult(data.message, limit);
   if (!result)
     fail("Modern history contains an unprojectable tool/result");
-  const tool = turn.tools.get(result.callId);
-  if (!tool)
+  let tool = turn.tools.get(result.callId);
+  if (!tool) {
+    const advertised = turn.advertisedTools.get(result.callId);
+    if (advertised && isForkedToolResult(data, result.callId, seq)) {
+      const item2 = {
+        type: "toolExecution",
+        itemId: modernItemId(sessionId, `event:${seq}:tool`),
+        toolName: advertised.toolName,
+        arguments: parseArguments(advertised.arguments)
+      };
+      const itemIndex = turn.items.length;
+      turn.items.push({ item: item2, outcome: incompleteToolOutcome(item2.toolName) });
+      tool = { itemIndex, item: item2, toolName: item2.toolName };
+    }
+  }
+  if (!tool) {
     fail("Modern history contains an unmatched projected tool/result");
+  }
   turn.tools.delete(result.callId);
+  turn.advertisedTools.delete(result.callId);
   const item = { ...tool.item, ...result.output ? { output: result.output } : {} };
   turn.items[tool.itemIndex] = {
     item,
@@ -27317,6 +27739,10 @@ function projectToolResultEvent(turn, sessionId, data, seq, limit) {
     }
   }
 }
+function isForkedToolResult(data, callId, seq) {
+  const message = data.message;
+  return isRecord4(data.error) && data.error.name === "ToolNotStartedError" && data.error.code === "TOOL_NOT_STARTED" && isRecord4(message) && message.role === "tool" && message.isError === true && message.toolCallId === callId && typeof message.id === "string" && message.id === `forked-tool-result-${callId}-${seq}`;
+}
 function finishIncompleteTools(turn, outcome) {
   for (const tool of turn.tools.values())
     turn.items[tool.itemIndex] = { item: tool.item, outcome };
@@ -27387,12 +27813,15 @@ function stepPosition(data, label) {
   };
 }
 function validateUserMessage(data, profile = DEEPSEEK_V012_PROFILE) {
-  exactKeys2(data, ["id", "role", "content", "source"]);
+  if (profile.sessionFormatVersion === 4)
+    requiredFields2(data, ["id", "role", "content", "source"]);
+  else
+    exactKeys2(data, ["id", "role", "content", "source"]);
   requiredString(data.id, "user/message id");
   if (data.role !== "user")
     fail("Modern history user/message has an invalid role");
   profile.validateContent(data.content);
-  if (!isRecord4(data.source) || !requiredString(data.source.kind, "user/message source kind")) {
+  if (!isRecord4(data.source) || !requiredString(data.source.kind, "user/message source kind") || profile.sessionFormatVersion === 4 && data.source.kind === "plugin") {
     fail("Modern history user/message has an invalid source");
   }
   if (data.source.kind === "user" && data.source.rpcId !== void 0) {
@@ -27402,7 +27831,10 @@ function validateUserMessage(data, profile = DEEPSEEK_V012_PROFILE) {
 function validateAssistantMessage(value, profile = DEEPSEEK_V012_PROFILE) {
   if (!isRecord4(value))
     fail("Modern history assistant/message is malformed");
-  exactKeys2(value, ["id", "role", "content", "source"]);
+  if (profile.sessionFormatVersion === 4)
+    requiredFields2(value, ["id", "role", "content", "source"]);
+  else
+    exactKeys2(value, ["id", "role", "content", "source"]);
   requiredString(value.id, "assistant/message id");
   if (value.role !== "assistant")
     fail("Modern history assistant/message has an invalid role");
@@ -27414,6 +27846,19 @@ function validateAssistantMessage(value, profile = DEEPSEEK_V012_PROFILE) {
 function validateToolResultMessage(value, profile = DEEPSEEK_V012_PROFILE) {
   if (!isRecord4(value))
     fail("Modern history tool/result message is malformed");
+  if (profile.sessionFormatVersion === 4) {
+    requiredFields2(value, ["id", "role", "content", "source", "toolCallId"]);
+    requiredString(value.id, "tool/result message id");
+    if (value.role !== "tool" || !isRecord4(value.source) || value.source.kind !== "tool") {
+      fail("Modern history tool/result message has an invalid role or source");
+    }
+    const callId2 = requiredString(value.source.callId, "tool/result source callId");
+    if (value.toolCallId !== callId2 || value.isError !== void 0 && typeof value.isError !== "boolean") {
+      fail("Modern history tool/result message has invalid callId or isError");
+    }
+    profile.validateContent(value.content);
+    return callId2;
+  }
   exactKeys2(value, ["id", "role", "content", "source"]);
   requiredString(value.id, "tool/result message id");
   if (value.role !== "user" || !isRecord4(value.source) || value.source.kind !== "tool") {
@@ -27434,6 +27879,11 @@ function validateToolResultMessage(value, profile = DEEPSEEK_V012_PROFILE) {
   }
   return callId;
 }
+function requiredFields2(value, fields) {
+  if (fields.some((field) => !Object.hasOwn(value, field))) {
+    fail("Modern history known event omitted a required field");
+  }
+}
 function validateUsage(value) {
   if (!validUsage(value))
     fail("Modern history usage is malformed");
@@ -27457,7 +27907,7 @@ function validUsage(value) {
   }
   return fields.slice(2).every((field) => value[field] === void 0 || nonNegativeSafeInteger2(value[field]));
 }
-function validateTurnReason(value) {
+function validateTurnReason(value, profile) {
   if (!isRecord4(value) || typeof value.kind !== "string") {
     fail("Modern history turn/end reason is malformed");
   }
@@ -27468,6 +27918,11 @@ function validateTurnReason(value) {
     case "interrupted":
       exactKeys2(value, ["kind"]);
       return;
+    case "forked":
+      if (profile.sessionFormatVersion !== 4)
+        fail("Modern history contains an unknown Turn outcome");
+      exactKeys2(value, ["kind"]);
+      return;
     case "aborted":
       exactKeys2(value, ["kind", "reason"]);
       if (!isRecord4(value.reason) || typeof value.reason.kind !== "string") {
@@ -27522,7 +27977,7 @@ function validateRequestHeader(data) {
   }
 }
 function validateRequestContext(data, profile) {
-  requiredOptionalKeys(data, ["provider", "model"], isDeepSeekV015(profile) ? ["contextWindow", "systemPromptUpdate"] : ["contextWindow"]);
+  requiredOptionalKeys(data, ["provider", "model"], hasDeepSeekModernStream(profile) ? ["contextWindow", "systemPromptUpdate"] : ["contextWindow"]);
   if (!nonBlankString(data.provider) || !nonBlankString(data.model)) {
     fail("Modern history request/context has an invalid Model route");
   }
@@ -27540,12 +27995,15 @@ function validateModelSelection(data) {
     fail("Modern history model/selection has invalid reasoningEffort");
   }
 }
-function validateToolError(value) {
+function validateToolError(value, profile) {
   if (!isRecord4(value))
     fail("Modern history tool/result error is malformed");
-  exactKeys2(value, ["name", "code"]);
+  requiredOptionalKeys(value, ["name", "code"], profile.sessionFormatVersion === 4 ? ["reason"] : []);
   requiredString(value.name, "tool/result error name");
   requiredString(value.code, "tool/result error code");
+  if (value.reason !== void 0 && typeof value.reason !== "string") {
+    fail("Modern history tool/result error reason is malformed");
+  }
 }
 function validateInboxSplice(data, profile) {
   requiredOptionalKeys(data, ["target", "start", "inserted"], ["removedCount", "outcome"]);
@@ -27655,7 +28113,7 @@ function validateRetry(data) {
   requiredString(data.provider, "llm/retry provider");
   requiredString(data.policyKey, "llm/retry policyKey");
   positiveInteger(data.retry, "llm/retry retry");
-  nonNegativeInteger(data.delayMs, "llm/retry delayMs");
+  nonNegativeFiniteNumber(data.delayMs, "llm/retry delayMs");
   if (mode === "normal")
     positiveInteger(data.maxRetries, "llm/retry maxRetries");
   validateLlmFailure(data.failure, "llm/retry failure");
@@ -27869,7 +28327,7 @@ function validateSubagentModelPolicy(data) {
     validateModelRoute(route, "subagent Model policy route");
 }
 function validateTeamEvent(type, data, profile) {
-  if (data.version !== (isDeepSeekV015(profile) ? 2 : 1))
+  if (data.version !== (hasDeepSeekModernStream(profile) ? 2 : 1))
     fail("Modern history team event version is malformed");
   requiredString(data.teamId, "team event teamId");
   if (type === "team/message/delivered") {
@@ -28057,7 +28515,8 @@ var ModernHarnessSession = class {
       sessionId: this.#sessionId,
       nativeRef: projection.nativeRef,
       modelCatalog: this.#modelCatalog,
-      permissionModes: this.#permissionModes
+      permissionModes: this.#permissionModes,
+      profile: this.#profile
     });
     this.#nativeRef = projection.nativeRef;
     this.initialState = configuration.state;
@@ -28357,7 +28816,8 @@ ${question.detail}` : question.question;
       sessionId: this.#sessionId,
       nativeRef: this.#nativeRef,
       modelCatalog: this.#modelCatalog,
-      permissionModes: this.#permissionModes
+      permissionModes: this.#permissionModes,
+      profile: this.#profile
     });
   }
   #onConfigurationProjection() {
@@ -28991,6 +29451,9 @@ ${question.detail}` : question.question;
     if (attempt && !attempt.projected && active?.nativeTurn === attempt.turn && active.agent) {
       this.#cancelAgentItem(active);
     }
+    if (attempt && active?.reasoning?.attemptId === attempt.attemptId) {
+      this.#cancelReasoningItem(active);
+    }
     this.#assistantAttempt = void 0;
   }
   #cancelAgentItem(active) {
@@ -29008,6 +29471,13 @@ ${question.detail}` : question.question;
     delete active.agent;
     this.#completeItem(active, agent.item, { status: "cancelled" });
   }
+  #cancelReasoningItem(active) {
+    const reasoning2 = active.reasoning;
+    if (!reasoning2)
+      return;
+    delete active.reasoning;
+    this.#completeItem(active, reasoning2.item, { status: "cancelled" });
+  }
   #projectAssistantLiveChunks() {
     const attempt = this.#assistantAttempt;
     const active = this.#active;
@@ -29042,6 +29512,7 @@ ${question.detail}` : question.question;
         this.#projectAssistantLiveChunks();
     } else {
       this.#cancelAgentItem(active);
+      this.#cancelReasoningItem(active);
     }
     attempt.projected = true;
     if (attempt.ended)
@@ -29261,6 +29732,7 @@ ${question.detail}` : question.question;
       input: [...input],
       autonomous,
       tools: /* @__PURE__ */ new Map(),
+      reasoningOrdinal: 0,
       interactions: /* @__PURE__ */ new Set(),
       terminal: false,
       cancelAcknowledged: false
@@ -29316,6 +29788,9 @@ ${question.detail}` : question.question;
         if (event.surfaceOp === "append")
           this.#completeTool(active, data, event.seq);
         return;
+      case "step/end":
+        this.#cancelReasoningItem(active);
+        return;
       case "turn/end":
         this.#finishTurn(buffer, active, data.reason, event.seq);
         return;
@@ -29327,6 +29802,7 @@ ${question.detail}` : question.question;
     if (chunk.type === "text-delta") {
       this.#appendAgent(active, chunk.text, step, attemptId);
     } else if (chunk.type === "reasoning-delta") {
+      this.#appendReasoning(active, chunk.text, step, true, attemptId);
     } else if (chunk.type === "usage" && !initialReplay) {
       this.#publishUsageChanges(active.turnId);
     }
@@ -29352,36 +29828,48 @@ ${question.detail}` : question.question;
       update: { type: "text.append", text }
     });
   }
-  #startReasoning(active, step) {
+  #startReasoning(active, step, provisional, attemptId) {
     if (!active.reasoning) {
+      const key = provisional ? `reasoning:provisional:${++active.reasoningOrdinal}` : "reasoning";
       const item = {
         type: "reasoning",
-        itemId: modernItemId(this.#sessionId, `turn:${active.nativeTurn}:step:${step}:reasoning`),
+        itemId: modernItemId(this.#sessionId, `turn:${active.nativeTurn}:step:${step}:${key}`),
         text: ""
       };
-      active.reasoning = { item, text: "" };
+      active.reasoning = {
+        item,
+        text: "",
+        provisional,
+        pendingLineBreaks: "",
+        ...attemptId ? { attemptId } : {}
+      };
       this.#emit({ type: "item.started", turnId: active.turnId, item });
     }
     return active.reasoning;
   }
-  #appendReasoning(active, text, step) {
+  #appendReasoning(active, text, step, provisional = false, attemptId, final = false) {
     if (!text)
       return;
-    const reasoning2 = this.#startReasoning(active, step);
-    reasoning2.text += text;
+    const reasoning2 = this.#startReasoning(active, step, provisional, attemptId);
+    const candidate = final ? text : reasoning2.pendingLineBreaks + text;
+    const appended = final ? candidate : candidate.replace(/[\r\n]+$/u, "");
+    reasoning2.pendingLineBreaks = final ? "" : candidate.slice(appended.length);
+    if (!appended)
+      return;
+    reasoning2.text += appended;
     reasoning2.item = { ...reasoning2.item, text: reasoning2.text };
     this.#emit({
       type: "item.updated",
       turnId: active.turnId,
       itemId: reasoning2.item.itemId,
-      update: { type: "text.append", text }
+      update: { type: "text.append", text: appended }
     });
   }
   #completeAssistant(active, data) {
     const message = data.message;
     const step = data.step;
-    const reasoning2 = contentText(message.content, "reasoning");
-    const text = contentText(message.content, "text");
+    const reasoning2 = contentText2(message.content, "reasoning");
+    const text = contentText2(message.content, "text");
     if (this.#profile.assistantStream && active.agent && !text.startsWith(active.agent.text)) {
       this.#cancelAgentItem(active);
     }
@@ -29396,8 +29884,12 @@ ${question.detail}` : question.question;
     }
   }
   #completeReasoning(active, finalText, step) {
-    if (finalText)
-      this.#appendReasoning(active, finalText, step);
+    if (active.reasoning && !finalText.startsWith(active.reasoning.text)) {
+      this.#cancelReasoningItem(active);
+    }
+    const suffix = finalText.slice(active.reasoning?.text.length ?? 0);
+    if (suffix)
+      this.#appendReasoning(active, suffix, step, false, void 0, true);
     const current = active.reasoning;
     if (!current)
       return;
@@ -29482,6 +29974,7 @@ ${question.detail}` : question.question;
     const projected = turnOutcome(reason);
     const itemOutcome2 = toItemOutcome(projected);
     this.#discardAssistantAttempt();
+    this.#cancelReasoningItem(active);
     this.#closeActiveInteractions(active);
     this.#completeOpenItems(active, itemOutcome2);
     active.terminal = true;
@@ -29593,6 +30086,7 @@ ${question.detail}` : question.question;
         input: hostBound ? [...pending.command.input] : [...buffer.input],
         autonomous: !hostBound,
         tools: /* @__PURE__ */ new Map(),
+        reasoningOrdinal: 0,
         interactions: /* @__PURE__ */ new Set(),
         terminal: false,
         cancelAcknowledged: false
@@ -30033,6 +30527,9 @@ function turnOutcome(reason) {
   if (reason.kind === "aborted") {
     return { status: "cancelled", reason: "Cancelled by user" };
   }
+  if (reason.kind === "forked") {
+    return { status: "cancelled", reason: "Forked from parent Session" };
+  }
   return {
     status: "failed",
     error: {
@@ -30053,7 +30550,7 @@ function toItemOutcome(outcome) {
 function textInputs2(value) {
   return Array.isArray(value) ? value.flatMap((block) => isRecord4(block) && block.type === "text" && typeof block.text === "string" ? [{ type: "text", text: block.text }] : []) : [];
 }
-function contentText(value, type) {
+function contentText2(value, type) {
   return Array.isArray(value) ? value.filter((block) => isRecord4(block) && block.type === type && typeof block.text === "string").map((block) => block.text).join("") : "";
 }
 function isVisibleWork(event) {
@@ -30160,17 +30657,17 @@ function boundedId(value, area) {
 function validUpdatedAt(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= DEEPSEEK_MODERN_SESSION_UPDATED_AT_MAX && !Object.is(value, -0);
 }
-function titleFromProjections(value) {
+function titleFromProjections(value, profile) {
   if (value === void 0)
     return null;
-  if (!isPlainRecord7(value) || !exactKeys5(value, ["asOfSeq", "values"]) || !Number.isSafeInteger(value.asOfSeq) || value.asOfSeq < -1 || !isPlainRecord7(value.values)) {
+  if (!isPlainRecord7(value) || !exactKeys5(value, profile.sessionFormatVersion === 4 ? ["kind", "asOfSeq", "values"] : ["asOfSeq", "values"]) || profile.sessionFormatVersion === 4 && value.kind !== "cached" && value.kind !== "sequenced" || !Number.isSafeInteger(value.asOfSeq) || value.asOfSeq < -1 || !isPlainRecord7(value.values)) {
     throw sessionListError("protocolError", "DeepSeek Harness returned invalid Session list projections");
   }
   const title = value.values.title;
   return typeof title === "string" && title.trim().length > 0 && title.length <= DEEPSEEK_MODERN_SESSION_TITLE_MAX_LENGTH && !title.includes("\0") ? title : null;
 }
-function parseSummary(value) {
-  if (!isPlainRecord7(value) || !exactKeys5(value, ["sessionId", "updatedAt", "running", "blank"], ["parentSessionId", "origin", "cwd", "projections"]) || typeof value.running !== "boolean" || typeof value.blank !== "boolean" || !validUpdatedAt(value.updatedAt)) {
+function parseSummary(value, profile) {
+  if (!isPlainRecord7(value) || !exactKeys5(value, profile.sessionFormatVersion === 4 ? ["sessionId", "updatedAt", "agentAvailable", "running", "blank"] : ["sessionId", "updatedAt", "running", "blank"], ["parentSessionId", "origin", "cwd", "projections"]) || typeof value.running !== "boolean" || typeof value.blank !== "boolean" || profile.sessionFormatVersion === 4 && typeof value.agentAvailable !== "boolean" || !validUpdatedAt(value.updatedAt)) {
     throw sessionListError("protocolError", "DeepSeek Harness returned an invalid Session row");
   }
   const sessionId = boundedId(value.sessionId, "Session id");
@@ -30193,13 +30690,13 @@ function parseSummary(value) {
     blank: value.blank,
     ...value.origin === void 0 ? {} : { origin: value.origin },
     ...value.cwd === void 0 ? {} : { cwd: value.cwd },
-    title: titleFromProjections(value.projections)
+    title: titleFromProjections(value.projections, profile)
   };
 }
 function isCanonicalAbsoluteCwd(value) {
   return value !== void 0 && value.trim().length > 0 && !value.includes("\0") && path2.isAbsolute(value) && path2.resolve(value) === value;
 }
-function parseModernSessionCandidates(value) {
+function parseModernSessionCandidates(value, profile = DEEPSEEK_V015_PROFILE) {
   assertBoundedJson4(value);
   if (!isPlainRecord7(value) || !exactKeys5(value, ["items"]) || !Array.isArray(value.items)) {
     throw sessionListError("protocolError", "DeepSeek Harness returned an invalid Session list");
@@ -30209,7 +30706,7 @@ function parseModernSessionCandidates(value) {
   }
   const seen = /* @__PURE__ */ new Set();
   const summaries = value.items.map((item) => {
-    const summary = parseSummary(item);
+    const summary = parseSummary(item, profile);
     if (seen.has(summary.sessionId)) {
       throw sessionListError("protocolError", "DeepSeek Harness returned duplicate Session identities");
     }
@@ -30231,14 +30728,14 @@ function parseModernSessionCandidates(value) {
     ];
   });
 }
-async function loadModernSessionCandidates(remote, signal) {
+async function loadModernSessionCandidates(remote, signal, profile = DEEPSEEK_V015_PROFILE) {
   try {
     const result = await remote.call("session/list", { _request: {} }, signal);
     if (!result.ok) {
       const safe = sanitizeModernRemoteFailure(result.error);
       throw sessionListError("remoteError", `DeepSeek Harness session/list failed: ${safe.message}`, safe.code);
     }
-    return parseModernSessionCandidates(result.value);
+    return parseModernSessionCandidates(result.value, profile);
   } catch (error51) {
     if (error51 instanceof ModernSessionListError)
       throw error51;
@@ -30307,6 +30804,7 @@ var ModernDeepSeekHarnessAdapter = class {
       onFault: (error51) => this.#fail(toHarnessError(error51, "unavailable"))
     });
     this.#control = new ModernControlStore(this.#connection, {
+      profile: this.#profile,
       onFault: (error51) => this.#fail(toHarnessError(error51, "unavailable"))
     });
     this.#removeConnectionFaultListener = this.#connection.onFault((error51) => {
@@ -30379,7 +30877,7 @@ var ModernDeepSeekHarnessAdapter = class {
     try {
       await this.#connection.connect();
       this.#assertAccepting();
-      const candidates = await loadModernSessionCandidates(this.#connection, this.#lifetime.signal);
+      const candidates = await loadModernSessionCandidates(this.#connection, this.#lifetime.signal, this.#profile);
       this.#assertAccepting();
       return { ok: true, value: candidates };
     } catch (error51) {
@@ -30475,7 +30973,7 @@ var ModernDeepSeekHarnessAdapter = class {
       this.#assertAccepting();
       if (forkExpectation) {
         await this.#verifyForkJournal(forkExpectation, journal, cwd);
-        if (isDeepSeekV015(this.#profile) && await clearInheritedForkInbox(this.#connection, journal, this.#lifetime.signal)) {
+        if (hasDeepSeekModernStream(this.#profile) && await clearInheritedForkInbox(this.#connection, journal, this.#lifetime.signal)) {
           await journal.close();
           journal = await openModernJournal(this.#connection, { sessionId, cwd }, this.#journalOptions());
           await this.#verifyForkJournal(forkExpectation, journal, cwd);
@@ -30511,10 +31009,11 @@ var ModernDeepSeekHarnessAdapter = class {
           harnessId: this.harnessId,
           nativeSessionId: sessionId,
           formatVersion: 1,
-          ...isDeepSeekV015(this.#profile) ? { locator: { dshVersion: this.#profile.version } } : {}
+          ...hasDeepSeekModernStream(this.#profile) ? { locator: { dshVersion: this.#profile.version } } : {}
         }),
         modelCatalog: catalog,
-        permissionModes
+        permissionModes,
+        profile: this.#profile
       });
       verifyCreateConfiguration(createConfiguration, openedConfiguration);
       if (createConfiguration?.unattended && !delegationPermissionIsApplied(journal.events)) {
@@ -30532,7 +31031,7 @@ var ModernDeepSeekHarnessAdapter = class {
         modelCatalog: catalog,
         permissionModes,
         sessionId,
-        ...isDeepSeekV015(this.#profile) ? { flushSession: () => this.#connection.flushSession(sessionId) } : {},
+        ...hasDeepSeekModernStream(this.#profile) ? { flushSession: () => this.#connection.flushSession(sessionId) } : {},
         randomUUID: this.#dependencies.randomUUID,
         now: this.#dependencies.now,
         ...this.#options.toolOutputLimit === void 0 ? {} : { toolOutputLimit: this.#options.toolOutputLimit },
@@ -30674,7 +31173,7 @@ var ModernDeepSeekHarnessAdapter = class {
       }
       atSeq = boundary.atSeq;
       minimumSeedLength = boundary.events.length;
-      if (boundary.events.length < source.events.length) {
+      if (this.#profile.sessionFormatVersion === 4 || boundary.events.length < source.events.length) {
         exactSeedLength = boundary.events.length;
       }
     } finally {
@@ -30767,7 +31266,7 @@ var ModernDeepSeekHarnessAdapter = class {
     }
     if (this.#permissionModesPromise)
       return this.#permissionModesPromise;
-    const operation = loadModernPermissionModeCatalog(this.#connection).then((catalog) => {
+    const operation = loadModernPermissionModeCatalog(this.#connection, this.#lifetime.signal, this.#profile).then((catalog) => {
       this.#permissionModes = catalog;
       this.#permissionModesLoaded = true;
       return catalog;
@@ -30992,18 +31491,19 @@ function parseModernForkInput(input, profile) {
 function sessionLocatorMatches(locator, profile) {
   if (locator === void 0)
     return true;
-  if (!isDeepSeekV015(profile) || !isRecord8(locator) || Reflect.ownKeys(locator).length !== 1 || typeof locator.dshVersion !== "string") {
+  if (!hasDeepSeekModernStream(profile) || !isRecord8(locator) || Reflect.ownKeys(locator).length !== 1 || typeof locator.dshVersion !== "string") {
     return false;
   }
   try {
     const { version: version2 } = classifyDeepSeekVersionOutput(locator.dshVersion);
-    return isDeepSeekV015(deepSeekModernProfile(version2));
+    const original = deepSeekModernProfile(version2);
+    return original.sessionFormatVersion === profile.sessionFormatVersion || profile.sessionFormatVersion === 4 && original.sessionFormatVersion === 3;
   } catch {
     return false;
   }
 }
 function checkpointLocatorMatches(locator, profile) {
-  return isDeepSeekV015(profile) ? profileLocatorMatches(locator, profile) : locator === void 0;
+  return hasDeepSeekModernStream(profile) ? profileLocatorMatches(locator, profile) : locator === void 0;
 }
 function profileLocatorMatches(locator, profile) {
   return isRecord8(locator) && Reflect.ownKeys(locator).length === 1 && locator.dshVersion === profile.version;
@@ -31214,7 +31714,7 @@ var DeepSeekHarnessAdapter = class {
             harnessId: this.harnessId,
             nativeSessionId,
             formatVersion: 1,
-            ...this.#delegate && isDeepSeekV015(deepSeekModernProfile(this.#delegate.version)) ? { locator: { dshVersion: this.#delegate.version } } : {}
+            ...this.#delegate && hasDeepSeekModernStream(deepSeekModernProfile(this.#delegate.version)) ? { locator: { dshVersion: this.#delegate.version } } : {}
           })
         }
       };