@liberseek/boft-cli-win32-arm64 0.7.0 → 0.7.1

package/app/plugins/pi/plugin.mjs

@@ -5,9 +5,15 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// dist/pi-empty-session.js
-import { createReadStream } from "node:fs";
-import { createInterface } from "node:readline";
+// dist/pi-credential-imports.js
+import { randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync, lstatSync, renameSync, rmdirSync } from "node:fs";
+import { realpath } from "node:fs/promises";
+import os2 from "node:os";
+import path3 from "node:path";
+import { pathToFileURL } from "node:url";
 
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -731,9 +737,9 @@ function floatSafeRemainder(val, step) {
   return ratio - roundedRatio;
 }
 var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
-function defineLazy(object2, key, getter) {
+function defineLazy(object3, key, getter) {
   let value = void 0;
-  Object.defineProperty(object2, key, {
+  Object.defineProperty(object3, key, {
     get() {
       if (value === EVALUATING) {
         return void 0;
@@ -745,7 +751,7 @@ function defineLazy(object2, key, getter) {
       return value;
     },
     set(v) {
-      Object.defineProperty(object2, key, {
+      Object.defineProperty(object3, key, {
         value: v
         // configurable: true,
       });
@@ -775,10 +781,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path7) {
-  if (!path7)
+function getElementAtPath(obj, path10) {
+  if (!path10)
     return obj;
-  return path7.reduce((acc, key) => acc?.[key], obj);
+  return path10.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1187,11 +1193,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path7, issues) {
+function prefixIssues(path10, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path7);
+    iss.path.unshift(path10);
     return iss;
   });
 }
@@ -1338,16 +1344,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path7 = []) => {
+  const processError = (error52, path10 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1374,17 +1380,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path7 = []) => {
+  const processError = (error52, path10 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1416,8 +1422,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path7) {
+  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path10) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -2670,9 +2676,9 @@ var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
   def.pattern ?? (def.pattern = e164);
   $ZodStringFormat.init(inst, def);
 });
-function isValidJWT(token, algorithm = null) {
+function isValidJWT(token2, algorithm = null) {
   try {
-    const tokensParts = token.split(".");
+    const tokensParts = token2.split(".");
     if (tokensParts.length !== 3)
       return false;
     const [header] = tokensParts;
@@ -7647,8 +7653,8 @@ function ko_default() {
 }
 
 // ../../../node_modules/zod/v4/locales/lt.js
-var capitalizeFirstCharacter = (text) => {
-  return text.charAt(0).toUpperCase() + text.slice(1);
+var capitalizeFirstCharacter = (text2) => {
+  return text2.charAt(0).toUpperCase() + text2.slice(1);
 };
 function getUnitTypeFromNumber(number4) {
   const abs = Math.abs(number4);
@@ -14109,13 +14115,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path7 = ref.slice(1).split("/").filter(Boolean);
-  if (path7.length === 0) {
+  const path10 = ref.slice(1).split("/").filter(Boolean);
+  if (path10.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path7[0] === defsKey) {
-    const key = path7[1];
+  if (path10[0] === defsKey) {
+    const key = path10[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14523,6 +14529,61 @@ function date4(params) {
 // ../../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// ../../shared-contracts/dist/credential-imports.js
+var credentialSourceSchema = external_exports.object({
+  id: external_exports.string().min(1).max(256),
+  harnessId: external_exports.string().min(1),
+  label: external_exports.string().min(1).max(512),
+  provider: external_exports.enum(["openai-codex", "xai"])
+}).strict();
+var credentialImportNameSchema = external_exports.string().regex(/^[a-z][a-z0-9-]{0,47}$/);
+var credentialImportRecordSchema = external_exports.object({
+  name: credentialImportNameSchema,
+  source: credentialSourceSchema,
+  importedAt: external_exports.string()
+}).strict();
+var credentialImportsRequestSchema = external_exports.discriminatedUnion("action", [
+  external_exports.object({ action: external_exports.literal("list") }).strict(),
+  external_exports.object({
+    action: external_exports.literal("import"),
+    sourceId: external_exports.string().min(1).max(256),
+    name: credentialImportNameSchema,
+    confirmed: external_exports.literal(true)
+  }).strict(),
+  external_exports.object({
+    action: external_exports.literal("reimport"),
+    sourceId: external_exports.string().min(1).max(256),
+    name: credentialImportNameSchema,
+    confirmed: external_exports.literal(true)
+  }).strict(),
+  external_exports.object({
+    action: external_exports.literal("remove"),
+    name: credentialImportNameSchema,
+    confirmed: external_exports.literal(true)
+  }).strict()
+]);
+var credentialOtherLoginSchema = external_exports.object({
+  provider: external_exports.string().min(1).max(128),
+  type: external_exports.enum(["oauth", "api_key", "unknown"]),
+  /** Best-effort account label (e.g. the email in a Codex token), derived locally when present. */
+  label: external_exports.string().min(1).max(512).optional(),
+  /** Recognized credential vendor, derived from the OAuth token issuer. Absent when unknown. */
+  vendor: external_exports.enum(["openai-codex", "xai"]).optional()
+}).strict();
+var credentialImportsResultSchema = external_exports.object({
+  sources: external_exports.array(credentialSourceSchema),
+  targets: external_exports.array(external_exports.object({
+    harnessId: external_exports.string(),
+    providers: external_exports.array(external_exports.enum(["openai-codex", "xai"])),
+    imports: external_exports.array(credentialImportRecordSchema),
+    others: external_exports.array(credentialOtherLoginSchema).default([])
+  }).strict())
+}).strict();
+var credentialImportsParamsSchema = external_exports.object({
+  targetHarnessId: external_exports.string().min(1).max(128).optional(),
+  request: credentialImportsRequestSchema
+}).strict();
+
 // ../../shared-contracts/dist/version.js
 var WORKSPACE_CONTRACT_VERSION = 1;
 
@@ -14938,8 +14999,8 @@ var harnessConfigurationStateSchema = external_exports.object({
   effectiveThinkingOptionId: harnessThinkingOptionIdSchema.optional(),
   availableThinkingOptions: harnessThinkingOptionsSchema.optional(),
   effectivePermissionModeId: harnessPermissionModeIdSchema.optional()
-}).strict().superRefine((state, context) => {
-  if (state.effectiveThinkingOptionId && state.availableThinkingOptions && !state.availableThinkingOptions.some(({ id }) => id === state.effectiveThinkingOptionId)) {
+}).strict().superRefine((state2, context) => {
+  if (state2.effectiveThinkingOptionId && state2.availableThinkingOptions && !state2.availableThinkingOptions.some(({ id }) => id === state2.effectiveThinkingOptionId)) {
     context.addIssue({
       code: "custom",
       message: "Effective Thinking option must be currently available",
@@ -15072,6 +15133,8 @@ var pluginPresentationShape = {
   id: harnessPluginIdSchema,
   name: external_exports.string().trim().min(1).max(128),
   version: external_exports.string().min(1).max(128),
+  /** The factory accepts a persisted local entrypoint through its construction context. */
+  launchCommand: external_exports.literal(true).optional(),
   links: external_exports.object({
     documentation: documentationUrlSchema.optional(),
     installation: documentationUrlSchema.optional()
@@ -15109,6 +15172,19 @@ var harnessPluginRouteSchema = external_exports.object({
   permissionModeId: harnessPermissionModeIdSchema.optional()
 }).strict();
 
+// ../../shared-contracts/dist/harness-launch-settings.js
+var harnessLaunchPathSchema = external_exports.string().trim().min(1).max(4096).refine((value) => !/[\u0000\r\n]/u.test(value), "Invalid entrypoint path");
+var harnessLaunchSettingsGetSchema = external_exports.object({
+  harnessId: harnessPluginIdSchema
+}).strict();
+var harnessLaunchSettingsSetSchema = harnessLaunchSettingsGetSchema.extend({
+  path: harnessLaunchPathSchema.nullable()
+});
+var harnessLaunchSettingsSchema = external_exports.object({
+  path: harnessLaunchPathSchema.nullable(),
+  restartRequired: external_exports.boolean()
+}).strict();
+
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
 var nonBlankTextSchema3 = external_exports.string().trim().min(1);
@@ -15399,149 +15475,1103 @@ var updateStatusResultSchema = external_exports.strictObject({
 // ../../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";
+// ../../harness-discovery/dist/environment.js
+import fs from "node:fs";
 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 targetPath(platform) {
+  return platform === "win32" ? path.win32 : path.posix;
 }
-function assertNativePart(value, name) {
-  if (value.trim().length === 0)
-    throw new Error(`Pi ${name} must not be empty`);
+function environmentValue(environment, name) {
+  const lowered = name.toLowerCase();
+  for (const [key, value] of Object.entries(environment)) {
+    if (key.toLowerCase() === lowered)
+      return value;
+  }
+  return void 0;
 }
-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 pathDelimiter(platform) {
+  return platform === "win32" ? ";" : ":";
 }
-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;
+function pathDirectories(environment, platform) {
+  return (environmentValue(environment, "PATH") ?? "").split(pathDelimiter(platform)).map((directory) => directory.trim().replace(/^"|"$/gu, "")).filter(Boolean);
+}
+function executableExtensions(command, platform, environment) {
+  if (platform !== "win32")
+    return [""];
+  if (targetPath(platform).extname(command) !== "")
+    return [""];
+  return (environmentValue(environment, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").map((extension) => extension.trim()).filter(Boolean);
+}
+function isExecutableFile(filePath, platform) {
   try {
-    decoded = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    fs.accessSync(filePath, platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
+    return fs.statSync(filePath).isFile();
   } 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 false;
   }
-  return native;
 }
-function samePiModel(left, right) {
-  return left === null ? right === null : right !== null && left.provider === right.provider && left.id === right.id;
+function subdirectoryNames(directory) {
+  try {
+    return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
 }
-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 newestFirst(names) {
+  return [...names].sort((left, right) => right.localeCompare(left, void 0, { numeric: true }));
 }
-function normalizePiThinkingOptions(levels) {
-  return levels.map((id) => harnessThinkingOptionSchema.parse({
-    id,
-    label: PI_THINKING_LABELS[id] ?? fallbackThinkingLabel(id)
-  }));
+
+// ../../harness-discovery/dist/node-runtime.js
+import path2 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 = path2.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))) {
+    directories.push(runtimeDirectory);
+  }
+  return { ...environment, [pathKey]: directories.join(delimiter) };
 }
-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;
+
+// ../../harness-discovery/dist/resolve.js
+import os from "node:os";
+
+// ../../harness-discovery/dist/version-managers.js
+function versionManagerBinaryDirectories(context) {
+  const { platform, environment, home } = context;
+  const list = context.subdirectories ?? subdirectoryNames;
+  const pathFlavor = targetPath(platform);
+  const value = (name) => environmentValue(environment, name);
+  const directories = [];
+  const versioned = (root, ...tail) => {
+    for (const version2 of newestFirst(list(root))) {
+      directories.push(pathFlavor.join(root, version2, ...tail));
     }
-    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 (platform === "win32") {
+    const appData = value("APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming");
+    const localAppData = value("LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local");
+    versioned(pathFlavor.join(appData, "nvm"));
+    versioned(value("FNM_DIR") ?? pathFlavor.join(appData, "fnm", "node-versions"), "installation");
+    directories.push(pathFlavor.join(localAppData, "Volta", "bin"));
+    directories.push(pathFlavor.join(home, ".bun", "bin"));
+    const pnpmHome2 = value("PNPM_HOME");
+    if (pnpmHome2)
+      directories.push(pnpmHome2);
+    directories.push(pathFlavor.join(localAppData, "pnpm"));
+    return directories;
   }
-  if (thinkingLevels && effectiveThinkingOptionId && !thinkingLevels.includes(effectiveThinkingOptionId)) {
-    throw new Error("Pi effective Thinking option is absent from the available option catalog");
+  versioned(pathFlavor.join(value("NVM_DIR") ?? pathFlavor.join(home, ".nvm"), "versions", "node"), "bin");
+  const fnmRoots = [
+    value("FNM_DIR"),
+    pathFlavor.join(home, ".local", "share", "fnm"),
+    pathFlavor.join(home, "Library", "Application Support", "fnm")
+  ].filter((root) => root !== void 0);
+  for (const root of fnmRoots) {
+    versioned(pathFlavor.join(root, "node-versions"), "installation", "bin");
   }
-  if (thinkingLevels && !effectiveThinkingOptionId) {
-    throw new Error("Pi did not report an effective Thinking option");
+  const voltaHome = value("VOLTA_HOME") ?? pathFlavor.join(home, ".volta");
+  versioned(pathFlavor.join(voltaHome, "tools", "image", "node"), "bin");
+  directories.push(pathFlavor.join(voltaHome, "bin"));
+  const asdfHome = value("ASDF_DATA_DIR") ?? pathFlavor.join(home, ".asdf");
+  versioned(pathFlavor.join(asdfHome, "installs", "nodejs"), "bin");
+  directories.push(pathFlavor.join(asdfHome, "shims"));
+  const nodenvHome = value("NODENV_ROOT") ?? pathFlavor.join(home, ".nodenv");
+  versioned(pathFlavor.join(nodenvHome, "versions"), "bin");
+  directories.push(pathFlavor.join(nodenvHome, "shims"));
+  versioned(pathFlavor.join(value("N_PREFIX") ?? "/usr/local", "n", "versions", "node"), "bin");
+  directories.push(pathFlavor.join(home, ".bun", "bin"));
+  const pnpmHome = value("PNPM_HOME");
+  if (pnpmHome)
+    directories.push(pnpmHome);
+  directories.push(pathFlavor.join(home, "Library", "pnpm"));
+  directories.push(pathFlavor.join(home, ".local", "share", "pnpm"));
+  for (const prefix of ["/opt/homebrew/opt", "/usr/local/opt"]) {
+    for (const formula of newestFirst(list(prefix).filter((name) => name.startsWith("node@")))) {
+      directories.push(pathFlavor.join(prefix, formula, "bin"));
+    }
   }
-  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 } : {}
-  });
+  return directories;
 }
 
-// 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("");
+// ../../harness-discovery/dist/resolve.js
+var VERSION_MANAGER_ROOTS = "<version-managers>";
+function installRootExtensions(platform) {
+  return platform === "win32" ? [".exe", ".cmd"] : [""];
 }
-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 resolveHomeDirectory(input) {
+  return input.homeDirectory ?? environmentValue(input.environment, "HOME") ?? environmentValue(input.environment, "USERPROFILE") ?? os.homedir();
 }
-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 templateVariables(environment, platform, home) {
+  const pathFlavor = targetPath(platform);
+  return {
+    HOME: home,
+    USERPROFILE: home,
+    APPDATA: environmentValue(environment, "APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming"),
+    LOCALAPPDATA: environmentValue(environment, "LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local")
+  };
 }
-function activePiEntries(history) {
+function joinTemplate(platform, value) {
+  const pathFlavor = targetPath(platform);
+  const segments = value.split("/");
+  const head = segments[0] ?? "";
+  const tail = segments.slice(1);
+  if (head === "")
+    return pathFlavor.join(pathFlavor.sep, ...tail);
+  return tail.length === 0 ? head : pathFlavor.join(head, ...tail);
+}
+function expandInstallRoot(template, environment, platform, home) {
+  const variables = templateVariables(environment, platform, home);
+  let unresolved = false;
+  const substituted = template.replace(/^~(?=\/|$)/u, home).replace(/\$\{(\w+)\}/gu, (_match, name) => {
+    const value = variables[name] ?? environmentValue(environment, name);
+    if (value === void 0 || value === "") {
+      unresolved = true;
+      return "";
+    }
+    return value;
+  });
+  return unresolved ? void 0 : joinTemplate(platform, substituted);
+}
+function installRootDirectories(spec, input, dependencies, platform, home) {
+  const templates = (platform === "win32" ? spec.installRoots?.windows : spec.installRoots?.posix) ?? [];
+  const directories = [];
+  for (const template of templates) {
+    if (template === VERSION_MANAGER_ROOTS) {
+      directories.push(...versionManagerBinaryDirectories({
+        platform,
+        environment: input.environment,
+        home,
+        ...dependencies.subdirectories ? { subdirectories: dependencies.subdirectories } : {}
+      }));
+      continue;
+    }
+    const directory = expandInstallRoot(template, input.environment, platform, home);
+    if (directory !== void 0)
+      directories.push(directory);
+  }
+  return directories;
+}
+function harnessCandidates(spec, input, dependencies = {}) {
+  const platform = input.platform ?? process.platform;
+  const pathFlavor = targetPath(platform);
+  const configured = input.command ?? (spec.commandEnvironmentVariable ? environmentValue(input.environment, spec.commandEnvironmentVariable) : void 0);
+  const command = configured ?? spec.command;
+  if (pathFlavor.isAbsolute(command) || command.includes("/") || command.includes("\\")) {
+    return [{ candidate: command, source: "configured" }];
+  }
+  const candidates = [];
+  const extensions = executableExtensions(command, platform, input.environment);
+  for (const directory of pathDirectories(input.environment, platform)) {
+    for (const extension of extensions) {
+      candidates.push({
+        candidate: pathFlavor.join(directory, command + extension),
+        source: "path"
+      });
+    }
+  }
+  if (configured !== void 0)
+    return candidates;
+  const home = resolveHomeDirectory(input);
+  for (const directory of installRootDirectories(spec, input, dependencies, platform, home)) {
+    for (const extension of installRootExtensions(platform)) {
+      candidates.push({
+        candidate: pathFlavor.join(directory, spec.command + extension),
+        source: "install-root"
+      });
+    }
+  }
+  return candidates;
+}
+function resolveHarnessExecutable(spec, input, dependencies = {}) {
+  const platform = input.platform ?? process.platform;
+  const isExecutable = dependencies.isExecutable ?? ((candidate) => isExecutableFile(candidate, platform));
+  const runnable = spec.runnableCandidate ?? ((candidate) => candidate);
+  const context = { platform, isExecutable };
+  for (const { candidate, source } of harnessCandidates(spec, input, dependencies)) {
+    const executable = runnable(candidate, context);
+    if (executable !== void 0 && isExecutable(executable))
+      return { executable, source };
+  }
+  return void 0;
+}
+
+// dist/command.js
+var piDiscoverySpec = {
+  id: "pi",
+  command: "pi",
+  commandEnvironmentVariable: "PI_COMMAND",
+  installRoots: {
+    posix: [
+      "~/.npm-global/bin",
+      "~/.local/bin",
+      VERSION_MANAGER_ROOTS,
+      "/opt/homebrew/bin",
+      "/usr/local/bin"
+    ],
+    windows: ["${APPDATA}/npm", "~/.local/bin", VERSION_MANAGER_ROOTS]
+  }
+};
+function resolvePiExecutable(input, dependencies = {}) {
+  const resolution = resolveHarnessExecutable(piDiscoverySpec, {
+    ...input.command ? { command: input.command } : {},
+    environment: input.environment,
+    ...dependencies.platform ? { platform: dependencies.platform } : {},
+    ...dependencies.homeDirectory ? { homeDirectory: dependencies.homeDirectory } : {}
+  }, { ...dependencies.isExecutable ? { isExecutable: dependencies.isExecutable } : {} });
+  return resolution?.executable ?? input.command ?? input.environment.PI_COMMAND ?? "pi";
+}
+
+// dist/pi-credential-imports.js
+var PREFIX = "codexhost-account-";
+function object2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseAuth(raw) {
+  const value = JSON.parse(raw ?? "{}");
+  if (!object2(value))
+    throw new Error("Invalid Pi auth store");
+  return value;
+}
+var OAUTH_VENDORS = [
+  {
+    issuer: "https://auth.openai.com",
+    client: "app_EMoamEEZ73f0CkXaXp7hrann",
+    vendor: "openai-codex"
+  },
+  { issuer: "https://auth.x.ai", client: "b1a00492-073a-47ea-816f-4c329264a828", vendor: "xai" }
+];
+function describeOauth(credential) {
+  if (!object2(credential) || credential.type !== "oauth")
+    return {};
+  const token2 = credential.access;
+  if (typeof token2 !== "string")
+    return {};
+  let claims;
+  try {
+    claims = JSON.parse(Buffer.from(token2.split(".")[1] ?? "", "base64url").toString("utf8"));
+  } catch {
+    return {};
+  }
+  if (!object2(claims))
+    return {};
+  const match = OAUTH_VENDORS.find((candidate) => claims.iss === candidate.issuer && claims.client_id === candidate.client);
+  const profile = claims["https://api.openai.com/profile"];
+  const email3 = object2(profile) ? profile.email : claims.email;
+  return {
+    ...typeof email3 === "string" && email3.length > 0 && email3.length <= 512 ? { label: email3 } : {},
+    ...match ? { vendor: match.vendor } : {}
+  };
+}
+function writeAuth(filename, content) {
+  const temporary = `${filename}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, content, { flag: "wx", mode: 384 });
+    renameSync(temporary, filename);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
+function removeOwnedFiles(dir) {
+  rmSync(path3.join(dir, "index.ts"), { force: true });
+  rmSync(path3.join(dir, "import.json"), { force: true });
+  try {
+    rmdirSync(dir);
+  } catch {
+  }
+}
+async function installation(command, environment, authPath) {
+  const executable = await realpath(resolvePiExecutable({ ...command ? { command } : {}, environment }));
+  let directory = path3.dirname(executable);
+  while (true) {
+    const manifest = path3.join(directory, "package.json");
+    if (existsSync(manifest)) {
+      const pkg = JSON.parse(readFileSync(manifest, "utf8"));
+      if (pkg.name === "@earendil-works/pi-coding-agent")
+        break;
+    }
+    const parent = path3.dirname(directory);
+    if (parent === directory)
+      throw new Error("Pi credential import requires a supported npm Pi installation");
+    directory = parent;
+  }
+  const storage = await import(pathToFileURL(path3.join(directory, "dist/core/auth-storage.js")).href);
+  const ai = path3.join(directory, "node_modules/@earendil-works/pi-ai/dist");
+  const all = await import(pathToFileURL(path3.join(ai, "providers/all.js")).href);
+  const providers = all.getBuiltinProviders();
+  const providerModules = {
+    "openai-codex": pathToFileURL(path3.join(ai, "providers/openai-codex.js")).href,
+    xai: pathToFileURL(path3.join(ai, "providers/xai.js")).href
+  };
+  for (const [id, url2] of Object.entries(providerModules)) {
+    const module = await import(url2);
+    const provider = id === "xai" ? module.xaiProvider() : module.openaiCodexProvider();
+    if (!provider.auth?.oauth || !provider.getModels().length)
+      throw new Error("Pi version does not support subscription imports");
+  }
+  return {
+    backend: new storage.FileAuthStorageBackend(authPath),
+    providerModules,
+    reservedNames: providers.map((p) => typeof p === "string" ? p : p.id),
+    async configuredProviderNames() {
+      const { stdout } = await promisify(execFile)(process.execPath, [executable, "--offline", "--no-approve", "--list-models"], {
+        cwd: existsSync(path3.dirname(authPath)) ? path3.dirname(authPath) : os2.homedir(),
+        env: { ...environment, PI_CODING_AGENT_DIR: path3.dirname(authPath), PI_OFFLINE: "1" },
+        timeout: 15e3,
+        maxBuffer: 4 * 1024 * 1024
+      });
+      return stdout.split(/\r?\n/).map((line) => line.trim().split(/\s+/)[0] ?? "").filter(Boolean);
+    }
+  };
+}
+function extensionSource(moduleUrl, provider, name, owner) {
+  return `// Managed by codexhost. Removing this file disables the imported Provider.
+export default async function (pi) {
+  const moduleUrl = ${JSON.stringify(moduleUrl)};
+  const nativeModule = await import(moduleUrl);
+  const native = nativeModule.${provider === "xai" ? "xaiProvider" : "openaiCodexProvider"}();
+  const oauth = native.auth.oauth;
+  const models = native.getModels().map(model => ({ ...model, provider: ${JSON.stringify(name)} }));
+  pi.registerProvider({
+    ...native, id: ${JSON.stringify(name)}, name: ${JSON.stringify(name)},
+    auth: { oauth: { ...oauth,
+      async refresh(credential, signal) {
+        return { ...await oauth.refresh(credential, signal), codexhostImportId: ${JSON.stringify(owner)} };
+      }
+    } },
+    getModels: () => models
+  });
+}
+`;
+}
+function createPiCredentialImports(options = {}) {
+  const env = { ...process.env, ...options.environment };
+  const agentDir = env.PI_CODING_AGENT_DIR ?? path3.join(env.HOME ?? os2.homedir(), ".pi/agent");
+  const authPath = path3.join(agentDir, "auth.json");
+  const extensionsDir = path3.join(agentDir, "extensions");
+  const saveAuth = (auth) => (options.writeAuth ?? writeAuth)(authPath, JSON.stringify(auth, null, 2) + "\n");
+  const resolve = () => options.resolveInstallation?.(authPath) ?? installation(options.command, env, authPath);
+  const location = (name) => path3.join(extensionsDir, `${PREFIX}${credentialImportNameSchema.parse(name)}`);
+  const readRecord = (name) => {
+    const dir = location(name);
+    if (lstatSync(dir).isSymbolicLink())
+      throw new Error("Imported configuration was changed; manage it in Pi");
+    const value = JSON.parse(readFileSync(path3.join(dir, "import.json"), "utf8"));
+    if (value.version !== 1 || typeof value.owner !== "string" || typeof value.extension !== "string")
+      throw new Error("Invalid import metadata");
+    const record6 = value.record;
+    if (!object2(record6))
+      throw new Error("Invalid import metadata");
+    value.record = credentialImportRecordSchema.parse({
+      name: record6.name,
+      source: record6.source,
+      importedAt: record6.importedAt
+    });
+    if (value.record.name !== name)
+      throw new Error("Import identity mismatch");
+    return value;
+  };
+  const owned = (meta3, auth) => {
+    const credential = auth[meta3.record.name];
+    const file2 = path3.join(location(meta3.record.name), "index.ts");
+    return existsSync(file2) && !lstatSync(file2).isSymbolicLink() && readFileSync(file2, "utf8") === meta3.extension && object2(credential) && credential.type === "oauth" && credential.codexhostImportId === meta3.owner;
+  };
+  const readAuth = () => existsSync(authPath) ? parseAuth(readFileSync(authPath, "utf8")) : {};
+  const ownedRecords = (auth) => {
+    if (!existsSync(extensionsDir))
+      return [];
+    const result = [];
+    for (const entry of readdirSync(extensionsDir)) {
+      if (!entry.startsWith(PREFIX))
+        continue;
+      const name = entry.slice(PREFIX.length);
+      if (!credentialImportNameSchema.safeParse(name).success)
+        continue;
+      if (!existsSync(path3.join(location(name), "import.json")))
+        continue;
+      try {
+        const meta3 = readRecord(name);
+        if (owned(meta3, auth))
+          result.push(meta3.record);
+      } catch {
+      }
+    }
+    return result;
+  };
+  return {
+    providers: ["openai-codex", "xai"],
+    async list() {
+      if (!existsSync(agentDir))
+        throw new Error("Pi has no configuration directory");
+      await resolve();
+      return ownedRecords(readAuth());
+    },
+    async listOthers() {
+      const auth = readAuth();
+      const ours = new Set(ownedRecords(auth).map((record6) => record6.name));
+      const result = /* @__PURE__ */ new Map();
+      const usable = (provider) => Boolean(provider) && provider.length <= 128 && !ours.has(provider) && !result.has(provider);
+      for (const [provider, credential] of Object.entries(auth)) {
+        if (!usable(provider))
+          continue;
+        const type = object2(credential) ? credential.type : void 0;
+        result.set(provider, {
+          provider,
+          type: type === "oauth" || type === "api_key" ? type : "unknown",
+          ...describeOauth(credential)
+        });
+      }
+      const modelsPath = path3.join(agentDir, "models.json");
+      if (existsSync(modelsPath)) {
+        const models = JSON.parse(readFileSync(modelsPath, "utf8"));
+        const providers = object2(models) && object2(models.providers) ? models.providers : {};
+        for (const [provider, definition] of Object.entries(providers)) {
+          if (!usable(provider) || !object2(definition) || !definition.apiKey)
+            continue;
+          const name = definition.name;
+          const label = typeof name === "string" && name && name !== provider ? name : void 0;
+          result.set(provider, { provider, type: "api_key", ...label ? { label } : {} });
+        }
+      }
+      return [...result.values()].sort((a, b) => a.provider.localeCompare(b.provider));
+    },
+    async add(name, transfer) {
+      credentialImportNameSchema.parse(name);
+      const sdk = await resolve();
+      if (!this.providers.includes(transfer.source.provider))
+        throw new Error("Unsupported credential source");
+      if (sdk.reservedNames.includes(name) || (await sdk.configuredProviderNames?.())?.includes(name))
+        throw new Error("Provider name already exists; choose another name");
+      const owner = randomUUID();
+      const record6 = credentialImportRecordSchema.parse({
+        name,
+        source: transfer.source,
+        importedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const extension = extensionSource(sdk.providerModules[transfer.source.provider], transfer.source.provider, name, owner);
+      const dir = location(name);
+      let created = false;
+      let committed = false;
+      try {
+        sdk.backend.withLock((current) => {
+          const auth = parseAuth(current);
+          const modelsPath = path3.join(agentDir, "models.json");
+          const models = existsSync(modelsPath) ? JSON.parse(readFileSync(modelsPath, "utf8")) : {};
+          if (Object.hasOwn(auth, name) || Object.hasOwn(models.providers ?? {}, name) || existsSync(dir) || existsSync(path3.join(extensionsDir, `${name}-provider.ts`)))
+            throw new Error("Provider name already exists; choose another name");
+          mkdirSync(extensionsDir, { recursive: true, mode: 448 });
+          mkdirSync(dir, { mode: 448 });
+          created = true;
+          writeFileSync(path3.join(dir, "import.json"), JSON.stringify({ version: 1, owner, record: record6, extension }), { flag: "wx", mode: 384 });
+          writeFileSync(path3.join(dir, "index.ts"), extension, { flag: "wx", mode: 384 });
+          auth[name] = { type: "oauth", ...transfer.oauth, codexhostImportId: owner };
+          saveAuth(auth);
+          committed = true;
+          return { result: void 0 };
+        });
+      } catch (error51) {
+        if (created && !committed)
+          removeOwnedFiles(dir);
+        throw error51;
+      }
+    },
+    async reimport(name, transfer) {
+      const sdk = await resolve();
+      sdk.backend.withLock((current) => {
+        const meta3 = readRecord(name);
+        const auth = parseAuth(current);
+        if (!owned(meta3, auth) || meta3.record.source.id !== transfer.source.id || meta3.record.source.provider !== transfer.source.provider)
+          throw new Error("Import ownership or source account changed; refusing replacement");
+        const metadataPath = path3.join(location(name), "import.json");
+        const previous = readFileSync(metadataPath, "utf8");
+        const updated = {
+          ...meta3,
+          record: { ...meta3.record, importedAt: (/* @__PURE__ */ new Date()).toISOString() }
+        };
+        writeAuth(metadataPath, JSON.stringify(updated));
+        try {
+          saveAuth({
+            ...auth,
+            [name]: { type: "oauth", ...transfer.oauth, codexhostImportId: meta3.owner }
+          });
+        } catch (error51) {
+          writeAuth(metadataPath, previous);
+          throw error51;
+        }
+        return { result: void 0 };
+      });
+    },
+    async remove(name) {
+      const sdk = await resolve();
+      const meta3 = readRecord(name);
+      sdk.backend.withLock((current) => {
+        const auth = parseAuth(current);
+        if (!owned(meta3, auth))
+          throw new Error("Imported configuration was changed; manage it in Pi");
+        saveAuth(Object.fromEntries(Object.entries(auth).filter(([key]) => key !== name)));
+        removeOwnedFiles(location(name));
+        return { result: void 0 };
+      });
+    }
+  };
+}
+
+// dist/pi-empty-session.js
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { link, open as open2, rm } from "node:fs/promises";
+import path4 from "node:path";
+
+// dist/pi-subagents.js
+import { createHash } from "node:crypto";
+
+// dist/pi-subagent-workflow.js
+var PREFIX2 = "pi-subagents-workflow-v1:";
+var STATES = {
+  pending: "pending",
+  running: "running",
+  completed: "completed",
+  failed: "failed",
+  paused: "interrupted",
+  stopped: "interrupted",
+  rejected: "failed",
+  detached: "running"
+};
+function record2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(value, limit = 256) {
+  return typeof value === "string" && value.length > 0 && value.length <= limit;
+}
+function piWorkflowSummary(result) {
+  if (!record2(result) || !record2(result.details) || result.details.mode !== "workflow" || result.details.asyncId !== void 0)
+    return null;
+  const details = result.details;
+  const summary = details.workflowChildren;
+  if (!record2(summary) || summary.version !== 1 || !text(summary.workflowRunId) || summary.workflowRunId !== details.runId || !text(summary.parentToolCallId) || typeof summary.inventoryComplete !== "boolean" || !Array.isArray(summary.children) || summary.children.length > 256)
+    return null;
+  const children = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const child of summary.children) {
+    if (!record2(child) || !text(child.childId) || seen.has(child.childId) || typeof child.state !== "string" || !Object.hasOwn(STATES, child.state))
+      return null;
+    for (const key of ["agent", "sessionName", "model", "thinking"]) {
+      if (child[key] !== void 0 && !text(child[key], 2048))
+        return null;
+    }
+    const mappedState = STATES[child.state];
+    if (!mappedState)
+      return null;
+    seen.add(child.childId);
+    children.push({
+      childId: child.childId,
+      state: mappedState,
+      background: child.state === "detached",
+      ...typeof child.agent === "string" ? { agent: child.agent } : {},
+      ...typeof child.sessionName === "string" ? { sessionName: child.sessionName } : {},
+      ...typeof child.model === "string" ? { model: child.model } : {},
+      ...typeof child.thinking === "string" ? { thinking: child.thinking } : {}
+    });
+  }
+  return {
+    workflowRunId: summary.workflowRunId,
+    parentToolCallId: summary.parentToolCallId,
+    children
+  };
+}
+function piWorkflowSubagentId(address) {
+  return PREFIX2 + Buffer.from(JSON.stringify([address.workflowRunId, address.childId])).toString("base64url");
+}
+function parsePiWorkflowSubagentId(id) {
+  if (!id.startsWith(PREFIX2))
+    return null;
+  if (id.length > 3e3)
+    throw new Error("Invalid Pi workflow child identity");
+  const value = JSON.parse(Buffer.from(id.slice(PREFIX2.length), "base64url").toString("utf8"));
+  if (!Array.isArray(value) || value.length !== 2 || !text(value[0]) || !text(value[1]))
+    throw new Error("Invalid Pi workflow child identity");
+  const address = { workflowRunId: value[0], childId: value[1] };
+  if (piWorkflowSubagentId(address) !== id)
+    throw new Error("Non-canonical Pi workflow child identity");
+  return address;
+}
+function projectPiWorkflow(summary, itemId2) {
+  if (!summary.children.length)
+    return null;
+  return {
+    type: "subagentDelegation",
+    itemId: itemId2,
+    operation: "spawn",
+    subagents: summary.children.map((child) => {
+      const id = piWorkflowSubagentId({
+        workflowRunId: summary.workflowRunId,
+        childId: child.childId
+      });
+      return {
+        subagentId: id,
+        nativeSubagentId: id,
+        description: child.sessionName ?? child.agent ?? child.childId,
+        status: child.state,
+        background: child.background,
+        ...child.agent ? { role: child.agent } : {},
+        ...child.model ? { model: child.model } : {},
+        ...child.thinking ? { reasoningEffort: child.thinking } : {}
+      };
+    })
+  };
+}
+
+// dist/pi-subagents.js
+var STATUS_PREFIX = "PI_SUBAGENT_ASYNC_JSON:";
+var INSPECT_PREFIX = "PI_SUBAGENT_INSPECT_JSON:";
+var ID_PREFIX = "pi-subagents-v1:";
+var MAX_BYTES = 64 * 1024;
+function record3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function token(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 256 && !value.startsWith("--") && !/\s/u.test(value) && [...value].every((character) => character.charCodeAt(0) > 32 && character.charCodeAt(0) !== 127);
+}
+var statuses = {
+  queued: "pending",
+  running: "running",
+  complete: "completed",
+  failed: "failed",
+  partial: "failed",
+  paused: "interrupted",
+  stopped: "interrupted",
+  rejected: "failed"
+};
+function node(value, depth, budget) {
+  if (!record3(value) || depth > 8 || ++budget.count > 256 || !token(value.id) || !["subagent", "workflow", "step", "host-step"].includes(String(value.kind)) || typeof value.label !== "string" || value.label.length > 2048 || typeof value.state !== "string" || !Object.hasOwn(statuses, value.state))
+    return null;
+  const children = [];
+  if (value.children !== void 0) {
+    if (!Array.isArray(value.children))
+      return null;
+    for (const child of value.children) {
+      const parsed = node(child, depth + 1, budget);
+      if (!parsed)
+        return null;
+      children.push(parsed);
+    }
+  }
+  return {
+    id: value.id,
+    kind: value.kind,
+    label: value.label,
+    state: value.state,
+    ...children.length ? { children } : {}
+  };
+}
+function widget(value, key, prefix) {
+  if (!record3(value) || value.type !== "extension_ui_request" || value.method !== "setWidget" || value.widgetKey !== key || !Array.isArray(value.widgetLines))
+    return null;
+  const line = value.widgetLines.find((part) => typeof part === "string" && part.startsWith(prefix));
+  if (!line || Buffer.byteLength(line) > MAX_BYTES + prefix.length)
+    return null;
+  try {
+    const parsed = JSON.parse(line.slice(prefix.length));
+    return record3(parsed) && parsed.version === 1 ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function parsePiSubagentStatus(value) {
+  const parsed = widget(value, "subagent-async", STATUS_PREFIX);
+  if (!parsed || parsed.kind !== "pi-subagents.async-status-snapshot" || !Array.isArray(parsed.runs))
+    return null;
+  const runs = [];
+  const budget = { count: 0 };
+  for (const run of parsed.runs) {
+    const parsedNode = node(run, 0, budget);
+    if (!parsedNode)
+      return null;
+    runs.push(parsedNode);
+  }
+  return runs;
+}
+function piSubagentId(address) {
+  return ID_PREFIX + Buffer.from(JSON.stringify([address.runId, address.childId ?? null])).toString("base64url");
+}
+function parsePiSubagentId(id) {
+  if (!id.startsWith(ID_PREFIX) || id.length > 1500)
+    throw new Error("Invalid Pi Subagent identity");
+  const value = JSON.parse(Buffer.from(id.slice(ID_PREFIX.length), "base64url").toString("utf8"));
+  if (!Array.isArray(value) || value.length !== 2 || !token(value[0]) || value[1] !== null && !token(value[1]))
+    throw new Error("Invalid Pi Subagent identity");
+  const address = { runId: value[0], ...value[1] === null ? {} : { childId: value[1] } };
+  if (piSubagentId(address) !== id)
+    throw new Error("Non-canonical Pi Subagent identity");
+  return address;
+}
+function states(run) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (entry, root) => {
+    if (entry.kind === "host-step" || !root && entry.kind === "workflow")
+      return;
+    if (entry.kind !== "workflow") {
+      const id = piSubagentId({ runId: run.id, ...!root ? { childId: entry.id } : {} });
+      if (!seen.has(id)) {
+        seen.add(id);
+        result.push({
+          subagentId: id,
+          nativeSubagentId: id,
+          description: entry.label,
+          background: true,
+          status: statuses[entry.state] ?? "running"
+        });
+      }
+    }
+    for (const child of entry.children ?? []) {
+      if (entry.kind === "subagent" && child.kind === "step") {
+        for (const nested of child.children ?? [])
+          visit(nested, false);
+      } else
+        visit(child, false);
+    }
+  };
+  visit(run, true);
+  return result;
+}
+function asyncRunId(toolName, result) {
+  if (toolName !== "subagent" || !record3(result) || !record3(result.details))
+    return null;
+  const details = result.details;
+  return ["single", "parallel", "chain", "workflow"].includes(String(details.mode)) && token(details.asyncId) && typeof details.asyncDir === "string" ? details.asyncId : null;
+}
+var PiSubagents = class {
+  emit;
+  #children = /* @__PURE__ */ new Map();
+  #active = /* @__PURE__ */ new Map();
+  #waiting = /* @__PURE__ */ new Map();
+  constructor(emit) {
+    this.emit = emit;
+  }
+  observe(runs) {
+    this.#apply(runs, true);
+  }
+  restore(runs) {
+    this.#apply(runs, false);
+  }
+  #apply(runs, publish) {
+    for (const run of runs) {
+      const observed = states(run);
+      const retained = this.#children.get(run.id) ?? /* @__PURE__ */ new Map();
+      for (const child of observed)
+        retained.set(child.subagentId, child);
+      this.#children.set(run.id, retained);
+      const children = [...retained.values()];
+      if (!publish)
+        continue;
+      const waiting = this.#waiting.get(run.id);
+      if (waiting && children.length) {
+        const item = {
+          type: "subagentDelegation",
+          itemId: waiting.itemId,
+          operation: "spawn",
+          subagents: children
+        };
+        this.#waiting.delete(run.id);
+        this.#active.set(run.id, { turnId: waiting.turnId, item });
+        this.emit({ type: "item.started", turnId: waiting.turnId, item });
+      }
+      const active = this.#active.get(run.id);
+      if (active && children.length) {
+        const merged = new Map(active.item.subagents.map((child) => [child.nativeSubagentId, child]));
+        for (const child of children)
+          merged.set(child.nativeSubagentId, child);
+        active.item = { ...active.item, subagents: [...merged.values()] };
+        this.emit({
+          type: "item.updated",
+          turnId: active.turnId,
+          itemId: active.item.itemId,
+          update: { type: "subagents.replace", subagents: active.item.subagents }
+        });
+      }
+      for (const child of observed) {
+        this.emit({
+          type: "subagent.state.changed",
+          nativeSubagentId: child.subagentId,
+          status: child.status
+        });
+        this.emit({ type: "subagent.transcript.changed", nativeSubagentId: child.subagentId });
+      }
+    }
+  }
+  project(toolName, result, itemId2, callId) {
+    const workflow = toolName === "subagent" ? piWorkflowSummary(result) : null;
+    if (workflow && (!callId || workflow.parentToolCallId === callId))
+      return projectPiWorkflow(workflow, itemId2);
+    const runId = asyncRunId(toolName, result);
+    if (!runId || !this.#children.has(runId))
+      return null;
+    const children = [...this.#children.get(runId)?.values() ?? []];
+    return children.length ? { type: "subagentDelegation", itemId: itemId2, operation: "spawn", subagents: children } : null;
+  }
+  start(turnId, toolName, result, itemId2, callId) {
+    const workflow = toolName === "subagent" ? piWorkflowSummary(result) : null;
+    if (workflow && (!callId || workflow.parentToolCallId === callId)) {
+      const key = `workflow:${workflow.workflowRunId}`;
+      const previous = this.#active.get(key);
+      const item2 = projectPiWorkflow(workflow, previous?.item.itemId ?? itemId2);
+      if (!item2)
+        return;
+      if (previous) {
+        const children = new Map(previous.item.subagents.map((child) => [child.nativeSubagentId, child]));
+        for (const child of item2.subagents)
+          children.set(child.nativeSubagentId, child);
+        item2.subagents = [...children.values()];
+        previous.item = item2;
+        this.emit({
+          type: "item.updated",
+          turnId: previous.turnId,
+          itemId: item2.itemId,
+          update: { type: "subagents.replace", subagents: item2.subagents }
+        });
+      } else {
+        this.#active.set(key, { turnId, item: item2 });
+        this.emit({ type: "item.started", turnId, item: item2 });
+      }
+      for (const child of item2.subagents) {
+        this.emit({
+          type: "subagent.state.changed",
+          nativeSubagentId: child.subagentId,
+          status: child.status
+        });
+        this.emit({ type: "subagent.transcript.changed", nativeSubagentId: child.subagentId });
+      }
+      return;
+    }
+    const runId = asyncRunId(toolName, result);
+    const item = this.project(toolName, result, itemId2);
+    if (!runId || this.#active.has(runId))
+      return;
+    if (!item) {
+      this.#waiting.set(runId, { turnId, itemId: itemId2 });
+      return;
+    }
+    this.#active.set(runId, { turnId, item });
+    this.emit({ type: "item.started", turnId, item });
+  }
+  finish(turnId) {
+    for (const [runId, waiting] of this.#waiting) {
+      if (waiting.turnId === turnId)
+        this.#waiting.delete(runId);
+    }
+    for (const [runId, active] of this.#active) {
+      if (active.turnId !== turnId)
+        continue;
+      this.#active.delete(runId);
+      this.emit({
+        type: "item.completed",
+        turnId,
+        snapshot: { item: active.item, outcome: { status: "succeeded" } }
+      });
+    }
+  }
+};
+function parsePiSubagentInspection(value) {
+  const parsed = widget(value, "subagent-inspect", INSPECT_PREFIX);
+  if (!parsed || parsed.kind !== "pi-subagents.inspect-reply" || !token(parsed.requestId))
+    return null;
+  if (parsed.error !== void 0 && (!record3(parsed.error) || typeof parsed.error.code !== "string" || typeof parsed.error.message !== "string"))
+    return null;
+  for (const field of ["asyncId", "childId", "status", "task", "finalOutput"]) {
+    if (parsed[field] !== void 0 && typeof parsed[field] !== "string")
+      return null;
+  }
+  if (parsed.messages !== void 0 && (!Array.isArray(parsed.messages) || parsed.messages.length > 200 || parsed.messages.some((entry) => !record3(entry) || typeof entry.role !== "string" || typeof entry.text !== "string" || !["text", "toolCall", "toolResult"].includes(String(entry.kind)) || entry.name !== void 0 && typeof entry.name !== "string")))
+    return null;
+  if (parsed.truncated !== void 0 && (!record3(parsed.truncated) || typeof parsed.truncated.task !== "boolean" || typeof parsed.truncated.finalOutput !== "boolean" || !Number.isSafeInteger(parsed.truncated.messages) || Number(parsed.truncated.messages) < 0))
+    return null;
+  return parsed;
+}
+function piSubagentSnapshot(parentSessionId, id, reply) {
+  const messages = reply.messages ?? [];
+  const texts = messages.map((entry) => entry.kind === "text" && entry.role === "assistant" ? entry.text : `[${entry.role}${entry.name ? `: ${entry.name}` : ""} / ${entry.kind}]
+${entry.text}`);
+  if (!texts.length && reply.finalOutput)
+    texts.push(reply.finalOutput);
+  if (reply.truncated && (reply.truncated.task || reply.truncated.messages || reply.truncated.finalOutput)) {
+    texts.push("[Pi subagent: native inspection returned a truncated transcript window.]");
+  }
+  return {
+    turns: [
+      {
+        nativeTurnRef: nativeTurnRefSchema.parse({
+          harnessId: "pi",
+          nativeSessionId: parentSessionId,
+          nativeTurnKey: `pi-subagent-${createHash("sha256").update(id).digest("hex")}`,
+          formatVersion: 1
+        }),
+        input: reply.task ? [{ type: "text", text: reply.task }] : [],
+        items: texts.map((text2, index) => ({
+          item: {
+            type: "agentMessage",
+            text: text2,
+            itemId: hostItemIdSchema.parse(`pi-subagent-${createHash("sha256").update(`${id}:${index}:${text2}`).digest("hex")}`)
+          },
+          outcome: { status: "succeeded" }
+        })),
+        outcome: reply.status === "complete" ? { status: "succeeded" } : reply.status === "stopped" ? { status: "cancelled", reason: "Pi subagent stopped" } : ["failed", "partial", "rejected"].includes(reply.status ?? "") ? {
+          status: "failed",
+          error: {
+            code: "nativeFailure",
+            message: `Pi subagent ${reply.status}`,
+            retryable: false
+          }
+        } : {
+          status: "unknown",
+          reason: `Pi subagent ${reply.status ?? "status unavailable"}`
+        }
+      }
+    ]
+  };
+}
+
+// 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) => {
@@ -15609,10 +16639,10 @@ function itemOutcome(outcome) {
   return { status: "succeeded" };
 }
 function toolOutput(value) {
-  const text = textContent(value);
-  return text.length > 0 ? { content: [{ type: "text", text }] } : void 0;
+  const text2 = textContent(value);
+  return text2.length > 0 ? { content: [{ type: "text", text: text2 }] } : void 0;
 }
-function snapshotItems(entries, outcome) {
+function snapshotItems(entries, outcome, subagents) {
   const snapshots = [];
   const toolCalls = /* @__PURE__ */ new Map();
   for (const entry of entries) {
@@ -15621,7 +16651,7 @@ function snapshotItems(entries, outcome) {
       continue;
     const content = Array.isArray(nativeMessage.content) ? nativeMessage.content : [];
     if (nativeMessage.role === "assistant") {
-      const text = textContent(content);
+      const text2 = textContent(content);
       const reasoning = thinkingContent(content);
       let projectedText = false;
       let projectedReasoning = false;
@@ -15638,11 +16668,11 @@ function snapshotItems(entries, outcome) {
           projectedReasoning = true;
           continue;
         }
-        if (part.type === "text" && !projectedText && text.length > 0) {
+        if (part.type === "text" && !projectedText && text2.length > 0) {
           const item2 = {
             type: "agentMessage",
             itemId: itemId(entry.id, "assistant", 0),
-            text
+            text: text2
           };
           snapshots.push({ item: item2, outcome: itemOutcome(outcome) });
           projectedText = true;
@@ -15678,6 +16708,7 @@ function snapshotItems(entries, outcome) {
       ...output ? { output } : {}
     };
     const toolFailed = nativeMessage.isError === true;
+    const delegation = subagents?.project(call.name, nativeMessage, itemId(call.entryId, "subagent", call.ordinal), nativeMessage.toolCallId);
     snapshots.push({
       item,
       outcome: toolFailed ? {
@@ -15689,16 +16720,18 @@ function snapshotItems(entries, outcome) {
         }
       } : { status: "succeeded" }
     });
+    if (delegation)
+      snapshots.push({ item: delegation, outcome: { status: "succeeded" } });
   }
   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) {
+function mapPiSnapshot(history, state2, subagents = new PiSubagents(() => void 0)) {
   const active = activePiEntries(history);
   const turns = [];
-  let effectiveModel = state.model;
+  let effectiveModel = state2.model;
   for (let index = 0; index < active.length; ) {
     const model = modelChange(active[index]);
     if (model) {
@@ -15719,13 +16752,13 @@ function mapPiSnapshot(history, state) {
     const userText = textContent(message(user)?.content);
     const nativeTurnRef = nativeTurnRefSchema.parse({
       harnessId: piHarnessId,
-      nativeSessionId: state.sessionId,
+      nativeSessionId: state2.sessionId,
       nativeTurnKey: user.id,
       formatVersion: 1
     });
     const checkpoint = nativeCheckpointRefSchema.parse({
       harnessId: piHarnessId,
-      nativeSessionId: state.sessionId,
+      nativeSessionId: state2.sessionId,
       checkpointId: user.id,
       formatVersion: 1
     });
@@ -15733,7 +16766,7 @@ function mapPiSnapshot(history, state) {
       nativeTurnRef,
       checkpoint,
       input: [{ type: "text", text: userText }],
-      items: snapshotItems(entries, outcome),
+      items: snapshotItems(entries, outcome, subagents),
       outcome,
       ...effectiveModel ? { model: encodePiModelRef(effectiveModel) } : {}
     });
@@ -15764,7 +16797,7 @@ function resolvePiForkBoundary(history, checkpointId) {
 }
 
 // dist/pi-session-file.js
-import { open, realpath } from "node:fs/promises";
+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 isRecord2(value) {
@@ -15808,8 +16841,8 @@ async function verifyPiSessionCwd(input) {
     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)
+    realpath2(header.cwd),
+    realpath2(input.expectedCwd)
   ]);
   if (actualCwd !== expectedCwd) {
     throw new Error("Pi Fork Session did not bind the requested cwd");
@@ -15818,9 +16851,9 @@ async function verifyPiSessionCwd(input) {
 
 // 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)
+  const { state: state2, history, sourceSessionFile, sourceSessionId, cwd } = input;
+  const destination = state2.sessionFile;
+  if (!destination || !path4.isAbsolute(destination) || path4.resolve(destination) === path4.resolve(sourceSessionFile) || state2.sessionId === sourceSessionId || mapPiSnapshot(history, { sessionId: state2.sessionId, model: null }).turns.length !== 0)
     throw new Error("Pi empty Session is not an independent empty native fork");
   await verifyPiSessionCwd({
     sessionFile: sourceSessionFile,
@@ -15839,12 +16872,12 @@ async function persistEmptyPiSession(input) {
   const header = {
     type: "session",
     version: 3,
-    id: state.sessionId,
+    id: state2.sessionId,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     cwd,
     parentSession: sourceSessionFile
   };
-  const temporary = path.join(path.dirname(destination), `.codexhost-${randomUUID()}.tmp`);
+  const temporary = path4.join(path4.dirname(destination), `.codexhost-${randomUUID2()}.tmp`);
   try {
     const file2 = await open2(temporary, "wx", 384);
     try {
@@ -15855,7 +16888,7 @@ async function persistEmptyPiSession(input) {
     }
     await link(temporary, destination);
     if (process.platform !== "win32") {
-      const directory = await open2(path.dirname(destination), "r");
+      const directory = await open2(path4.dirname(destination), "r");
       try {
         await directory.sync();
       } finally {
@@ -16018,16 +17051,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path7, added, removed, oldPosInc, options) {
-    const last = path7.lastComponent;
+  addToPath(path10, added, removed, oldPosInc, options) {
+    const last = path10.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path7.oldPos + oldPosInc,
+        oldPos: path10.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path7.oldPos + oldPosInc,
+        oldPos: path10.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -16393,788 +17426,729 @@ function formatPatch(patch) {
   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 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 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 (!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 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;
-  }
-  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);
-}
-
-// ../../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 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}'`);
-    }
-  }
-  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`);
-    }
-  }
-  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`);
-    }
-  }
-  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 ["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`);
+    if (hunk.oldLines === 0) {
+      hunk.oldStart -= 1;
     }
-  }
-  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 (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);
     }
   }
-  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");
+  return ret.join("\n") + "\n";
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  if (typeof options === "function") {
+    options = { callback: options };
   }
-  if (value.planFiveHourResetsAtUnix !== void 0 && value.planFiveHourUsedPercent === void 0) {
-    throw new Error("Harness Usage 'planFiveHourResetsAtUnix' must be provided with 'planFiveHourUsedPercent'");
+  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 (value.planSevenDayResetsAtUnix !== void 0 && value.planSevenDayUsedPercent === void 0) {
-    throw new Error("Harness Usage 'planSevenDayResetsAtUnix' must be provided with 'planSevenDayUsedPercent'");
+}
+function splitLines(text2) {
+  const hasTrailingNl = text2.endsWith("\n");
+  const result = text2.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
   }
-  return { ...value };
+  return result;
 }
 
-// dist/pi-last-turn-rollback.js
-function modelFromState(state) {
-  if (state.provider === null && state.modelId === null)
-    return null;
-  if (state.provider === null || state.modelId === null) {
-    throw new Error("Pi state contains a partial Model identity");
-  }
-  return { provider: state.provider, id: state.modelId };
+// dist/pi-adapter.js
+import { randomUUID as randomUUID5 } from "node:crypto";
+import path9 from "node:path";
+
+// ../../harness-adapter/dist/question.js
+function invalidRequest(message3) {
+  return { code: "invalidRequest", message: message3, retryable: false };
 }
-async function rollbackPiLastTurn(transport, sourceSessionId, cwd) {
-  const startupState = transport.state;
-  const startupSessionId = startupState.sessionId;
-  const currentModel = modelFromState(startupState);
-  const currentThinking = startupState.thinkingLevel;
-  const copiedHistory = await transport.getEntries();
-  const boundary = resolvePiLastTurnBoundary(copiedHistory);
-  if (!boundary)
-    return { ok: false, reason: "empty" };
-  const sourceSnapshot = mapPiSnapshot(copiedHistory, {
-    sessionId: startupSessionId,
-    model: currentModel
-  });
-  let state = await transport.fork(boundary.lastUserEntryId);
-  if (state.sessionId === sourceSessionId || state.sessionId === startupSessionId) {
-    throw new Error("Pi last-Turn rollback did not create a distinct Native Session");
-  }
-  if (!samePiModel(modelFromState(state), currentModel)) {
-    if (!currentModel)
-      throw new Error("Pi last-Turn rollback changed the current Model");
-    state = await transport.selectModel(currentModel);
-  }
-  if (state.thinkingLevel !== currentThinking) {
-    if (!currentThinking)
-      throw new Error("Pi last-Turn rollback changed current Thinking");
-    state = await transport.selectThinkingOption(currentThinking);
-  }
-  if (!samePiModel(modelFromState(state), currentModel) || state.thinkingLevel !== currentThinking) {
-    throw new Error("Pi last-Turn rollback could not restore current Model and Thinking");
+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");
   }
-  const snapshot = mapPiSnapshot(await transport.getEntries(), {
-    sessionId: state.sessionId,
-    model: modelFromState(state)
-  });
-  const expectedTurnKeys = sourceSnapshot.turns.slice(0, -1).map((turn) => turn.nativeTurnRef.nativeTurnKey);
-  const actualTurnKeys = snapshot.turns.map((turn) => turn.nativeTurnRef.nativeTurnKey);
-  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");
+  for (const answerId of Object.keys(response.answers)) {
+    if (!questionIds.has(answerId)) {
+      return invalidRequest("Question Response contains an unknown Question ID");
+    }
   }
-  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 };
+  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 (!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");
     }
-    throw error51;
   }
+  return null;
 }
 
-// dist/pi-session-import.js
-import { createReadStream as createReadStream2 } from "node:fs";
-import { opendir, realpath as realpath2, stat } from "node:fs/promises";
-import os from "node:os";
-import path2 from "node:path";
-import { createInterface as createInterface2 } from "node:readline";
-var PiSessionChangedError = class extends Error {
+// ../../harness-adapter/dist/output-channel.js
+var HarnessOutputChannel = class {
+  outputs;
+  #consumerCreated = false;
+  #ended = false;
+  #pending = [];
+  #values = [];
   constructor() {
-    super("Pi Session changed during discovery; refresh and retry");
+    this.outputs = {
+      [Symbol.asyncIterator]: () => {
+        if (this.#consumerCreated) {
+          throw new Error("Harness outputs allow only one consumer");
+        }
+        this.#consumerCreated = true;
+        return {
+          next: () => this.#next()
+        };
+      }
+    };
   }
-};
-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 isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function missing(error51) {
-  return isRecord4(error51) && error51.code === "ENOENT";
-}
-function expandDirectory(value, home) {
-  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();
-  const custom2 = environment.PI_CODING_AGENT_SESSION_DIR;
-  if (custom2)
-    return { directory: expandDirectory(custom2, home), flat: true };
-  const agent = environment.PI_CODING_AGENT_DIR;
-  return {
-    directory: path2.join(agent ? expandDirectory(agent, home) : path2.join(home, ".pi", "agent"), "sessions"),
-    flat: false
-  };
-}
-async function sessionFiles(directory, flat, signal) {
-  const files = [];
-  const visit = async (dir, projectLevel) => {
-    signal.throwIfAborted();
-    const entries = await opendir(dir).catch((error51) => {
-      if (missing(error51))
-        return null;
-      throw error51;
-    });
-    if (!entries)
+  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;
+  }
+  end() {
+    if (this.#ended)
       return;
-    for await (const entry of entries) {
-      signal.throwIfAborted();
-      if (projectLevel && entry.isDirectory())
-        await visit(path2.join(dir, entry.name), false);
-      else if (!projectLevel && entry.isFile() && entry.name.endsWith(".jsonl")) {
-        files.push(path2.join(dir, entry.name));
-      }
-    }
-  };
-  await visit(directory, !flat);
-  return files;
-}
-async function readCandidate(file2, signal) {
-  const before = await stat(file2);
-  if (!before.isFile() || before.size === 0)
-    return null;
-  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;
-  let hasUser = false;
-  let updatedAt = before.mtimeMs;
-  const entries = /* @__PURE__ */ new Map();
-  try {
-    for await (const line of lines) {
-      signal.throwIfAborted();
-      if (!line.trim())
-        continue;
-      let entry;
-      try {
-        entry = JSON.parse(line);
-      } catch {
-        return null;
-      }
-      if (!isRecord4(entry))
-        return null;
-      if (!header) {
-        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 = 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) => 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;
-      entries.set(entry.id, hasUser);
-      if (entry.type === "session_info")
-        name = typeof entry.name === "string" ? entry.name.trim() || null : null;
-      if (entry.type === "message" && (message3?.role === "user" || message3?.role === "assistant")) {
-        const time3 = typeof message3.timestamp === "number" ? message3.timestamp : typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : NaN;
-        if (Number.isFinite(time3))
-          updatedAt = time3;
-      }
-    }
-  } finally {
-    lines.close();
-    stream.destroy();
+    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));
   }
-  if (!header)
-    return null;
-  if (!hasUser)
-    return null;
-  const after = await stat(file2);
-  if (!sameFile(before, after))
-    throw new PiSessionChangedError();
-  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 realpath2(file2) },
-    formatVersion: 1
-  });
-  const candidate = harnessSessionImportCandidateSchema.safeParse({
-    nativeSessionId: header.id,
-    cwd,
-    title: name ?? firstMessage,
-    updatedAt: Math.floor(updatedAt),
-    running: null
-  });
-  return candidate.success && nativeRef.success ? { candidate: candidate.data, nativeRef: nativeRef.data } : null;
+};
+
+// ../../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);
 }
-async function readIdentity(file2, signal) {
-  const stream = createReadStream2(file2, { encoding: "utf8", signal });
-  const lines = createInterface2({ input: stream, crlfDelay: Infinity });
-  try {
-    for await (const line of lines) {
-      signal.throwIfAborted();
-      if (!line.trim())
-        continue;
-      let header;
-      try {
-        header = JSON.parse(line);
-      } catch {
-        return null;
-      }
-      return isRecord4(header) && header.type === "session" && header.version === 3 && typeof header.id === "string" ? header.id : 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 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}'`);
     }
-    return null;
-  } finally {
-    lines.close();
-    stream.destroy();
   }
-}
-var PiSessionImportIndex = class {
-  #location;
-  #cache = /* @__PURE__ */ new Map();
-  #listing;
-  constructor(environment) {
-    this.#location = piSessionImportDirectory(environment);
+  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`);
+    }
   }
-  list(signal) {
-    this.#listing ??= this.#scan(signal).finally(() => {
-      this.#listing = void 0;
-    });
-    return this.#listing;
+  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`);
+    }
   }
-  async #scan(signal) {
-    const { directory, flat } = this.#location;
-    const files = await sessionFiles(directory, flat, signal);
-    const next = /* @__PURE__ */ new Map();
-    const identities = /* @__PURE__ */ new Set();
-    const sources = [];
-    for (const file2 of files) {
-      signal.throwIfAborted();
-      try {
-        const fingerprint = await stat(file2);
-        const cached2 = this.#cache.get(file2);
-        const source = cached2 && sameFile(cached2.fingerprint, fingerprint) ? cached2.source : await readCandidate(file2, signal);
-        if (!source)
-          continue;
-        if (!(await stat(source.candidate.cwd)).isDirectory())
-          continue;
-        if (identities.has(source.nativeRef.nativeSessionId))
-          throw new Error("Pi Session identity is ambiguous across files");
-        identities.add(source.nativeRef.nativeSessionId);
-        next.set(file2, { fingerprint, source });
-        sources.push(source);
-      } catch (error51) {
-        if (!missing(error51) && !(error51 instanceof PiSessionChangedError))
-          throw error51;
-      }
+  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`);
     }
-    this.#cache = next;
-    return structuredClone(sources.sort((left, right) => right.candidate.updatedAt - left.candidate.updatedAt));
   }
-  async resolve(nativeSessionId, signal) {
-    const { directory, flat } = this.#location;
-    let selected;
-    for (const file2 of await sessionFiles(directory, flat, signal)) {
-      signal.throwIfAborted();
-      try {
-        const fingerprint = await stat(file2);
-        const cached2 = this.#cache.get(file2);
-        const id = cached2 && sameFile(cached2.fingerprint, fingerprint) ? cached2.source.nativeRef.nativeSessionId : await readIdentity(file2, signal);
-        if (id !== nativeSessionId)
-          continue;
-        if (selected)
-          throw new Error("Pi Session identity is ambiguous across files");
-        selected = file2;
-      } catch (error51) {
-        if (!missing(error51))
-          throw error51;
-      }
+  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 ["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`);
     }
-    if (!selected)
-      return null;
-    try {
-      const source = await readCandidate(selected, signal);
-      return source?.nativeRef.nativeSessionId === nativeSessionId ? source : null;
-    } catch (error51) {
-      if (missing(error51))
-        return null;
-      throw error51;
+  }
+  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-rpc-session.js
-import { spawn, spawnSync } from "node:child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
+// dist/pi-workflow-child-history.js
+import { createHash as createHash2 } from "node:crypto";
+import { constants } from "node:fs";
+import { open as open3 } from "node:fs/promises";
 import path5 from "node:path";
-
-// ../../harness-discovery/dist/environment.js
-import fs from "node:fs";
-import path3 from "node:path";
-function targetPath(platform) {
-  return platform === "win32" ? path3.win32 : path3.posix;
+function record4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function environmentValue(environment, name) {
-  const lowered = name.toLowerCase();
-  for (const [key, value] of Object.entries(environment)) {
-    if (key.toLowerCase() === lowered)
-      return value;
+var MAX_SESSION_BYTES = 8 * 1024 * 1024;
+async function childHistory(file2, parentSessionId, identity) {
+  if (!path5.isAbsolute(file2))
+    throw new Error("Pi child Session path is not absolute");
+  const handle = await open3(file2, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+  try {
+    const stat2 = await handle.stat();
+    if (!stat2.isFile() || stat2.size > MAX_SESSION_BYTES)
+      throw new Error("Pi child Session exceeds read bounds");
+    const buffer = Buffer.alloc(MAX_SESSION_BYTES + 1);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    if (bytesRead > MAX_SESSION_BYTES)
+      throw new Error("Pi child Session exceeds read bounds");
+    const values = buffer.subarray(0, bytesRead).toString("utf8").split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+    const header = values[0];
+    if (!record4(header) || header.type !== "session" || typeof header.id !== "string" || header.version !== 3)
+      throw new Error("Unsupported Pi child Session header");
+    const entries = [];
+    for (const entry of values.slice(1)) {
+      const parsed = jsonValueSchema.safeParse(entry);
+      if (!parsed.success || !record4(parsed.data) || typeof parsed.data.id !== "string")
+        throw new Error("Malformed Pi child Session entry");
+      entries.push(parsed.data);
+    }
+    const history = { entries, leafId: String(entries.at(-1)?.id ?? "") || null };
+    const snapshot = mapPiSnapshot(history, { sessionId: parentSessionId, model: null });
+    const prefix = createHash2("sha256").update(identity).digest("hex");
+    return {
+      turns: snapshot.turns.map((turn) => {
+        const readonlyTurn = {
+          ...turn,
+          nativeTurnRef: {
+            ...turn.nativeTurnRef,
+            nativeTurnKey: `${prefix}:${turn.nativeTurnRef.nativeTurnKey}`
+          }
+        };
+        delete readonlyTurn.checkpoint;
+        return readonlyTurn;
+      })
+    };
+  } finally {
+    await handle.close();
   }
-  return void 0;
 }
-function pathDelimiter(platform) {
-  return platform === "win32" ? ";" : ":";
+async function readPiWorkflowChild(history, parentSessionId, address) {
+  for (const entry of activePiEntries(history).reverse()) {
+    const message3 = entry.message;
+    if (!record4(message3) || message3.role !== "toolResult" || message3.toolName !== "subagent")
+      continue;
+    const summary = piWorkflowSummary(message3);
+    if (!summary || summary.workflowRunId !== address.workflowRunId || summary.parentToolCallId !== message3.toolCallId)
+      continue;
+    const child = summary.children.find((candidate) => candidate.childId === address.childId);
+    if (!child)
+      break;
+    const details = message3.details;
+    if (!record4(details) || !Array.isArray(details.results))
+      break;
+    const result = details.results.findLast((candidate) => record4(candidate) && candidate.workflowKey === address.childId);
+    if (!record4(result))
+      break;
+    const id = piWorkflowSubagentId(address);
+    if (typeof result.sessionFile === "string") {
+      try {
+        const snapshot = await childHistory(result.sessionFile, parentSessionId, id);
+        if (snapshot.turns.length)
+          return { ok: true, value: snapshot };
+      } catch {
+      }
+    }
+    if (typeof result.finalOutput === "string" && result.finalOutput.length > 0) {
+      const output = result.finalOutput.slice(0, 64 * 1024);
+      return {
+        ok: true,
+        value: piSubagentSnapshot(parentSessionId, id, {
+          kind: "pi-subagents.inspect-reply",
+          version: 1,
+          requestId: "native-workflow-result",
+          status: child.state === "completed" ? "complete" : child.state === "failed" ? "failed" : child.state === "interrupted" ? "paused" : "running",
+          ...typeof result.task === "string" ? { task: result.task.slice(0, 4096) } : {},
+          finalOutput: `[Pi subagent: saved native result; Session transcript unavailable.]
+${output}`,
+          truncated: {
+            task: typeof result.task === "string" && result.task.length > 4096,
+            messages: 0,
+            finalOutput: output.length < result.finalOutput.length
+          }
+        })
+      };
+    }
+    break;
+  }
+  return {
+    ok: false,
+    error: {
+      code: "sessionNotFound",
+      message: "Pi workflow child has no published transcript/result in this parent's active history",
+      retryable: true
+    }
+  };
 }
-function pathDirectories(environment, platform) {
-  return (environmentValue(environment, "PATH") ?? "").split(pathDelimiter(platform)).map((directory) => directory.trim().replace(/^"|"$/gu, "")).filter(Boolean);
+
+// dist/pi-subagent-history.js
+import { constants as constants2 } from "node:fs";
+import { open as open4 } from "node:fs/promises";
+import path6 from "node:path";
+function record5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function executableExtensions(command, platform, environment) {
-  if (platform !== "win32")
-    return [""];
-  if (targetPath(platform).extname(command) !== "")
-    return [""];
-  return (environmentValue(environment, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").map((extension) => extension.trim()).filter(Boolean);
+function state(value) {
+  return value === "pending" ? "queued" : value === "completed" ? "complete" : value;
 }
-function isExecutableFile(filePath, platform) {
-  try {
-    fs.accessSync(filePath, platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
-    return fs.statSync(filePath).isFile();
-  } catch {
-    return false;
+function piSubagentArtifact(value, runId, parentSessionId) {
+  if (!record5(value) || value.lifecycleArtifactVersion !== 3 || value.runId !== runId || value.sessionId !== parentSessionId || !["single", "parallel", "chain", "workflow"].includes(String(value.mode)))
+    return null;
+  if (value.steps !== void 0 && (!Array.isArray(value.steps) || value.steps.length > 128))
+    return null;
+  const steps = Array.isArray(value.steps) ? value.steps : [];
+  const children = [];
+  for (const [index, step] of steps.entries()) {
+    if (!record5(step) || typeof step.agent !== "string")
+      return null;
+    children.push({
+      id: step.workflowKey ?? step.runId ?? `step:${index}`,
+      kind: "step",
+      label: step.label ?? step.agent,
+      state: state(step.status)
+    });
   }
+  return parsePiSubagentStatus({
+    type: "extension_ui_request",
+    method: "setWidget",
+    widgetKey: "subagent-async",
+    widgetLines: [
+      "PI_SUBAGENT_ASYNC_JSON:" + JSON.stringify({
+        kind: "pi-subagents.async-status-snapshot",
+        version: 1,
+        runs: [
+          {
+            id: runId,
+            kind: value.mode === "single" ? "subagent" : "workflow",
+            label: "Pi subagent",
+            state: value.state,
+            children
+          }
+        ]
+      })
+    ]
+  });
 }
-function subdirectoryNames(directory) {
-  try {
-    return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  } catch {
-    return [];
+async function restorePiSubagents(history, parentSessionId, observer) {
+  const receipts = /* @__PURE__ */ new Map();
+  for (const entry of activePiEntries(history)) {
+    if (!record5(entry.message) || entry.message.role !== "toolResult" || entry.message.toolName !== "subagent" || entry.message.isError !== false || !record5(entry.message.details))
+      continue;
+    const details = entry.message.details;
+    if (!["single", "parallel", "chain", "workflow"].includes(String(details.mode)) || typeof details.asyncId !== "string" || typeof details.asyncDir !== "string" || !path6.isAbsolute(details.asyncDir) || path6.basename(details.asyncDir) !== details.asyncId)
+      continue;
+    receipts.set(details.asyncId, details.asyncDir);
+  }
+  for (const [id, directory] of [...receipts].slice(-128)) {
+    let file2;
+    try {
+      file2 = await open4(path6.join(directory, "status.json"), constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
+      const stat2 = await file2.stat();
+      if (!stat2.isFile() || stat2.size > 1024 * 1024)
+        continue;
+      const buffer = Buffer.alloc(1024 * 1024 + 1);
+      const { bytesRead } = await file2.read(buffer, 0, buffer.length, 0);
+      if (bytesRead > 1024 * 1024)
+        continue;
+      const value = JSON.parse(buffer.subarray(0, bytesRead).toString("utf8"));
+      const runs = piSubagentArtifact(value, id, parentSessionId);
+      if (runs)
+        observer.restore(runs);
+    } catch {
+    } finally {
+      await file2?.close();
+    }
   }
-}
-function newestFirst(names) {
-  return [...names].sort((left, right) => right.localeCompare(left, void 0, { numeric: true }));
 }
 
-// ../../harness-discovery/dist/node-runtime.js
-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 = 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))) {
-    directories.unshift(runtimeDirectory);
+// dist/pi-last-turn-rollback.js
+function modelFromState(state2) {
+  if (state2.provider === null && state2.modelId === null)
+    return null;
+  if (state2.provider === null || state2.modelId === null) {
+    throw new Error("Pi state contains a partial Model identity");
   }
-  return { ...environment, [pathKey]: directories.join(delimiter) };
+  return { provider: state2.provider, id: state2.modelId };
 }
-
-// ../../harness-discovery/dist/resolve.js
-import os2 from "node:os";
-
-// ../../harness-discovery/dist/version-managers.js
-function versionManagerBinaryDirectories(context) {
-  const { platform, environment, home } = context;
-  const list = context.subdirectories ?? subdirectoryNames;
-  const pathFlavor = targetPath(platform);
-  const value = (name) => environmentValue(environment, name);
-  const directories = [];
-  const versioned = (root, ...tail) => {
-    for (const version2 of newestFirst(list(root))) {
-      directories.push(pathFlavor.join(root, version2, ...tail));
-    }
-  };
-  if (platform === "win32") {
-    const appData = value("APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming");
-    const localAppData = value("LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local");
-    versioned(pathFlavor.join(appData, "nvm"));
-    versioned(value("FNM_DIR") ?? pathFlavor.join(appData, "fnm", "node-versions"), "installation");
-    directories.push(pathFlavor.join(localAppData, "Volta", "bin"));
-    directories.push(pathFlavor.join(home, ".bun", "bin"));
-    const pnpmHome2 = value("PNPM_HOME");
-    if (pnpmHome2)
-      directories.push(pnpmHome2);
-    directories.push(pathFlavor.join(localAppData, "pnpm"));
-    return directories;
+async function rollbackPiLastTurn(transport, sourceSessionId, cwd) {
+  const startupState = transport.state;
+  const startupSessionId = startupState.sessionId;
+  const currentModel = modelFromState(startupState);
+  const currentThinking = startupState.thinkingLevel;
+  const copiedHistory = await transport.getEntries();
+  const boundary = resolvePiLastTurnBoundary(copiedHistory);
+  if (!boundary)
+    return { ok: false, reason: "empty" };
+  const sourceSnapshot = mapPiSnapshot(copiedHistory, {
+    sessionId: startupSessionId,
+    model: currentModel
+  });
+  let state2 = await transport.fork(boundary.lastUserEntryId);
+  if (state2.sessionId === sourceSessionId || state2.sessionId === startupSessionId) {
+    throw new Error("Pi last-Turn rollback did not create a distinct Native Session");
   }
-  versioned(pathFlavor.join(value("NVM_DIR") ?? pathFlavor.join(home, ".nvm"), "versions", "node"), "bin");
-  const fnmRoots = [
-    value("FNM_DIR"),
-    pathFlavor.join(home, ".local", "share", "fnm"),
-    pathFlavor.join(home, "Library", "Application Support", "fnm")
-  ].filter((root) => root !== void 0);
-  for (const root of fnmRoots) {
-    versioned(pathFlavor.join(root, "node-versions"), "installation", "bin");
+  if (!samePiModel(modelFromState(state2), currentModel)) {
+    if (!currentModel)
+      throw new Error("Pi last-Turn rollback changed the current Model");
+    state2 = await transport.selectModel(currentModel);
   }
-  const voltaHome = value("VOLTA_HOME") ?? pathFlavor.join(home, ".volta");
-  versioned(pathFlavor.join(voltaHome, "tools", "image", "node"), "bin");
-  directories.push(pathFlavor.join(voltaHome, "bin"));
-  const asdfHome = value("ASDF_DATA_DIR") ?? pathFlavor.join(home, ".asdf");
-  versioned(pathFlavor.join(asdfHome, "installs", "nodejs"), "bin");
-  directories.push(pathFlavor.join(asdfHome, "shims"));
-  const nodenvHome = value("NODENV_ROOT") ?? pathFlavor.join(home, ".nodenv");
-  versioned(pathFlavor.join(nodenvHome, "versions"), "bin");
-  directories.push(pathFlavor.join(nodenvHome, "shims"));
-  versioned(pathFlavor.join(value("N_PREFIX") ?? "/usr/local", "n", "versions", "node"), "bin");
-  directories.push(pathFlavor.join(home, ".bun", "bin"));
-  const pnpmHome = value("PNPM_HOME");
-  if (pnpmHome)
-    directories.push(pnpmHome);
-  directories.push(pathFlavor.join(home, "Library", "pnpm"));
-  directories.push(pathFlavor.join(home, ".local", "share", "pnpm"));
-  for (const prefix of ["/opt/homebrew/opt", "/usr/local/opt"]) {
-    for (const formula of newestFirst(list(prefix).filter((name) => name.startsWith("node@")))) {
-      directories.push(pathFlavor.join(prefix, formula, "bin"));
+  if (state2.thinkingLevel !== currentThinking) {
+    if (!currentThinking)
+      throw new Error("Pi last-Turn rollback changed current Thinking");
+    state2 = await transport.selectThinkingOption(currentThinking);
+  }
+  if (!samePiModel(modelFromState(state2), currentModel) || state2.thinkingLevel !== currentThinking) {
+    throw new Error("Pi last-Turn rollback could not restore current Model and Thinking");
+  }
+  const snapshot = mapPiSnapshot(await transport.getEntries(), {
+    sessionId: state2.sessionId,
+    model: modelFromState(state2)
+  });
+  const expectedTurnKeys = sourceSnapshot.turns.slice(0, -1).map((turn) => turn.nativeTurnRef.nativeTurnKey);
+  const actualTurnKeys = snapshot.turns.map((turn) => turn.nativeTurnRef.nativeTurnKey);
+  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");
+  }
+  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;
   }
-  return directories;
 }
 
-// ../../harness-discovery/dist/resolve.js
-var VERSION_MANAGER_ROOTS = "<version-managers>";
-function installRootExtensions(platform) {
-  return platform === "win32" ? [".exe", ".cmd"] : [""];
+// dist/pi-session-import.js
+import { createReadStream as createReadStream2 } from "node:fs";
+import { opendir, realpath as realpath3, stat } from "node:fs/promises";
+import os3 from "node:os";
+import path7 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");
+  }
+};
+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 resolveHomeDirectory(input) {
-  return input.homeDirectory ?? environmentValue(input.environment, "HOME") ?? environmentValue(input.environment, "USERPROFILE") ?? os2.homedir();
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function templateVariables(environment, platform, home) {
-  const pathFlavor = targetPath(platform);
+function missing(error51) {
+  return isRecord4(error51) && error51.code === "ENOENT";
+}
+function expandDirectory(value, home) {
+  return path7.resolve(value === "~" ? home : value.startsWith(`~${path7.sep}`) || value.startsWith("~/") ? path7.join(home, value.slice(2)) : value);
+}
+function piSessionImportDirectory(environment) {
+  const home = (process.platform === "win32" ? environment.USERPROFILE : environment.HOME) || os3.homedir();
+  const custom2 = environment.PI_CODING_AGENT_SESSION_DIR;
+  if (custom2)
+    return { directory: expandDirectory(custom2, home), flat: true };
+  const agent = environment.PI_CODING_AGENT_DIR;
   return {
-    HOME: home,
-    USERPROFILE: home,
-    APPDATA: environmentValue(environment, "APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming"),
-    LOCALAPPDATA: environmentValue(environment, "LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local")
+    directory: path7.join(agent ? expandDirectory(agent, home) : path7.join(home, ".pi", "agent"), "sessions"),
+    flat: false
   };
 }
-function joinTemplate(platform, value) {
-  const pathFlavor = targetPath(platform);
-  const segments = value.split("/");
-  const head = segments[0] ?? "";
-  const tail = segments.slice(1);
-  if (head === "")
-    return pathFlavor.join(pathFlavor.sep, ...tail);
-  return tail.length === 0 ? head : pathFlavor.join(head, ...tail);
+async function sessionFiles(directory, flat, signal) {
+  const files = [];
+  const visit = async (dir, projectLevel) => {
+    signal.throwIfAborted();
+    const entries = await opendir(dir).catch((error51) => {
+      if (missing(error51))
+        return null;
+      throw error51;
+    });
+    if (!entries)
+      return;
+    for await (const entry of entries) {
+      signal.throwIfAborted();
+      if (projectLevel && entry.isDirectory())
+        await visit(path7.join(dir, entry.name), false);
+      else if (!projectLevel && entry.isFile() && entry.name.endsWith(".jsonl")) {
+        files.push(path7.join(dir, entry.name));
+      }
+    }
+  };
+  await visit(directory, !flat);
+  return files;
 }
-function expandInstallRoot(template, environment, platform, home) {
-  const variables = templateVariables(environment, platform, home);
-  let unresolved = false;
-  const substituted = template.replace(/^~(?=\/|$)/u, home).replace(/\$\{(\w+)\}/gu, (_match, name) => {
-    const value = variables[name] ?? environmentValue(environment, name);
-    if (value === void 0 || value === "") {
-      unresolved = true;
-      return "";
+async function readCandidate(file2, signal) {
+  const before = await stat(file2);
+  if (!before.isFile() || before.size === 0)
+    return null;
+  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;
+  let hasUser = false;
+  let updatedAt = before.mtimeMs;
+  const entries = /* @__PURE__ */ new Map();
+  try {
+    for await (const line of lines) {
+      signal.throwIfAborted();
+      if (!line.trim())
+        continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        return null;
+      }
+      if (!isRecord4(entry))
+        return null;
+      if (!header) {
+        if (entry.type !== "session" || entry.version !== 3 || typeof entry.id !== "string" || typeof entry.cwd !== "string" || !path7.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 = isRecord4(entry.message) ? entry.message : null;
+      if (!firstMessage && entry.type === "message" && message3?.role === "user") {
+        const content = message3.content;
+        const text2 = 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 = text2.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;
+      entries.set(entry.id, hasUser);
+      if (entry.type === "session_info")
+        name = typeof entry.name === "string" ? entry.name.trim() || null : null;
+      if (entry.type === "message" && (message3?.role === "user" || message3?.role === "assistant")) {
+        const time3 = typeof message3.timestamp === "number" ? message3.timestamp : typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : NaN;
+        if (Number.isFinite(time3))
+          updatedAt = time3;
+      }
     }
-    return value;
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+  if (!header)
+    return null;
+  if (!hasUser)
+    return null;
+  const after = await stat(file2);
+  if (!sameFile(before, after))
+    throw new PiSessionChangedError();
+  const cwd = await realpath3(String(header.cwd));
+  if (!(await stat(cwd)).isDirectory())
+    return null;
+  const nativeRef = nativeSessionRefSchema.safeParse({
+    harnessId: "pi",
+    nativeSessionId: header.id,
+    locator: { sessionFile: await realpath3(file2) },
+    formatVersion: 1
   });
-  return unresolved ? void 0 : joinTemplate(platform, substituted);
+  const candidate = harnessSessionImportCandidateSchema.safeParse({
+    nativeSessionId: header.id,
+    cwd,
+    title: name ?? firstMessage,
+    updatedAt: Math.floor(updatedAt),
+    running: null
+  });
+  return candidate.success && nativeRef.success ? { candidate: candidate.data, nativeRef: nativeRef.data } : null;
 }
-function installRootDirectories(spec, input, dependencies, platform, home) {
-  const templates = (platform === "win32" ? spec.installRoots?.windows : spec.installRoots?.posix) ?? [];
-  const directories = [];
-  for (const template of templates) {
-    if (template === VERSION_MANAGER_ROOTS) {
-      directories.push(...versionManagerBinaryDirectories({
-        platform,
-        environment: input.environment,
-        home,
-        ...dependencies.subdirectories ? { subdirectories: dependencies.subdirectories } : {}
-      }));
-      continue;
+async function readIdentity(file2, signal) {
+  const stream = createReadStream2(file2, { encoding: "utf8", signal });
+  const lines = createInterface2({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of lines) {
+      signal.throwIfAborted();
+      if (!line.trim())
+        continue;
+      let header;
+      try {
+        header = JSON.parse(line);
+      } catch {
+        return null;
+      }
+      return isRecord4(header) && header.type === "session" && header.version === 3 && typeof header.id === "string" ? header.id : null;
     }
-    const directory = expandInstallRoot(template, input.environment, platform, home);
-    if (directory !== void 0)
-      directories.push(directory);
+    return null;
+  } finally {
+    lines.close();
+    stream.destroy();
   }
-  return directories;
 }
-function harnessCandidates(spec, input, dependencies = {}) {
-  const platform = input.platform ?? process.platform;
-  const pathFlavor = targetPath(platform);
-  const configured = input.command ?? (spec.commandEnvironmentVariable ? environmentValue(input.environment, spec.commandEnvironmentVariable) : void 0);
-  const command = configured ?? spec.command;
-  if (pathFlavor.isAbsolute(command) || command.includes("/") || command.includes("\\")) {
-    return [{ candidate: command, source: "configured" }];
+var PiSessionImportIndex = class {
+  #location;
+  #cache = /* @__PURE__ */ new Map();
+  #listing;
+  constructor(environment) {
+    this.#location = piSessionImportDirectory(environment);
   }
-  const candidates = [];
-  const extensions = executableExtensions(command, platform, input.environment);
-  for (const directory of pathDirectories(input.environment, platform)) {
-    for (const extension of extensions) {
-      candidates.push({
-        candidate: pathFlavor.join(directory, command + extension),
-        source: "path"
-      });
-    }
+  list(signal) {
+    this.#listing ??= this.#scan(signal).finally(() => {
+      this.#listing = void 0;
+    });
+    return this.#listing;
   }
-  if (configured !== void 0)
-    return candidates;
-  const home = resolveHomeDirectory(input);
-  for (const directory of installRootDirectories(spec, input, dependencies, platform, home)) {
-    for (const extension of installRootExtensions(platform)) {
-      candidates.push({
-        candidate: pathFlavor.join(directory, spec.command + extension),
-        source: "install-root"
-      });
+  async #scan(signal) {
+    const { directory, flat } = this.#location;
+    const files = await sessionFiles(directory, flat, signal);
+    const next = /* @__PURE__ */ new Map();
+    const identities = /* @__PURE__ */ new Set();
+    const sources = [];
+    for (const file2 of files) {
+      signal.throwIfAborted();
+      try {
+        const fingerprint = await stat(file2);
+        const cached2 = this.#cache.get(file2);
+        const source = cached2 && sameFile(cached2.fingerprint, fingerprint) ? cached2.source : await readCandidate(file2, signal);
+        if (!source)
+          continue;
+        if (!(await stat(source.candidate.cwd)).isDirectory())
+          continue;
+        if (identities.has(source.nativeRef.nativeSessionId))
+          throw new Error("Pi Session identity is ambiguous across files");
+        identities.add(source.nativeRef.nativeSessionId);
+        next.set(file2, { fingerprint, source });
+        sources.push(source);
+      } catch (error51) {
+        if (!missing(error51) && !(error51 instanceof PiSessionChangedError))
+          throw error51;
+      }
     }
+    this.#cache = next;
+    return structuredClone(sources.sort((left, right) => right.candidate.updatedAt - left.candidate.updatedAt));
   }
-  return candidates;
-}
-function resolveHarnessExecutable(spec, input, dependencies = {}) {
-  const platform = input.platform ?? process.platform;
-  const isExecutable = dependencies.isExecutable ?? ((candidate) => isExecutableFile(candidate, platform));
-  const runnable = spec.runnableCandidate ?? ((candidate) => candidate);
-  const context = { platform, isExecutable };
-  for (const { candidate, source } of harnessCandidates(spec, input, dependencies)) {
-    const executable = runnable(candidate, context);
-    if (executable !== void 0 && isExecutable(executable))
-      return { executable, source };
-  }
-  return void 0;
-}
-
-// dist/command.js
-var piDiscoverySpec = {
-  id: "pi",
-  command: "pi",
-  commandEnvironmentVariable: "PI_COMMAND",
-  installRoots: {
-    posix: [
-      "~/.npm-global/bin",
-      "~/.local/bin",
-      VERSION_MANAGER_ROOTS,
-      "/opt/homebrew/bin",
-      "/usr/local/bin"
-    ],
-    windows: ["${APPDATA}/npm", "~/.local/bin", VERSION_MANAGER_ROOTS]
+  async resolve(nativeSessionId, signal) {
+    const { directory, flat } = this.#location;
+    let selected;
+    for (const file2 of await sessionFiles(directory, flat, signal)) {
+      signal.throwIfAborted();
+      try {
+        const fingerprint = await stat(file2);
+        const cached2 = this.#cache.get(file2);
+        const id = cached2 && sameFile(cached2.fingerprint, fingerprint) ? cached2.source.nativeRef.nativeSessionId : await readIdentity(file2, signal);
+        if (id !== nativeSessionId)
+          continue;
+        if (selected)
+          throw new Error("Pi Session identity is ambiguous across files");
+        selected = file2;
+      } catch (error51) {
+        if (!missing(error51))
+          throw error51;
+      }
+    }
+    if (!selected)
+      return null;
+    try {
+      const source = await readCandidate(selected, signal);
+      return source?.nativeRef.nativeSessionId === nativeSessionId ? source : null;
+    } catch (error51) {
+      if (missing(error51))
+        return null;
+      throw error51;
+    }
   }
 };
-function resolvePiExecutable(input, dependencies = {}) {
-  const resolution = resolveHarnessExecutable(piDiscoverySpec, {
-    ...input.command ? { command: input.command } : {},
-    environment: input.environment,
-    ...dependencies.platform ? { platform: dependencies.platform } : {},
-    ...dependencies.homeDirectory ? { homeDirectory: dependencies.homeDirectory } : {}
-  }, { ...dependencies.isExecutable ? { isExecutable: dependencies.isExecutable } : {} });
-  return resolution?.executable ?? input.command ?? input.environment.PI_COMMAND ?? "pi";
-}
+
+// dist/pi-rpc-session.js
+import { spawn, spawnSync } from "node:child_process";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import path8 from "node:path";
 
 // dist/pi-usage.js
 function isRecord5(value) {
@@ -17247,6 +18221,82 @@ function optionalPiStateContextUsage(value) {
   }
 }
 
+// dist/pi-subagent-rpc.js
+import { randomUUID as randomUUID3 } from "node:crypto";
+var PiSubagentRpc = class {
+  send;
+  timeoutMs;
+  #handler;
+  #latest;
+  #pending = /* @__PURE__ */ new Map();
+  constructor(send, timeoutMs) {
+    this.send = send;
+    this.timeoutMs = timeoutMs;
+  }
+  setHandler(handler) {
+    this.#handler = handler;
+    if (this.#latest)
+      handler(this.#latest);
+  }
+  handle(value) {
+    if (value.type !== "extension_ui_request" || value.method !== "setWidget" || value.widgetKey !== "subagent-async" && value.widgetKey !== "subagent-inspect")
+      return false;
+    const status = parsePiSubagentStatus(value);
+    if (status) {
+      this.#latest = status;
+      this.#handler?.(status);
+    }
+    const reply = parsePiSubagentInspection(value);
+    if (reply) {
+      const pending = this.#pending.get(reply.requestId);
+      if (pending) {
+        this.#pending.delete(reply.requestId);
+        clearTimeout(pending.timer);
+        pending.resolve(reply);
+      }
+    }
+    return true;
+  }
+  async inspect(nativeSubagentId) {
+    const address = parsePiSubagentId(nativeSubagentId);
+    const commands = await this.send("get_commands", {});
+    const data = commands.data;
+    if (!Array.isArray(data?.commands) || !data.commands.some((command) => command?.name === "subagents-inspect-rpc" && command.source === "extension")) {
+      throw new Error("Installed Pi has no pi-subagents Host inspection command");
+    }
+    const requestId = randomUUID3();
+    const reply = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.#pending.delete(requestId);
+        reject(new Error("Pi subagent inspection timed out"));
+      }, this.timeoutMs);
+      this.#pending.set(requestId, { resolve, reject, timer });
+    });
+    try {
+      const message3 = `/subagents-inspect-rpc ${requestId} ${address.runId}${address.childId ? ` ${address.childId}` : ""} --lines 200`;
+      const [, result] = await Promise.all([this.send("prompt", { message: message3 }), reply]);
+      if (!result.error && (result.asyncId !== address.runId && result.asyncId !== address.childId || result.childId !== address.childId)) {
+        throw new Error("Pi subagent inspection identity does not match the request");
+      }
+      return result;
+    } finally {
+      const pending = this.#pending.get(requestId);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.#pending.delete(requestId);
+      }
+    }
+  }
+  close(error51 = new Error("Pi subagent inspection transport closed")) {
+    for (const pending of this.#pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error51);
+    }
+    this.#pending.clear();
+    this.#handler = void 0;
+  }
+};
+
 // dist/pi-rpc-session.js
 var PiRpcFaultError = class extends Error {
   kind;
@@ -17378,15 +18428,15 @@ function extractReasoningText(content) {
     return null;
   const type = String(content.type ?? "");
   if (type === "thinking" || type === "reasoning" || type === "thought") {
-    const text = content.thinking ?? content.reasoning ?? content.text ?? content.delta;
-    return typeof text === "string" ? text : null;
+    const text2 = content.thinking ?? content.reasoning ?? content.text ?? content.delta;
+    return typeof text2 === "string" ? text2 : null;
   }
   return null;
 }
 function assistantReasoning(value) {
   if (!isRecord6(value) || value.role !== "assistant" || !Array.isArray(value.content))
     return null;
-  return value.content.map(extractReasoningText).filter((text) => typeof text === "string").join("");
+  return value.content.map(extractReasoningText).filter((text2) => typeof text2 === "string").join("");
 }
 function assistantFailure(value) {
   if (!isRecord6(value) || value.role !== "assistant")
@@ -17451,7 +18501,7 @@ function piRpcProcessCommand(options, dependencies = {}) {
     ...thinkingArguments,
     ...sessionArguments
   ];
-  const extension = path5.win32.extname(command).toLowerCase();
+  const extension = path8.win32.extname(command).toLowerCase();
   if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
     return { command, arguments: arguments_, windowsVerbatimArguments: false };
   }
@@ -17493,6 +18543,7 @@ var PiRpcSession = class {
   #latestCacheHitRatePercent;
   #manualCompaction = null;
   #stderrTail = "";
+  #subagents;
   constructor(options, processAdapter = nodeProcessAdapter) {
     if (options.sessionFile && options.forkSessionFile) {
       throw new Error("Pi RPC cannot combine Session resume and Fork startup");
@@ -17507,6 +18558,7 @@ var PiRpcSession = class {
       ...options
     };
     this.#processAdapter = processAdapter;
+    this.#subagents = new PiSubagentRpc((type, payload) => this.#send(type, payload), this.#options.commandTimeoutMs);
   }
   get state() {
     if (!this.#state)
@@ -17516,6 +18568,12 @@ var PiRpcSession = class {
   get stderrTail() {
     return this.#stderrTail;
   }
+  setSubagentStatusHandler(handler) {
+    this.#subagents.setHandler(handler);
+  }
+  inspectSubagent(id) {
+    return this.#subagents.inspect(id);
+  }
   setAutonomousTurnHandler(handler) {
     this.#autonomousTurnHandler = handler;
   }
@@ -17685,13 +18743,13 @@ var PiRpcSession = class {
       throw fault;
     }
   }
-  async runTurn(text, onEvent) {
+  async runTurn(text2, onEvent) {
     if (!this.#child || !this.#state || this.#closed || this.#failed) {
       throw new Error("Pi RPC Session is unavailable");
     }
     if (this.#activeTurn)
       throw new Error("Pi RPC Session already has an active Turn");
-    if (text.length === 0)
+    if (text2.length === 0)
       throw new Error("Pi text Turn must not be empty");
     const settled = new Promise((resolve, reject) => {
       this.#activeTurn = {
@@ -17720,7 +18778,7 @@ var PiRpcSession = class {
       };
     });
     try {
-      await this.#send("prompt", { message: text });
+      await this.#send("prompt", { message: text2 });
     } catch (error51) {
       this.#rejectActiveTurn(error51 instanceof Error ? error51 : new Error(message2(error51)));
     }
@@ -17840,6 +18898,8 @@ var PiRpcSession = class {
       this.#handleResponse(value);
       return;
     }
+    if (this.#subagents.handle(value))
+      return;
     if (value.type === "compaction_start") {
       this.#compactionActive = true;
       this.#compactionTurn = this.#activeTurn;
@@ -17954,7 +19014,7 @@ var PiRpcSession = class {
     const active = {
       origin: "autonomous",
       autonomousEvents: events,
-      nativeTurnKey: assistantMessageId(value) ?? randomUUID2(),
+      nativeTurnKey: assistantMessageId(value) ?? randomUUID4(),
       nativeCancellationObserved: false,
       text: "",
       assistantMessageId: null,
@@ -18156,13 +19216,13 @@ var PiRpcSession = class {
   async #confirmSettledTurn(active) {
     try {
       const response = await this.#send("get_state", {});
-      const state = parseSessionState(response);
+      const state2 = parseSessionState(response);
       if (parseSessionStreaming(response)) {
         throw new PiRpcFaultError("protocolError", "Pi RPC agent_settled state is still Streaming");
       }
       if (this.#activeTurn !== active)
         return;
-      this.#state = state;
+      this.#state = state2;
       active.settlement = "confirmed";
       this.#finishSettledTurn(active);
     } catch (error51) {
@@ -18217,7 +19277,7 @@ var PiRpcSession = class {
     if (active.assistantMessageId !== null && active.reasoningMessageOpen) {
       active.onEvent({ type: "reasoning.completed", messageId: active.assistantMessageId });
     }
-    const messageId = assistantMessageId(value) ?? randomUUID2();
+    const messageId = assistantMessageId(value) ?? randomUUID4();
     active.assistantMessageId = messageId;
     active.sawStreamedMessageText = false;
     active.sawStreamedMessageReasoning = false;
@@ -18278,7 +19338,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-${randomUUID2()}`;
+    const id = `codexhost-${randomUUID4()}`;
     return new Promise((resolve, reject) => {
       const pending = {
         command: type,
@@ -18364,6 +19424,7 @@ var PiRpcSession = class {
     }
   }
   #rejectAll(error51) {
+    this.#subagents.close(error51);
     for (const pending of this.#pending.values()) {
       if (pending.timeout)
         clearTimeout(pending.timeout);
@@ -18442,38 +19503,38 @@ function normalizedError(error51, fallbackCode) {
 function invalidState(message3) {
   return { code: "invalidState", message: message3, retryable: false };
 }
-function nativeModelFromState(state) {
-  if (state.provider === null && state.modelId === null)
+function nativeModelFromState(state2) {
+  if (state2.provider === null && state2.modelId === null)
     return null;
-  if (state.provider === null || state.modelId === null) {
+  if (state2.provider === null || state2.modelId === null) {
     throw new PiRpcFaultError("protocolError", "Pi state contains a partial Model identity");
   }
-  return { provider: state.provider, id: state.modelId };
+  return { provider: state2.provider, id: state2.modelId };
 }
-function effectiveModelFromState(state) {
-  const model = nativeModelFromState(state);
+function effectiveModelFromState(state2) {
+  const model = nativeModelFromState(state2);
   return model ? encodePiModelRef(model) : void 0;
 }
-function harnessStateFromPi(state, thinkingLevels) {
-  const effectiveModel = effectiveModelFromState(state);
+function harnessStateFromPi(state2, thinkingLevels) {
+  const effectiveModel = effectiveModelFromState(state2);
   const availableThinkingOptions = thinkingLevels ? normalizePiThinkingOptions(thinkingLevels) : void 0;
-  if (availableThinkingOptions && (!state.thinkingLevel || !thinkingLevels?.includes(state.thinkingLevel))) {
+  if (availableThinkingOptions && (!state2.thinkingLevel || !thinkingLevels?.includes(state2.thinkingLevel))) {
     throw new PiRpcFaultError("protocolError", "Pi effective Thinking level is absent from its available levels");
   }
   return {
     nativeRef: nativeSessionRefSchema.parse({
       harnessId: piHarnessId2,
-      nativeSessionId: state.sessionId,
-      ...state.sessionFile ? { locator: { sessionFile: state.sessionFile } } : {},
+      nativeSessionId: state2.sessionId,
+      ...state2.sessionFile ? { locator: { sessionFile: state2.sessionFile } } : {},
       formatVersion: 1
     }),
     ...effectiveModel ? { effectiveModel } : {},
-    ...state.thinkingLevel ? { effectiveThinkingOptionId: state.thinkingLevel } : {},
+    ...state2.thinkingLevel ? { effectiveThinkingOptionId: state2.thinkingLevel } : {},
     ...availableThinkingOptions ? { availableThinkingOptions } : {}
   };
 }
-function nativeModelForHistory(state) {
-  return nativeModelFromState(state);
+function nativeModelForHistory(state2) {
+  return nativeModelFromState(state2);
 }
 function sessionFileFromRef(ref) {
   if (ref.harnessId !== piHarnessId2 || !isRecord7(ref.locator) || typeof ref.locator.sessionFile !== "string" || ref.locator.sessionFile.length === 0) {
@@ -18493,20 +19554,20 @@ function nativeText(value) {
     return value;
   if (!isRecord7(value) || !Array.isArray(value.content))
     return "";
-  return value.content.filter((content) => isRecord7(content) && content.type === "text" && typeof content.text === "string").map(({ text }) => text).join("");
+  return value.content.filter((content) => isRecord7(content) && content.type === "text" && typeof content.text === "string").map(({ text: text2 }) => text2).join("");
 }
 function boundedOutput(value, limit) {
-  const text = nativeText(value);
-  if (text.length === 0)
+  const text2 = nativeText(value);
+  if (text2.length === 0)
     return void 0;
-  const truncated = text.length > limit;
+  const truncated = text2.length > limit;
   return {
-    content: [{ type: "text", text: truncated ? text.slice(0, limit) : text }],
+    content: [{ type: "text", text: truncated ? text2.slice(0, limit) : text2 }],
     ...truncated ? { truncated: true } : {}
   };
 }
 function outputText(output) {
-  return output?.content.filter((content) => content.type === "text").map(({ text }) => text).join("") ?? "";
+  return output?.content.filter((content) => content.type === "text").map(({ text: text2 }) => text2).join("") ?? "";
 }
 function stringField(value, key) {
   if (!isRecord7(value))
@@ -18538,10 +19599,10 @@ function stripDiffPrefix(pathString) {
   return pathString.startsWith("a/") || pathString.startsWith("b/") ? pathString.slice(2) : pathString;
 }
 function displayPath(nativePath, cwd) {
-  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 resolvedCwd = path9.resolve(cwd);
+  const resolvedPath = path9.isAbsolute(nativePath) ? path9.resolve(nativePath) : path9.resolve(cwd, nativePath);
+  const relative = path9.relative(resolvedCwd, resolvedPath);
+  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path9.sep}`);
   const selected = inside ? relative : resolvedPath;
   const normalized = selected.replaceAll("\\", "/");
   if (normalized.length === 0 || normalized === ".")
@@ -18731,6 +19792,8 @@ var PiHarnessSession = class {
   initialUsage;
   outputs;
   #channel = new HarnessOutputChannel();
+  #subagents = new PiSubagents((event) => this.#event(event));
+  #pendingSubagentStatus = null;
   #closeTimeoutMs;
   #createTransport;
   #cwd;
@@ -18766,7 +19829,8 @@ var PiHarnessSession = class {
         permissionModeScope: "live"
       },
       history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: true },
-      autonomousTurns: { observe: true }
+      autonomousTurns: { observe: true },
+      subagents: { observe: true, readTranscript: true }
     };
     this.commands = {
       list: async () => ({ ok: true, value: piCommandCatalog }),
@@ -18781,6 +19845,24 @@ var PiHarnessSession = class {
     if (this.#transport)
       this.#bindAutonomousTurnHandler(this.#transport);
   }
+  ownsNativeSession(id) {
+    return this.#transport?.state.sessionId === id;
+  }
+  async readSubagentHistory(cwd) {
+    if (this.#phase !== "open" || path9.resolve(cwd) !== path9.resolve(this.#cwd)) {
+      throw new Error("Pi Subagent parent workspace or Session is unavailable");
+    }
+    return (await this.#ensureTransport()).getEntries();
+  }
+  async inspectSubagent(id, cwd) {
+    if (this.#phase !== "open" || path9.resolve(cwd) !== path9.resolve(this.#cwd)) {
+      throw new Error("Pi Subagent parent workspace or Session is unavailable");
+    }
+    const transport = await this.#ensureTransport();
+    if (!transport.inspectSubagent)
+      throw new Error("Pi transport does not support Subagent inspection");
+    return transport.inspectSubagent(id);
+  }
   handleTransportFault(error51) {
     queueMicrotask(() => this.#fault(error51));
   }
@@ -18801,13 +19883,14 @@ var PiHarnessSession = class {
     try {
       const transport = await this.#ensureTransport();
       const history = await transport.getEntries();
+      await restorePiSubagents(history, transport.state.sessionId, this.#subagents);
       return {
         ok: true,
         value: {
           ...mapPiSnapshot(history, {
             sessionId: transport.state.sessionId,
             model: nativeModelForHistory(transport.state)
-          }),
+          }, this.#subagents),
           state: this.#state
         }
       };
@@ -18850,8 +19933,8 @@ var PiHarnessSession = class {
         }
       };
     }
-    const text = command.input.filter((input) => input.type === "text").map((input) => input.text).join("\n");
-    if (text.length === 0) {
+    const text2 = command.input.filter((input) => input.type === "text").map((input) => input.text).join("\n");
+    if (text2.length === 0) {
       return {
         ok: false,
         error: {
@@ -18908,7 +19991,7 @@ var PiHarnessSession = class {
       this.#active = active;
       this.#event({ type: "turn.started", turnId: command.turnId });
       this.#event({ type: "item.started", turnId: command.turnId, item });
-      void transport.runTurn(text, (event) => this.#handleTurnEvent(active, event)).then(async (result) => {
+      void transport.runTurn(text2, (event) => this.#handleTurnEvent(active, event)).then(async (result) => {
         try {
           const identity = await this.#completedTurnIdentity(active, transport);
           this.#completeTurn(active, result.cancelled ? {
@@ -19027,19 +20110,19 @@ var PiHarnessSession = class {
     const previousModel = this.#state.effectiveModel;
     this.#configuring = true;
     try {
-      let state;
+      let state2;
       let thinkingLevels;
       try {
-        state = await transport.selectModel(requested);
+        state2 = await transport.selectModel(requested);
         thinkingLevels = await transport.getAvailableThinkingLevels();
-        this.#publishTransportState(state, thinkingLevels);
+        this.#publishTransportState(state2, thinkingLevels);
       } catch (error51) {
         if (error51 instanceof PiRpcFaultError)
           this.#fault(error51);
         return { ok: false, error: normalizedError(error51, "nativeFailure") };
       }
-      const actual = nativeModelFromState(state);
-      const nextModel = effectiveModelFromState(state);
+      const actual = nativeModelFromState(state2);
+      const nextModel = effectiveModelFromState(state2);
       if (previousModel?.id !== nextModel?.id) {
         this.#invalidateUsage();
         void this.#refreshUsage();
@@ -19101,10 +20184,10 @@ var PiHarnessSession = class {
     const thinkingOptionId = parsedThinkingOptionId.data;
     this.#configuring = true;
     try {
-      let state;
+      let state2;
       let thinkingLevels;
       try {
-        state = await transport.selectThinkingOption(thinkingOptionId);
+        state2 = await transport.selectThinkingOption(thinkingOptionId);
         thinkingLevels = await transport.getAvailableThinkingLevels();
       } catch (error51) {
         if (error51 instanceof PiRpcFaultError)
@@ -19122,7 +20205,7 @@ var PiHarnessSession = class {
         };
       }
       try {
-        this.#publishTransportState(state, thinkingLevels);
+        this.#publishTransportState(state2, thinkingLevels);
       } catch (error51) {
         if (error51 instanceof PiRpcFaultError)
           this.#fault(error51);
@@ -19279,16 +20362,16 @@ var PiHarnessSession = class {
     const starting = transport.start().then(async () => {
       if (this.#phase !== "open")
         throw new Error("Pi Session closed during startup");
-      let state = transport.state;
+      let state2 = transport.state;
       let thinkingLevels = await transport.getAvailableThinkingLevels();
       if (this.#requestedModel) {
         const requested = decodePiModelRef(this.#requestedModel);
-        const current = nativeModelFromState(state);
+        const current = nativeModelFromState(state2);
         if (!samePiModel(current, requested))
-          state = await transport.selectModel(requested);
+          state2 = await transport.selectModel(requested);
         thinkingLevels = await transport.getAvailableThinkingLevels();
-        if (!samePiModel(nativeModelFromState(state), requested)) {
-          this.#publishTransportState(state, thinkingLevels);
+        if (!samePiModel(nativeModelFromState(state2), requested)) {
+          this.#publishTransportState(state2, thinkingLevels);
           throw new Error("Pi did not activate the requested create Model");
         }
       }
@@ -19300,11 +20383,11 @@ var PiHarnessSession = class {
             retryable: false
           });
         }
-        state = await transport.selectThinkingOption(this.#requestedThinkingOptionId);
+        state2 = await transport.selectThinkingOption(this.#requestedThinkingOptionId);
         thinkingLevels = await transport.getAvailableThinkingLevels();
       }
       this.#transport = transport;
-      this.#publishTransportState(state, thinkingLevels);
+      this.#publishTransportState(state2, thinkingLevels);
       this.#drainPendingAutonomousTurns(transport);
       return transport;
     }).catch(async (error51) => {
@@ -19321,6 +20404,14 @@ var PiHarnessSession = class {
     return starting;
   }
   #bindAutonomousTurnHandler(transport) {
+    transport.setSubagentStatusHandler?.((runs) => {
+      if (this.#phase !== "open")
+        return;
+      if (this.#transport !== transport)
+        this.#pendingSubagentStatus = runs;
+      else
+        this.#subagents.observe(runs);
+    });
     transport.setAutonomousTurnHandler((turn) => {
       if (this.#phase !== "open")
         return;
@@ -19332,6 +20423,10 @@ var PiHarnessSession = class {
     });
   }
   #drainPendingAutonomousTurns(transport) {
+    if (this.#pendingSubagentStatus) {
+      this.#subagents.observe(this.#pendingSubagentStatus);
+      this.#pendingSubagentStatus = null;
+    }
     const pending = this.#pendingAutonomousTurns.filter((candidate) => candidate.transport === transport);
     this.#pendingAutonomousTurns = this.#pendingAutonomousTurns.filter((candidate) => candidate.transport !== transport);
     for (const candidate of pending) {
@@ -19359,7 +20454,7 @@ var PiHarnessSession = class {
       }));
       return;
     }
-    const turnId = hostTurnIdSchema.parse(randomUUID3());
+    const turnId = hostTurnIdSchema.parse(randomUUID5());
     let resolveCompletion = () => void 0;
     const completion = new Promise((resolve) => {
       resolveCompletion = resolve;
@@ -19412,8 +20507,8 @@ var PiHarnessSession = class {
       this.#fault(new PiAdapterFaultError(normalized));
     }
   }
-  #publishTransportState(state, thinkingLevels) {
-    this.#state = harnessStateFromPi(state, thinkingLevels);
+  #publishTransportState(state2, thinkingLevels) {
+    this.#state = harnessStateFromPi(state2, thinkingLevels);
     this.#event({ type: "session.state.changed", state: this.#state });
   }
   #invalidateUsage() {
@@ -19521,7 +20616,7 @@ var PiHarnessSession = class {
     if (active.interactionByNativeId.has(request.requestId)) {
       throw new Error("Pi Interaction started more than once");
     }
-    const interactionId = hostInteractionIdSchema.parse(randomUUID3());
+    const interactionId = hostInteractionIdSchema.parse(randomUUID5());
     const question = request.method === "select" ? {
       id: "answer",
       type: "choice",
@@ -19600,16 +20695,16 @@ var PiHarnessSession = class {
     active.agentMessageId = messageId;
     active.sawAssistantMessage = true;
   }
-  #appendText(active, text) {
+  #appendText(active, text2) {
     if (active.agentMessageId === null || !active.agentItem) {
       throw new Error("Pi Assistant text arrived outside an active message");
     }
-    active.agentItem = { ...active.agentItem, text: active.agentItem.text + text };
+    active.agentItem = { ...active.agentItem, text: active.agentItem.text + text2 };
     this.#event({
       type: "item.updated",
       turnId: active.command.turnId,
       itemId: active.agentItem.itemId,
-      update: { type: "text.append", text }
+      update: { type: "text.append", text: text2 }
     });
   }
   #completeAgentItem(active, outcome, completeEmpty) {
@@ -19620,8 +20715,8 @@ var PiHarnessSession = class {
     active.agentItem = null;
     this.#completeItem(active, item, outcome);
   }
-  #appendReasoning(active, text) {
-    if (text.length === 0)
+  #appendReasoning(active, text2) {
+    if (text2.length === 0)
       return;
     if (!active.reasoningItem) {
       active.reasoningItem = {
@@ -19637,13 +20732,13 @@ var PiHarnessSession = class {
     }
     active.reasoningItem = {
       ...active.reasoningItem,
-      text: active.reasoningItem.text + text
+      text: active.reasoningItem.text + text2
     };
     this.#event({
       type: "item.updated",
       turnId: active.command.turnId,
       itemId: active.reasoningItem.itemId,
-      update: { type: "text.append", text }
+      update: { type: "text.append", text: text2 }
     });
   }
   #completeReasoning(active, outcome) {
@@ -19680,6 +20775,7 @@ var PiHarnessSession = class {
     const tool = active.tools.get(event.callId);
     if (!tool)
       throw new Error("Pi Tool update references an unknown Tool Call");
+    this.#subagents.start(active.command.turnId, tool.nativeName, event.output, this.#newItemId(), event.callId);
     const output = boundedOutput(event.output, this.#toolOutputLimit);
     if (!output)
       return;
@@ -19736,6 +20832,7 @@ var PiHarnessSession = class {
     }
     const outcome = active.cancellationRequested ? { status: "cancelled", reason: "Cancelled by user" } : event.isError ? { status: "failed", error: toolFailure(event.toolName) } : { status: "succeeded" };
     this.#completeItem(active, tool.item, outcome);
+    this.#subagents.start(active.command.turnId, event.toolName, event.result, this.#newItemId(), event.callId);
     if (!event.isError) {
       try {
         const kind = fileMutatingKind(event.toolName);
@@ -19805,6 +20902,7 @@ var PiHarnessSession = class {
     for (const tool of active.tools.values())
       this.#completeItem(active, tool.item, itemOutcome2);
     active.tools.clear();
+    this.#subagents.finish(active.command.turnId);
     if (!active.sawAssistantMessage && finalText !== void 0 && active.agentItem) {
       active.agentItem = { ...active.agentItem, text: finalText };
     }
@@ -19865,12 +20963,66 @@ var PiHarnessSession = class {
     this.#channel.emit({ kind: "event", event });
   }
   #newItemId() {
-    return hostItemIdSchema.parse(randomUUID3());
+    return hostItemIdSchema.parse(randomUUID5());
   }
 };
 var PiAdapter = class {
+  credentialImports;
   commandCatalog = piCommandCatalog;
   harnessId = piHarnessId2;
+  subagents = {
+    readSnapshot: async ({ parent, nativeSubagentId, cwd }) => {
+      let transport;
+      try {
+        if (this.#closePromise || parent.harnessId !== this.harnessId) {
+          return { ok: false, error: invalidState("Pi Subagent parent is unavailable") };
+        }
+        const workflow = parsePiWorkflowSubagentId(nativeSubagentId);
+        if (!workflow)
+          parsePiSubagentId(nativeSubagentId);
+        const live = [...this.#sessions].find((session) => session.ownsNativeSession(parent.nativeSessionId));
+        let reply;
+        if (live) {
+          if (workflow)
+            return await readPiWorkflowChild(await live.readSubagentHistory(cwd), parent.nativeSessionId, workflow);
+          reply = await live.inspectSubagent(nativeSubagentId, cwd);
+        } else {
+          const sessionFile = sessionFileFromRef(parent);
+          transport = this.#createTransport({ cwd, sessionFile });
+          this.#inspections.add(transport);
+          await transport.start();
+          if (transport.state.sessionId !== parent.nativeSessionId)
+            throw new Error("Pi Subagent parent identity mismatch");
+          await transport.verifySessionCwd(cwd);
+          if (workflow)
+            return await readPiWorkflowChild(await transport.getEntries(), parent.nativeSessionId, workflow);
+          if (!transport.inspectSubagent)
+            throw new Error("Pi transport does not support Subagent inspection");
+          reply = await transport.inspectSubagent(nativeSubagentId);
+        }
+        if (reply.error)
+          return {
+            ok: false,
+            error: {
+              code: reply.error.code === "foreign_session" ? "invalidRequest" : ["not_found", "stale"].includes(reply.error.code) ? "sessionNotFound" : "unavailable",
+              message: reply.error.message,
+              retryable: false
+            }
+          };
+        return {
+          ok: true,
+          value: piSubagentSnapshot(parent.nativeSessionId, nativeSubagentId, reply)
+        };
+      } catch (error51) {
+        return { ok: false, error: normalizedError(error51, "unavailable") };
+      } finally {
+        if (transport) {
+          this.#inspections.delete(transport);
+          await transport.close();
+        }
+      }
+    }
+  };
   sessionImport = Object.freeze({
     listCandidates: async () => {
       const result = await this.#readImport((signal) => this.#importIndex.list(signal));
@@ -19906,6 +21058,19 @@ var PiAdapter = class {
   constructor(options = {}, dependencies = {
     createTransport: (sessionOptions) => new PiRpcSession({ ...options, ...sessionOptions })
   }) {
+    const imports = createPiCredentialImports(options);
+    const updateCatalog = async (operation) => {
+      await operation;
+      this.#inspectionCache.clear();
+    };
+    this.credentialImports = {
+      providers: imports.providers,
+      list: () => imports.list(),
+      listOthers: () => imports.listOthers?.() ?? Promise.resolve([]),
+      add: (name, credential) => updateCatalog(imports.add(name, credential)),
+      reimport: (name, credential) => updateCatalog(imports.reimport(name, credential)),
+      remove: (name) => updateCatalog(imports.remove(name))
+    };
     this.#createTransport = dependencies.createTransport;
     this.#importIndex = new PiSessionImportIndex({ ...process.env, ...options.environment });
     this.#closeTimeoutMs = options.closeTimeoutMs ?? 2e3;
@@ -19983,7 +21148,8 @@ var PiAdapter = class {
             permissionModeScope: "live"
           },
           history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: true },
-          autonomousTurns: { observe: true }
+          autonomousTurns: { observe: true },
+          subagents: { observe: true, readTranscript: true }
         }
       };
     } catch (error51) {
@@ -20137,40 +21303,40 @@ var PiAdapter = class {
           });
         }
         if (rolledBack.unpersisted) {
-          const state = transport.state;
+          const state2 = transport.state;
           const history = await transport.getEntries();
           await transport.close();
           await persistEmptyPiSession({
-            state,
+            state: state2,
             history,
             sourceSessionFile,
             sourceSessionId: sourceRef.nativeSessionId,
             cwd: input.cwd
           });
-          if (!state.sessionFile)
+          if (!state2.sessionFile)
             throw new Error("Pi empty fork has no Session file");
-          const configuration = await readPiEmptySessionConfiguration(state.sessionFile);
+          const configuration = await readPiEmptySessionConfiguration(state2.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,
+            sessionFile: state2.sessionFile,
             emptySessionConfiguration: configuration,
             onFault: (error51) => session?.handleTransportFault(error51)
           });
           await transport.start();
-          if (transport.state.sessionId !== state.sessionId) {
+          if (transport.state.sessionId !== state2.sessionId) {
             throw new Error("Pi empty fork resumed with a different identity");
           }
-          const model = nativeModelFromState(state);
+          const model = nativeModelFromState(state2);
           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 (state2.thinkingLevel && transport.state.thinkingLevel !== state2.thinkingLevel) {
+            await transport.selectThinkingOption(state2.thinkingLevel);
           }
-          if (!samePiModel(nativeModelFromState(transport.state), model) || transport.state.thinkingLevel !== state.thinkingLevel) {
+          if (!samePiModel(nativeModelFromState(transport.state), model) || transport.state.thinkingLevel !== state2.thinkingLevel) {
             throw new Error("Pi empty fork could not restore its configuration");
           }
           await transport.verifySessionCwd(input.cwd);