@codexhost/cli-darwin-x64 0.6.0 → 0.6.2

package/app/plugins/pi/plugin.mjs

@@ -5,529 +5,9 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../../../node_modules/diff/libesm/diff/base.js
-var Diff = class {
-  diff(oldStr, newStr, options = {}) {
-    let callback;
-    if (typeof options === "function") {
-      callback = options;
-      options = {};
-    } else if ("callback" in options) {
-      callback = options.callback;
-    }
-    const oldString = this.castInput(oldStr, options);
-    const newString = this.castInput(newStr, options);
-    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
-    const newTokens = this.removeEmpty(this.tokenize(newString, options));
-    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
-  }
-  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
-    var _a3;
-    const done = (value) => {
-      value = this.postProcess(value, options);
-      if (callback) {
-        setTimeout(function() {
-          callback(value);
-        }, 0);
-        return void 0;
-      } else {
-        return value;
-      }
-    };
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let editLength = 1;
-    let maxEditLength = newLen + oldLen;
-    if (options.maxEditLength != null) {
-      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-    }
-    const maxExecutionTime = (_a3 = options.timeout) !== null && _a3 !== void 0 ? _a3 : Infinity;
-    const abortAfterTimestamp = Date.now() + maxExecutionTime;
-    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
-    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
-    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
-    }
-    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-    const execEditLength = () => {
-      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-        let basePath;
-        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-        if (removePath) {
-          bestPath[diagonalPath - 1] = void 0;
-        }
-        let canAdd = false;
-        if (addPath) {
-          const addPathNewPos = addPath.oldPos - diagonalPath;
-          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-        }
-        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
-        if (!canAdd && !canRemove) {
-          bestPath[diagonalPath] = void 0;
-          continue;
-        }
-        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
-          basePath = this.addToPath(addPath, true, false, 0, options);
-        } else {
-          basePath = this.addToPath(removePath, false, true, 1, options);
-        }
-        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
-        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
-        } else {
-          bestPath[diagonalPath] = basePath;
-          if (basePath.oldPos + 1 >= oldLen) {
-            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
-          }
-          if (newPos + 1 >= newLen) {
-            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
-          }
-        }
-      }
-      editLength++;
-    };
-    if (callback) {
-      (function exec() {
-        setTimeout(function() {
-          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-            return callback(void 0);
-          }
-          if (!execEditLength()) {
-            exec();
-          }
-        }, 0);
-      })();
-    } else {
-      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-        const ret = execEditLength();
-        if (ret) {
-          return ret;
-        }
-      }
-    }
-  }
-  addToPath(path6, added, removed, oldPosInc, options) {
-    const last = path6.lastComponent;
-    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
-      return {
-        oldPos: path6.oldPos + oldPosInc,
-        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
-      };
-    } else {
-      return {
-        oldPos: path6.oldPos + oldPosInc,
-        lastComponent: { count: 1, added, removed, previousComponent: last }
-      };
-    }
-  }
-  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
-      newPos++;
-      oldPos++;
-      commonCount++;
-      if (options.oneChangePerToken) {
-        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
-      }
-    }
-    if (commonCount && !options.oneChangePerToken) {
-      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
-    }
-    basePath.oldPos = oldPos;
-    return newPos;
-  }
-  equals(left, right, options) {
-    if (options.comparator) {
-      return options.comparator(left, right);
-    } else {
-      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
-    }
-  }
-  removeEmpty(array2) {
-    const ret = [];
-    for (let i = 0; i < array2.length; i++) {
-      if (array2[i]) {
-        ret.push(array2[i]);
-      }
-    }
-    return ret;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  castInput(value, options) {
-    return value;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  tokenize(value, options) {
-    return Array.from(value);
-  }
-  join(chars) {
-    return chars.join("");
-  }
-  postProcess(changeObjects, options) {
-    return changeObjects;
-  }
-  get useLongestToken() {
-    return false;
-  }
-  buildValues(lastComponent, newTokens, oldTokens) {
-    const components = [];
-    let nextComponent;
-    while (lastComponent) {
-      components.push(lastComponent);
-      nextComponent = lastComponent.previousComponent;
-      delete lastComponent.previousComponent;
-      lastComponent = nextComponent;
-    }
-    components.reverse();
-    const componentLen = components.length;
-    let componentPos = 0, newPos = 0, oldPos = 0;
-    for (; componentPos < componentLen; componentPos++) {
-      const component = components[componentPos];
-      if (!component.removed) {
-        if (!component.added && this.useLongestToken) {
-          let value = newTokens.slice(newPos, newPos + component.count);
-          value = value.map(function(value2, i) {
-            const oldValue = oldTokens[oldPos + i];
-            return oldValue.length > value2.length ? oldValue : value2;
-          });
-          component.value = this.join(value);
-        } else {
-          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
-        }
-        newPos += component.count;
-        if (!component.added) {
-          oldPos += component.count;
-        }
-      } else {
-        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
-        oldPos += component.count;
-      }
-    }
-    return components;
-  }
-};
-
-// ../../../node_modules/diff/libesm/diff/line.js
-var LineDiff = class extends Diff {
-  constructor() {
-    super(...arguments);
-    this.tokenize = tokenize;
-  }
-  equals(left, right, options) {
-    if (options.ignoreWhitespace) {
-      if (!options.newlineIsToken || !left.includes("\n")) {
-        left = left.trim();
-      }
-      if (!options.newlineIsToken || !right.includes("\n")) {
-        right = right.trim();
-      }
-    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-      if (left.endsWith("\n")) {
-        left = left.slice(0, -1);
-      }
-      if (right.endsWith("\n")) {
-        right = right.slice(0, -1);
-      }
-    }
-    return super.equals(left, right, options);
-  }
-};
-var lineDiff = new LineDiff();
-function diffLines(oldStr, newStr, options) {
-  return lineDiff.diff(oldStr, newStr, options);
-}
-function tokenize(value, options) {
-  if (options.stripTrailingCr) {
-    value = value.replace(/\r\n/g, "\n");
-  }
-  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-    linesAndNewlines.pop();
-  }
-  for (let i = 0; i < linesAndNewlines.length; i++) {
-    const line = linesAndNewlines[i];
-    if (i % 2 && !options.newlineIsToken) {
-      retLines[retLines.length - 1] += line;
-    } else {
-      retLines.push(line);
-    }
-  }
-  return retLines;
-}
-
-// ../../../node_modules/diff/libesm/patch/parse.js
-function parsePatch(uniDiff) {
-  const diffstr = uniDiff.split(/\n/), list = [];
-  let i = 0;
-  function parseIndex() {
-    const index = {};
-    list.push(index);
-    while (i < diffstr.length) {
-      const line = diffstr[i];
-      if (/^(---|\+\+\+|@@)\s/.test(line)) {
-        break;
-      }
-      const header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
-      if (header) {
-        index.index = header[1];
-      }
-      i++;
-    }
-    parseFileHeader(index);
-    parseFileHeader(index);
-    index.hunks = [];
-    while (i < diffstr.length) {
-      const line = diffstr[i];
-      if (/^(Index:\s|diff\s|---\s|\+\+\+\s|===================================================================)/.test(line)) {
-        break;
-      } else if (/^@@/.test(line)) {
-        index.hunks.push(parseHunk());
-      } else if (line) {
-        throw new Error("Unknown line " + (i + 1) + " " + JSON.stringify(line));
-      } else {
-        i++;
-      }
-    }
-  }
-  function parseFileHeader(index) {
-    const fileHeader = /^(---|\+\+\+)\s+(.*)\r?$/.exec(diffstr[i]);
-    if (fileHeader) {
-      const data = fileHeader[2].split("	", 2), header = (data[1] || "").trim();
-      let fileName = data[0].replace(/\\\\/g, "\\");
-      if (/^".*"$/.test(fileName)) {
-        fileName = fileName.substr(1, fileName.length - 2);
-      }
-      if (fileHeader[1] === "---") {
-        index.oldFileName = fileName;
-        index.oldHeader = header;
-      } else {
-        index.newFileName = fileName;
-        index.newHeader = header;
-      }
-      i++;
-    }
-  }
-  function parseHunk() {
-    var _a3;
-    const chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
-    const hunk = {
-      oldStart: +chunkHeader[1],
-      oldLines: typeof chunkHeader[2] === "undefined" ? 1 : +chunkHeader[2],
-      newStart: +chunkHeader[3],
-      newLines: typeof chunkHeader[4] === "undefined" ? 1 : +chunkHeader[4],
-      lines: []
-    };
-    if (hunk.oldLines === 0) {
-      hunk.oldStart += 1;
-    }
-    if (hunk.newLines === 0) {
-      hunk.newStart += 1;
-    }
-    let addCount = 0, removeCount = 0;
-    for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a3 = diffstr[i]) === null || _a3 === void 0 ? void 0 : _a3.startsWith("\\"))); i++) {
-      const operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? " " : diffstr[i][0];
-      if (operation === "+" || operation === "-" || operation === " " || operation === "\\") {
-        hunk.lines.push(diffstr[i]);
-        if (operation === "+") {
-          addCount++;
-        } else if (operation === "-") {
-          removeCount++;
-        } else if (operation === " ") {
-          addCount++;
-          removeCount++;
-        }
-      } else {
-        throw new Error(`Hunk at line ${chunkHeaderIndex + 1} contained invalid line ${diffstr[i]}`);
-      }
-    }
-    if (!addCount && hunk.newLines === 1) {
-      hunk.newLines = 0;
-    }
-    if (!removeCount && hunk.oldLines === 1) {
-      hunk.oldLines = 0;
-    }
-    if (addCount !== hunk.newLines) {
-      throw new Error("Added line count did not match for hunk at line " + (chunkHeaderIndex + 1));
-    }
-    if (removeCount !== hunk.oldLines) {
-      throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
-    }
-    return hunk;
-  }
-  while (i < diffstr.length) {
-    parseIndex();
-  }
-  return list;
-}
-
-// ../../../node_modules/diff/libesm/patch/create.js
-function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-  let optionsObj;
-  if (!options) {
-    optionsObj = {};
-  } else if (typeof options === "function") {
-    optionsObj = { callback: options };
-  } else {
-    optionsObj = options;
-  }
-  if (typeof optionsObj.context === "undefined") {
-    optionsObj.context = 4;
-  }
-  const context = optionsObj.context;
-  if (optionsObj.newlineIsToken) {
-    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
-  }
-  if (!optionsObj.callback) {
-    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
-  } else {
-    const { callback } = optionsObj;
-    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
-      const patch = diffLinesResultToPatch(diff);
-      callback(patch);
-    } }));
-  }
-  function diffLinesResultToPatch(diff) {
-    if (!diff) {
-      return;
-    }
-    diff.push({ value: "", lines: [] });
-    function contextLines(lines) {
-      return lines.map(function(entry) {
-        return " " + entry;
-      });
-    }
-    const hunks = [];
-    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
-    for (let i = 0; i < diff.length; i++) {
-      const current = diff[i], lines = current.lines || splitLines(current.value);
-      current.lines = lines;
-      if (current.added || current.removed) {
-        if (!oldRangeStart) {
-          const prev = diff[i - 1];
-          oldRangeStart = oldLine;
-          newRangeStart = newLine;
-          if (prev) {
-            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
-            oldRangeStart -= curRange.length;
-            newRangeStart -= curRange.length;
-          }
-        }
-        for (const line of lines) {
-          curRange.push((current.added ? "+" : "-") + line);
-        }
-        if (current.added) {
-          newLine += lines.length;
-        } else {
-          oldLine += lines.length;
-        }
-      } else {
-        if (oldRangeStart) {
-          if (lines.length <= context * 2 && i < diff.length - 2) {
-            for (const line of contextLines(lines)) {
-              curRange.push(line);
-            }
-          } else {
-            const contextSize = Math.min(lines.length, context);
-            for (const line of contextLines(lines.slice(0, contextSize))) {
-              curRange.push(line);
-            }
-            const hunk = {
-              oldStart: oldRangeStart,
-              oldLines: oldLine - oldRangeStart + contextSize,
-              newStart: newRangeStart,
-              newLines: newLine - newRangeStart + contextSize,
-              lines: curRange
-            };
-            hunks.push(hunk);
-            oldRangeStart = 0;
-            newRangeStart = 0;
-            curRange = [];
-          }
-        }
-        oldLine += lines.length;
-        newLine += lines.length;
-      }
-    }
-    for (const hunk of hunks) {
-      for (let i = 0; i < hunk.lines.length; i++) {
-        if (hunk.lines[i].endsWith("\n")) {
-          hunk.lines[i] = hunk.lines[i].slice(0, -1);
-        } else {
-          hunk.lines.splice(i + 1, 0, "\");
-          i++;
-        }
-      }
-    }
-    return {
-      oldFileName,
-      newFileName,
-      oldHeader,
-      newHeader,
-      hunks
-    };
-  }
-}
-function formatPatch(patch) {
-  if (Array.isArray(patch)) {
-    return patch.map(formatPatch).join("\n");
-  }
-  const ret = [];
-  if (patch.oldFileName == patch.newFileName) {
-    ret.push("Index: " + patch.oldFileName);
-  }
-  ret.push("===================================================================");
-  ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "	" + patch.oldHeader));
-  ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "	" + patch.newHeader));
-  for (let i = 0; i < patch.hunks.length; i++) {
-    const hunk = patch.hunks[i];
-    if (hunk.oldLines === 0) {
-      hunk.oldStart -= 1;
-    }
-    if (hunk.newLines === 0) {
-      hunk.newStart -= 1;
-    }
-    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
-    for (const line of hunk.lines) {
-      ret.push(line);
-    }
-  }
-  return ret.join("\n") + "\n";
-}
-function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-  if (typeof options === "function") {
-    options = { callback: options };
-  }
-  if (!(options === null || options === void 0 ? void 0 : options.callback)) {
-    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
-    if (!patchObj) {
-      return;
-    }
-    return formatPatch(patchObj);
-  } else {
-    const { callback } = options;
-    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
-      if (!patchObj) {
-        callback(void 0);
-      } else {
-        callback(formatPatch(patchObj));
-      }
-    } }));
-  }
-}
-function splitLines(text) {
-  const hasTrailingNl = text.endsWith("\n");
-  const result = text.split("\n").map((line) => line + "\n");
-  if (hasTrailingNl) {
-    result.pop();
-  } else {
-    result.push(result.pop().slice(0, -1));
-  }
-  return result;
-}
-
-// dist/pi-adapter.js
-import { randomUUID as randomUUID2 } from "node:crypto";
-import path5 from "node:path";
+// dist/pi-empty-session.js
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
 
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -1295,10 +775,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path6) {
-  if (!path6)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path6.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1707,11 +1187,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path6, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path6);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -1858,16 +1338,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path6 = []) => {
+  const processError = (error52, path7 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path6, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1894,17 +1374,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path6 = []) => {
+  const processError = (error52, path7 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path6, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1936,8 +1416,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path6) {
+  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14629,13 +14109,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path6 = ref.slice(1).split("/").filter(Boolean);
-  if (path6.length === 0) {
+  const path7 = ref.slice(1).split("/").filter(Boolean);
+  if (path7.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path6[0] === defsKey) {
-    const key = path6[1];
+  if (path7[0] === defsKey) {
+    const key = path7[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15069,6 +14549,8 @@ var threadUsageSnapshotSchema = external_exports.object({
   reasoningOutputTokens: nonNegativeSafeIntegerSchema.optional(),
   totalTokens: nonNegativeSafeIntegerSchema.optional(),
   totalCostUsd: finiteNonNegativeNumberSchema.optional(),
+  totalCredits: finiteNonNegativeNumberSchema.optional(),
+  contextUsagePercent: finiteNonNegativeNumberSchema.optional(),
   cacheHitRatePercent: cacheHitRatePercentSchema.optional(),
   contextWindowTokens: nonNegativeSafeIntegerSchema.optional(),
   contextUsedTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -15699,713 +15181,1405 @@ var externalThreadForkResultSchema = external_exports.object({
   threadId: hostThreadIdSchema
 }).strict();
 
-// ../../shared-contracts/dist/harness-commands.js
-var commandIdSchema = external_exports.string().trim().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/u).brand();
-var commandInvocationSchema = external_exports.string().min(1).max(128);
-var commandLabelSchema = external_exports.string().trim().min(1).max(128);
-var commandDescriptionSchema = external_exports.string().trim().min(1).max(512);
-var harnessCommandDescriptorSchema = external_exports.object({
-  id: commandIdSchema,
-  invocation: commandInvocationSchema,
-  label: commandLabelSchema,
-  description: commandDescriptionSchema.optional(),
-  argumentMode: external_exports.enum(["none", "text"])
-}).strict();
-var harnessCommandCatalogSchema = external_exports.object({
-  commands: external_exports.array(harnessCommandDescriptorSchema)
-}).strict().superRefine((catalog, context) => {
-  const ids = /* @__PURE__ */ new Set();
-  for (const [index, command] of catalog.commands.entries()) {
-    if (ids.has(command.id)) {
-      context.addIssue({
-        code: "custom",
-        message: "Harness command IDs must be unique",
-        path: ["commands", index, "id"]
-      });
+// ../../shared-contracts/dist/harness-commands.js
+var commandIdSchema = external_exports.string().trim().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/u).brand();
+var commandInvocationSchema = external_exports.string().min(1).max(128);
+var commandLabelSchema = external_exports.string().trim().min(1).max(128);
+var commandDescriptionSchema = external_exports.string().trim().min(1).max(512);
+var harnessCommandDescriptorSchema = external_exports.object({
+  id: commandIdSchema,
+  invocation: commandInvocationSchema,
+  label: commandLabelSchema,
+  description: commandDescriptionSchema.optional(),
+  argumentMode: external_exports.enum(["none", "text"])
+}).strict();
+var harnessCommandCatalogSchema = external_exports.object({
+  commands: external_exports.array(harnessCommandDescriptorSchema)
+}).strict().superRefine((catalog, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, command] of catalog.commands.entries()) {
+    if (ids.has(command.id)) {
+      context.addIssue({
+        code: "custom",
+        message: "Harness command IDs must be unique",
+        path: ["commands", index, "id"]
+      });
+    }
+    ids.add(command.id);
+  }
+});
+var harnessCommandsInspectParamsSchema = external_exports.object({ harnessId: harnessIdSchema }).strict();
+var threadCommandsInspectParamsSchema = external_exports.object({
+  threadId: hostThreadIdSchema
+}).strict();
+var threadCommandExecuteParamsSchema = external_exports.object({
+  threadId: hostThreadIdSchema,
+  commandId: commandIdSchema,
+  turnId: hostTurnIdSchema.optional(),
+  arguments: jsonObjectSchema.optional()
+}).strict();
+var threadCommandExecuteResultSchema = external_exports.object({
+  accepted: external_exports.literal(true),
+  turnId: hostTurnIdSchema
+}).strict();
+
+// ../../shared-contracts/dist/json-rpc.js
+var jsonRpcVersionSchema = external_exports.literal("2.0").optional();
+var absentSchema = external_exports.never().optional();
+var methodSchema = external_exports.string().min(1);
+var jsonRpcIdSchema = external_exports.union([external_exports.string(), external_exports.number().int()]);
+var jsonRpcErrorSchema = external_exports.object({
+  code: external_exports.number().int(),
+  message: external_exports.string(),
+  data: jsonValueSchema.optional()
+}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["data"]));
+var jsonRpcRequestSchema = external_exports.object({
+  jsonrpc: jsonRpcVersionSchema,
+  id: jsonRpcIdSchema,
+  method: methodSchema,
+  params: jsonValueSchema.optional(),
+  result: absentSchema,
+  error: absentSchema
+}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "params", "result", "error"]));
+var jsonRpcNotificationSchema = external_exports.object({
+  jsonrpc: jsonRpcVersionSchema,
+  id: absentSchema,
+  method: methodSchema,
+  params: jsonValueSchema.optional(),
+  result: absentSchema,
+  error: absentSchema
+}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "id", "params", "result", "error"]));
+var jsonRpcSuccessResponseSchema = external_exports.object({
+  jsonrpc: jsonRpcVersionSchema,
+  id: jsonRpcIdSchema,
+  method: absentSchema,
+  params: absentSchema,
+  result: jsonValueSchema,
+  error: absentSchema
+}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "method", "params", "error"]));
+var jsonRpcErrorResponseSchema = external_exports.object({
+  jsonrpc: jsonRpcVersionSchema,
+  id: jsonRpcIdSchema,
+  method: absentSchema,
+  params: absentSchema,
+  result: absentSchema,
+  error: jsonRpcErrorSchema
+}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "method", "params", "result"]));
+var jsonRpcEnvelopeSchema = external_exports.union([
+  jsonRpcRequestSchema,
+  jsonRpcNotificationSchema,
+  jsonRpcSuccessResponseSchema,
+  jsonRpcErrorResponseSchema
+]);
+
+// ../../shared-contracts/dist/native-refs.js
+var nativeIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
+  message: "Native identifier must not be empty or whitespace"
+});
+var nativeSessionRefV1RuntimeSchema = external_exports.strictObject({
+  harnessId: harnessIdSchema,
+  nativeSessionId: nativeIdSchema,
+  locator: jsonValueSchema.optional(),
+  formatVersion: external_exports.literal(1)
+}).superRefine(rejectExplicitUndefined(["locator"]));
+var nativeSessionRefV1Schema = nativeSessionRefV1RuntimeSchema;
+var nativeSessionRefSchema = nativeSessionRefV1Schema;
+var nativeTurnRefV1Schema = external_exports.strictObject({
+  harnessId: harnessIdSchema,
+  nativeSessionId: nativeIdSchema,
+  nativeTurnKey: nativeIdSchema,
+  formatVersion: external_exports.literal(1)
+});
+var nativeTurnRefSchema = nativeTurnRefV1Schema;
+var nativeCheckpointRefV1RuntimeSchema = external_exports.strictObject({
+  harnessId: harnessIdSchema,
+  nativeSessionId: nativeIdSchema,
+  checkpointId: nativeIdSchema,
+  locator: jsonValueSchema.optional(),
+  formatVersion: external_exports.literal(1)
+}).superRefine(rejectExplicitUndefined(["locator"]));
+var nativeCheckpointRefV1Schema = nativeCheckpointRefV1RuntimeSchema;
+var nativeCheckpointRefSchema = nativeCheckpointRefV1Schema;
+
+// ../../shared-contracts/dist/updates.js
+var UPDATE_ERROR_MAX_LENGTH = 500;
+var UPDATE_SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u;
+var updateSemanticVersionSchema = external_exports.string().regex(UPDATE_SEMVER_PATTERN);
+var updateInstallationSchema = external_exports.enum(["npm", "windows-installer", "macos-dmg"]);
+var updatePhaseSchema = external_exports.enum([
+  "prepared",
+  "downloading",
+  "waiting-for-exit",
+  "installing",
+  "restarting",
+  "succeeded",
+  "failed"
+]);
+var updateStatusSchema = external_exports.strictObject({
+  version: updateSemanticVersionSchema,
+  installation: updateInstallationSchema,
+  phase: updatePhaseSchema,
+  updatedAt: external_exports.number().int().nonnegative(),
+  downloadedBytes: external_exports.number().int().nonnegative().optional(),
+  totalBytes: external_exports.number().int().positive().optional(),
+  error: external_exports.string().min(1).max(UPDATE_ERROR_MAX_LENGTH).nullable()
+}).superRefine((status, context) => {
+  if (status.downloadedBytes !== void 0 && status.totalBytes !== void 0 && status.downloadedBytes > status.totalBytes) {
+    context.addIssue({
+      code: "custom",
+      path: ["downloadedBytes"],
+      message: "downloadedBytes must not exceed totalBytes"
+    });
+  }
+});
+var updateEmptyParamsSchema = external_exports.strictObject({});
+var githubReleaseNotesUrlSchema = external_exports.string().max(300).regex(/^https:\/\/github\.com\/BytePioneer-AI\/codex-host\/releases\/tag\/v[0-9A-Za-z.+-]+$/u, "release notes URL must identify a codexhost GitHub Release");
+var updateCheckResultSchema = external_exports.strictObject({
+  currentVersion: updateSemanticVersionSchema,
+  installation: updateInstallationSchema.nullable(),
+  latestVersion: updateSemanticVersionSchema.nullable(),
+  updateAvailable: external_exports.boolean(),
+  installationAvailable: external_exports.boolean(),
+  releaseNotes: external_exports.string().min(1).max(2e4).nullable(),
+  releaseNotesUrl: githubReleaseNotesUrlSchema.nullable(),
+  status: updateStatusSchema.nullable(),
+  error: external_exports.string().min(1).max(UPDATE_ERROR_MAX_LENGTH).nullable()
+});
+var updateStartResultSchema = external_exports.strictObject({
+  status: updateStatusSchema
+});
+var updateStatusResultSchema = external_exports.strictObject({
+  status: updateStatusSchema.nullable()
+});
+
+// ../../shared-contracts/dist/index.js
+var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
+
+// dist/pi-empty-session.js
+import { randomUUID } from "node:crypto";
+import { link, open as open2, rm } from "node:fs/promises";
+import path from "node:path";
+
+// dist/pi-model-catalog.js
+var PI_MODEL_REF_PREFIX = "pi-model-v1.";
+var PI_DRAFT_THINKING_OPTION_IDS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+].map((id) => harnessThinkingOptionIdSchema.parse(id));
+var PI_THINKING_LABELS = {
+  off: "Off",
+  minimal: "Minimal",
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  xhigh: "Extra High",
+  max: "Max"
+};
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function assertNativePart(value, name) {
+  if (value.trim().length === 0)
+    throw new Error(`Pi ${name} must not be empty`);
+}
+function encodePiModelRef(model) {
+  assertNativePart(model.provider, "Model provider");
+  assertNativePart(model.id, "Model id");
+  const encoded = Buffer.from(JSON.stringify([model.provider, model.id]), "utf8").toString("base64url");
+  return harnessModelRefSchema.parse({ id: `${PI_MODEL_REF_PREFIX}${encoded}` });
+}
+function decodePiModelRef(ref) {
+  const parsedRef = harnessModelRefSchema.parse(ref);
+  if (!parsedRef.id.startsWith(PI_MODEL_REF_PREFIX)) {
+    throw new Error("Model Ref does not belong to PiAdapter");
+  }
+  const encoded = parsedRef.id.slice(PI_MODEL_REF_PREFIX.length);
+  let decoded;
+  try {
+    decoded = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+  } catch {
+    throw new Error("Pi Model Ref is malformed");
+  }
+  if (!Array.isArray(decoded) || decoded.length !== 2 || typeof decoded[0] !== "string" || typeof decoded[1] !== "string") {
+    throw new Error("Pi Model Ref has an invalid native identity");
+  }
+  const native = { provider: decoded[0], id: decoded[1] };
+  assertNativePart(native.provider, "Model provider");
+  assertNativePart(native.id, "Model id");
+  if (encodePiModelRef(native).id !== parsedRef.id) {
+    throw new Error("Pi Model Ref is not canonical");
+  }
+  return native;
+}
+function samePiModel(left, right) {
+  return left === null ? right === null : right !== null && left.provider === right.provider && left.id === right.id;
+}
+function fallbackThinkingLabel(id) {
+  const label = id.split(/[._~-]+/u).filter((part) => part.length > 0).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
+  return label || id;
+}
+function normalizePiThinkingOptions(levels) {
+  return levels.map((id) => harnessThinkingOptionSchema.parse({
+    id,
+    label: PI_THINKING_LABELS[id] ?? fallbackThinkingLabel(id)
+  }));
+}
+function normalizePiModelCatalog(nativeModels, effectiveModel, thinkingLevels, effectiveThinkingOptionId) {
+  const byRef = /* @__PURE__ */ new Map();
+  for (const native of nativeModels) {
+    const ref = encodePiModelRef(native);
+    const existing = byRef.get(ref.id);
+    if (existing) {
+      if (existing.reasoning !== native.reasoning) {
+        throw new Error("Pi duplicate Model entries disagree on reasoning capability");
+      }
+      continue;
+    }
+    byRef.set(ref.id, {
+      model: {
+        ref,
+        label: `${native.provider} / ${native.id}`
+      },
+      reasoning: native.reasoning
+    });
+  }
+  const defaultModel = effectiveModel ? encodePiModelRef(effectiveModel) : void 0;
+  if (defaultModel && !byRef.has(defaultModel.id)) {
+    throw new Error("Pi effective Model is absent from the available Model catalog");
+  }
+  if (thinkingLevels && effectiveThinkingOptionId && !thinkingLevels.includes(effectiveThinkingOptionId)) {
+    throw new Error("Pi effective Thinking option is absent from the available option catalog");
+  }
+  if (thinkingLevels && !effectiveThinkingOptionId) {
+    throw new Error("Pi did not report an effective Thinking option");
+  }
+  const thinkingOptions = thinkingLevels ? normalizePiThinkingOptions(PI_DRAFT_THINKING_OPTION_IDS) : [];
+  const allThinkingOptionIds = thinkingOptions.map(({ id }) => id);
+  const offThinkingOptionId = thinkingOptions.find(({ id }) => id === "off")?.id;
+  const models = [...byRef.values()].map(({ model, reasoning }) => ({
+    ...model,
+    supportedThinkingOptionIds: reasoning ? allThinkingOptionIds : offThinkingOptionId ? [offThinkingOptionId] : []
+  })).sort((left, right) => compareText(left.label, right.label) || compareText(left.ref.id, right.ref.id));
+  const defaultThinkingOptionId = thinkingOptions.find(({ id }) => id === effectiveThinkingOptionId)?.id;
+  return harnessModelCatalogSchema.parse({
+    models,
+    ...defaultModel ? { defaultModel } : {},
+    thinkingOptions,
+    ...defaultThinkingOptionId ? { defaultThinkingOptionId } : {}
+  });
+}
+
+// dist/pi-history.js
+var piHarnessId = harnessIdSchema.parse("pi");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function textContent(value) {
+  if (typeof value === "string")
+    return value;
+  if (!Array.isArray(value))
+    return "";
+  return value.filter((part) => isRecord(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
+}
+function thinkingContent(value) {
+  if (!Array.isArray(value))
+    return "";
+  return value.filter((part) => isRecord(part) && part.type === "thinking" && typeof part.thinking === "string").map((part) => part.thinking).join("");
+}
+function validatedEntry(value) {
+  if (typeof value.id !== "string" || value.id.length === 0 || value.parentId !== null && typeof value.parentId !== "string" || typeof value.type !== "string") {
+    throw new Error("Pi history contains an invalid Entry identity");
+  }
+  return value;
+}
+function activePiEntries(history) {
+  if (history.leafId === null)
+    return [];
+  const byId = new Map(history.entries.map((value) => {
+    const entry = validatedEntry(value);
+    return [entry.id, entry];
+  }));
+  const reversed = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = history.leafId;
+  while (current !== null) {
+    if (visited.has(current))
+      throw new Error("Pi history active branch contains a cycle");
+    visited.add(current);
+    const entry = byId.get(current);
+    if (!entry)
+      throw new Error("Pi history active branch references a missing Entry");
+    reversed.push(entry);
+    current = entry.parentId;
+  }
+  return reversed.reverse();
+}
+function message(entry) {
+  return entry.type === "message" && isRecord(entry.message) ? entry.message : null;
+}
+function messageRole(entry) {
+  const value = message(entry)?.role;
+  return typeof value === "string" ? value : null;
+}
+function itemId(entryId, kind, ordinal) {
+  return hostItemIdSchema.parse(`pi-item-v1-${entryId}-${kind}-${ordinal}`);
+}
+function assistantOutcome(entries) {
+  const assistants = entries.map((entry) => message(entry)).filter((value) => value?.role === "assistant");
+  const final = assistants.at(-1);
+  if (!final)
+    return { status: "unknown", reason: "Pi history has no Assistant terminal" };
+  const stopReason = final.stopReason;
+  if (stopReason === "aborted") {
+    return { status: "cancelled", reason: "Pi Assistant was aborted" };
+  }
+  if (stopReason === "error") {
+    return {
+      status: "failed",
+      error: {
+        code: "nativeFailure",
+        message: typeof final.errorMessage === "string" && final.errorMessage.length > 0 ? final.errorMessage : "Pi Assistant failed",
+        retryable: false
+      }
+    };
+  }
+  if (typeof stopReason === "string" || textContent(final.content).length > 0) {
+    return { status: "succeeded" };
+  }
+  return { status: "unknown", reason: "Pi Assistant terminal is not classifiable" };
+}
+function itemOutcome(outcome) {
+  if (outcome.status === "failed")
+    return { status: "failed", error: outcome.error };
+  if (outcome.status === "cancelled") {
+    return {
+      status: "cancelled",
+      ...outcome.reason ? { reason: outcome.reason } : {}
+    };
+  }
+  return { status: "succeeded" };
+}
+function toolOutput(value) {
+  const text = textContent(value);
+  return text.length > 0 ? { content: [{ type: "text", text }] } : void 0;
+}
+function snapshotItems(entries, outcome) {
+  const snapshots = [];
+  const toolCalls = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const nativeMessage = message(entry);
+    if (!nativeMessage)
+      continue;
+    const content = Array.isArray(nativeMessage.content) ? nativeMessage.content : [];
+    if (nativeMessage.role === "assistant") {
+      const text = textContent(content);
+      const reasoning = thinkingContent(content);
+      let projectedText = false;
+      let projectedReasoning = false;
+      for (const [ordinal, part] of content.entries()) {
+        if (!isRecord(part))
+          continue;
+        if (part.type === "thinking" && !projectedReasoning && reasoning.length > 0) {
+          const item2 = {
+            type: "reasoning",
+            itemId: itemId(entry.id, "reasoning", 0),
+            text: reasoning
+          };
+          snapshots.push({ item: item2, outcome: itemOutcome(outcome) });
+          projectedReasoning = true;
+          continue;
+        }
+        if (part.type === "text" && !projectedText && text.length > 0) {
+          const item2 = {
+            type: "agentMessage",
+            itemId: itemId(entry.id, "assistant", 0),
+            text
+          };
+          snapshots.push({ item: item2, outcome: itemOutcome(outcome) });
+          projectedText = true;
+          continue;
+        }
+        if (part.type !== "toolCall" || typeof part.id !== "string" || typeof part.name !== "string") {
+          continue;
+        }
+        const parsedArguments = jsonValueSchema.safeParse(part.arguments);
+        if (!parsedArguments.success)
+          continue;
+        toolCalls.set(part.id, {
+          entryId: entry.id,
+          ordinal,
+          name: part.name,
+          arguments: parsedArguments.data
+        });
+      }
+      continue;
     }
-    ids.add(command.id);
+    if (nativeMessage.role !== "toolResult" || typeof nativeMessage.toolCallId !== "string" || typeof nativeMessage.toolName !== "string") {
+      continue;
+    }
+    const call = toolCalls.get(nativeMessage.toolCallId);
+    if (!call || call.name !== nativeMessage.toolName)
+      continue;
+    const output = toolOutput(nativeMessage.content);
+    const item = {
+      type: "toolExecution",
+      itemId: itemId(call.entryId, "tool", call.ordinal),
+      toolName: call.name,
+      arguments: call.arguments,
+      ...output ? { output } : {}
+    };
+    const toolSucceeded = nativeMessage.isError === false;
+    snapshots.push({
+      item,
+      outcome: toolSucceeded ? { status: "succeeded" } : {
+        status: "failed",
+        error: {
+          code: "nativeFailure",
+          message: `Pi Tool '${call.name}' failed`,
+          retryable: false
+        }
+      }
+    });
   }
-});
-var harnessCommandsInspectParamsSchema = external_exports.object({ harnessId: harnessIdSchema }).strict();
-var threadCommandsInspectParamsSchema = external_exports.object({
-  threadId: hostThreadIdSchema
-}).strict();
-var threadCommandExecuteParamsSchema = external_exports.object({
-  threadId: hostThreadIdSchema,
-  commandId: commandIdSchema,
-  turnId: hostTurnIdSchema.optional(),
-  arguments: jsonObjectSchema.optional()
-}).strict();
-var threadCommandExecuteResultSchema = external_exports.object({
-  accepted: external_exports.literal(true),
-  turnId: hostTurnIdSchema
-}).strict();
-
-// ../../shared-contracts/dist/json-rpc.js
-var jsonRpcVersionSchema = external_exports.literal("2.0").optional();
-var absentSchema = external_exports.never().optional();
-var methodSchema = external_exports.string().min(1);
-var jsonRpcIdSchema = external_exports.union([external_exports.string(), external_exports.number().int()]);
-var jsonRpcErrorSchema = external_exports.object({
-  code: external_exports.number().int(),
-  message: external_exports.string(),
-  data: jsonValueSchema.optional()
-}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["data"]));
-var jsonRpcRequestSchema = external_exports.object({
-  jsonrpc: jsonRpcVersionSchema,
-  id: jsonRpcIdSchema,
-  method: methodSchema,
-  params: jsonValueSchema.optional(),
-  result: absentSchema,
-  error: absentSchema
-}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "params", "result", "error"]));
-var jsonRpcNotificationSchema = external_exports.object({
-  jsonrpc: jsonRpcVersionSchema,
-  id: absentSchema,
-  method: methodSchema,
-  params: jsonValueSchema.optional(),
-  result: absentSchema,
-  error: absentSchema
-}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "id", "params", "result", "error"]));
-var jsonRpcSuccessResponseSchema = external_exports.object({
-  jsonrpc: jsonRpcVersionSchema,
-  id: jsonRpcIdSchema,
-  method: absentSchema,
-  params: absentSchema,
-  result: jsonValueSchema,
-  error: absentSchema
-}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "method", "params", "error"]));
-var jsonRpcErrorResponseSchema = external_exports.object({
-  jsonrpc: jsonRpcVersionSchema,
-  id: jsonRpcIdSchema,
-  method: absentSchema,
-  params: absentSchema,
-  result: absentSchema,
-  error: jsonRpcErrorSchema
-}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "method", "params", "result"]));
-var jsonRpcEnvelopeSchema = external_exports.union([
-  jsonRpcRequestSchema,
-  jsonRpcNotificationSchema,
-  jsonRpcSuccessResponseSchema,
-  jsonRpcErrorResponseSchema
-]);
-
-// ../../shared-contracts/dist/native-refs.js
-var nativeIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
-  message: "Native identifier must not be empty or whitespace"
-});
-var nativeSessionRefV1RuntimeSchema = external_exports.strictObject({
-  harnessId: harnessIdSchema,
-  nativeSessionId: nativeIdSchema,
-  locator: jsonValueSchema.optional(),
-  formatVersion: external_exports.literal(1)
-}).superRefine(rejectExplicitUndefined(["locator"]));
-var nativeSessionRefV1Schema = nativeSessionRefV1RuntimeSchema;
-var nativeSessionRefSchema = nativeSessionRefV1Schema;
-var nativeTurnRefV1Schema = external_exports.strictObject({
-  harnessId: harnessIdSchema,
-  nativeSessionId: nativeIdSchema,
-  nativeTurnKey: nativeIdSchema,
-  formatVersion: external_exports.literal(1)
-});
-var nativeTurnRefSchema = nativeTurnRefV1Schema;
-var nativeCheckpointRefV1RuntimeSchema = external_exports.strictObject({
-  harnessId: harnessIdSchema,
-  nativeSessionId: nativeIdSchema,
-  checkpointId: nativeIdSchema,
-  locator: jsonValueSchema.optional(),
-  formatVersion: external_exports.literal(1)
-}).superRefine(rejectExplicitUndefined(["locator"]));
-var nativeCheckpointRefV1Schema = nativeCheckpointRefV1RuntimeSchema;
-var nativeCheckpointRefSchema = nativeCheckpointRefV1Schema;
-
-// ../../shared-contracts/dist/updates.js
-var UPDATE_ERROR_MAX_LENGTH = 500;
-var UPDATE_SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u;
-var updateSemanticVersionSchema = external_exports.string().regex(UPDATE_SEMVER_PATTERN);
-var updateInstallationSchema = external_exports.enum(["npm", "windows-installer", "macos-dmg"]);
-var updatePhaseSchema = external_exports.enum([
-  "prepared",
-  "downloading",
-  "waiting-for-exit",
-  "installing",
-  "restarting",
-  "succeeded",
-  "failed"
-]);
-var updateStatusSchema = external_exports.strictObject({
-  version: updateSemanticVersionSchema,
-  installation: updateInstallationSchema,
-  phase: updatePhaseSchema,
-  updatedAt: external_exports.number().int().nonnegative(),
-  downloadedBytes: external_exports.number().int().nonnegative().optional(),
-  totalBytes: external_exports.number().int().positive().optional(),
-  error: external_exports.string().min(1).max(UPDATE_ERROR_MAX_LENGTH).nullable()
-}).superRefine((status, context) => {
-  if (status.downloadedBytes !== void 0 && status.totalBytes !== void 0 && status.downloadedBytes > status.totalBytes) {
-    context.addIssue({
-      code: "custom",
-      path: ["downloadedBytes"],
-      message: "downloadedBytes must not exceed totalBytes"
+  return snapshots;
+}
+function modelChange(entry) {
+  return entry.type === "model_change" && typeof entry.provider === "string" && typeof entry.modelId === "string" ? { provider: entry.provider, id: entry.modelId } : null;
+}
+function mapPiSnapshot(history, state) {
+  const active = activePiEntries(history);
+  const turns = [];
+  let effectiveModel = state.model;
+  for (let index = 0; index < active.length; ) {
+    const model = modelChange(active[index]);
+    if (model) {
+      effectiveModel = model;
+      index += 1;
+      continue;
+    }
+    const user = active[index];
+    if (messageRole(user) !== "user") {
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    while (end < active.length && messageRole(active[end]) !== "user")
+      end += 1;
+    const entries = active.slice(index, end);
+    const outcome = assistantOutcome(entries);
+    const userText = textContent(message(user)?.content);
+    const nativeTurnRef = nativeTurnRefSchema.parse({
+      harnessId: piHarnessId,
+      nativeSessionId: state.sessionId,
+      nativeTurnKey: user.id,
+      formatVersion: 1
+    });
+    const checkpoint = nativeCheckpointRefSchema.parse({
+      harnessId: piHarnessId,
+      nativeSessionId: state.sessionId,
+      checkpointId: user.id,
+      formatVersion: 1
+    });
+    turns.push({
+      nativeTurnRef,
+      checkpoint,
+      input: [{ type: "text", text: userText }],
+      items: snapshotItems(entries, outcome),
+      outcome,
+      ...effectiveModel ? { model: encodePiModelRef(effectiveModel) } : {}
     });
+    for (const entry of entries) {
+      const changed = modelChange(entry);
+      if (changed)
+        effectiveModel = changed;
+    }
+    index = end;
   }
-});
-var updateEmptyParamsSchema = external_exports.strictObject({});
-var githubReleaseNotesUrlSchema = external_exports.string().max(300).regex(/^https:\/\/github\.com\/BytePioneer-AI\/codex-host\/releases\/tag\/v[0-9A-Za-z.+-]+$/u, "release notes URL must identify a codexhost GitHub Release");
-var updateCheckResultSchema = external_exports.strictObject({
-  currentVersion: updateSemanticVersionSchema,
-  installation: updateInstallationSchema.nullable(),
-  latestVersion: updateSemanticVersionSchema.nullable(),
-  updateAvailable: external_exports.boolean(),
-  installationAvailable: external_exports.boolean(),
-  releaseNotes: external_exports.string().min(1).max(2e4).nullable(),
-  releaseNotesUrl: githubReleaseNotesUrlSchema.nullable(),
-  status: updateStatusSchema.nullable(),
-  error: external_exports.string().min(1).max(UPDATE_ERROR_MAX_LENGTH).nullable()
-});
-var updateStartResultSchema = external_exports.strictObject({
-  status: updateStatusSchema
-});
-var updateStatusResultSchema = external_exports.strictObject({
-  status: updateStatusSchema.nullable()
-});
+  return { turns };
+}
+function resolvePiLastTurnBoundary(history) {
+  const users = activePiEntries(history).filter((entry) => messageRole(entry) === "user");
+  const last = users.at(-1);
+  return last ? { lastUserEntryId: last.id, sourceTurnCount: users.length } : null;
+}
+function resolvePiForkBoundary(history, checkpointId) {
+  const active = activePiEntries(history);
+  const users = active.filter((entry) => messageRole(entry) === "user");
+  const targetTurnIndex = users.findIndex((entry) => entry.id === checkpointId);
+  if (targetTurnIndex < 0)
+    throw new Error("Pi Checkpoint is not on the active branch");
+  return {
+    targetTurnIndex,
+    nextUserEntryId: users[targetTurnIndex + 1]?.id ?? null
+  };
+}
 
-// ../../shared-contracts/dist/index.js
-var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
+// dist/pi-session-file.js
+import { open, realpath } from "node:fs/promises";
+var MAX_SESSION_HEADER_BYTES = 64 * 1024;
+var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readPiSessionHeader(sessionFile) {
+  const handle = await open(sessionFile, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(MAX_SESSION_HEADER_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const contents = buffer.subarray(0, bytesRead);
+    const newline = contents.indexOf(10);
+    if (newline < 0 && bytesRead === buffer.length) {
+      throw new Error("Pi Session header exceeds the supported size");
+    }
+    const headerText = utf8Decoder.decode(newline < 0 ? contents : contents.subarray(0, newline));
+    let parsed;
+    try {
+      parsed = JSON.parse(headerText);
+    } catch {
+      throw new Error("Pi Session header is not valid JSON");
+    }
+    if (!isRecord2(parsed) || parsed.type !== "session" || typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
+      throw new Error("Pi Session header is invalid");
+    }
+    return {
+      type: "session",
+      id: parsed.id,
+      cwd: parsed.cwd,
+      ...typeof parsed.version === "number" ? { version: parsed.version } : {}
+    };
+  } finally {
+    await handle.close();
+  }
+}
+async function verifyPiSessionCwd(input) {
+  if (!input.sessionFile)
+    throw new Error("Pi Fork Session has no persisted Session file");
+  const header = await readPiSessionHeader(input.sessionFile);
+  if (header.id !== input.sessionId) {
+    throw new Error("Pi Fork Session header identity does not match RPC state");
+  }
+  const [actualCwd, expectedCwd] = await Promise.all([
+    realpath(header.cwd),
+    realpath(input.expectedCwd)
+  ]);
+  if (actualCwd !== expectedCwd) {
+    throw new Error("Pi Fork Session did not bind the requested cwd");
+  }
+}
 
-// ../../harness-adapter/dist/question.js
-function invalidRequest(message3) {
-  return { code: "invalidRequest", message: message3, retryable: false };
+// dist/pi-empty-session.js
+async function persistEmptyPiSession(input) {
+  const { state, history, sourceSessionFile, sourceSessionId, cwd } = input;
+  const destination = state.sessionFile;
+  if (!destination || !path.isAbsolute(destination) || path.resolve(destination) === path.resolve(sourceSessionFile) || state.sessionId === sourceSessionId || mapPiSnapshot(history, { sessionId: state.sessionId, model: null }).turns.length !== 0)
+    throw new Error("Pi empty Session is not an independent empty native fork");
+  await verifyPiSessionCwd({
+    sessionFile: sourceSessionFile,
+    sessionId: sourceSessionId,
+    expectedCwd: cwd
+  });
+  const sourceHeader = await readPiSessionHeader(sourceSessionFile);
+  if (sourceHeader.type !== "session" || sourceHeader.version !== 3) {
+    throw new Error("Pi empty Session persistence requires native v3 history");
+  }
+  const entries = history.entries;
+  const active = activePiEntries(history);
+  if (active.length !== entries.length || active.some((entry, index) => entry.id !== entries[index]?.id)) {
+    throw new Error("Pi empty Session must expose its complete active branch");
+  }
+  const header = {
+    type: "session",
+    version: 3,
+    id: state.sessionId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    cwd,
+    parentSession: sourceSessionFile
+  };
+  const temporary = path.join(path.dirname(destination), `.codexhost-${randomUUID()}.tmp`);
+  try {
+    const file2 = await open2(temporary, "wx", 384);
+    try {
+      await file2.writeFile([header, ...entries].map((entry) => JSON.stringify(entry)).join("\n") + "\n");
+      await file2.sync();
+    } finally {
+      await file2.close();
+    }
+    await link(temporary, destination);
+    if (process.platform !== "win32") {
+      const directory = await open2(path.dirname(destination), "r");
+      try {
+        await directory.sync();
+      } finally {
+        await directory.close();
+      }
+    }
+  } finally {
+    await rm(temporary, { force: true });
+  }
 }
-function validateHostQuestionResponse(interaction, response) {
-  const questionIds = new Set(interaction.questions.map(({ id }) => id));
-  if (response.cancelled) {
-    return Object.keys(response.answers).length === 0 ? null : invalidRequest("Cancelled Question Response must not contain answers");
+async function readPiEmptySessionConfiguration(sessionFile) {
+  let header;
+  try {
+    header = await readPiSessionHeader(sessionFile);
+  } catch (error51) {
+    if (error51.code === "ENOENT")
+      return void 0;
+    throw error51;
   }
-  for (const answerId of Object.keys(response.answers)) {
-    if (!questionIds.has(answerId)) {
-      return invalidRequest("Question Response contains an unknown Question ID");
+  if (header.version !== 3)
+    return void 0;
+  const stream = createReadStream(sessionFile, { encoding: "utf8" });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  let readFailure;
+  stream.on("error", (error51) => {
+    readFailure = error51;
+    lines.close();
+  });
+  let model;
+  let thinkingLevel;
+  let previous = null;
+  let first = true;
+  try {
+    for await (const line of lines) {
+      if (first) {
+        first = false;
+        continue;
+      }
+      if (!line.trim())
+        continue;
+      const entry = jsonValueSchema.parse(JSON.parse(line));
+      if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        return void 0;
+      if (entry.type === "message" || typeof entry.id !== "string" || entry.parentId !== previous)
+        return void 0;
+      previous = entry.id;
+      if (entry.type === "model_change" && typeof entry.provider === "string" && typeof entry.modelId === "string") {
+        model = { provider: entry.provider, id: entry.modelId };
+      }
+      if (entry.type === "thinking_level_change") {
+        thinkingLevel = harnessThinkingOptionIdSchema.parse(entry.thinkingLevel);
+      }
     }
+  } finally {
+    lines.close();
+    stream.destroy();
   }
-  for (const question of interaction.questions) {
-    const answers = response.answers[question.id] ?? [];
-    if (!question.optional && answers.length === 0) {
-      return invalidRequest("Question Response omits a required answer");
+  if (readFailure)
+    throw readFailure;
+  return model && thinkingLevel ? { model, thinkingLevel } : void 0;
+}
+
+// ../../../node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a3;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a3 = options.timeout) !== null && _a3 !== void 0 ? _a3 : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path7, added, removed, oldPosInc, options) {
+    const last = path7.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path7.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path7.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array2) {
+    const ret = [];
+    for (let i = 0; i < array2.length; i++) {
+      if (array2[i]) {
+        ret.push(array2[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
     }
-    if (question.type === "text") {
-      if (answers.length > 1) {
-        return invalidRequest("Text Question accepts at most one answer");
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
       }
-      continue;
-    }
-    if (!question.multiple && answers.length > 1) {
-      return invalidRequest("Single-choice Question accepts at most one answer");
-    }
-    const declared = new Set(question.options.map(({ value }) => value));
-    if (!question.allowOther && answers.some((answer) => !declared.has(answer))) {
-      return invalidRequest("Question Response contains an undeclared choice");
     }
+    return components;
   }
-  return null;
-}
+};
 
-// ../../harness-adapter/dist/output-channel.js
-var HarnessOutputChannel = class {
-  outputs;
-  #consumerCreated = false;
-  #ended = false;
-  #pending = [];
-  #values = [];
+// ../../../node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
   constructor() {
-    this.outputs = {
-      [Symbol.asyncIterator]: () => {
-        if (this.#consumerCreated) {
-          throw new Error("Harness outputs allow only one consumer");
-        }
-        this.#consumerCreated = true;
-        return {
-          next: () => this.#next()
-        };
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
       }
-    };
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
   }
-  emit(value) {
-    if (this.#ended)
-      return false;
-    const resolve = this.#pending.shift();
-    if (resolve)
-      resolve({ done: false, value });
-    else
-      this.#values.push(value);
-    return true;
+};
+var lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
   }
-  end() {
-    if (this.#ended)
-      return;
-    this.#ended = true;
-    if (this.#values.length !== 0)
-      return;
-    for (const resolve of this.#pending.splice(0))
-      resolve({ done: true, value: void 0 });
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
   }
-  #next() {
-    const value = this.#values.shift();
-    if (value !== void 0)
-      return Promise.resolve({ done: false, value });
-    if (this.#ended)
-      return Promise.resolve({ done: true, value: void 0 });
-    return new Promise((resolve) => this.#pending.push(resolve));
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
   }
-};
-
-// ../../harness-adapter/dist/diagnostics.js
-var DIAGNOSTIC_TAIL_MAX_LENGTH = 8e3;
-var SENSITIVE_VALUE_PATTERN = /(api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret)(\s*[:=]\s*)([^\s,;]+)/giu;
-var BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]+/giu;
-function sanitizeDiagnosticTail(value) {
-  const redacted = value.replace(BEARER_PATTERN, "Bearer [redacted]").replace(SENSITIVE_VALUE_PATTERN, "$1$2[redacted]");
-  return redacted.length <= DIAGNOSTIC_TAIL_MAX_LENGTH ? redacted : redacted.slice(-DIAGNOSTIC_TAIL_MAX_LENGTH);
+  return retLines;
 }
 
-// ../../harness-adapter/dist/usage.js
-var tokenFields = [
-  "inputTokens",
-  "cachedInputTokens",
-  "cacheWriteInputTokens",
-  "outputTokens",
-  "outputTokensPerSecond",
-  "reasoningOutputTokens",
-  "totalTokens",
-  "contextWindowTokens",
-  "contextUsedTokens"
-];
-var safeIntegerFields = [
-  "planFiveHourResetsAtUnix",
-  "planSevenDayResetsAtUnix"
-];
-var percentFields = [
-  "cacheHitRatePercent",
-  "planFiveHourUsedPercent",
-  "planSevenDayUsedPercent"
-];
-var usageFields = /* @__PURE__ */ new Set([
-  ...tokenFields,
-  ...safeIntegerFields,
-  ...percentFields,
-  "totalCostUsd"
-]);
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function parseHostUsage(value) {
-  if (!isRecord(value))
-    throw new Error("Harness Usage must be an object");
-  const keys = Object.keys(value);
-  if (keys.length === 0)
-    throw new Error("Harness Usage must contain a reliable field");
-  for (const key of keys) {
-    if (!usageFields.has(key)) {
-      throw new Error(`Harness Usage contains unknown field '${key}'`);
+// ../../../node_modules/diff/libesm/patch/parse.js
+function parsePatch(uniDiff) {
+  const diffstr = uniDiff.split(/\n/), list = [];
+  let i = 0;
+  function parseIndex() {
+    const index = {};
+    list.push(index);
+    while (i < diffstr.length) {
+      const line = diffstr[i];
+      if (/^(---|\+\+\+|@@)\s/.test(line)) {
+        break;
+      }
+      const header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
+      if (header) {
+        index.index = header[1];
+      }
+      i++;
+    }
+    parseFileHeader(index);
+    parseFileHeader(index);
+    index.hunks = [];
+    while (i < diffstr.length) {
+      const line = diffstr[i];
+      if (/^(Index:\s|diff\s|---\s|\+\+\+\s|===================================================================)/.test(line)) {
+        break;
+      } else if (/^@@/.test(line)) {
+        index.hunks.push(parseHunk());
+      } else if (line) {
+        throw new Error("Unknown line " + (i + 1) + " " + JSON.stringify(line));
+      } else {
+        i++;
+      }
+    }
+  }
+  function parseFileHeader(index) {
+    const fileHeader = /^(---|\+\+\+)\s+(.*)\r?$/.exec(diffstr[i]);
+    if (fileHeader) {
+      const data = fileHeader[2].split("	", 2), header = (data[1] || "").trim();
+      let fileName = data[0].replace(/\\\\/g, "\\");
+      if (/^".*"$/.test(fileName)) {
+        fileName = fileName.substr(1, fileName.length - 2);
+      }
+      if (fileHeader[1] === "---") {
+        index.oldFileName = fileName;
+        index.oldHeader = header;
+      } else {
+        index.newFileName = fileName;
+        index.newHeader = header;
+      }
+      i++;
+    }
+  }
+  function parseHunk() {
+    var _a3;
+    const chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    const hunk = {
+      oldStart: +chunkHeader[1],
+      oldLines: typeof chunkHeader[2] === "undefined" ? 1 : +chunkHeader[2],
+      newStart: +chunkHeader[3],
+      newLines: typeof chunkHeader[4] === "undefined" ? 1 : +chunkHeader[4],
+      lines: []
+    };
+    if (hunk.oldLines === 0) {
+      hunk.oldStart += 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart += 1;
+    }
+    let addCount = 0, removeCount = 0;
+    for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a3 = diffstr[i]) === null || _a3 === void 0 ? void 0 : _a3.startsWith("\\"))); i++) {
+      const operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? " " : diffstr[i][0];
+      if (operation === "+" || operation === "-" || operation === " " || operation === "\\") {
+        hunk.lines.push(diffstr[i]);
+        if (operation === "+") {
+          addCount++;
+        } else if (operation === "-") {
+          removeCount++;
+        } else if (operation === " ") {
+          addCount++;
+          removeCount++;
+        }
+      } else {
+        throw new Error(`Hunk at line ${chunkHeaderIndex + 1} contained invalid line ${diffstr[i]}`);
+      }
     }
-  }
-  for (const field of tokenFields) {
-    const candidate = value[field];
-    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+    if (!addCount && hunk.newLines === 1) {
+      hunk.newLines = 0;
     }
-  }
-  for (const field of safeIntegerFields) {
-    const candidate = value[field];
-    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+    if (!removeCount && hunk.oldLines === 1) {
+      hunk.oldLines = 0;
     }
-  }
-  if (value.outputTokensPerSecond !== void 0 && (typeof value.outputTokensPerSecond !== "number" || !Number.isFinite(value.outputTokensPerSecond) || value.outputTokensPerSecond < 0)) {
-    throw new Error("Harness Usage 'outputTokensPerSecond' must be a finite non-negative number");
-  }
-  if (value.totalCostUsd !== void 0 && (typeof value.totalCostUsd !== "number" || !Number.isFinite(value.totalCostUsd) || value.totalCostUsd < 0)) {
-    throw new Error("Harness Usage 'totalCostUsd' must be a finite non-negative number");
-  }
-  for (const field of percentFields) {
-    const candidate = value[field];
-    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0 || candidate > 100)) {
-      throw new Error(`Harness Usage '${field}' must be between 0 and 100`);
+    if (addCount !== hunk.newLines) {
+      throw new Error("Added line count did not match for hunk at line " + (chunkHeaderIndex + 1));
     }
+    if (removeCount !== hunk.oldLines) {
+      throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
+    }
+    return hunk;
   }
-  const hasContextUsed = value.contextUsedTokens !== void 0;
-  const hasContextWindow = value.contextWindowTokens !== void 0;
-  if (hasContextUsed !== hasContextWindow) {
-    throw new Error("Harness Usage context fields must be provided together");
-  }
-  if (hasContextWindow && value.contextWindowTokens === 0) {
-    throw new Error("Harness Usage 'contextWindowTokens' must be greater than zero");
-  }
-  if (value.planFiveHourResetsAtUnix !== void 0 && value.planFiveHourUsedPercent === void 0) {
-    throw new Error("Harness Usage 'planFiveHourResetsAtUnix' must be provided with 'planFiveHourUsedPercent'");
-  }
-  if (value.planSevenDayResetsAtUnix !== void 0 && value.planSevenDayUsedPercent === void 0) {
-    throw new Error("Harness Usage 'planSevenDayResetsAtUnix' must be provided with 'planSevenDayUsedPercent'");
+  while (i < diffstr.length) {
+    parseIndex();
   }
-  return { ...value };
+  return list;
 }
 
-// dist/pi-model-catalog.js
-var PI_MODEL_REF_PREFIX = "pi-model-v1.";
-var PI_DRAFT_THINKING_OPTION_IDS = [
-  "off",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max"
-].map((id) => harnessThinkingOptionIdSchema.parse(id));
-var PI_THINKING_LABELS = {
-  off: "Off",
-  minimal: "Minimal",
-  low: "Low",
-  medium: "Medium",
-  high: "High",
-  xhigh: "Extra High",
-  max: "Max"
-};
-function compareText(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-function assertNativePart(value, name) {
-  if (value.trim().length === 0)
-    throw new Error(`Pi ${name} must not be empty`);
-}
-function encodePiModelRef(model) {
-  assertNativePart(model.provider, "Model provider");
-  assertNativePart(model.id, "Model id");
-  const encoded = Buffer.from(JSON.stringify([model.provider, model.id]), "utf8").toString("base64url");
-  return harnessModelRefSchema.parse({ id: `${PI_MODEL_REF_PREFIX}${encoded}` });
-}
-function decodePiModelRef(ref) {
-  const parsedRef = harnessModelRefSchema.parse(ref);
-  if (!parsedRef.id.startsWith(PI_MODEL_REF_PREFIX)) {
-    throw new Error("Model Ref does not belong to PiAdapter");
+// ../../../node_modules/diff/libesm/patch/create.js
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
   }
-  const encoded = parsedRef.id.slice(PI_MODEL_REF_PREFIX.length);
-  let decoded;
-  try {
-    decoded = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
-  } catch {
-    throw new Error("Pi Model Ref is malformed");
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
   }
-  if (!Array.isArray(decoded) || decoded.length !== 2 || typeof decoded[0] !== "string" || typeof decoded[1] !== "string") {
-    throw new Error("Pi Model Ref has an invalid native identity");
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
   }
-  const native = { provider: decoded[0], id: decoded[1] };
-  assertNativePart(native.provider, "Model provider");
-  assertNativePart(native.id, "Model id");
-  if (encodePiModelRef(native).id !== parsedRef.id) {
-    throw new Error("Pi Model Ref is not canonical");
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
   }
-  return native;
-}
-function samePiModel(left, right) {
-  return left === null ? right === null : right !== null && left.provider === right.provider && left.id === right.id;
-}
-function fallbackThinkingLabel(id) {
-  const label = id.split(/[._~-]+/u).filter((part) => part.length > 0).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
-  return label || id;
-}
-function normalizePiThinkingOptions(levels) {
-  return levels.map((id) => harnessThinkingOptionSchema.parse({
-    id,
-    label: PI_THINKING_LABELS[id] ?? fallbackThinkingLabel(id)
-  }));
-}
-function normalizePiModelCatalog(nativeModels, effectiveModel, thinkingLevels, effectiveThinkingOptionId) {
-  const byRef = /* @__PURE__ */ new Map();
-  for (const native of nativeModels) {
-    const ref = encodePiModelRef(native);
-    const existing = byRef.get(ref.id);
-    if (existing) {
-      if (existing.reasoning !== native.reasoning) {
-        throw new Error("Pi duplicate Model entries disagree on reasoning capability");
-      }
-      continue;
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
     }
-    byRef.set(ref.id, {
-      model: {
-        ref,
-        label: `${native.provider} / ${native.id}`
-      },
-      reasoning: native.reasoning
-    });
-  }
-  const defaultModel = effectiveModel ? encodePiModelRef(effectiveModel) : void 0;
-  if (defaultModel && !byRef.has(defaultModel.id)) {
-    throw new Error("Pi effective Model is absent from the available Model catalog");
-  }
-  if (thinkingLevels && effectiveThinkingOptionId && !thinkingLevels.includes(effectiveThinkingOptionId)) {
-    throw new Error("Pi effective Thinking option is absent from the available option catalog");
-  }
-  if (thinkingLevels && !effectiveThinkingOptionId) {
-    throw new Error("Pi did not report an effective Thinking option");
-  }
-  const thinkingOptions = thinkingLevels ? normalizePiThinkingOptions(PI_DRAFT_THINKING_OPTION_IDS) : [];
-  const allThinkingOptionIds = thinkingOptions.map(({ id }) => id);
-  const offThinkingOptionId = thinkingOptions.find(({ id }) => id === "off")?.id;
-  const models = [...byRef.values()].map(({ model, reasoning }) => ({
-    ...model,
-    supportedThinkingOptionIds: reasoning ? allThinkingOptionIds : offThinkingOptionId ? [offThinkingOptionId] : []
-  })).sort((left, right) => compareText(left.label, right.label) || compareText(left.ref.id, right.ref.id));
-  const defaultThinkingOptionId = thinkingOptions.find(({ id }) => id === effectiveThinkingOptionId)?.id;
-  return harnessModelCatalogSchema.parse({
-    models,
-    ...defaultModel ? { defaultModel } : {},
-    thinkingOptions,
-    ...defaultThinkingOptionId ? { defaultThinkingOptionId } : {}
-  });
-}
-
-// dist/pi-history.js
-var piHarnessId = harnessIdSchema.parse("pi");
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function textContent(value) {
-  if (typeof value === "string")
-    return value;
-  if (!Array.isArray(value))
-    return "";
-  return value.filter((part) => isRecord2(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
-}
-function thinkingContent(value) {
-  if (!Array.isArray(value))
-    return "";
-  return value.filter((part) => isRecord2(part) && part.type === "thinking" && typeof part.thinking === "string").map((part) => part.thinking).join("");
-}
-function validatedEntry(value) {
-  if (typeof value.id !== "string" || value.id.length === 0 || value.parentId !== null && typeof value.parentId !== "string" || typeof value.type !== "string") {
-    throw new Error("Pi history contains an invalid Entry identity");
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      const current = diff[i], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i = 0; i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith("\n")) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
   }
-  return value;
 }
-function activePiEntries(history) {
-  if (history.leafId === null)
-    return [];
-  const byId = new Map(history.entries.map((value) => {
-    const entry = validatedEntry(value);
-    return [entry.id, entry];
-  }));
-  const reversed = [];
-  const visited = /* @__PURE__ */ new Set();
-  let current = history.leafId;
-  while (current !== null) {
-    if (visited.has(current))
-      throw new Error("Pi history active branch contains a cycle");
-    visited.add(current);
-    const entry = byId.get(current);
-    if (!entry)
-      throw new Error("Pi history active branch references a missing Entry");
-    reversed.push(entry);
-    current = entry.parentId;
+function formatPatch(patch) {
+  if (Array.isArray(patch)) {
+    return patch.map(formatPatch).join("\n");
   }
-  return reversed.reverse();
-}
-function message(entry) {
-  return entry.type === "message" && isRecord2(entry.message) ? entry.message : null;
-}
-function messageRole(entry) {
-  const value = message(entry)?.role;
-  return typeof value === "string" ? value : null;
-}
-function itemId(entryId, kind, ordinal) {
-  return hostItemIdSchema.parse(`pi-item-v1-${entryId}-${kind}-${ordinal}`);
+  const ret = [];
+  if (patch.oldFileName == patch.newFileName) {
+    ret.push("Index: " + patch.oldFileName);
+  }
+  ret.push("===================================================================");
+  ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "	" + patch.oldHeader));
+  ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "	" + patch.newHeader));
+  for (let i = 0; i < patch.hunks.length; i++) {
+    const hunk = patch.hunks[i];
+    if (hunk.oldLines === 0) {
+      hunk.oldStart -= 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart -= 1;
+    }
+    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
+    for (const line of hunk.lines) {
+      ret.push(line);
+    }
+  }
+  return ret.join("\n") + "\n";
 }
-function assistantOutcome(entries) {
-  const assistants = entries.map((entry) => message(entry)).filter((value) => value?.role === "assistant");
-  const final = assistants.at(-1);
-  if (!final)
-    return { status: "unknown", reason: "Pi history has no Assistant terminal" };
-  const stopReason = final.stopReason;
-  if (stopReason === "aborted") {
-    return { status: "cancelled", reason: "Pi Assistant was aborted" };
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  if (typeof options === "function") {
+    options = { callback: options };
   }
-  if (stopReason === "error") {
-    return {
-      status: "failed",
-      error: {
-        code: "nativeFailure",
-        message: typeof final.errorMessage === "string" && final.errorMessage.length > 0 ? final.errorMessage : "Pi Assistant failed",
-        retryable: false
+  if (!(options === null || options === void 0 ? void 0 : options.callback)) {
+    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+    if (!patchObj) {
+      return;
+    }
+    return formatPatch(patchObj);
+  } else {
+    const { callback } = options;
+    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
+      if (!patchObj) {
+        callback(void 0);
+      } else {
+        callback(formatPatch(patchObj));
       }
-    };
-  }
-  if (typeof stopReason === "string" || textContent(final.content).length > 0) {
-    return { status: "succeeded" };
+    } }));
   }
-  return { status: "unknown", reason: "Pi Assistant terminal is not classifiable" };
 }
-function itemOutcome(outcome) {
-  if (outcome.status === "failed")
-    return { status: "failed", error: outcome.error };
-  if (outcome.status === "cancelled") {
-    return {
-      status: "cancelled",
-      ...outcome.reason ? { reason: outcome.reason } : {}
-    };
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith("\n");
+  const result = text.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
   }
-  return { status: "succeeded" };
+  return result;
 }
-function toolOutput(value) {
-  const text = textContent(value);
-  return text.length > 0 ? { content: [{ type: "text", text }] } : void 0;
+
+// dist/pi-adapter.js
+import { randomUUID as randomUUID3 } from "node:crypto";
+import path6 from "node:path";
+
+// ../../harness-adapter/dist/question.js
+function invalidRequest(message3) {
+  return { code: "invalidRequest", message: message3, retryable: false };
 }
-function snapshotItems(entries, outcome) {
-  const snapshots = [];
-  const toolCalls = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const nativeMessage = message(entry);
-    if (!nativeMessage)
-      continue;
-    const content = Array.isArray(nativeMessage.content) ? nativeMessage.content : [];
-    if (nativeMessage.role === "assistant") {
-      const text = textContent(content);
-      const reasoning = thinkingContent(content);
-      let projectedText = false;
-      let projectedReasoning = false;
-      for (const [ordinal, part] of content.entries()) {
-        if (!isRecord2(part))
-          continue;
-        if (part.type === "thinking" && !projectedReasoning && reasoning.length > 0) {
-          const item2 = {
-            type: "reasoning",
-            itemId: itemId(entry.id, "reasoning", 0),
-            text: reasoning
-          };
-          snapshots.push({ item: item2, outcome: itemOutcome(outcome) });
-          projectedReasoning = true;
-          continue;
-        }
-        if (part.type === "text" && !projectedText && text.length > 0) {
-          const item2 = {
-            type: "agentMessage",
-            itemId: itemId(entry.id, "assistant", 0),
-            text
-          };
-          snapshots.push({ item: item2, outcome: itemOutcome(outcome) });
-          projectedText = true;
-          continue;
-        }
-        if (part.type !== "toolCall" || typeof part.id !== "string" || typeof part.name !== "string") {
-          continue;
-        }
-        const parsedArguments = jsonValueSchema.safeParse(part.arguments);
-        if (!parsedArguments.success)
-          continue;
-        toolCalls.set(part.id, {
-          entryId: entry.id,
-          ordinal,
-          name: part.name,
-          arguments: parsedArguments.data
-        });
+function validateHostQuestionResponse(interaction, response) {
+  const questionIds = new Set(interaction.questions.map(({ id }) => id));
+  if (response.cancelled) {
+    return Object.keys(response.answers).length === 0 ? null : invalidRequest("Cancelled Question Response must not contain answers");
+  }
+  for (const answerId of Object.keys(response.answers)) {
+    if (!questionIds.has(answerId)) {
+      return invalidRequest("Question Response contains an unknown Question ID");
+    }
+  }
+  for (const question of interaction.questions) {
+    const answers = response.answers[question.id] ?? [];
+    if (!question.optional && answers.length === 0) {
+      return invalidRequest("Question Response omits a required answer");
+    }
+    if (question.type === "text") {
+      if (answers.length > 1) {
+        return invalidRequest("Text Question accepts at most one answer");
       }
       continue;
     }
-    if (nativeMessage.role !== "toolResult" || typeof nativeMessage.toolCallId !== "string" || typeof nativeMessage.toolName !== "string") {
-      continue;
+    if (!question.multiple && answers.length > 1) {
+      return invalidRequest("Single-choice Question accepts at most one answer");
     }
-    const call = toolCalls.get(nativeMessage.toolCallId);
-    if (!call || call.name !== nativeMessage.toolName)
-      continue;
-    const output = toolOutput(nativeMessage.content);
-    const item = {
-      type: "toolExecution",
-      itemId: itemId(call.entryId, "tool", call.ordinal),
-      toolName: call.name,
-      arguments: call.arguments,
-      ...output ? { output } : {}
-    };
-    const toolSucceeded = nativeMessage.isError === false;
-    snapshots.push({
-      item,
-      outcome: toolSucceeded ? { status: "succeeded" } : {
-        status: "failed",
-        error: {
-          code: "nativeFailure",
-          message: `Pi Tool '${call.name}' failed`,
-          retryable: false
+    const declared = new Set(question.options.map(({ value }) => value));
+    if (!question.allowOther && answers.some((answer) => !declared.has(answer))) {
+      return invalidRequest("Question Response contains an undeclared choice");
+    }
+  }
+  return null;
+}
+
+// ../../harness-adapter/dist/output-channel.js
+var HarnessOutputChannel = class {
+  outputs;
+  #consumerCreated = false;
+  #ended = false;
+  #pending = [];
+  #values = [];
+  constructor() {
+    this.outputs = {
+      [Symbol.asyncIterator]: () => {
+        if (this.#consumerCreated) {
+          throw new Error("Harness outputs allow only one consumer");
         }
+        this.#consumerCreated = true;
+        return {
+          next: () => this.#next()
+        };
       }
-    });
+    };
+  }
+  emit(value) {
+    if (this.#ended)
+      return false;
+    const resolve = this.#pending.shift();
+    if (resolve)
+      resolve({ done: false, value });
+    else
+      this.#values.push(value);
+    return true;
   }
-  return snapshots;
+  end() {
+    if (this.#ended)
+      return;
+    this.#ended = true;
+    if (this.#values.length !== 0)
+      return;
+    for (const resolve of this.#pending.splice(0))
+      resolve({ done: true, value: void 0 });
+  }
+  #next() {
+    const value = this.#values.shift();
+    if (value !== void 0)
+      return Promise.resolve({ done: false, value });
+    if (this.#ended)
+      return Promise.resolve({ done: true, value: void 0 });
+    return new Promise((resolve) => this.#pending.push(resolve));
+  }
+};
+
+// ../../harness-adapter/dist/diagnostics.js
+var DIAGNOSTIC_TAIL_MAX_LENGTH = 8e3;
+var SENSITIVE_VALUE_PATTERN = /(api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret)(\s*[:=]\s*)([^\s,;]+)/giu;
+var BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]+/giu;
+function sanitizeDiagnosticTail(value) {
+  const redacted = value.replace(BEARER_PATTERN, "Bearer [redacted]").replace(SENSITIVE_VALUE_PATTERN, "$1$2[redacted]");
+  return redacted.length <= DIAGNOSTIC_TAIL_MAX_LENGTH ? redacted : redacted.slice(-DIAGNOSTIC_TAIL_MAX_LENGTH);
 }
-function modelChange(entry) {
-  return entry.type === "model_change" && typeof entry.provider === "string" && typeof entry.modelId === "string" ? { provider: entry.provider, id: entry.modelId } : null;
+
+// ../../harness-adapter/dist/usage.js
+var tokenFields = [
+  "inputTokens",
+  "cachedInputTokens",
+  "cacheWriteInputTokens",
+  "outputTokens",
+  "outputTokensPerSecond",
+  "reasoningOutputTokens",
+  "totalTokens",
+  "contextWindowTokens",
+  "contextUsedTokens"
+];
+var safeIntegerFields = [
+  "planFiveHourResetsAtUnix",
+  "planSevenDayResetsAtUnix"
+];
+var percentFields = [
+  "cacheHitRatePercent",
+  "planFiveHourUsedPercent",
+  "planSevenDayUsedPercent"
+];
+var usageFields = /* @__PURE__ */ new Set([
+  ...tokenFields,
+  ...safeIntegerFields,
+  ...percentFields,
+  "totalCostUsd",
+  "totalCredits",
+  "contextUsagePercent"
+]);
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function mapPiSnapshot(history, state) {
-  const active = activePiEntries(history);
-  const turns = [];
-  let effectiveModel = state.model;
-  for (let index = 0; index < active.length; ) {
-    const model = modelChange(active[index]);
-    if (model) {
-      effectiveModel = model;
-      index += 1;
-      continue;
+function parseHostUsage(value) {
+  if (!isRecord3(value))
+    throw new Error("Harness Usage must be an object");
+  const keys = Object.keys(value);
+  if (keys.length === 0)
+    throw new Error("Harness Usage must contain a reliable field");
+  for (const key of keys) {
+    if (!usageFields.has(key)) {
+      throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
-    const user = active[index];
-    if (messageRole(user) !== "user") {
-      index += 1;
-      continue;
+  }
+  for (const field of ["totalCredits", "contextUsagePercent"]) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
     }
-    let end = index + 1;
-    while (end < active.length && messageRole(active[end]) !== "user")
-      end += 1;
-    const entries = active.slice(index, end);
-    const outcome = assistantOutcome(entries);
-    const userText = textContent(message(user)?.content);
-    const nativeTurnRef = nativeTurnRefSchema.parse({
-      harnessId: piHarnessId,
-      nativeSessionId: state.sessionId,
-      nativeTurnKey: user.id,
-      formatVersion: 1
-    });
-    const checkpoint = nativeCheckpointRefSchema.parse({
-      harnessId: piHarnessId,
-      nativeSessionId: state.sessionId,
-      checkpointId: user.id,
-      formatVersion: 1
-    });
-    turns.push({
-      nativeTurnRef,
-      checkpoint,
-      input: [{ type: "text", text: userText }],
-      items: snapshotItems(entries, outcome),
-      outcome,
-      ...effectiveModel ? { model: encodePiModelRef(effectiveModel) } : {}
-    });
-    for (const entry of entries) {
-      const changed = modelChange(entry);
-      if (changed)
-        effectiveModel = changed;
+  }
+  for (const field of tokenFields) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
     }
-    index = end;
   }
-  return { turns };
-}
-function resolvePiLastTurnBoundary(history) {
-  const users = activePiEntries(history).filter((entry) => messageRole(entry) === "user");
-  const last = users.at(-1);
-  return last ? { lastUserEntryId: last.id, sourceTurnCount: users.length } : null;
-}
-function resolvePiForkBoundary(history, checkpointId) {
-  const active = activePiEntries(history);
-  const users = active.filter((entry) => messageRole(entry) === "user");
-  const targetTurnIndex = users.findIndex((entry) => entry.id === checkpointId);
-  if (targetTurnIndex < 0)
-    throw new Error("Pi Checkpoint is not on the active branch");
-  return {
-    targetTurnIndex,
-    nextUserEntryId: users[targetTurnIndex + 1]?.id ?? null
-  };
+  for (const field of safeIntegerFields) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+    }
+  }
+  if (value.outputTokensPerSecond !== void 0 && (typeof value.outputTokensPerSecond !== "number" || !Number.isFinite(value.outputTokensPerSecond) || value.outputTokensPerSecond < 0)) {
+    throw new Error("Harness Usage 'outputTokensPerSecond' must be a finite non-negative number");
+  }
+  if (value.totalCostUsd !== void 0 && (typeof value.totalCostUsd !== "number" || !Number.isFinite(value.totalCostUsd) || value.totalCostUsd < 0)) {
+    throw new Error("Harness Usage 'totalCostUsd' must be a finite non-negative number");
+  }
+  for (const field of percentFields) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0 || candidate > 100)) {
+      throw new Error(`Harness Usage '${field}' must be between 0 and 100`);
+    }
+  }
+  const hasContextUsed = value.contextUsedTokens !== void 0;
+  const hasContextWindow = value.contextWindowTokens !== void 0;
+  if (hasContextUsed !== hasContextWindow) {
+    throw new Error("Harness Usage context fields must be provided together");
+  }
+  if (hasContextWindow && value.contextWindowTokens === 0) {
+    throw new Error("Harness Usage 'contextWindowTokens' must be greater than zero");
+  }
+  if (value.planFiveHourResetsAtUnix !== void 0 && value.planFiveHourUsedPercent === void 0) {
+    throw new Error("Harness Usage 'planFiveHourResetsAtUnix' must be provided with 'planFiveHourUsedPercent'");
+  }
+  if (value.planSevenDayResetsAtUnix !== void 0 && value.planSevenDayUsedPercent === void 0) {
+    throw new Error("Harness Usage 'planSevenDayResetsAtUnix' must be provided with 'planSevenDayUsedPercent'");
+  }
+  return { ...value };
 }
 
 // dist/pi-last-turn-rollback.js
@@ -16456,16 +16630,23 @@ async function rollbackPiLastTurn(transport, sourceSessionId, cwd) {
   if (snapshot.turns.length !== boundary.sourceTurnCount - 1 || actualTurnKeys.some((key, index) => key !== expectedTurnKeys[index])) {
     throw new Error("Pi last-Turn rollback did not produce the exact retained history prefix");
   }
-  await transport.verifySessionCwd(cwd);
-  return { ok: true };
+  try {
+    await transport.verifySessionCwd(cwd);
+    return { ok: true, unpersisted: false };
+  } catch (error51) {
+    if (snapshot.turns.length === 0 && error51?.code === "ENOENT") {
+      return { ok: true, unpersisted: true };
+    }
+    throw error51;
+  }
 }
 
 // dist/pi-session-import.js
-import { createReadStream } from "node:fs";
-import { opendir, realpath, stat } from "node:fs/promises";
+import { createReadStream as createReadStream2 } from "node:fs";
+import { opendir, realpath as realpath2, stat } from "node:fs/promises";
 import os from "node:os";
-import path from "node:path";
-import { createInterface } from "node:readline";
+import path2 from "node:path";
+import { createInterface as createInterface2 } from "node:readline";
 var PiSessionChangedError = class extends Error {
   constructor() {
     super("Pi Session changed during discovery; refresh and retry");
@@ -16474,14 +16655,14 @@ var PiSessionChangedError = class extends Error {
 function sameFile(left, right) {
   return left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs && left.ino === right.ino && left.dev === right.dev;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function missing(error51) {
-  return isRecord3(error51) && error51.code === "ENOENT";
+  return isRecord4(error51) && error51.code === "ENOENT";
 }
 function expandDirectory(value, home) {
-  return path.resolve(value === "~" ? home : value.startsWith(`~${path.sep}`) || value.startsWith("~/") ? path.join(home, value.slice(2)) : value);
+  return path2.resolve(value === "~" ? home : value.startsWith(`~${path2.sep}`) || value.startsWith("~/") ? path2.join(home, value.slice(2)) : value);
 }
 function piSessionImportDirectory(environment) {
   const home = (process.platform === "win32" ? environment.USERPROFILE : environment.HOME) || os.homedir();
@@ -16490,7 +16671,7 @@ function piSessionImportDirectory(environment) {
     return { directory: expandDirectory(custom2, home), flat: true };
   const agent = environment.PI_CODING_AGENT_DIR;
   return {
-    directory: path.join(agent ? expandDirectory(agent, home) : path.join(home, ".pi", "agent"), "sessions"),
+    directory: path2.join(agent ? expandDirectory(agent, home) : path2.join(home, ".pi", "agent"), "sessions"),
     flat: false
   };
 }
@@ -16508,9 +16689,9 @@ async function sessionFiles(directory, flat, signal) {
     for await (const entry of entries) {
       signal.throwIfAborted();
       if (projectLevel && entry.isDirectory())
-        await visit(path.join(dir, entry.name), false);
+        await visit(path2.join(dir, entry.name), false);
       else if (!projectLevel && entry.isFile() && entry.name.endsWith(".jsonl")) {
-        files.push(path.join(dir, entry.name));
+        files.push(path2.join(dir, entry.name));
       }
     }
   };
@@ -16521,8 +16702,8 @@ async function readCandidate(file2, signal) {
   const before = await stat(file2);
   if (!before.isFile() || before.size === 0)
     return null;
-  const stream = createReadStream(file2, { encoding: "utf8", signal, end: before.size - 1 });
-  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  const stream = createReadStream2(file2, { encoding: "utf8", signal, end: before.size - 1 });
+  const lines = createInterface2({ input: stream, crlfDelay: Infinity });
   let header;
   let name = null;
   let firstMessage = null;
@@ -16540,20 +16721,20 @@ async function readCandidate(file2, signal) {
       } catch {
         return null;
       }
-      if (!isRecord3(entry))
+      if (!isRecord4(entry))
         return null;
       if (!header) {
-        if (entry.type !== "session" || entry.version !== 3 || typeof entry.id !== "string" || typeof entry.cwd !== "string" || !path.isAbsolute(entry.cwd))
+        if (entry.type !== "session" || entry.version !== 3 || typeof entry.id !== "string" || typeof entry.cwd !== "string" || !path2.isAbsolute(entry.cwd))
           return null;
         header = entry;
         continue;
       }
       if (typeof entry.id !== "string" || entry.id.length === 0 || entries.has(entry.id) || entry.parentId !== null && (typeof entry.parentId !== "string" || !entries.has(entry.parentId)))
         return null;
-      const message3 = isRecord3(entry.message) ? entry.message : null;
+      const message3 = isRecord4(entry.message) ? entry.message : null;
       if (!firstMessage && entry.type === "message" && message3?.role === "user") {
         const content = message3.content;
-        const text = typeof content === "string" ? content : Array.isArray(content) ? content.filter((block) => isRecord3(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text).join(" ") : "";
+        const text = typeof content === "string" ? content : Array.isArray(content) ? content.filter((block) => isRecord4(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text).join(" ") : "";
         firstMessage = text.replaceAll("\0", "").trim().slice(0, HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH) || null;
       }
       hasUser = entry.type === "message" && message3?.role === "user" || typeof entry.parentId === "string" && entries.get(entry.parentId) === true;
@@ -16577,13 +16758,13 @@ async function readCandidate(file2, signal) {
   const after = await stat(file2);
   if (!sameFile(before, after))
     throw new PiSessionChangedError();
-  const cwd = await realpath(String(header.cwd));
+  const cwd = await realpath2(String(header.cwd));
   if (!(await stat(cwd)).isDirectory())
     return null;
   const nativeRef = nativeSessionRefSchema.safeParse({
     harnessId: "pi",
     nativeSessionId: header.id,
-    locator: { sessionFile: await realpath(file2) },
+    locator: { sessionFile: await realpath2(file2) },
     formatVersion: 1
   });
   const candidate = harnessSessionImportCandidateSchema.safeParse({
@@ -16596,8 +16777,8 @@ async function readCandidate(file2, signal) {
   return candidate.success && nativeRef.success ? { candidate: candidate.data, nativeRef: nativeRef.data } : null;
 }
 async function readIdentity(file2, signal) {
-  const stream = createReadStream(file2, { encoding: "utf8", signal });
-  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  const stream = createReadStream2(file2, { encoding: "utf8", signal });
+  const lines = createInterface2({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of lines) {
       signal.throwIfAborted();
@@ -16609,7 +16790,7 @@ async function readIdentity(file2, signal) {
       } catch {
         return null;
       }
-      return isRecord3(header) && header.type === "session" && header.version === 3 && typeof header.id === "string" ? header.id : null;
+      return isRecord4(header) && header.type === "session" && header.version === 3 && typeof header.id === "string" ? header.id : null;
     }
     return null;
   } finally {
@@ -16693,14 +16874,14 @@ var PiSessionImportIndex = class {
 
 // dist/pi-rpc-session.js
 import { spawn, spawnSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import path4 from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import path5 from "node:path";
 
 // ../../harness-discovery/dist/environment.js
 import fs from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 function targetPath(platform) {
-  return platform === "win32" ? path2.win32 : path2.posix;
+  return platform === "win32" ? path3.win32 : path3.posix;
 }
 function environmentValue(environment, name) {
   const lowered = name.toLowerCase();
@@ -16743,11 +16924,11 @@ function newestFirst(names) {
 }
 
 // ../../harness-discovery/dist/node-runtime.js
-import path3 from "node:path";
+import path4 from "node:path";
 function withNodeRuntimeOnPath(environment, runtimeExecutable = process.execPath, platform = process.platform) {
   const pathKey = Object.keys(environment).find((name) => name.toLowerCase() === "path") ?? "PATH";
   const delimiter = platform === "win32" ? ";" : ":";
-  const runtimeDirectory = path3.dirname(runtimeExecutable);
+  const runtimeDirectory = path4.dirname(runtimeExecutable);
   const directories = (environment[pathKey] ?? "").split(delimiter).filter(Boolean);
   const equal = platform === "win32" ? (value) => value.toLowerCase() : (value) => value;
   if (!directories.some((directory) => equal(directory) === equal(runtimeDirectory))) {
@@ -16946,14 +17127,14 @@ function resolvePiExecutable(input, dependencies = {}) {
 }
 
 // dist/pi-usage.js
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonNegativeSafeInteger(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
 }
 function optionalPiCacheHitRatePercent(value) {
-  if (!isRecord4(value) || value.role !== "assistant" || !isRecord4(value.usage))
+  if (!isRecord5(value) || value.role !== "assistant" || !isRecord5(value.usage))
     return null;
   const input = nonNegativeSafeInteger(value.usage.input);
   const cacheRead = nonNegativeSafeInteger(value.usage.cacheRead);
@@ -16966,20 +17147,20 @@ function optionalPiCacheHitRatePercent(value) {
 function latestPiCacheHitRatePercent(history) {
   let latest = null;
   for (const entry of activePiEntries(history)) {
-    if (entry.type === "message" && isRecord4(entry.message) && entry.message.role === "assistant") {
+    if (entry.type === "message" && isRecord5(entry.message) && entry.message.role === "assistant") {
       latest = optionalPiCacheHitRatePercent(entry.message);
     }
   }
   return latest;
 }
 function responseData(response, operation) {
-  if (!isRecord4(response.data)) {
+  if (!isRecord5(response.data)) {
     throw new Error(`Pi RPC ${operation} response has no data`);
   }
   return response.data;
 }
 function contextUsage(value) {
-  if (!isRecord4(value))
+  if (!isRecord5(value))
     throw new Error("Pi RPC context Usage is invalid");
   return parseHostUsage({
     contextUsedTokens: value.tokens,
@@ -16989,15 +17170,15 @@ function contextUsage(value) {
 function parsePiSessionUsage(response) {
   const data = responseData(response, "Session stats");
   const tokens = data.tokens;
-  if (tokens !== void 0 && !isRecord4(tokens)) {
+  if (tokens !== void 0 && !isRecord5(tokens)) {
     throw new Error("Pi RPC Session stats tokens are invalid");
   }
   return parseHostUsage({
-    ...isRecord4(tokens) && tokens.input !== void 0 ? { inputTokens: tokens.input } : {},
-    ...isRecord4(tokens) && tokens.cacheRead !== void 0 ? { cachedInputTokens: tokens.cacheRead } : {},
-    ...isRecord4(tokens) && tokens.cacheWrite !== void 0 ? { cacheWriteInputTokens: tokens.cacheWrite } : {},
-    ...isRecord4(tokens) && tokens.output !== void 0 ? { outputTokens: tokens.output } : {},
-    ...isRecord4(tokens) && tokens.total !== void 0 ? { totalTokens: tokens.total } : {},
+    ...isRecord5(tokens) && tokens.input !== void 0 ? { inputTokens: tokens.input } : {},
+    ...isRecord5(tokens) && tokens.cacheRead !== void 0 ? { cachedInputTokens: tokens.cacheRead } : {},
+    ...isRecord5(tokens) && tokens.cacheWrite !== void 0 ? { cacheWriteInputTokens: tokens.cacheWrite } : {},
+    ...isRecord5(tokens) && tokens.output !== void 0 ? { outputTokens: tokens.output } : {},
+    ...isRecord5(tokens) && tokens.total !== void 0 ? { totalTokens: tokens.total } : {},
     ...data.cost !== void 0 ? { totalCostUsd: data.cost } : {},
     ...data.contextUsage !== void 0 ? contextUsage(data.contextUsage) : {}
   });
@@ -17016,54 +17197,6 @@ function optionalPiStateContextUsage(value) {
   }
 }
 
-// dist/pi-session-file.js
-import { open, realpath as realpath2 } from "node:fs/promises";
-var MAX_SESSION_HEADER_BYTES = 64 * 1024;
-var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
-function isRecord5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-async function readPiSessionHeader(sessionFile) {
-  const handle = await open(sessionFile, "r");
-  try {
-    const buffer = Buffer.allocUnsafe(MAX_SESSION_HEADER_BYTES);
-    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-    const contents = buffer.subarray(0, bytesRead);
-    const newline = contents.indexOf(10);
-    if (newline < 0 && bytesRead === buffer.length) {
-      throw new Error("Pi Session header exceeds the supported size");
-    }
-    const headerText = utf8Decoder.decode(newline < 0 ? contents : contents.subarray(0, newline));
-    let parsed;
-    try {
-      parsed = JSON.parse(headerText);
-    } catch {
-      throw new Error("Pi Session header is not valid JSON");
-    }
-    if (!isRecord5(parsed) || parsed.type !== "session" || typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
-      throw new Error("Pi Session header is invalid");
-    }
-    return { type: "session", id: parsed.id, cwd: parsed.cwd };
-  } finally {
-    await handle.close();
-  }
-}
-async function verifyPiSessionCwd(input) {
-  if (!input.sessionFile)
-    throw new Error("Pi Fork Session has no persisted Session file");
-  const header = await readPiSessionHeader(input.sessionFile);
-  if (header.id !== input.sessionId) {
-    throw new Error("Pi Fork Session header identity does not match RPC state");
-  }
-  const [actualCwd, expectedCwd] = await Promise.all([
-    realpath2(header.cwd),
-    realpath2(input.expectedCwd)
-  ]);
-  if (actualCwd !== expectedCwd) {
-    throw new Error("Pi Fork Session did not bind the requested cwd");
-  }
-}
-
 // dist/pi-rpc-session.js
 var PiRpcFaultError = class extends Error {
   kind;
@@ -17245,6 +17378,9 @@ function piRpcProcessCommand(options, dependencies = {}) {
   if (options.model && (options.sessionFile || options.forkSessionFile)) {
     throw new Error("Pi RPC cannot combine a startup Model with Session restore or Fork");
   }
+  if (options.emptySessionConfiguration && (!options.sessionFile || options.model || options.forkSessionFile)) {
+    throw new Error("Pi empty Session configuration requires an exclusive Session resume");
+  }
   const platform = dependencies.platform ?? process.platform;
   const command = resolvePiExecutable({
     ...options.command ? { command: options.command } : {},
@@ -17255,9 +17391,17 @@ function piRpcProcessCommand(options, dependencies = {}) {
     ...dependencies.isExecutable ? { isExecutable: dependencies.isExecutable } : {}
   });
   const sessionArguments = options.forkSessionFile ? ["--fork", options.forkSessionFile] : options.sessionFile ? ["--session", options.sessionFile] : [];
-  const modelArguments = options.model ? ["--provider", options.model.provider, "--model", options.model.id] : [];
-  const arguments_ = ["--mode", "rpc", ...modelArguments, ...sessionArguments];
-  const extension = path4.win32.extname(command).toLowerCase();
+  const startupModel = options.emptySessionConfiguration?.model ?? options.model;
+  const modelArguments = startupModel ? ["--provider", startupModel.provider, "--model", startupModel.id] : [];
+  const thinkingArguments = options.emptySessionConfiguration ? ["--thinking", options.emptySessionConfiguration.thinkingLevel] : [];
+  const arguments_ = [
+    "--mode",
+    "rpc",
+    ...modelArguments,
+    ...thinkingArguments,
+    ...sessionArguments
+  ];
+  const extension = path5.win32.extname(command).toLowerCase();
   if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
     return { command, arguments: arguments_, windowsVerbatimArguments: false };
   }
@@ -17290,6 +17434,7 @@ var PiRpcSession = class {
   #buffer = Buffer.alloc(0);
   #child = null;
   #closed = false;
+  #closePromise = null;
   #compactionActive = false;
   #compactionTurn = null;
   #compactionTimeout = null;
@@ -17340,7 +17485,8 @@ var PiRpcSession = class {
       }),
       ...this.#options.sessionFile ? { sessionFile: this.#options.sessionFile } : {},
       ...this.#options.forkSessionFile ? { forkSessionFile: this.#options.forkSessionFile } : {},
-      ...this.#options.model ? { model: this.#options.model } : {}
+      ...this.#options.model ? { model: this.#options.model } : {},
+      ...this.#options.emptySessionConfiguration ? { emptySessionConfiguration: this.#options.emptySessionConfiguration } : {}
     });
     this.#child = child;
     child.stdout.on("data", (chunk) => this.#push(chunk));
@@ -17597,12 +17743,13 @@ var PiRpcSession = class {
     this.#fail(fault);
     void this.close().catch(() => void 0);
   }
-  async close() {
-    if (this.#closed)
-      return;
-    this.#closed = true;
-    this.#rejectAll(new Error("Pi RPC Session closed"));
-    await this.#stopProcess();
+  close() {
+    if (!this.#closed) {
+      this.#closed = true;
+      this.#rejectAll(new Error("Pi RPC Session closed"));
+    }
+    this.#closePromise ??= this.#stopProcess();
+    return this.#closePromise;
   }
   async #stopProcess() {
     const child = this.#child;
@@ -17766,7 +17913,7 @@ var PiRpcSession = class {
     const active = {
       origin: "autonomous",
       autonomousEvents: events,
-      nativeTurnKey: assistantMessageId(value) ?? randomUUID(),
+      nativeTurnKey: assistantMessageId(value) ?? randomUUID2(),
       nativeCancellationObserved: false,
       text: "",
       assistantMessageId: null,
@@ -18009,7 +18156,7 @@ var PiRpcSession = class {
     if (active.assistantMessageId !== null && active.reasoningMessageOpen) {
       active.onEvent({ type: "reasoning.completed", messageId: active.assistantMessageId });
     }
-    const messageId = assistantMessageId(value) ?? randomUUID();
+    const messageId = assistantMessageId(value) ?? randomUUID2();
     active.assistantMessageId = messageId;
     active.sawStreamedMessageText = false;
     active.sawStreamedMessageReasoning = false;
@@ -18070,7 +18217,7 @@ var PiRpcSession = class {
     if (!child?.stdin.writable || this.#closed || this.#failed) {
       return Promise.reject(new Error("Pi RPC stdin is unavailable"));
     }
-    const id = `codexhost-${randomUUID()}`;
+    const id = `codexhost-${randomUUID2()}`;
     return new Promise((resolve, reject) => {
       const pending = {
         command: type,
@@ -18122,7 +18269,7 @@ var PiRpcSession = class {
     }
     let finalFault = fault;
     try {
-      await this.#stopProcess();
+      await this.close();
     } catch (error51) {
       finalFault = new PiRpcFaultError("processExited", `Pi RPC timed-out Prompt cleanup failed: ${message2(error51)}`);
     }
@@ -18333,10 +18480,10 @@ function stripDiffPrefix(pathString) {
   return pathString.startsWith("a/") || pathString.startsWith("b/") ? pathString.slice(2) : pathString;
 }
 function displayPath(nativePath, cwd) {
-  const resolvedCwd = path5.resolve(cwd);
-  const resolvedPath = path5.isAbsolute(nativePath) ? path5.resolve(nativePath) : path5.resolve(cwd, nativePath);
-  const relative = path5.relative(resolvedCwd, resolvedPath);
-  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path5.sep}`);
+  const resolvedCwd = path6.resolve(cwd);
+  const resolvedPath = path6.isAbsolute(nativePath) ? path6.resolve(nativePath) : path6.resolve(cwd, nativePath);
+  const relative = path6.relative(resolvedCwd, resolvedPath);
+  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path6.sep}`);
   const selected = inside ? relative : resolvedPath;
   const normalized = selected.replaceAll("\\", "/");
   if (normalized.length === 0 || normalized === ".")
@@ -19149,7 +19296,7 @@ var PiHarnessSession = class {
       }));
       return;
     }
-    const turnId = hostTurnIdSchema.parse(randomUUID2());
+    const turnId = hostTurnIdSchema.parse(randomUUID3());
     let resolveCompletion = () => void 0;
     const completion = new Promise((resolve) => {
       resolveCompletion = resolve;
@@ -19311,7 +19458,7 @@ var PiHarnessSession = class {
     if (active.interactionByNativeId.has(request.requestId)) {
       throw new Error("Pi Interaction started more than once");
     }
-    const interactionId = hostInteractionIdSchema.parse(randomUUID2());
+    const interactionId = hostInteractionIdSchema.parse(randomUUID3());
     const question = request.method === "select" ? {
       id: "answer",
       type: "choice",
@@ -19650,7 +19797,7 @@ var PiHarnessSession = class {
     this.#channel.emit({ kind: "event", event });
   }
   #newItemId() {
-    return hostItemIdSchema.parse(randomUUID2());
+    return hostItemIdSchema.parse(randomUUID3());
   }
 };
 var PiAdapter = class {
@@ -19865,8 +20012,11 @@ var PiAdapter = class {
           });
         }
       }
+      const emptySessionConfiguration = input.kind === "resume" ? await readPiEmptySessionConfiguration(sourceSessionFile) : void 0;
       transport = this.#createTransport({
         cwd: input.cwd,
+        ...input.environment ? { environment: input.environment } : {},
+        ...emptySessionConfiguration ? { emptySessionConfiguration } : {},
         ...input.kind === "resume" ? { sessionFile: sourceSessionFile } : { forkSessionFile: sourceSessionFile },
         onFault: (error51) => session?.handleTransportFault(error51)
       });
@@ -19918,6 +20068,45 @@ var PiAdapter = class {
             retryable: false
           });
         }
+        if (rolledBack.unpersisted) {
+          const state = transport.state;
+          const history = await transport.getEntries();
+          await transport.close();
+          await persistEmptyPiSession({
+            state,
+            history,
+            sourceSessionFile,
+            sourceSessionId: sourceRef.nativeSessionId,
+            cwd: input.cwd
+          });
+          if (!state.sessionFile)
+            throw new Error("Pi empty fork has no Session file");
+          const configuration = await readPiEmptySessionConfiguration(state.sessionFile);
+          if (!configuration)
+            throw new Error("Pi empty fork has no restorable configuration");
+          transport = this.#createTransport({
+            cwd: input.cwd,
+            ...input.environment ? { environment: input.environment } : {},
+            sessionFile: state.sessionFile,
+            emptySessionConfiguration: configuration,
+            onFault: (error51) => session?.handleTransportFault(error51)
+          });
+          await transport.start();
+          if (transport.state.sessionId !== state.sessionId) {
+            throw new Error("Pi empty fork resumed with a different identity");
+          }
+          const model = nativeModelFromState(state);
+          if (model && !samePiModel(nativeModelFromState(transport.state), model)) {
+            await transport.selectModel(model);
+          }
+          if (state.thinkingLevel && transport.state.thinkingLevel !== state.thinkingLevel) {
+            await transport.selectThinkingOption(state.thinkingLevel);
+          }
+          if (!samePiModel(nativeModelFromState(transport.state), model) || transport.state.thinkingLevel !== state.thinkingLevel) {
+            throw new Error("Pi empty fork could not restore its configuration");
+          }
+          await transport.verifySessionCwd(input.cwd);
+        }
       }
       const startedThinkingLevels = await transport.getAvailableThinkingLevels();
       this.#thinkingSelectionSupported = startedThinkingLevels !== null;