@codexhost/cli-win32-arm64 0.16.0 → 0.17.0

package/app/plugins/pi/plugin.mjs

@@ -528,9 +528,9 @@ async function jsonlHeader(file2, match, signal, maxLines = 4) {
         continue;
       }
       if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        const record7 = value;
-        if (match(record7))
-          return record7;
+        const record9 = value;
+        if (match(record9))
+          return record9;
       }
     }
     return null;
@@ -1317,10 +1317,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path16) {
-  if (!path16)
+function getElementAtPath(obj, path17) {
+  if (!path17)
     return obj;
-  return path16.reduce((acc, key) => acc?.[key], obj);
+  return path17.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1729,11 +1729,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path16, issues) {
+function prefixIssues(path17, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path16);
+    iss.path.unshift(path17);
     return iss;
   });
 }
@@ -1880,16 +1880,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path16 = []) => {
+  const processError = (error52, path17 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path17, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
       } else {
-        const fullpath = [...path16, ...issue2.path];
+        const fullpath = [...path17, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1916,17 +1916,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path16 = []) => {
+  const processError = (error52, path17 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path17, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
       } else {
-        const fullpath = [...path16, ...issue2.path];
+        const fullpath = [...path17, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1958,8 +1958,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path16 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path16) {
+  const path17 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path17) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -8189,8 +8189,8 @@ function ko_default() {
 }
 
 // ../../../node_modules/zod/v4/locales/lt.js
-var capitalizeFirstCharacter = (text2) => {
-  return text2.charAt(0).toUpperCase() + text2.slice(1);
+var capitalizeFirstCharacter = (text3) => {
+  return text3.charAt(0).toUpperCase() + text3.slice(1);
 };
 function getUnitTypeFromNumber(number4) {
   const abs = Math.abs(number4);
@@ -14651,13 +14651,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path16 = ref.slice(1).split("/").filter(Boolean);
-  if (path16.length === 0) {
+  const path17 = ref.slice(1).split("/").filter(Boolean);
+  if (path17.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path16[0] === defsKey) {
-    const key = path16[1];
+  if (path17[0] === defsKey) {
+    const key = path17[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15146,7 +15146,7 @@ var harnessDisplaySetSchema = external_exports.strictObject({
 
 // ../../shared-contracts/dist/harness-presentation.js
 var localeSchema = external_exports.string().max(64).regex(/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/u);
-var displayText = (maximum) => external_exports.string().min(1).max(maximum).refine((text2) => text2.trim().length > 0);
+var displayText = (maximum) => external_exports.string().min(1).max(maximum).refine((text3) => text3.trim().length > 0);
 var harnessLocalizationsSchema = external_exports.record(localeSchema, external_exports.object({
   label: displayText(256).optional(),
   description: displayText(1024).optional()
@@ -15474,7 +15474,7 @@ var threadManualCompactionStartedSchema = external_exports.strictObject({
 var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
 var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
 var cacheHitRatePercentSchema = external_exports.number().finite().min(0).max(100);
-var indicatorTextSchema = (maximum) => harnessLocalizedTextSchema.refine((entries) => Object.values(entries).every((text2) => text2.length <= maximum));
+var indicatorTextSchema = (maximum) => harnessLocalizedTextSchema.refine((entries) => Object.values(entries).every((text3) => text3.length <= maximum));
 var composerIndicatorsSchema = external_exports.array(external_exports.object({
   kind: external_exports.literal("countdown"),
   id: external_exports.string().min(1).max(64),
@@ -16111,7 +16111,10 @@ var harnessPluginRouteSchema = external_exports.object({
   harnessId: harnessPluginIdSchema,
   model: harnessModelRefSchema.optional(),
   thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
-  permissionModeId: harnessPermissionModeIdSchema.optional()
+  permissionModeId: harnessPermissionModeIdSchema.optional(),
+  /** A draft prewarm create: stays unsubmitted until the user's first Turn.
+   * Desktop forwards only the Model of a main-process prewarm to thread/start. */
+  prewarm: external_exports.literal(true).optional()
 }).strict();
 
 // ../../shared-contracts/dist/harness-launch-settings.js
@@ -16716,8 +16719,8 @@ async function readCandidate(file2, signal) {
       const message3 = isRecord(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) => isRecord(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text).join(" ") : "";
-        firstMessage = sessionImportTitle(text2);
+        const text3 = typeof content === "string" ? content : Array.isArray(content) ? content.filter((block) => isRecord(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text).join(" ") : "";
+        firstMessage = sessionImportTitle(text3);
       }
       hasUser = entry.type === "message" && message3?.role === "user" || typeof entry.parentId === "string" && entries.get(entry.parentId) === true;
       entries.set(entry.id, hasUser);
@@ -17230,8 +17233,8 @@ function liveHarnessCommandPrompt(catalog, idPrefix, commandId, argumentText) {
   const descriptor = catalog.commands.find(({ id }) => id === commandId);
   if (!descriptor)
     return null;
-  const text2 = typeof argumentText === "string" ? argumentText.trim() : "";
-  return text2 ? `${descriptor.invocation} ${text2}` : descriptor.invocation;
+  const text3 = typeof argumentText === "string" ? argumentText.trim() : "";
+  return text3 ? `${descriptor.invocation} ${text3}` : descriptor.invocation;
 }
 function mergeLiveHarnessCommands(builtIns, idPrefix, live, exclusions = {}) {
   if (!live)
@@ -17367,16 +17370,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path16, added, removed, oldPosInc, options) {
-    const last = path16.lastComponent;
+  addToPath(path17, added, removed, oldPosInc, options) {
+    const last = path17.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path16.oldPos + oldPosInc,
+        oldPos: path17.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path16.oldPos + oldPosInc,
+        oldPos: path17.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -17776,9 +17779,9 @@ function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader
     } }));
   }
 }
-function splitLines(text2) {
-  const hasTrailingNl = text2.endsWith("\n");
-  const result = text2.split("\n").map((line) => line + "\n");
+function splitLines(text3) {
+  const hasTrailingNl = text3.endsWith("\n");
+  const result = text3.split("\n").map((line) => line + "\n");
   if (hasTrailingNl) {
     result.pop();
   } else {
@@ -18012,11 +18015,344 @@ function piNestedCallFileChanges(nestedCalls, cwd) {
   return projected;
 }
 
-// dist/pi-subagents.js
+// dist/pi-message-item-id.js
 import { createHash } from "node:crypto";
+function piMessageIdentity(sessionId, message3, timestampCounts) {
+  if (typeof message3 !== "object" || message3 === null || !("role" in message3) || message3.role !== "assistant")
+    return void 0;
+  if ("timestamp" in message3 && typeof message3.timestamp === "number" && Number.isSafeInteger(message3.timestamp) && message3.timestamp >= 0) {
+    const occurrence = timestampCounts.get(message3.timestamp) ?? 0;
+    timestampCounts.set(message3.timestamp, occurrence + 1);
+    return { sessionId, timestamp: message3.timestamp, occurrence };
+  }
+  if ("responseId" in message3 && typeof message3.responseId === "string" && message3.responseId.trim().length > 0)
+    return { responseId: message3.responseId };
+  return void 0;
+}
+function piHistoryMessageIdentities(sessionId, entries) {
+  const timestampCounts = /* @__PURE__ */ new Map();
+  const identities = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const identity = piMessageIdentity(sessionId, entry.message, timestampCounts);
+    if (identity)
+      identities.set(entry.id, identity);
+  }
+  return { identities, timestampCounts };
+}
+function piMessageItemId(identity, kind) {
+  if (!identity)
+    return null;
+  const timestampIdentity = "timestamp" in identity;
+  const value = timestampIdentity ? JSON.stringify([identity.sessionId, identity.timestamp, identity.occurrence]) : identity.responseId;
+  const digest = createHash("sha256").update(value).digest("hex");
+  return hostItemIdSchema.parse(`pi-${timestampIdentity ? "message" : "response"}-v1-${digest}-${kind}`);
+}
+
+// dist/pi-assistant-outcome.js
+function piAssistantWasAborted(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const message3 = value;
+  return message3.role === "assistant" && (message3.stopReason === "aborted" || message3.stopReason === "error" && message3.errorMessage === "This operation was aborted");
+}
+function piAssistantPhase(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return void 0;
+  const message3 = value;
+  if (message3.role !== "assistant")
+    return void 0;
+  const lastText = Array.isArray(message3.content) ? message3.content.findLast((part) => typeof part === "object" && part !== null && !Array.isArray(part) && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string" && part.text.trim().length > 0) : void 0;
+  if (!lastText && !(typeof message3.content === "string" && message3.content.trim()))
+    return void 0;
+  if (typeof lastText?.textSignature === "string") {
+    try {
+      const signature = JSON.parse(lastText.textSignature);
+      if (typeof signature === "object" && signature !== null && !Array.isArray(signature) && "v" in signature && signature.v === 1 && "id" in signature && typeof signature.id === "string" && "phase" in signature && (signature.phase === "commentary" || signature.phase === "final_answer"))
+        return signature.phase;
+    } catch {
+    }
+  }
+  if (message3.stopReason === "toolUse")
+    return "commentary";
+  if (message3.stopReason === "stop")
+    return "final_answer";
+  return void 0;
+}
+
+// dist/pi-subagents.js
+import { createHash as createHash3 } from "node:crypto";
+
+// dist/pi-gotgenes-extension.js
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import path7 from "node:path";
+var GOTGENES_WIDGET = "codexhost-gotgenes-subagents";
+var GOTGENES_PREFIX = "CODEXHOST_GOTGENES_SUBAGENTS_V1:";
+var GOTGENES_EXTENSION = `export default function(pi) {
+  let ctx, timer, service, previous = "";
+  const publish = () => {
+    if (!ctx) return;
+    // Child SDK sessions can publish their own process-global service. Bind this parent once.
+    if (!service) {
+      const candidate = globalThis[Symbol.for("@gotgenes/pi-subagents:service")];
+      if (typeof candidate?.listAgents !== "function") return;
+      service = candidate;
+    }
+    const agents = service.listAgents().slice(0, 128).map((r) => ({
+      id: r.id, type: r.type, description: r.description?.slice(0, 2048),
+      status: r.status, isBackground: r.isBackground, outputFile: r.outputFile,
+      toolUses: r.toolUses, startedAt: r.startedAt, completedAt: r.completedAt,
+      result: r.result?.slice(0, 2048), error: r.error?.slice(0, 2048),
+      turnBudget: r.turnBudget, lifetimeUsage: r.lifetimeUsage,
+    }));
+    const payload = JSON.stringify({version: 1, agents});
+    if (payload === previous) return;
+    previous = payload;
+    ctx.ui.setWidget("${GOTGENES_WIDGET}", ["${GOTGENES_PREFIX}" + payload]);
+  };
+  const schedule = () => queueMicrotask(publish);
+  for (const name of ["created", "started", "completed", "failed", "resuming", "resumed", "compacted", "steered", "update"]) {
+    pi.events.on("subagents:" + name, schedule);
+  }
+  pi.on("session_start", (_event, context) => {
+    // A session switch keeps this extension's manager/service; only reload creates a new instance.
+    ctx = context; previous = ""; clearInterval(timer);
+    schedule();
+    // The public service publishes outputFile only after queued session creation and has no progress event.
+    timer = setInterval(publish, 1000);
+    timer.unref?.();
+  });
+  pi.on("session_shutdown", () => { clearInterval(timer); timer = undefined; ctx = undefined; service = undefined; });
+}
+`;
+async function ensureGotgenesExtension(environment) {
+  const digest = createHash2("sha256").update(GOTGENES_EXTENSION).digest("hex").slice(0, 16);
+  const root = environment.CODEXHOST_DATA_DIR ?? path7.join(environment.HOME ?? environment.USERPROFILE ?? homedir2(), ".codexhost");
+  const directory = path7.resolve(root, "extensions", "pi-subagent-observer");
+  const file2 = path7.join(directory, `${digest}.mjs`);
+  if (await readFile(file2, "utf8").catch(() => "") === GOTGENES_EXTENSION)
+    return file2;
+  await mkdir(directory, { recursive: true });
+  const temporary = `${file2}.${randomUUID()}.tmp`;
+  try {
+    await writeFile2(temporary, GOTGENES_EXTENSION, { mode: 384 });
+    try {
+      await rename(temporary, file2);
+    } catch (error51) {
+      if (await readFile(file2, "utf8").catch(() => "") !== GOTGENES_EXTENSION)
+        throw error51;
+    }
+  } finally {
+    await rm2(temporary, { force: true });
+  }
+  return file2;
+}
+
+// dist/pi-gotgenes-subagents.js
+var PREFIX = "pi-gotgenes-v1:";
+var STATUSES = {
+  queued: "pending",
+  running: "running",
+  background: "pending",
+  completed: "completed",
+  aborted: "interrupted",
+  stopped: "interrupted",
+  error: "failed"
+};
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(value, limit = 2048) {
+  return typeof value === "string" && value.length > 0 && value.length <= limit;
+}
+function gotgenesId(id) {
+  return PREFIX + Buffer.from(id).toString("base64url");
+}
+function parseGotgenesId(value) {
+  if (!value.startsWith(PREFIX))
+    return null;
+  const id = Buffer.from(value.slice(PREFIX.length), "base64url").toString("utf8");
+  if (!text(id, 256) || /[\s/\\]/u.test(id) || gotgenesId(id) !== value)
+    throw new Error("Invalid gotgenes subagent identity");
+  return id;
+}
+function gotgenesRecord(value) {
+  if (!isRecord4(value) || !text(value.id, 256) || /[\s/\\]/u.test(value.id) || !text(value.type) || !text(value.description) || typeof value.status !== "string" || !Object.hasOwn(STATUSES, value.status))
+    return null;
+  const status = STATUSES[value.status];
+  if (!status)
+    return null;
+  const id = gotgenesId(value.id);
+  const progress = typeof value.toolUses === "number" ? `${value.toolUses} tool uses` : void 0;
+  const result = typeof value.error === "string" ? value.error : typeof value.result === "string" ? value.result : progress;
+  return {
+    id: value.id,
+    roleKnown: value.roleKnown !== false,
+    backgroundKnown: typeof value.isBackground === "boolean",
+    child: {
+      subagentId: id,
+      nativeSubagentId: id,
+      description: value.description,
+      role: value.type,
+      status,
+      background: value.isBackground === true,
+      ...text(value.modelName) ? { model: value.modelName } : {},
+      ...result ? { resultSummary: result.slice(0, 2048) } : {}
+    },
+    ...text(value.outputFile, 8192) ? { outputFile: value.outputFile } : {},
+    revision: JSON.stringify([
+      value.toolUses,
+      value.turnBudget,
+      value.lifetimeUsage,
+      value.outputFile
+    ])
+  };
+}
+function gotgenesToolRecord(toolName, result) {
+  if (!["subagent", "get_subagent_result"].includes(toolName) || !isRecord4(result) || !isRecord4(result.details))
+    return null;
+  const d = result.details;
+  if (!text(d.agentId, 256) || !text(d.displayName) || !text(d.description))
+    return null;
+  return gotgenesRecord({
+    ...d,
+    id: d.agentId,
+    type: d.subagentType ?? d.displayName,
+    roleKnown: text(d.subagentType),
+    isBackground: toolName === "subagent" ? d.status === "background" || Array.isArray(d.tags) && d.tags.includes("background") : void 0,
+    outputFile: d.transcriptPath,
+    result: d.preview
+  });
+}
+function parseGotgenesWidget(value) {
+  if (!isRecord4(value) || value.type !== "extension_ui_request" || value.method !== "setWidget" || value.widgetKey !== GOTGENES_WIDGET || !Array.isArray(value.widgetLines))
+    return null;
+  const line = value.widgetLines.find((x) => typeof x === "string" && x.startsWith(GOTGENES_PREFIX));
+  if (!line || Buffer.byteLength(line) > 1024 * 1024)
+    return null;
+  try {
+    const payload = JSON.parse(line.slice(GOTGENES_PREFIX.length));
+    if (!isRecord4(payload) || payload.version !== 1 || !Array.isArray(payload.agents) || payload.agents.length > 128)
+      return null;
+    const records = payload.agents.map(gotgenesRecord);
+    return records.every((r) => r !== null) ? records : null;
+  } catch {
+    return null;
+  }
+}
+function mergeGotgenesRecord(previous, record9) {
+  const model2 = record9.child.model ?? previous?.child.model;
+  const role = record9.roleKnown ? record9.child.role : previous?.child.role ?? record9.child.role;
+  return {
+    ...previous,
+    ...record9,
+    roleKnown: record9.roleKnown || previous?.roleKnown === true,
+    backgroundKnown: record9.backgroundKnown || previous?.backgroundKnown === true,
+    outputFile: record9.outputFile ?? previous?.outputFile,
+    child: {
+      ...previous?.child,
+      ...record9.child,
+      ...model2 ? { model: model2 } : {},
+      ...role ? { role } : {},
+      background: record9.backgroundKnown ? record9.child.background : previous?.child.background ?? record9.child.background
+    }
+  };
+}
+var GotgenesSubagents = class {
+  emit;
+  records = /* @__PURE__ */ new Map();
+  #nativeObserved = /* @__PURE__ */ new Set();
+  #active = /* @__PURE__ */ new Map();
+  constructor(emit) {
+    this.emit = emit;
+  }
+  observe(records, publish = true, activeTurn, nativeObservation = false) {
+    for (const record9 of records) {
+      if (!publish && this.#nativeObserved.has(record9.id))
+        continue;
+      if (nativeObservation)
+        this.#nativeObserved.add(record9.id);
+      const previous = this.records.get(record9.id);
+      const merged = mergeGotgenesRecord(previous, record9);
+      this.records.set(record9.id, merged);
+      if (publish && !previous && activeTurn && !this.#active.has(record9.id)) {
+        const item = {
+          type: "subagentDelegation",
+          itemId: activeTurn.nextItemId(),
+          operation: "spawn",
+          subagents: [merged.child]
+        };
+        this.#active.set(record9.id, { turnId: activeTurn.turnId, item });
+        this.emit({ type: "item.started", turnId: activeTurn.turnId, item });
+      }
+      if (!publish || JSON.stringify(previous) === JSON.stringify(merged))
+        continue;
+      const active = this.#active.get(record9.id);
+      if (active) {
+        active.item = { ...active.item, subagents: [merged.child] };
+        this.emit({
+          type: "item.updated",
+          turnId: active.turnId,
+          itemId: active.item.itemId,
+          update: { type: "subagents.replace", subagents: [merged.child] }
+        });
+      }
+      this.emit({
+        type: "subagent.state.changed",
+        nativeSubagentId: merged.child.subagentId,
+        status: merged.child.status
+      });
+      this.emit({ type: "subagent.transcript.changed", nativeSubagentId: merged.child.subagentId });
+    }
+  }
+  project(toolName, result, itemId2) {
+    const parsed = gotgenesToolRecord(toolName, result);
+    if (!parsed || toolName !== "subagent")
+      return null;
+    const child = this.records.get(parsed.id)?.child ?? parsed.child;
+    return { type: "subagentDelegation", itemId: itemId2, operation: "spawn", subagents: [child] };
+  }
+  start(turnId, toolName, result, itemId2) {
+    const parsed = gotgenesToolRecord(toolName, result);
+    if (!parsed)
+      return false;
+    const prior = this.records.get(parsed.id);
+    if (!prior || !this.#nativeObserved.has(parsed.id))
+      this.observe([parsed]);
+    else {
+      this.observe([
+        {
+          ...prior,
+          child: { ...prior.child, ...parsed.child.model ? { model: parsed.child.model } : {} }
+        }
+      ]);
+    }
+    if (toolName === "subagent" && !this.#active.has(parsed.id)) {
+      const item = this.project(toolName, result, itemId2);
+      if (!item)
+        return false;
+      this.#active.set(parsed.id, { turnId, item });
+      this.emit({ type: "item.started", turnId, item });
+    }
+    return true;
+  }
+  finish(turnId) {
+    for (const [id, active] of this.#active) {
+      if (active.turnId !== turnId)
+        continue;
+      this.#active.delete(id);
+      this.emit({
+        type: "item.completed",
+        turnId,
+        snapshot: { item: active.item, outcome: { status: "succeeded" } }
+      });
+    }
+  }
+};
 
 // dist/pi-subagent-workflow.js
-var PREFIX = "pi-subagents-workflow-v1:";
+var PREFIX2 = "pi-subagents-workflow-v1:";
 var STATES = {
   pending: "pending",
   running: "running",
@@ -18030,7 +18366,7 @@ var STATES = {
 function record2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function text(value, limit = 256) {
+function text2(value, limit = 256) {
   return typeof value === "string" && value.length > 0 && value.length <= limit;
 }
 function piWorkflowSummary(result) {
@@ -18038,15 +18374,15 @@ function piWorkflowSummary(result) {
     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)
+  if (!record2(summary) || summary.version !== 1 || !text2(summary.workflowRunId) || summary.workflowRunId !== details.runId || !text2(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))
+    if (!record2(child) || !text2(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))
+      if (child[key] !== void 0 && !text2(child[key], 2048))
         return null;
     }
     const mappedState = STATES[child.state];
@@ -18070,15 +18406,15 @@ function piWorkflowSummary(result) {
   };
 }
 function piWorkflowSubagentId(address) {
-  return PREFIX + Buffer.from(JSON.stringify([address.workflowRunId, address.childId])).toString("base64url");
+  return PREFIX2 + Buffer.from(JSON.stringify([address.workflowRunId, address.childId])).toString("base64url");
 }
 function parsePiWorkflowSubagentId(id) {
-  if (!id.startsWith(PREFIX))
+  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(PREFIX.length), "base64url").toString("utf8"));
-  if (!Array.isArray(value) || value.length !== 2 || !text(value[0]) || !text(value[1]))
+  const value = JSON.parse(Buffer.from(id.slice(PREFIX2.length), "base64url").toString("utf8"));
+  if (!Array.isArray(value) || value.length !== 2 || !text2(value[0]) || !text2(value[1]))
     throw new Error("Invalid Pi workflow child identity");
   const address = { workflowRunId: value[0], childId: value[1] };
   if (piWorkflowSubagentId(address) !== id)
@@ -18236,8 +18572,13 @@ var PiSubagents = class {
   #children = /* @__PURE__ */ new Map();
   #active = /* @__PURE__ */ new Map();
   #waiting = /* @__PURE__ */ new Map();
+  gotgenes;
   constructor(emit) {
     this.emit = emit;
+    this.gotgenes = new GotgenesSubagents(emit);
+  }
+  observeGotgenes(records, activeTurn) {
+    this.gotgenes.observe(records, true, activeTurn, true);
   }
   observe(runs) {
     this.#apply(runs, true);
@@ -18291,6 +18632,9 @@ var PiSubagents = class {
     }
   }
   project(toolName, result, itemId2, callId) {
+    const gotgenes = this.gotgenes.project(toolName, result, itemId2);
+    if (gotgenes)
+      return gotgenes;
     const workflow = toolName === "subagent" ? piWorkflowSummary(result) : null;
     if (workflow && (!callId || workflow.parentToolCallId === callId))
       return projectPiWorkflow(workflow, itemId2);
@@ -18301,6 +18645,8 @@ var PiSubagents = class {
     return children.length ? { type: "subagentDelegation", itemId: itemId2, operation: "spawn", subagents: children } : null;
   }
   start(turnId, toolName, result, itemId2, callId) {
+    if (this.gotgenes.start(turnId, toolName, result, itemId2))
+      return;
     const workflow = toolName === "subagent" ? piWorkflowSummary(result) : null;
     if (workflow && (!callId || workflow.parentToolCallId === callId)) {
       const key = `workflow:${workflow.workflowRunId}`;
@@ -18346,6 +18692,7 @@ var PiSubagents = class {
     this.emit({ type: "item.started", turnId, item });
   }
   finish(turnId) {
+    this.gotgenes.finish(turnId);
     for (const [runId, waiting] of this.#waiting) {
       if (waiting.turnId === turnId)
         this.#waiting.delete(runId);
@@ -18393,15 +18740,15 @@ ${entry.text}`);
         nativeTurnRef: nativeTurnRefSchema.parse({
           harnessId: "pi",
           nativeSessionId: parentSessionId,
-          nativeTurnKey: `pi-subagent-${createHash("sha256").update(id).digest("hex")}`,
+          nativeTurnKey: `pi-subagent-${createHash3("sha256").update(id).digest("hex")}`,
           formatVersion: 1
         }),
         input: reply.task ? [{ type: "text", text: reply.task }] : [],
-        items: texts.map((text2, index) => ({
+        items: texts.map((text3, index) => ({
           item: {
             type: "agentMessage",
-            text: text2,
-            itemId: hostItemIdSchema.parse(`pi-subagent-${createHash("sha256").update(`${id}:${index}:${text2}`).digest("hex")}`)
+            text: text3,
+            itemId: hostItemIdSchema.parse(`pi-subagent-${createHash3("sha256").update(`${id}:${index}:${text3}`).digest("hex")}`)
           },
           outcome: { status: "succeeded" }
         })),
@@ -18549,22 +18896,149 @@ function normalizePiModelCatalog(nativeModels, effectiveModel, thinkingLevels, e
   });
 }
 
+// dist/pi-progress.js
+import { createHash as createHash4 } from "node:crypto";
+function record4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function textContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.filter((part) => record4(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
+}
+function boundedPiProgress(text3) {
+  const limit = 64e3;
+  return text3.length <= limit ? text3 : `${text3.slice(0, limit)}
+[Pi notification truncated]`;
+}
+function visibleText(text3) {
+  return text3.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function noticeDisplay(value, fallback) {
+  if (!record4(value) || !record4(value.details) || typeof value.details.summary !== "string")
+    return visibleText(fallback);
+  const details = value.details;
+  const parts = [visibleText(details.summary)];
+  if (typeof details.exitCode === "number")
+    parts.push(`Exit code: ${details.exitCode}`);
+  for (const key of ["signal", "error", "errorMessage"])
+    if (typeof details[key] === "string" && details[key])
+      parts.push(`${key}: ${visibleText(details[key])}`);
+  if (record4(details.logMatch) && typeof details.logMatch.line === "string")
+    parts.push(`Log: ${visibleText(details.logMatch.line)}`);
+  if (typeof details.command === "string" && details.command)
+    parts.push(`Command: ${visibleText(details.command)}`);
+  return parts.join("\n\n");
+}
+function piCustomNoticeKey(value) {
+  if (!record4(value) || value.type !== "custom_message" && value.role !== "custom" || value.display !== true || typeof value.customType !== "string")
+    return null;
+  const text3 = textContent(value.content);
+  if (text3.trim().length === 0)
+    return null;
+  return JSON.stringify([value.customType, text3]);
+}
+function piCustomNotice(value, sessionId, occurrences) {
+  const key = piCustomNoticeKey(value);
+  if (!key)
+    return null;
+  const occurrence = occurrences.get(key) ?? 0;
+  occurrences.set(key, occurrence + 1);
+  const digest = createHash4("sha256").update(JSON.stringify([sessionId, key, occurrence])).digest("hex");
+  const [customType, text3] = JSON.parse(key);
+  return {
+    type: "progress.message",
+    itemId: hostItemIdSchema.parse(`pi-notice-v1-${digest}`),
+    text: boundedPiProgress(`Pi notification (${visibleText(customType)})
+
+${noticeDisplay(value, text3)}`)
+  };
+}
+function piHistoryNotices(sessionId, entries) {
+  const occurrences = /* @__PURE__ */ new Map();
+  const notices = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const notice = piCustomNotice(entry.message ?? entry, sessionId, occurrences);
+    if (notice)
+      notices.set(entry.id, notice);
+  }
+  return { notices, occurrences };
+}
+function piStatusText(value) {
+  if (value.type === "auto_retry_start") {
+    const attempt = typeof value.attempt === "number" ? ` ${value.attempt}` : "";
+    const maximum = typeof value.maxAttempts === "number" ? `/${value.maxAttempts}` : "";
+    const delay2 = typeof value.delayMs === "number" && value.delayMs >= 0 ? ` Waiting ${value.delayMs / 1e3} s before retrying.` : "";
+    const reason = typeof value.errorMessage === "string" ? `
+
+${visibleText(value.errorMessage)}` : "";
+    return boundedPiProgress(`Pi retry${attempt}${maximum}.${delay2}${reason}`);
+  }
+  if (value.type === "auto_retry_end") {
+    if (typeof value.success !== "boolean")
+      return null;
+    const reason = typeof value.finalError === "string" ? `
+
+${visibleText(value.finalError)}` : "";
+    return boundedPiProgress(`Pi retry ${value.success ? "succeeded" : "ended without success"}.${reason}`);
+  }
+  if (value.type !== "extension_ui_request")
+    return null;
+  if (value.method === "notify" && typeof value.message === "string" && value.message.trim()) {
+    const level = typeof value.notifyType === "string" ? ` (${value.notifyType})` : "";
+    return boundedPiProgress(`Pi notification${level}
+
+${visibleText(value.message)}`);
+  }
+  if (value.method === "setStatus" && typeof value.statusKey === "string") {
+    return typeof value.statusText === "string" && value.statusText.trim() ? boundedPiProgress(`Pi status (${visibleText(value.statusKey)})
+
+${visibleText(value.statusText)}`) : `Pi status (${visibleText(value.statusKey)}) cleared.`;
+  }
+  return null;
+}
+
+// dist/pi-tool-command.js
+function record5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(value, key) {
+  if (!record5(value))
+    return void 0;
+  for (const source of [value, value.input, value.arguments]) {
+    if (record5(source) && typeof source[key] === "string" && source[key].length > 0)
+      return source[key];
+  }
+  return void 0;
+}
+function piToolCommand(name, arguments_) {
+  if (!["bash", "exec", "terminal", "run"].includes(name.toLowerCase()))
+    return null;
+  const command = ["command", "cmd", "script", "commandLine", "command_line"].map((key) => stringField(arguments_, key)).find((value) => value !== void 0);
+  if (!command)
+    return null;
+  const cwd = stringField(arguments_, "cwd");
+  return { command, ...cwd ? { cwd } : {} };
+}
+
 // dist/pi-history.js
 var piHarnessId = harnessIdSchema.parse("pi");
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function textContent(value) {
+function textContent2(value) {
   if (typeof value === "string")
     return value;
   if (!Array.isArray(value))
     return "";
-  return value.filter((part) => isRecord4(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
+  return value.filter((part) => isRecord5(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) => isRecord4(part) && part.type === "thinking" && typeof part.thinking === "string").map((part) => part.thinking).join("");
+  return value.filter((part) => isRecord5(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") {
@@ -18595,7 +19069,7 @@ function activePiEntries(history) {
   return reversed.reverse();
 }
 function message(entry) {
-  return entry.type === "message" && isRecord4(entry.message) ? entry.message : null;
+  return entry.type === "message" && isRecord5(entry.message) ? entry.message : null;
 }
 function messageRole(entry) {
   const value = message(entry)?.role;
@@ -18610,7 +19084,7 @@ function assistantOutcome(entries) {
   if (!final)
     return { status: "unknown", reason: "Pi history has no Assistant terminal" };
   const stopReason = final.stopReason;
-  if (stopReason === "aborted") {
+  if (piAssistantWasAborted(final)) {
     return { status: "cancelled", reason: "Pi Assistant was aborted" };
   }
   if (stopReason === "error") {
@@ -18623,7 +19097,7 @@ function assistantOutcome(entries) {
       }
     };
   }
-  if (typeof stopReason === "string" || textContent(final.content).length > 0) {
+  if (typeof stopReason === "string" || textContent2(final.content).length > 0) {
     return { status: "succeeded" };
   }
   return { status: "unknown", reason: "Pi Assistant terminal is not classifiable" };
@@ -18640,8 +19114,8 @@ function itemOutcome(outcome) {
   return { status: "succeeded" };
 }
 function toolOutput(value) {
-  const text2 = textContent(value);
-  return text2.length > 0 ? { content: [{ type: "text", text: text2 }] } : void 0;
+  const text3 = textContent2(value);
+  return text3.length > 0 ? { content: [{ type: "text", text: text3 }] } : void 0;
 }
 function historicalFileChanges(call, nativeMessage, toolItemId, cwd) {
   const items = [];
@@ -18664,37 +19138,52 @@ function historicalFileChanges(call, nativeMessage, toolItemId, cwd) {
   }
   return items;
 }
-function snapshotItems(entries, outcome, subagents, cwd) {
+function snapshotItems(entries, messageIdentities, notices, outcome, subagents, cwd) {
   const snapshots = [];
   const toolCalls = /* @__PURE__ */ new Map();
   for (const entry of entries) {
+    const notice = notices.get(entry.id);
+    if (notice) {
+      snapshots.push({
+        item: {
+          type: "agentMessage",
+          itemId: notice.itemId,
+          text: notice.text,
+          phase: "commentary"
+        },
+        outcome: { status: "succeeded" }
+      });
+      continue;
+    }
     const nativeMessage = message(entry);
     if (!nativeMessage)
       continue;
     const content = Array.isArray(nativeMessage.content) ? nativeMessage.content : [];
     if (nativeMessage.role === "assistant") {
-      const text2 = textContent(content);
+      const text3 = textContent2(content);
       const reasoning = thinkingContent(content);
       let projectedText = false;
       let projectedReasoning = false;
       for (const [ordinal, part] of content.entries()) {
-        if (!isRecord4(part))
+        if (!isRecord5(part))
           continue;
         if (part.type === "thinking" && !projectedReasoning && reasoning.length > 0) {
           const item2 = {
             type: "reasoning",
-            itemId: itemId(entry.id, "reasoning", 0),
+            itemId: piMessageItemId(messageIdentities.get(entry.id), "reasoning") ?? itemId(entry.id, "reasoning", 0),
             text: reasoning
           };
           snapshots.push({ item: item2, outcome: itemOutcome(outcome) });
           projectedReasoning = true;
           continue;
         }
-        if (part.type === "text" && !projectedText && text2.length > 0) {
+        if (part.type === "text" && !projectedText && text3.length > 0) {
+          const phase = piAssistantPhase(nativeMessage);
           const item2 = {
             type: "agentMessage",
-            itemId: itemId(entry.id, "assistant", 0),
-            text: text2
+            itemId: piMessageItemId(messageIdentities.get(entry.id), "assistant") ?? itemId(entry.id, "assistant", 0),
+            text: text3,
+            ...phase ? { phase } : {}
           };
           snapshots.push({ item: item2, outcome: itemOutcome(outcome) });
           projectedText = true;
@@ -18722,9 +19211,24 @@ function snapshotItems(entries, outcome, subagents, cwd) {
     if (!call || call.name !== nativeMessage.toolName)
       continue;
     const output = toolOutput(nativeMessage.content);
-    const item = {
-      type: "toolExecution",
+    const shell = piToolCommand(call.name, call.arguments);
+    const commandCwd = shell?.cwd ?? cwd;
+    const durationMs = typeof nativeMessage.durationMs === "number" && Number.isFinite(nativeMessage.durationMs) && nativeMessage.durationMs >= 0 ? nativeMessage.durationMs : void 0;
+    const base = {
       itemId: itemId(call.entryId, "tool", call.ordinal),
+      ...durationMs !== void 0 ? { durationMs } : {}
+    };
+    const exitCode = typeof nativeMessage.exitCode === "number" && Number.isInteger(nativeMessage.exitCode) ? nativeMessage.exitCode : void 0;
+    const item = shell ? {
+      ...base,
+      type: "commandExecution",
+      command: shell.command,
+      ...commandCwd ? { cwd: commandCwd } : {},
+      ...output ? { output: textContent2(nativeMessage.content) } : {},
+      ...exitCode !== void 0 ? { exitCode } : {}
+    } : {
+      ...base,
+      type: "toolExecution",
       toolName: call.name,
       arguments: call.arguments,
       ...output ? { output } : {}
@@ -18755,6 +19259,10 @@ function snapshotItems(entries, outcome, subagents, cwd) {
 function modelChange(entry) {
   return entry.type === "model_change" && typeof entry.provider === "string" && typeof entry.modelId === "string" ? { provider: entry.provider, id: entry.modelId } : null;
 }
+function isEmptyWakeup(entry) {
+  const content = message(entry)?.content;
+  return content === "" || Array.isArray(content) && content.every((part) => isRecord5(part) && part.type === "text" && part.text === "");
+}
 function turnStarts(active) {
   const starts = [];
   let terminal = true;
@@ -18762,6 +19270,8 @@ function turnStarts(active) {
   for (const [index, entry] of active.entries()) {
     const role = messageRole(entry);
     if (role === "user") {
+      if (pending && isEmptyWakeup(entry))
+        continue;
       starts.push({ entry, index });
       pending = null;
       terminal = false;
@@ -18778,6 +19288,8 @@ function turnStarts(active) {
 }
 function mapPiSnapshot(history, state2, subagents = new PiSubagents(() => void 0)) {
   const active = activePiEntries(history);
+  const { identities } = piHistoryMessageIdentities(state2.sessionId, active);
+  const { notices } = piHistoryNotices(state2.sessionId, active);
   const turns = [];
   const starts = turnStarts(active);
   const byIndex = new Map(starts.map((start, ordinal) => [start.index, ordinal]));
@@ -18799,7 +19311,7 @@ function mapPiSnapshot(history, state2, subagents = new PiSubagents(() => void 0
     const end = next?.index ?? active.length;
     const entries = active.slice(index, end);
     const outcome = assistantOutcome(entries);
-    const userText = textContent(message(user)?.content);
+    const userText = textContent2(message(user)?.content);
     const nativeTurnRef = nativeTurnRefSchema.parse({
       harnessId: piHarnessId,
       nativeSessionId: state2.sessionId,
@@ -18816,7 +19328,7 @@ function mapPiSnapshot(history, state2, subagents = new PiSubagents(() => void 0
       nativeTurnRef,
       ...!next || messageRole(next.entry) === "user" ? { checkpoint } : {},
       input: messageRole(user) === "user" ? [{ type: "text", text: userText }] : [],
-      items: snapshotItems(entries, outcome, subagents, state2.cwd),
+      items: snapshotItems(entries, identities, notices, outcome, subagents, state2.cwd),
       outcome,
       ...effectiveModel ? { model: encodePiModelRef(effectiveModel) } : {}
     });
@@ -18851,14 +19363,14 @@ function resolvePiForkBoundary(history, checkpointId) {
 }
 
 // dist/pi-usage.js
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonNegativeSafeInteger(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
 }
 function optionalPiCacheHitRatePercent(value) {
-  if (!isRecord5(value) || value.role !== "assistant" || !isRecord5(value.usage))
+  if (!isRecord6(value) || value.role !== "assistant" || !isRecord6(value.usage))
     return null;
   const input = nonNegativeSafeInteger(value.usage.input);
   const cacheRead = nonNegativeSafeInteger(value.usage.cacheRead);
@@ -18871,20 +19383,20 @@ function optionalPiCacheHitRatePercent(value) {
 function latestPiCacheHitRatePercent(history) {
   let latest = null;
   for (const entry of activePiEntries(history)) {
-    if (entry.type === "message" && isRecord5(entry.message) && entry.message.role === "assistant") {
+    if (entry.type === "message" && isRecord6(entry.message) && entry.message.role === "assistant") {
       latest = optionalPiCacheHitRatePercent(entry.message);
     }
   }
   return latest;
 }
 function responseData(response, operation) {
-  if (!isRecord5(response.data)) {
+  if (!isRecord6(response.data)) {
     throw new Error(`Pi RPC ${operation} response has no data`);
   }
   return response.data;
 }
 function contextUsage(value) {
-  if (!isRecord5(value))
+  if (!isRecord6(value))
     throw new Error("Pi RPC context Usage is invalid");
   return parseHostUsage({
     contextUsedTokens: value.tokens,
@@ -18894,15 +19406,15 @@ function contextUsage(value) {
 function parsePiSessionUsage(response) {
   const data = responseData(response, "Session stats");
   const tokens = data.tokens;
-  if (tokens !== void 0 && !isRecord5(tokens)) {
+  if (tokens !== void 0 && !isRecord6(tokens)) {
     throw new Error("Pi RPC Session stats tokens are invalid");
   }
   return parseHostUsage({
-    ...isRecord5(tokens) && tokens.input !== void 0 ? { inputTokens: tokens.input } : {},
-    ...isRecord5(tokens) && tokens.cacheRead !== void 0 ? { cachedInputTokens: tokens.cacheRead } : {},
-    ...isRecord5(tokens) && tokens.cacheWrite !== void 0 ? { cacheWriteInputTokens: tokens.cacheWrite } : {},
-    ...isRecord5(tokens) && tokens.output !== void 0 ? { outputTokens: tokens.output } : {},
-    ...isRecord5(tokens) && tokens.total !== void 0 ? { totalTokens: tokens.total } : {},
+    ...isRecord6(tokens) && tokens.input !== void 0 ? { inputTokens: tokens.input } : {},
+    ...isRecord6(tokens) && tokens.cacheRead !== void 0 ? { cachedInputTokens: tokens.cacheRead } : {},
+    ...isRecord6(tokens) && tokens.cacheWrite !== void 0 ? { cacheWriteInputTokens: tokens.cacheWrite } : {},
+    ...isRecord6(tokens) && tokens.output !== void 0 ? { outputTokens: tokens.output } : {},
+    ...isRecord6(tokens) && tokens.total !== void 0 ? { totalTokens: tokens.total } : {},
     ...data.cost !== void 0 ? { totalCostUsd: data.cost } : {},
     ...data.contextUsage !== void 0 ? contextUsage(data.contextUsage) : {}
   });
@@ -18921,9 +19433,9 @@ function optionalPiStateContextUsage(value) {
   }
 }
 function piUsageRecord(message3, extra = {}) {
-  if (!isRecord5(message3) || message3.role !== "assistant")
+  if (!isRecord6(message3) || message3.role !== "assistant")
     return null;
-  const usage = isRecord5(message3.usage) ? message3.usage : null;
+  const usage = isRecord6(message3.usage) ? message3.usage : null;
   const input = nonNegativeSafeInteger(usage?.input);
   const output = nonNegativeSafeInteger(usage?.output);
   const requestId = typeof message3.responseId === "string" && message3.responseId.length > 0 ? message3.responseId : typeof message3.timestamp === "number" && Number.isSafeInteger(message3.timestamp) ? `t${message3.timestamp}` : null;
@@ -18960,17 +19472,17 @@ function piUsageHistory(history) {
   for (const entry of history.entries) {
     if (entry.type !== "message")
       continue;
-    const record7 = piUsageRecord(entry.message, { historical: true });
-    if (record7?.kind === "request")
-      requests.push(record7.request);
-    else if (record7?.kind === "missing")
+    const record9 = piUsageRecord(entry.message, { historical: true });
+    if (record9?.kind === "request")
+      requests.push(record9.request);
+    else if (record9?.kind === "missing")
       complete = false;
   }
   return { requests, complete };
 }
 
 // dist/pi-usage-statistics.js
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function piUserText(content) {
@@ -18978,11 +19490,11 @@ function piUserText(content) {
     return content;
   if (!Array.isArray(content))
     return void 0;
-  return content.filter((block) => isRecord6(block) && block.type === "text" && typeof block.text === "string").map((block) => String(block.text)).join(" ");
+  return content.filter((block) => isRecord7(block) && block.type === "text" && typeof block.text === "string").map((block) => String(block.text)).join(" ");
 }
 async function readPiUsage(file2, signal) {
   const entries = [];
-  const header = await jsonlHeader(file2, (record7) => record7.type === "session", signal);
+  const header = await jsonlHeader(file2, (record9) => record9.type === "session", signal);
   let name;
   const session = {
     sessionId: typeof header?.id === "string" ? header.id : void 0,
@@ -18999,11 +19511,11 @@ async function readPiUsage(file2, signal) {
     if (!name && message3?.role === "user") {
       name = usageSessionTitle(piUserText(message3.content));
     }
-    const record7 = piUsageRecord(line.message);
-    if (record7?.kind !== "request")
+    const record9 = piUsageRecord(line.message);
+    if (record9?.kind !== "request")
       continue;
     const at = nativeTimeMs(message3.timestamp) ?? nativeTimeMs(line.timestamp);
-    const entry = at !== null && usageEntryFromRequest(record7.request, at);
+    const entry = at !== null && usageEntryFromRequest(record9.request, at);
     if (!entry)
       continue;
     if (!(typeof message3.responseId === "string" && message3.responseId.length > 0)) {
@@ -19024,9 +19536,9 @@ function createPiUsageStatistics(environment) {
 }
 
 // dist/account-balance.js
-import { readFile } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import path7 from "node:path";
+import { readFile as readFile2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import path8 from "node:path";
 var DEEPSEEK_BALANCE_ENDPOINT = "https://api.deepseek.com/user/balance";
 var SUB2API_USAGE_PATH = "/v1/usage";
 var REQUEST_TIMEOUT_MS = 1e4;
@@ -19035,18 +19547,18 @@ function agentDirectory(environment) {
   const configured = environment.PI_CODING_AGENT_DIR?.trim();
   if (configured)
     return configured;
-  return path7.join(environment.HOME ?? environment.USERPROFILE ?? homedir2(), ".pi", "agent");
+  return path8.join(environment.HOME ?? environment.USERPROFILE ?? homedir3(), ".pi", "agent");
 }
-var record4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+var record6 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 async function deepSeekApiKey(environment) {
-  const auth = record4(JSON.parse(await readFile(path7.join(agentDirectory(environment), "auth.json"), "utf8")));
-  const deepseek = record4(auth.deepseek);
+  const auth = record6(JSON.parse(await readFile2(path8.join(agentDirectory(environment), "auth.json"), "utf8")));
+  const deepseek = record6(auth.deepseek);
   if (deepseek.type !== "api_key")
     return void 0;
   return typeof deepseek.key === "string" && deepseek.key.trim() ? deepseek.key : void 0;
 }
 function projectSub2ApiUsage(payload, providerId) {
-  const data = record4(payload);
+  const data = record6(payload);
   if (data.isValid === false)
     return null;
   if (data.mode !== "unrestricted" && data.mode !== "quota_limited")
@@ -19056,7 +19568,7 @@ function projectSub2ApiUsage(payload, providerId) {
     return null;
   const wallet = finiteAmount(data.balance);
   const remaining = finiteAmount(data.remaining);
-  const quotaRemaining = finiteAmount(record4(data.quota).remaining);
+  const quotaRemaining = finiteAmount(record6(data.quota).remaining);
   const amount = wallet ?? remaining ?? quotaRemaining;
   if (amount === null)
     return null;
@@ -19076,10 +19588,10 @@ function finiteAmount(value) {
   return Number.isFinite(amount) && amount >= 0 ? amount : null;
 }
 function projectDeepSeekBalance(payload) {
-  const data = record4(payload);
+  const data = record6(payload);
   if (!Array.isArray(data.balance_infos))
     return null;
-  const first = record4(data.balance_infos[0]);
+  const first = record6(data.balance_infos[0]);
   const amount = finiteAmount(first.total_balance);
   const currency = typeof first.currency === "string" ? first.currency.trim() : "";
   if (amount === null || !currency)
@@ -19108,11 +19620,11 @@ function usageEndpoint(baseUrl) {
 }
 async function configuredSub2ApiProviders(environment) {
   try {
-    const models = record4(JSON.parse(await readFile(path7.join(agentDirectory(environment), "models.json"), "utf8")));
-    const providers = record4(models.providers);
+    const models = record6(JSON.parse(await readFile2(path8.join(agentDirectory(environment), "models.json"), "utf8")));
+    const providers = record6(models.providers);
     const found = [];
     for (const [id, definition] of Object.entries(providers)) {
-      const provider = record4(definition);
+      const provider = record6(definition);
       const apiKey = typeof provider.apiKey === "string" ? provider.apiKey.trim() : "";
       const baseUrl = typeof provider.baseUrl === "string" ? provider.baseUrl.trim() : "";
       if (!id.trim() || id.length > 128 || !apiKey || !usageEndpoint(baseUrl))
@@ -19170,21 +19682,21 @@ async function fetchPiAccountBalance(input) {
 }
 
 // dist/pi-credential-imports.js
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { execFile as execFile2 } from "node:child_process";
 import { promisify } from "node:util";
 import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync, lstatSync, renameSync, rmdirSync } from "node:fs";
 import { realpath as realpath2 } from "node:fs/promises";
 import os4 from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 import { pathToFileURL } from "node:url";
 
 // dist/command.js
 import fs2 from "node:fs";
-import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
-import path8 from "node:path";
+import { homedir as homedir4, tmpdir as tmpdir2 } from "node:os";
+import path9 from "node:path";
 var PI_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
-var PI_PACKAGE_PATH = path8.join("node_modules", "@earendil-works", "pi-coding-agent");
+var PI_PACKAGE_PATH = path9.join("node_modules", "@earendil-works", "pi-coding-agent");
 var piDiscoverySpec = {
   id: "pi",
   command: "pi",
@@ -19210,18 +19722,18 @@ function resolvePiExecutable(input, dependencies = {}) {
   return resolution?.executable ?? input.command ?? input.environment.PI_COMMAND ?? "pi";
 }
 function findPiPackageDirectory(executable) {
-  let directory = path8.dirname(executable);
+  let directory = path9.dirname(executable);
   while (true) {
-    for (const candidate of [directory, path8.join(directory, PI_PACKAGE_PATH)]) {
+    for (const candidate of [directory, path9.join(directory, PI_PACKAGE_PATH)]) {
       try {
-        const manifest = JSON.parse(fs2.readFileSync(path8.join(candidate, "package.json"), "utf8"));
+        const manifest = JSON.parse(fs2.readFileSync(path9.join(candidate, "package.json"), "utf8"));
         if (typeof manifest === "object" && manifest !== null && "name" in manifest && manifest.name === PI_PACKAGE_NAME) {
           return candidate;
         }
       } catch {
       }
     }
-    const parent = path8.dirname(directory);
+    const parent = path9.dirname(directory);
     if (parent === directory)
       return void 0;
     directory = parent;
@@ -19229,16 +19741,16 @@ function findPiPackageDirectory(executable) {
 }
 function findPiCliEntry(packageDirectory) {
   try {
-    const manifest = JSON.parse(fs2.readFileSync(path8.join(packageDirectory, "package.json"), "utf8"));
+    const manifest = JSON.parse(fs2.readFileSync(path9.join(packageDirectory, "package.json"), "utf8"));
     if (typeof manifest !== "object" || manifest === null || !("bin" in manifest))
       return void 0;
     const bin = manifest.bin;
     const entry = typeof bin === "string" ? bin : typeof bin === "object" && bin !== null && "pi" in bin ? bin.pi : void 0;
     if (typeof entry !== "string" || !entry.trim())
       return void 0;
-    const resolved = path8.resolve(packageDirectory, entry);
-    const relative = path8.relative(packageDirectory, resolved);
-    if (relative === ".." || relative.startsWith(`..${path8.sep}`) || path8.isAbsolute(relative) || !fs2.statSync(resolved).isFile()) {
+    const resolved = path9.resolve(packageDirectory, entry);
+    const relative = path9.relative(packageDirectory, resolved);
+    if (relative === ".." || relative.startsWith(`..${path9.sep}`) || path9.isAbsolute(relative) || !fs2.statSync(resolved).isFile()) {
       return void 0;
     }
     return resolved;
@@ -19247,11 +19759,11 @@ function findPiCliEntry(packageDirectory) {
   }
 }
 function isFilesystemRoot(cwd) {
-  const resolved = path8.resolve(cwd);
-  return resolved === path8.parse(resolved).root;
+  const resolved = path9.resolve(cwd);
+  return resolved === path9.parse(resolved).root;
 }
 function writableDirectory(candidate) {
-  if (!candidate || !path8.isAbsolute(candidate) || isFilesystemRoot(candidate))
+  if (!candidate || !path9.isAbsolute(candidate) || isFilesystemRoot(candidate))
     return void 0;
   try {
     if (!fs2.statSync(candidate).isDirectory())
@@ -19264,19 +19776,19 @@ function writableDirectory(candidate) {
 }
 function resolvePiInspectCwd(inputCwd, environment = process.env) {
   if (typeof inputCwd === "string" && inputCwd.length > 0 && !isFilesystemRoot(inputCwd)) {
-    return path8.resolve(inputCwd);
+    return path9.resolve(inputCwd);
   }
-  const candidates = [environment.USERPROFILE, environment.HOME, homedir3(), tmpdir2()];
+  const candidates = [environment.USERPROFILE, environment.HOME, homedir4(), tmpdir2()];
   for (const candidate of candidates) {
     const usable = writableDirectory(candidate);
     if (usable)
       return usable;
   }
-  return inputCwd && inputCwd.length > 0 ? path8.resolve(inputCwd) : process.cwd();
+  return inputCwd && inputCwd.length > 0 ? path9.resolve(inputCwd) : process.cwd();
 }
 
 // dist/pi-credential-imports.js
-var PREFIX2 = "codexhost-account-";
+var PREFIX3 = "codexhost-account-";
 function object2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -19317,7 +19829,7 @@ function describeOauth(credential) {
   };
 }
 function writeAuth(filename, content) {
-  const temporary = `${filename}.${randomUUID()}.tmp`;
+  const temporary = `${filename}.${randomUUID2()}.tmp`;
   try {
     writeFileSync(temporary, content, { flag: "wx", mode: 384 });
     renameSync(temporary, filename);
@@ -19326,8 +19838,8 @@ function writeAuth(filename, content) {
   }
 }
 function removeOwnedFiles(dir) {
-  rmSync(path9.join(dir, "index.ts"), { force: true });
-  rmSync(path9.join(dir, "import.json"), { force: true });
+  rmSync(path10.join(dir, "index.ts"), { force: true });
+  rmSync(path10.join(dir, "import.json"), { force: true });
   try {
     rmdirSync(dir);
   } catch {
@@ -19339,13 +19851,13 @@ async function installation(command, environment, authPath) {
   const cliEntry = directory ? findPiCliEntry(directory) : void 0;
   if (!directory || !cliEntry)
     throw new Error("Pi credential import requires a supported npm Pi installation");
-  const storage = await import(pathToFileURL(path9.join(directory, "dist/core/auth-storage.js")).href);
-  const ai = path9.join(directory, "node_modules/@earendil-works/pi-ai/dist");
-  const all = await import(pathToFileURL(path9.join(ai, "providers/all.js")).href);
+  const storage = await import(pathToFileURL(path10.join(directory, "dist/core/auth-storage.js")).href);
+  const ai = path10.join(directory, "node_modules/@earendil-works/pi-ai/dist");
+  const all = await import(pathToFileURL(path10.join(ai, "providers/all.js")).href);
   const providers = all.getBuiltinProviders();
   const providerModules = {
-    "openai-codex": pathToFileURL(path9.join(ai, "providers/openai-codex.js")).href,
-    xai: pathToFileURL(path9.join(ai, "providers/xai.js")).href
+    "openai-codex": pathToFileURL(path10.join(ai, "providers/openai-codex.js")).href,
+    xai: pathToFileURL(path10.join(ai, "providers/xai.js")).href
   };
   for (const [id, url2] of Object.entries(providerModules)) {
     const module = await import(url2);
@@ -19359,8 +19871,8 @@ async function installation(command, environment, authPath) {
     reservedNames: providers.map((p) => typeof p === "string" ? p : p.id),
     async configuredProviderNames() {
       const { stdout } = await promisify(execFile2)(process.execPath, [cliEntry, "--offline", "--no-approve", "--list-models"], {
-        cwd: existsSync(path9.dirname(authPath)) ? path9.dirname(authPath) : os4.homedir(),
-        env: { ...environment, PI_CODING_AGENT_DIR: path9.dirname(authPath), PI_OFFLINE: "1" },
+        cwd: existsSync(path10.dirname(authPath)) ? path10.dirname(authPath) : os4.homedir(),
+        env: { ...environment, PI_CODING_AGENT_DIR: path10.dirname(authPath), PI_OFFLINE: "1" },
         timeout: 15e3,
         maxBuffer: 4 * 1024 * 1024
       });
@@ -19390,26 +19902,26 @@ export default async function (pi) {
 }
 function createPiCredentialImports(options = {}) {
   const env = { ...process.env, ...options.environment };
-  const agentDir = env.PI_CODING_AGENT_DIR ?? path9.join(env.HOME ?? os4.homedir(), ".pi/agent");
-  const authPath = path9.join(agentDir, "auth.json");
-  const extensionsDir = path9.join(agentDir, "extensions");
+  const agentDir = env.PI_CODING_AGENT_DIR ?? path10.join(env.HOME ?? os4.homedir(), ".pi/agent");
+  const authPath = path10.join(agentDir, "auth.json");
+  const extensionsDir = path10.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) => path9.join(extensionsDir, `${PREFIX2}${credentialImportNameSchema.parse(name)}`);
+  const location = (name) => path10.join(extensionsDir, `${PREFIX3}${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(path9.join(dir, "import.json"), "utf8"));
+    const value = JSON.parse(readFileSync(path10.join(dir, "import.json"), "utf8"));
     if (value.version !== 1 || typeof value.owner !== "string" || typeof value.extension !== "string")
       throw new Error("Invalid import metadata");
-    const record7 = value.record;
-    if (!object2(record7))
+    const record9 = value.record;
+    if (!object2(record9))
       throw new Error("Invalid import metadata");
     value.record = credentialImportRecordSchema.parse({
-      name: record7.name,
-      source: record7.source,
-      importedAt: record7.importedAt
+      name: record9.name,
+      source: record9.source,
+      importedAt: record9.importedAt
     });
     if (value.record.name !== name)
       throw new Error("Import identity mismatch");
@@ -19417,7 +19929,7 @@ function createPiCredentialImports(options = {}) {
   };
   const owned = (meta3, auth) => {
     const credential = auth[meta3.record.name];
-    const file2 = path9.join(location(meta3.record.name), "index.ts");
+    const file2 = path10.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")) : {};
@@ -19426,12 +19938,12 @@ function createPiCredentialImports(options = {}) {
       return [];
     const result = [];
     for (const entry of readdirSync(extensionsDir)) {
-      if (!entry.startsWith(PREFIX2))
+      if (!entry.startsWith(PREFIX3))
         continue;
-      const name = entry.slice(PREFIX2.length);
+      const name = entry.slice(PREFIX3.length);
       if (!credentialImportNameSchema.safeParse(name).success)
         continue;
-      if (!existsSync(path9.join(location(name), "import.json")))
+      if (!existsSync(path10.join(location(name), "import.json")))
         continue;
       try {
         const meta3 = readRecord(name);
@@ -19452,7 +19964,7 @@ function createPiCredentialImports(options = {}) {
     },
     async listOthers() {
       const auth = readAuth();
-      const ours = new Set(ownedRecords(auth).map((record7) => record7.name));
+      const ours = new Set(ownedRecords(auth).map((record9) => record9.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)) {
@@ -19465,7 +19977,7 @@ function createPiCredentialImports(options = {}) {
           ...describeOauth(credential)
         });
       }
-      const modelsPath = path9.join(agentDir, "models.json");
+      const modelsPath = path10.join(agentDir, "models.json");
       if (existsSync(modelsPath)) {
         const models = JSON.parse(readFileSync(modelsPath, "utf8"));
         const providers = object2(models) && object2(models.providers) ? models.providers : {};
@@ -19486,8 +19998,8 @@ function createPiCredentialImports(options = {}) {
         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 record7 = credentialImportRecordSchema.parse({
+      const owner = randomUUID2();
+      const record9 = credentialImportRecordSchema.parse({
         name,
         source: transfer.source,
         importedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -19499,15 +20011,15 @@ function createPiCredentialImports(options = {}) {
       try {
         sdk.backend.withLock((current) => {
           const auth = parseAuth(current);
-          const modelsPath = path9.join(agentDir, "models.json");
+          const modelsPath = path10.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(path9.join(extensionsDir, `${name}-provider.ts`)))
+          if (Object.hasOwn(auth, name) || Object.hasOwn(models.providers ?? {}, name) || existsSync(dir) || existsSync(path10.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(path9.join(dir, "import.json"), JSON.stringify({ version: 1, owner, record: record7, extension }), { flag: "wx", mode: 384 });
-          writeFileSync(path9.join(dir, "index.ts"), extension, { flag: "wx", mode: 384 });
+          writeFileSync(path10.join(dir, "import.json"), JSON.stringify({ version: 1, owner, record: record9, extension }), { flag: "wx", mode: 384 });
+          writeFileSync(path10.join(dir, "index.ts"), extension, { flag: "wx", mode: 384 });
           auth[name] = { type: "oauth", ...transfer.oauth, codexhostImportId: owner };
           saveAuth(auth);
           committed = true;
@@ -19526,7 +20038,7 @@ function createPiCredentialImports(options = {}) {
         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 = path9.join(location(name), "import.json");
+        const metadataPath = path10.join(location(name), "import.json");
         const previous = readFileSync(metadataPath, "utf8");
         const updated = {
           ...meta3,
@@ -19561,10 +20073,10 @@ function createPiCredentialImports(options = {}) {
 }
 
 // dist/pi-fast-mode.js
-import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir, readFile as readFile2, rename, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import path10 from "node:path";
+import { createHash as createHash5, randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir as mkdir2, readFile as readFile3, rename as rename2, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import path11 from "node:path";
 var PI_FAST_COMMAND = "codexhost-fast-mode";
 var PI_FAST_ACK = "codexhost-fast-mode:";
 var PI_FAST_EXTENSION = `export default function(pi) {
@@ -19614,24 +20126,24 @@ var PI_FAST_EXTENSION = `export default function(pi) {
 }
 `;
 async function ensurePiFastExtension(environment) {
-  const digest = createHash2("sha256").update(PI_FAST_EXTENSION).digest("hex").slice(0, 16);
-  const dataDirectory = environment.CODEXHOST_DATA_DIR ?? path10.join(environment.HOME ?? environment.USERPROFILE ?? homedir4(), ".codexhost");
-  const directory = path10.resolve(dataDirectory, "extensions", "pi-codex-fast");
-  const file2 = path10.join(directory, `${digest}.mjs`);
-  if (await readFile2(file2, "utf8").catch(() => "") === PI_FAST_EXTENSION)
+  const digest = createHash5("sha256").update(PI_FAST_EXTENSION).digest("hex").slice(0, 16);
+  const dataDirectory = environment.CODEXHOST_DATA_DIR ?? path11.join(environment.HOME ?? environment.USERPROFILE ?? homedir5(), ".codexhost");
+  const directory = path11.resolve(dataDirectory, "extensions", "pi-codex-fast");
+  const file2 = path11.join(directory, `${digest}.mjs`);
+  if (await readFile3(file2, "utf8").catch(() => "") === PI_FAST_EXTENSION)
     return file2;
-  await mkdir(directory, { recursive: true });
-  const temporary = `${file2}.${randomUUID2()}.tmp`;
+  await mkdir2(directory, { recursive: true });
+  const temporary = `${file2}.${randomUUID3()}.tmp`;
   try {
-    await writeFile2(temporary, PI_FAST_EXTENSION, { mode: 384 });
+    await writeFile3(temporary, PI_FAST_EXTENSION, { mode: 384 });
     try {
-      await rename(temporary, file2);
+      await rename2(temporary, file2);
     } catch (error51) {
-      if (await readFile2(file2, "utf8").catch(() => "") !== PI_FAST_EXTENSION)
+      if (await readFile3(file2, "utf8").catch(() => "") !== PI_FAST_EXTENSION)
         throw error51;
     }
   } finally {
-    await rm2(temporary, { force: true });
+    await rm3(temporary, { force: true });
   }
   return file2;
 }
@@ -19648,15 +20160,15 @@ function withPiFast(catalog, supported) {
 // dist/pi-empty-session.js
 import { createReadStream as createReadStream3 } from "node:fs";
 import { createInterface as createInterface3 } from "node:readline";
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { link, open as open2, rm as rm3 } from "node:fs/promises";
-import path11 from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { link, open as open2, rm as rm4 } from "node:fs/promises";
+import path12 from "node:path";
 
 // dist/pi-session-file.js
 import { open, realpath as realpath3 } from "node:fs/promises";
 var MAX_SESSION_HEADER_BYTES = 64 * 1024;
 var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function readPiSessionHeader(sessionFile) {
@@ -19676,7 +20188,7 @@ async function readPiSessionHeader(sessionFile) {
     } catch {
       throw new Error("Pi Session header is not valid JSON");
     }
-    if (!isRecord7(parsed) || parsed.type !== "session" || typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
+    if (!isRecord8(parsed) || parsed.type !== "session" || typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
       throw new Error("Pi Session header is invalid");
     }
     return {
@@ -19709,7 +20221,7 @@ async function verifyPiSessionCwd(input) {
 async function persistEmptyPiSession(input) {
   const { state: state2, history, sourceSessionFile, sourceSessionId, cwd } = input;
   const destination = state2.sessionFile;
-  if (!destination || !path11.isAbsolute(destination) || path11.resolve(destination) === path11.resolve(sourceSessionFile) || state2.sessionId === sourceSessionId || mapPiSnapshot(history, { sessionId: state2.sessionId, model: null }).turns.length !== 0)
+  if (!destination || !path12.isAbsolute(destination) || path12.resolve(destination) === path12.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,
@@ -19733,7 +20245,7 @@ async function persistEmptyPiSession(input) {
     cwd,
     parentSession: sourceSessionFile
   };
-  const temporary = path11.join(path11.dirname(destination), `.codexhost-${randomUUID3()}.tmp`);
+  const temporary = path12.join(path12.dirname(destination), `.codexhost-${randomUUID4()}.tmp`);
   try {
     const file2 = await open2(temporary, "wx", 384);
     try {
@@ -19744,7 +20256,7 @@ async function persistEmptyPiSession(input) {
     }
     await link(temporary, destination);
     if (process.platform !== "win32") {
-      const directory = await open2(path11.dirname(destination), "r");
+      const directory = await open2(path12.dirname(destination), "r");
       try {
         await directory.sync();
       } finally {
@@ -19752,7 +20264,7 @@ async function persistEmptyPiSession(input) {
       }
     }
   } finally {
-    await rm3(temporary, { force: true });
+    await rm4(temporary, { force: true });
   }
 }
 async function readPiEmptySessionConfiguration(sessionFile) {
@@ -19808,20 +20320,20 @@ async function readPiEmptySessionConfiguration(sessionFile) {
 }
 
 // dist/pi-adapter.js
-import { randomUUID as randomUUID6 } from "node:crypto";
-import path15 from "node:path";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import path16 from "node:path";
 
 // dist/pi-workflow-child-history.js
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { constants } from "node:fs";
 import { open as open3 } from "node:fs/promises";
-import path12 from "node:path";
-function record5(value) {
+import path13 from "node:path";
+function record7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var MAX_SESSION_BYTES = 8 * 1024 * 1024;
-async function childHistory(file2, parentSessionId, identity) {
-  if (!path12.isAbsolute(file2))
+async function childHistory(file2, parentSessionId, identity, validateParent = false) {
+  if (!path13.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 {
@@ -19834,12 +20346,14 @@ async function childHistory(file2, parentSessionId, identity) {
       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 (!record5(header) || header.type !== "session" || typeof header.id !== "string" || header.version !== 3)
+    if (!record7(header) || header.type !== "session" || typeof header.id !== "string" || header.version !== 3)
       throw new Error("Unsupported Pi child Session header");
+    if (validateParent && header.parentSession !== parentSessionId)
+      throw new Error("Pi child Session parent identity mismatch");
     const entries = [];
     for (const entry of values.slice(1)) {
       const parsed = jsonValueSchema.safeParse(entry);
-      if (!parsed.success || !record5(parsed.data) || typeof parsed.data.id !== "string")
+      if (!parsed.success || !record7(parsed.data) || typeof parsed.data.id !== "string")
         throw new Error("Malformed Pi child Session entry");
       entries.push(parsed.data);
     }
@@ -19849,7 +20363,7 @@ async function childHistory(file2, parentSessionId, identity) {
       model: null,
       ...typeof header.cwd === "string" ? { cwd: header.cwd } : {}
     });
-    const prefix = createHash3("sha256").update(identity).digest("hex");
+    const prefix = createHash6("sha256").update(identity).digest("hex");
     return {
       turns: snapshot.turns.map((turn) => {
         const readonlyTurn = {
@@ -19870,7 +20384,7 @@ async function childHistory(file2, parentSessionId, identity) {
 async function readPiWorkflowChild(history, parentSessionId, address) {
   for (const entry of activePiEntries(history).reverse()) {
     const message3 = entry.message;
-    if (!record5(message3) || message3.role !== "toolResult" || message3.toolName !== "subagent")
+    if (!record7(message3) || message3.role !== "toolResult" || message3.toolName !== "subagent")
       continue;
     const summary = piWorkflowSummary(message3);
     if (!summary || summary.workflowRunId !== address.workflowRunId || summary.parentToolCallId !== message3.toolCallId)
@@ -19879,10 +20393,10 @@ async function readPiWorkflowChild(history, parentSessionId, address) {
     if (!child)
       break;
     const details = message3.details;
-    if (!record5(details) || !Array.isArray(details.results))
+    if (!record7(details) || !Array.isArray(details.results))
       break;
-    const result = details.results.findLast((candidate) => record5(candidate) && candidate.workflowKey === address.childId);
-    if (!record5(result))
+    const result = details.results.findLast((candidate) => record7(candidate) && candidate.workflowKey === address.childId);
+    if (!record7(result))
       break;
     const id = piWorkflowSubagentId(address);
     if (typeof result.sessionFile === "string") {
@@ -19925,25 +20439,69 @@ ${output}`,
   };
 }
 
+// dist/pi-gotgenes-history.js
+function gotgenesHistory(history) {
+  const records = /* @__PURE__ */ new Map();
+  for (const entry of activePiEntries(history)) {
+    const message3 = entry.message;
+    const parsed = entry.type === "custom" && entry.customType === "subagents:record" ? gotgenesRecord(entry.data) : isRecord4(message3) && message3.role === "toolResult" && typeof message3.toolName === "string" ? gotgenesToolRecord(message3.toolName, message3) : null;
+    if (!parsed)
+      continue;
+    records.set(parsed.id, mergeGotgenesRecord(records.get(parsed.id), parsed));
+  }
+  return [...records.values()];
+}
+function restoreGotgenes(history, observer) {
+  observer.observe(gotgenesHistory(history), false);
+}
+async function readGotgenesChild(history, parentSessionId, id, live) {
+  const saved = gotgenesHistory(history).find((entry) => entry.id === id);
+  const record9 = live?.outputFile ? live : saved;
+  if (!record9?.outputFile)
+    return {
+      ok: false,
+      error: {
+        code: "sessionNotFound",
+        message: "Pi subagent has not published its Session transcript path",
+        retryable: true
+      }
+    };
+  try {
+    return {
+      ok: true,
+      value: await childHistory(record9.outputFile, parentSessionId, gotgenesId(id), true)
+    };
+  } catch (error51) {
+    return {
+      ok: false,
+      error: {
+        code: "unavailable",
+        message: error51 instanceof Error ? error51.message : "Pi child transcript unavailable",
+        retryable: true
+      }
+    };
+  }
+}
+
 // dist/pi-subagent-history.js
 import { constants as constants2 } from "node:fs";
 import { open as open4 } from "node:fs/promises";
-import path13 from "node:path";
-function record6(value) {
+import path14 from "node:path";
+function record8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function state(value) {
   return value === "pending" ? "queued" : value === "completed" ? "complete" : value;
 }
 function piSubagentArtifact(value, runId, parentSessionId) {
-  if (!record6(value) || value.lifecycleArtifactVersion !== 3 || value.runId !== runId || value.sessionId !== parentSessionId || !["single", "parallel", "chain", "workflow"].includes(String(value.mode)))
+  if (!record8(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 (!record6(step) || typeof step.agent !== "string")
+    if (!record8(step) || typeof step.agent !== "string")
       return null;
     children.push({
       id: step.workflowKey ?? step.runId ?? `step:${index}`,
@@ -19974,19 +20532,20 @@ function piSubagentArtifact(value, runId, parentSessionId) {
   });
 }
 async function restorePiSubagents(history, parentSessionId, observer) {
+  restoreGotgenes(history, observer.gotgenes);
   const receipts = /* @__PURE__ */ new Map();
   for (const entry of activePiEntries(history)) {
-    if (!record6(entry.message) || entry.message.role !== "toolResult" || entry.message.toolName !== "subagent" || entry.message.isError !== false || !record6(entry.message.details))
+    if (!record8(entry.message) || entry.message.role !== "toolResult" || entry.message.toolName !== "subagent" || entry.message.isError !== false || !record8(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" || !path13.isAbsolute(details.asyncDir) || path13.basename(details.asyncDir) !== details.asyncId)
+    if (!["single", "parallel", "chain", "workflow"].includes(String(details.mode)) || typeof details.asyncId !== "string" || typeof details.asyncDir !== "string" || !path14.isAbsolute(details.asyncDir) || path14.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(path13.join(directory, "status.json"), constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
+      file2 = await open4(path14.join(directory, "status.json"), constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
       const stat2 = await file2.stat();
       if (!stat2.isFile() || stat2.size > 1024 * 1024)
         continue;
@@ -20068,8 +20627,8 @@ async function rollbackPiLastTurn(transport, sourceSessionId, cwd) {
 
 // dist/pi-rpc-session.js
 import { spawn, spawnSync } from "node:child_process";
-import { randomUUID as randomUUID5 } from "node:crypto";
-import path14 from "node:path";
+import { randomUUID as randomUUID6 } from "node:crypto";
+import path15 from "node:path";
 
 // dist/pi-slash-commands.js
 var DYNAMIC_ID_PREFIX = "pi.slash.";
@@ -20091,15 +20650,15 @@ function parsePiNativeCommands(response) {
   return data.commands.flatMap((entry) => {
     if (typeof entry !== "object" || entry === null)
       return [];
-    const record7 = entry;
-    const name = typeof record7.name === "string" ? record7.name.trim().replace(/^\//u, "") : "";
+    const record9 = entry;
+    const name = typeof record9.name === "string" ? record9.name.trim().replace(/^\//u, "") : "";
     if (!name)
       return [];
     return [
       {
         name,
-        ...typeof record7.description === "string" ? { description: record7.description } : {},
-        ...typeof record7.source === "string" ? { source: record7.source } : {}
+        ...typeof record9.description === "string" ? { description: record9.description } : {},
+        ...typeof record9.source === "string" ? { source: record9.source } : {}
       }
     ];
   });
@@ -20115,8 +20674,97 @@ function piDynamicCommandPrompt(catalog, commandId, argumentText) {
   return liveHarnessCommandPrompt(catalog, DYNAMIC_ID_PREFIX, commandId, argumentText);
 }
 
+// dist/pi-content-stream.js
+var PiContentStreamConflictError = class extends Error {
+};
+var PiContentStream = class {
+  kind;
+  #blocks = /* @__PURE__ */ new Map();
+  #indexed;
+  #legacyBlockIndex = 0;
+  #lastEmittedIndex = -Infinity;
+  constructor(kind) {
+    this.kind = kind;
+  }
+  append(index, delta) {
+    const block = this.#block(this.#key(index));
+    if (block.ended && delta.length > 0)
+      this.#conflict();
+    block.received += delta;
+    return this.#flush();
+  }
+  complete(index, content) {
+    this.#finish(this.#key(index), content);
+    if (this.#indexed === false)
+      this.#legacyBlockIndex += 1;
+    return this.#flush();
+  }
+  finalize(blocks) {
+    if (this.#indexed !== true) {
+      blocks = this.#legacyBlockIndex > 0 ? blocks.map(({ text: text3 }, index) => ({ index, text: text3 })) : [{ index: 0, text: blocks.map(({ text: text3 }) => text3).join("") }];
+    }
+    const indices = new Set(blocks.map(({ index }) => index));
+    for (const [index, block] of this.#blocks) {
+      if (indices.has(index))
+        continue;
+      if (block.emitted.length > 0)
+        this.#conflict();
+      this.#blocks.delete(index);
+    }
+    for (const { index, text: text3 } of blocks)
+      this.#finish(index, text3);
+    return this.#flush();
+  }
+  #key(index) {
+    const indexed = typeof index === "number" && Number.isInteger(index) && index >= 0;
+    this.#indexed ??= indexed;
+    if (!this.#indexed)
+      return this.#legacyBlockIndex;
+    if (!indexed)
+      this.#conflict();
+    return index;
+  }
+  #block(index) {
+    let block = this.#blocks.get(index);
+    if (!block) {
+      block = { received: "", emitted: "", ended: false };
+      this.#blocks.set(index, block);
+    }
+    return block;
+  }
+  #finish(index, content) {
+    const block = this.#block(index);
+    if (!content.startsWith(block.emitted))
+      this.#conflict();
+    block.received = content;
+    block.ended = true;
+  }
+  #flush() {
+    let delta = "";
+    for (const [index, block] of [...this.#blocks].sort(([left], [right]) => left - right)) {
+      const visible = this.kind === "reasoning" && !block.ended ? block.received.replace(/[\r\n]+$/u, "") : block.received;
+      if (!visible.startsWith(block.emitted))
+        this.#conflict();
+      const suffix = visible.slice(block.emitted.length);
+      if (suffix.length > 0) {
+        if (index < this.#lastEmittedIndex)
+          this.#conflict();
+        this.#lastEmittedIndex = index;
+        block.emitted = visible;
+        delta += suffix;
+      }
+      if (!block.ended)
+        break;
+    }
+    return delta;
+  }
+  #conflict() {
+    throw new PiContentStreamConflictError(`Pi ${this.kind} final content conflicts with already streamed content`);
+  }
+};
+
 // dist/pi-subagent-rpc.js
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 var PiSubagentRpc = class {
   send;
   timeoutMs;
@@ -20158,7 +20806,7 @@ var PiSubagentRpc = class {
     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 = randomUUID4();
+    const requestId = randomUUID5();
     const reply = new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.#pending.delete(requestId);
@@ -20192,6 +20840,12 @@ var PiSubagentRpc = class {
 };
 
 // dist/pi-rpc-session.js
+var PiRpcBusyError = class extends Error {
+  constructor() {
+    super("Pi is still running a native Turn; wait for completion or use the active Turn's stop/steer action");
+    this.name = "PiRpcBusyError";
+  }
+};
 var PiRpcFaultError = class extends Error {
   kind;
   diagnostic;
@@ -20219,8 +20873,11 @@ var READ_ONLY_COMMANDS = /* @__PURE__ */ new Set([
   "get_available_thinking_levels"
 ]);
 var MAX_EXPIRED_IDS = 64;
+function nativeMessageIdentity(active) {
+  return active.assistantNativeMessageIdentity ? { nativeMessageIdentity: active.assistantNativeMessageIdentity } : {};
+}
 var textDecoder = new TextDecoder("utf-8", { fatal: true });
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function message2(value) {
@@ -20232,13 +20889,13 @@ function nonBlankString(value) {
 function parseNativeModel(value, context) {
   if (value === null || value === void 0)
     return null;
-  if (!isRecord8(value) || !nonBlankString(value.provider) || !nonBlankString(value.id)) {
+  if (!isRecord9(value) || !nonBlankString(value.provider) || !nonBlankString(value.id)) {
     throw new PiRpcFaultError("protocolError", `Pi RPC returned an invalid ${context} Model`);
   }
   return { provider: value.provider, id: value.id };
 }
 function sessionStateData(response) {
-  const data = isRecord8(response.data) ? response.data : null;
+  const data = isRecord9(response.data) ? response.data : null;
   if (!data)
     throw new PiRpcFaultError("protocolError", "Pi RPC state response has no data");
   return data;
@@ -20246,7 +20903,7 @@ function sessionStateData(response) {
 function parseSessionState(response) {
   const data = sessionStateData(response);
   const model2 = parseNativeModel(data.model, "state");
-  const modelReasoning = isRecord8(data.model) && typeof data.model.reasoning === "boolean" ? data.model.reasoning : null;
+  const modelReasoning = isRecord9(data.model) && typeof data.model.reasoning === "boolean" ? data.model.reasoning : null;
   if (!nonBlankString(data.sessionId)) {
     throw new PiRpcFaultError("protocolError", "Pi RPC state has no stable Session identity");
   }
@@ -20272,13 +20929,13 @@ function parseSessionStreaming(response) {
   return isStreaming;
 }
 function parseSessionHistory(response) {
-  const data = isRecord8(response.data) ? response.data : null;
+  const data = isRecord9(response.data) ? response.data : null;
   if (!data || !Array.isArray(data.entries)) {
     throw new PiRpcFaultError("protocolError", "Pi RPC entries response has no Entries");
   }
   const entries = data.entries.map((entry) => {
     const parsed = jsonValueSchema.safeParse(entry);
-    if (!parsed.success || !isRecord8(parsed.data)) {
+    if (!parsed.success || !isRecord9(parsed.data)) {
       throw new PiRpcFaultError("protocolError", "Pi RPC entries response contains an invalid Entry");
     }
     return parsed.data;
@@ -20289,7 +20946,7 @@ function parseSessionHistory(response) {
   return { entries, leafId: data.leafId };
 }
 function parseAvailableThinkingLevels(response) {
-  const data = isRecord8(response.data) ? response.data : null;
+  const data = isRecord9(response.data) ? response.data : null;
   if (!data || !Array.isArray(data.levels) || data.levels.length === 0) {
     throw new PiRpcFaultError("protocolError", "Pi RPC Thinking catalog response has no levels");
   }
@@ -20306,13 +20963,13 @@ function parseAvailableThinkingLevels(response) {
   return levels;
 }
 function parseAvailableModels(response) {
-  const data = isRecord8(response.data) ? response.data : null;
+  const data = isRecord9(response.data) ? response.data : null;
   if (!data || !Array.isArray(data.models)) {
     throw new PiRpcFaultError("protocolError", "Pi RPC Model catalog response has no models");
   }
   return data.models.map((model2) => {
     const parsed = parseNativeModel(model2, "catalog");
-    if (!parsed || !isRecord8(model2) || typeof model2.reasoning !== "boolean") {
+    if (!parsed || !isRecord9(model2) || typeof model2.reasoning !== "boolean") {
       throw new PiRpcFaultError("protocolError", "Pi RPC catalog contains a Model without reasoning capability");
     }
     return {
@@ -20323,32 +20980,32 @@ function parseAvailableModels(response) {
   });
 }
 function assistantText(value) {
-  if (!isRecord8(value) || value.role !== "assistant" || !Array.isArray(value.content))
+  if (!isRecord9(value) || value.role !== "assistant" || !Array.isArray(value.content))
     return null;
-  return value.content.filter((content) => isRecord8(content) && content.type === "text" && typeof content.text === "string").map((content) => content.text).join("");
+  return value.content.filter((content) => isRecord9(content) && content.type === "text" && typeof content.text === "string").map((content) => content.text).join("");
 }
 function assistantMessageId(value) {
-  if (!isRecord8(value) || value.role !== "assistant")
+  if (!isRecord9(value) || value.role !== "assistant")
     return null;
   return nonBlankString(value.responseId) ? value.responseId : null;
 }
 function extractReasoningText(content) {
-  if (!isRecord8(content))
+  if (!isRecord9(content))
     return null;
   const type = String(content.type ?? "");
   if (type === "thinking" || type === "reasoning" || type === "thought") {
-    const text2 = content.thinking ?? content.reasoning ?? content.text ?? content.delta;
-    return typeof text2 === "string" ? text2 : null;
+    const text3 = content.thinking ?? content.reasoning ?? content.text ?? content.delta;
+    return typeof text3 === "string" ? text3 : null;
   }
   return null;
 }
 function assistantReasoning(value) {
-  if (!isRecord8(value) || value.role !== "assistant" || !Array.isArray(value.content))
+  if (!isRecord9(value) || value.role !== "assistant" || !Array.isArray(value.content))
     return null;
-  return value.content.map(extractReasoningText).filter((text2) => typeof text2 === "string").join("");
+  return value.content.map(extractReasoningText).filter((text3) => typeof text3 === "string").join("");
 }
 function assistantFailure(value) {
-  if (!isRecord8(value) || value.role !== "assistant")
+  if (!isRecord9(value) || value.role !== "assistant")
     return void 0;
   if (value.stopReason !== "error" && value.stopReason !== "aborted")
     return null;
@@ -20368,7 +21025,7 @@ function signalProcessTree(child, signal) {
   try {
     process.kill(-child.pid, signal);
   } catch (error51) {
-    if (!isRecord8(error51) || error51.code !== "ESRCH")
+    if (!isRecord9(error51) || error51.code !== "ESRCH")
       throw error51;
   }
 }
@@ -20405,13 +21062,14 @@ function piRpcProcessCommand(options, dependencies = {}) {
   const thinkingArguments = options.emptySessionConfiguration ? ["--thinking", options.emptySessionConfiguration.thinkingLevel] : [];
   const arguments_ = [
     ...options.fastExtension ? ["--extension", options.fastExtension] : [],
+    ...options.subagentExtension ? ["--extension", options.subagentExtension] : [],
     "--mode",
     "rpc",
     ...modelArguments,
     ...thinkingArguments,
     ...sessionArguments
   ];
-  const extension = path14.win32.extname(command).toLowerCase();
+  const extension = path15.win32.extname(command).toLowerCase();
   if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
     return { command, arguments: arguments_, windowsVerbatimArguments: false };
   }
@@ -20440,7 +21098,13 @@ var PiRpcSession = class {
   #options;
   #processAdapter;
   #activeTurn = null;
+  #runGeneration = 0;
+  #deferredRunFrames = [];
+  #deferredRunBytes = 0;
+  #runWaiters = /* @__PURE__ */ new Set();
+  #messageTimestampCounts = /* @__PURE__ */ new Map();
   #autonomousTurnHandler = null;
+  #autonomousLifecycleHandler = null;
   #usageHandler = null;
   #usageRequestStartedAtMs = null;
   // Pieces of the unterminated frame; joined once at its newline so a large frame (a long
@@ -20460,8 +21124,15 @@ var PiRpcSession = class {
   #fastAcknowledgement = null;
   #latestCacheHitRatePercent;
   #manualCompaction = null;
+  #noticeOccurrences = /* @__PURE__ */ new Map();
+  #seenNoticeFrames = /* @__PURE__ */ new Set();
+  #pendingProgress = [];
+  #omittedProgress = 0;
+  #extensionStatuses = /* @__PURE__ */ new Map();
   #stderrTail = "";
   #subagents;
+  #gotgenesHandler;
+  #gotgenesLatest;
   constructor(options, processAdapter = nodeProcessAdapter) {
     if (options.sessionFile && options.forkSessionFile) {
       throw new Error("Pi RPC cannot combine Session resume and Fork startup");
@@ -20491,9 +21162,17 @@ var PiRpcSession = class {
   get stderrTail() {
     return this.#stderrTail;
   }
+  get isBusy() {
+    return this.#activeTurn !== null || this.#manualCompaction !== null || this.#compactionActive || this.#deferredRunFrames.length > 0;
+  }
   setSubagentStatusHandler(handler) {
     this.#subagents.setHandler(handler);
   }
+  setGotgenesStatusHandler(handler) {
+    this.#gotgenesHandler = handler;
+    if (this.#gotgenesLatest)
+      handler(this.#gotgenesLatest, "idle");
+  }
   inspectSubagent(id) {
     return this.#subagents.inspect(id);
   }
@@ -20503,17 +21182,18 @@ var PiRpcSession = class {
   /** Every finished assistant message is one model request, with or without an active Turn. */
   #observeUsage(value) {
     if (value.type === "message_start") {
-      this.#usageRequestStartedAtMs = null;
+      if (isRecord9(value.message) && value.message.role === "assistant")
+        this.#usageRequestStartedAtMs = null;
       return;
     }
     if (value.type === "message_update") {
       const event = value.assistantMessageEvent;
-      if (this.#usageRequestStartedAtMs === null && isRecord8(event) && typeof event.type === "string" && /^(text|thinking|reasoning|thought|toolcall)_(start|delta)$/u.test(event.type)) {
+      if (this.#usageRequestStartedAtMs === null && isRecord9(event) && typeof event.type === "string" && /^(text|thinking|reasoning|thought|toolcall)_(start|delta)$/u.test(event.type)) {
         this.#usageRequestStartedAtMs = Date.now();
       }
       return;
     }
-    if (value.type === "message_end" && isRecord8(value.message)) {
+    if (value.type === "message_end" && isRecord9(value.message)) {
       if (value.message.role !== "assistant")
         return;
       const startedAtMs = this.#usageRequestStartedAtMs;
@@ -20527,14 +21207,21 @@ var PiRpcSession = class {
   }
   setAutonomousTurnHandler(handler) {
     this.#autonomousTurnHandler = handler;
+    this.#autonomousLifecycleHandler = null;
+  }
+  setAutonomousTurnLifecycleHandler(handler) {
+    this.#autonomousLifecycleHandler = handler;
+    this.#autonomousTurnHandler = null;
   }
   async start() {
     if (this.#child || this.#closed)
       throw new Error("Pi RPC Session cannot be started twice");
     const fastExtension = this.#processAdapter === nodeProcessAdapter ? await ensurePiFastExtension({ ...process.env, ...this.#options.environment }) : void 0;
+    const subagentExtension = this.#processAdapter === nodeProcessAdapter ? await ensureGotgenesExtension({ ...process.env, ...this.#options.environment }) : void 0;
     const child = this.#processAdapter.spawn({
       cwd: this.#options.cwd,
       ...fastExtension ? { fastExtension } : {},
+      ...subagentExtension ? { subagentExtension } : {},
       ...this.#options.command ? { command: this.#options.command } : {},
       environment: withNodeRuntimeOnPath({
         ...process.env,
@@ -20558,7 +21245,7 @@ var PiRpcSession = class {
       this.#stderrTail = sanitizeDiagnosticTail(`${this.#stderrTail}${chunk.toString()}`);
     });
     child.once("error", (error51) => {
-      const kind = isRecord8(error51) && error51.code === "ENOENT" ? "notInstalled" : "unavailable";
+      const kind = isRecord9(error51) && error51.code === "ENOENT" ? "notInstalled" : "unavailable";
       this.#fail(new PiRpcFaultError(kind, `Pi RPC failed to start: ${error51.message}`, this.stderrTail));
     });
     child.once("exit", (code, signal) => {
@@ -20575,6 +21262,7 @@ var PiRpcSession = class {
     ]);
     try {
       this.#state = parseSessionState(await this.#send("get_state", {}));
+      await this.getEntries();
     } catch (error51) {
       const fault = error51 instanceof PiRpcFaultError ? error51 : new PiRpcFaultError("unavailable", `Pi RPC state unavailable: ${message2(error51)}`);
       this.#fail(fault);
@@ -20588,7 +21276,12 @@ var PiRpcSession = class {
   }
   async getEntries() {
     try {
-      return parseSessionHistory(await this.#send("get_entries", {}));
+      const history = parseSessionHistory(await this.#send("get_entries", {}));
+      if (!this.#activeTurn && this.#state) {
+        this.#messageTimestampCounts = piHistoryMessageIdentities(this.state.sessionId, activePiEntries(history)).timestampCounts;
+        this.#noticeOccurrences = piHistoryNotices(this.state.sessionId, activePiEntries(history)).occurrences;
+      }
+      return history;
     } catch (error51) {
       if (error51 instanceof PiRpcFaultError)
         this.#fail(error51);
@@ -20648,11 +21341,15 @@ var PiRpcSession = class {
     if (entryId.length === 0)
       throw new Error("Pi Fork Entry ID must not be empty");
     await this.#send("fork", { entryId });
-    return this.#refreshState("Fork");
+    const state2 = await this.#refreshState("Fork");
+    await this.getEntries();
+    return state2;
   }
   async clone() {
     await this.#send("clone", {});
-    return this.#refreshState("Clone");
+    const state2 = await this.#refreshState("Clone");
+    await this.getEntries();
+    return state2;
   }
   verifySessionCwd(expectedCwd) {
     return verifyPiSessionCwd({
@@ -20689,7 +21386,7 @@ var PiRpcSession = class {
       return this.state;
     if (!await this.supportsFastMode())
       throw new Error("Installed Pi does not support the Host Fast extension");
-    const nonce = randomUUID5();
+    const nonce = randomUUID6();
     const mode = enabled ? "on" : "off";
     const acknowledgement = { message: `${PI_FAST_ACK}${nonce}:${mode}`, received: false };
     this.#fastAcknowledgement = acknowledgement;
@@ -20729,22 +21426,27 @@ var PiRpcSession = class {
       throw fault;
     }
   }
-  async runTurn(text2, onEvent) {
+  async runTurn(text3, 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 (text2.length === 0)
+    if (this.isBusy)
+      throw new PiRpcBusyError();
+    if (text3.length === 0)
       throw new Error("Pi text Turn must not be empty");
     const settled = new Promise((resolve, reject) => {
       this.#activeTurn = {
         origin: "requested",
+        autonomousRunId: null,
+        runGeneration: this.#runGeneration,
         autonomousEvents: null,
         nativeTurnKey: null,
         nativeCancellationObserved: false,
         text: "",
         assistantMessageId: null,
+        assistantNativeMessageIdentity: void 0,
+        textStream: new PiContentStream("text"),
+        reasoningStream: new PiContentStream("reasoning"),
         sawStreamedMessageText: false,
         sawStreamedMessageReasoning: false,
         lastFinalizedMessageText: null,
@@ -20764,7 +21466,8 @@ var PiRpcSession = class {
       };
     });
     try {
-      await this.#send("prompt", { message: text2 });
+      this.#drainProgress(onEvent);
+      await this.#send("prompt", { message: text3 });
     } catch (error51) {
       this.#rejectActiveTurn(error51 instanceof Error ? error51 : new Error(message2(error51)));
     }
@@ -20836,6 +21539,10 @@ var PiRpcSession = class {
     void this.close().catch(() => void 0);
   }
   close() {
+    this.#pendingProgress = [];
+    this.#omittedProgress = 0;
+    this.#seenNoticeFrames.clear();
+    this.#extensionStatuses.clear();
     if (!this.#closed) {
       this.#closed = true;
       this.#rejectAll(new Error("Pi RPC Session closed"));
@@ -20869,19 +21576,25 @@ var PiRpcSession = class {
       rest = rest.subarray(newline + 1);
       try {
         const value = JSON.parse(textDecoder.decode(frame));
-        if (!isRecord8(value) || typeof value.type !== "string") {
+        if (!isRecord9(value) || typeof value.type !== "string") {
           throw new PiRpcFaultError("protocolError", "Pi RPC returned an invalid envelope");
         }
         this.#handle(value);
       } catch (error51) {
-        this.#fail(error51 instanceof PiRpcFaultError ? error51 : new PiRpcFaultError("protocolError", `Pi RPC returned invalid JSONL: ${message2(error51)}`));
+        this.#fail(error51 instanceof PiRpcFaultError ? error51 : new PiRpcFaultError("protocolError", error51 instanceof PiContentStreamConflictError ? error51.message : `Pi RPC returned invalid JSONL: ${message2(error51)}`));
       }
       newline = rest.indexOf(10);
     }
     if (rest.length !== 0)
       this.#buffer.push(rest);
   }
-  #handle(value) {
+  #handle(value, observedGeneration) {
+    if (observedGeneration === void 0 && value.type === "agent_start") {
+      this.#runGeneration += 1;
+      for (const waiter of this.#runWaiters)
+        waiter.check();
+    }
+    const generation = observedGeneration ?? this.#runGeneration;
     if (value.type === "extension_ui_request" && value.method === "notify" && typeof value.message === "string" && value.message.startsWith(PI_FAST_ACK)) {
       if (this.#fastAcknowledgement?.message === value.message)
         this.#fastAcknowledgement.received = true;
@@ -20895,6 +21608,33 @@ var PiRpcSession = class {
     }
     if (this.#subagents.handle(value))
       return;
+    const settling = this.#activeTurn;
+    if (settling && settling.settlement !== "pending" && generation > settling.runGeneration) {
+      this.#deferredRunBytes += Buffer.byteLength(JSON.stringify(value));
+      if (this.#deferredRunBytes > 8 * 1024 * 1024) {
+        this.#fail(new PiRpcFaultError("protocolError", "Pi deferred run exceeded its event buffer bound"));
+        return;
+      }
+      this.#deferredRunFrames.push({ value, generation });
+      return;
+    }
+    if (value.type === "agent_start") {
+      if (this.#activeTurn)
+        this.#activeTurn.runGeneration = generation;
+      else if (!this.#manualCompaction && !this.#compactionActive && (this.#autonomousTurnHandler || this.#autonomousLifecycleHandler))
+        this.#startAutonomousTurn(void 0, generation);
+      return;
+    }
+    if (value.type === "extension_ui_request" && value.method === "setWidget" && value.widgetKey === GOTGENES_WIDGET) {
+      const records = parseGotgenesWidget(value);
+      if (records) {
+        this.#gotgenesLatest = records;
+        this.#gotgenesHandler?.(records, this.#activeTurn?.origin ?? "idle");
+      }
+      return;
+    }
+    if (this.#handleProgress(value))
+      return;
     this.#observeUsage(value);
     if (value.type === "compaction_start") {
       this.#compactionActive = true;
@@ -20918,7 +21658,7 @@ var PiRpcSession = class {
           this.#armCommandTimeout(id, pending);
         }
       }
-      const outcome = value.aborted === true ? "cancelled" : isRecord8(value.result) ? "succeeded" : "failed";
+      const outcome = value.aborted === true ? "cancelled" : isRecord9(value.result) ? "succeeded" : "failed";
       const event = {
         type: "compaction.completed",
         outcome,
@@ -20935,8 +21675,8 @@ var PiRpcSession = class {
       return;
     }
     let active = this.#activeTurn;
-    if (!active && !this.#manualCompaction && !this.#compactionActive && this.#autonomousTurnHandler && value.type === "message_start" && assistantText(value.message) !== null) {
-      active = this.#startAutonomousTurn(value.message);
+    if (!active && !this.#manualCompaction && !this.#compactionActive && (this.#autonomousTurnHandler || this.#autonomousLifecycleHandler) && value.type === "message_start" && assistantText(value.message) !== null) {
+      active = this.#startAutonomousTurn(value.message, generation);
     }
     if (!active) {
       if (value.type === "extension_ui_request" && this.#isBlockingInteraction(value)) {
@@ -20956,22 +21696,26 @@ var PiRpcSession = class {
       this.#startAssistantMessage(active, value.message);
       return;
     }
-    if (value.type === "message_update" && isRecord8(value.assistantMessageEvent)) {
+    if (value.type === "message_update" && isRecord9(value.assistantMessageEvent)) {
       const event = value.assistantMessageEvent;
       const eventType = String(event.type ?? "");
       const isThinking = eventType === "thinking_delta" || eventType === "reasoning_delta" || eventType === "thought_delta" || eventType === "thinking" || eventType === "reasoning";
       const isText = eventType === "text_delta" || eventType === "text" || eventType === "content_block_delta";
-      const delta = typeof event.delta === "string" ? event.delta : typeof event.thinking === "string" ? event.thinking : typeof event.reasoning === "string" ? event.reasoning : typeof event.text === "string" ? event.text : isRecord8(event.delta) && typeof event.delta.thinking === "string" ? event.delta.thinking : isRecord8(event.delta) && typeof event.delta.text === "string" ? event.delta.text : null;
-      if (isThinking && delta !== null && delta.length > 0) {
-        const messageId = this.#ensureAssistantMessage(active, value.message);
-        active.reasoningMessageOpen = true;
-        active.sawStreamedMessageReasoning = true;
-        active.onEvent({ type: "reasoning.delta", messageId, delta });
-      } else if (isText && delta !== null && delta.length > 0) {
-        const messageId = this.#ensureAssistantMessage(active, value.message);
-        active.text += delta;
-        active.sawStreamedMessageText = true;
-        active.onEvent({ type: "text.delta", messageId, delta });
+      const delta = typeof event.delta === "string" ? event.delta : typeof event.thinking === "string" ? event.thinking : typeof event.reasoning === "string" ? event.reasoning : typeof event.text === "string" ? event.text : isRecord9(event.delta) && typeof event.delta.thinking === "string" ? event.delta.thinking : isRecord9(event.delta) && typeof event.delta.text === "string" ? event.delta.text : null;
+      const endingReasoning = eventType === "thinking_end" || eventType === "reasoning_end";
+      const endingText = eventType === "text_end";
+      if ((endingReasoning || endingText) && typeof event.content === "string") {
+        this.#ensureAssistantMessage(active, value.message);
+        const stream = endingReasoning ? active.reasoningStream : active.textStream;
+        this.#emitContent(active, endingReasoning, stream.complete(event.contentIndex, event.content));
+      } else if ((isThinking || isText) && delta !== null && delta.length > 0) {
+        this.#ensureAssistantMessage(active, value.message);
+        if (isThinking)
+          active.sawStreamedMessageReasoning = true;
+        else
+          active.sawStreamedMessageText = true;
+        const stream = isThinking ? active.reasoningStream : active.textStream;
+        this.#emitContent(active, isThinking, stream.append(event.contentIndex, delta));
       } else if (event.type === "error") {
         this.#ensureAssistantMessage(active, value.message);
         active.failure = assistantFailure(event.error) ?? assistantFailure(value.message) ?? new Error("Pi assistant message failed");
@@ -21002,25 +21746,36 @@ var PiRpcSession = class {
       if (active.settlement !== "pending")
         return;
       active.settlement = "confirming";
-      void this.#confirmSettledTurn(active);
+      void this.#confirmSettledTurn(active, active.runGeneration);
     }
   }
-  #startAutonomousTurn(value) {
+  #startAutonomousTurn(value, generation) {
     const events = [];
+    const runId = randomUUID6();
     const active = {
       origin: "autonomous",
+      autonomousRunId: runId,
+      runGeneration: generation,
       autonomousEvents: events,
-      ...isRecord8(value) ? { autonomousMessage: value } : {},
+      ...isRecord9(value) ? { autonomousMessage: value } : {},
       nativeTurnKey: null,
       nativeCancellationObserved: false,
       text: "",
       assistantMessageId: null,
+      assistantNativeMessageIdentity: void 0,
+      textStream: new PiContentStream("text"),
+      reasoningStream: new PiContentStream("reasoning"),
       sawStreamedMessageText: false,
       sawStreamedMessageReasoning: false,
       lastFinalizedMessageText: null,
       lastFinalizedMessageReasoning: null,
       reasoningMessageOpen: false,
-      onEvent: (event) => events.push(event),
+      onEvent: (event) => {
+        if (this.#autonomousLifecycleHandler)
+          this.#autonomousLifecycleHandler({ type: "event", runId, event });
+        else
+          events.push(event);
+      },
       resolve: () => void 0,
       reject: () => void 0,
       failure: null,
@@ -21033,19 +21788,108 @@ var PiRpcSession = class {
       abortPromise: null
     };
     this.#activeTurn = active;
+    this.#autonomousLifecycleHandler?.({ type: "started", runId });
+    this.#drainProgress(active.onEvent);
     return active;
   }
+  #handleProgress(value) {
+    if ((value.type === "message_start" || value.type === "message_end") && isRecord9(value.message) && value.message.role === "custom") {
+      if (value.type !== "message_end" || !this.#state)
+        return true;
+      const key = piCustomNoticeKey(value.message);
+      if (!key)
+        return true;
+      const timestamp = value.message.timestamp;
+      if ((typeof timestamp === "number" || typeof timestamp === "string") && !this.#acceptNoticeFrame(JSON.stringify([key, timestamp])))
+        return true;
+      const progress = piCustomNotice(value.message, this.state.sessionId, this.#noticeOccurrences);
+      if (progress)
+        this.#publishProgress(progress);
+      return true;
+    }
+    if (value.type === "extension_ui_request" && value.method === "setStatus") {
+      if (typeof value.statusKey !== "string")
+        return true;
+      if (typeof value.statusText !== "string" || !value.statusText.trim()) {
+        if (!this.#extensionStatuses.has(value.statusKey))
+          return true;
+        this.#extensionStatuses.delete(value.statusKey);
+      } else {
+        if (this.#extensionStatuses.get(value.statusKey) === value.statusText)
+          return true;
+        this.#extensionStatuses.set(value.statusKey, value.statusText);
+      }
+    }
+    const text3 = piStatusText(value);
+    if (!text3)
+      return false;
+    if (value.type === "extension_ui_request" && typeof value.id === "string" && !this.#acceptNoticeFrame(JSON.stringify([value.type, value.id])))
+      return true;
+    this.#publishProgress({
+      type: "progress.message",
+      itemId: hostItemIdSchema.parse(`pi-progress-${randomUUID6()}`),
+      text: text3
+    }, value.method === "setStatus" && typeof value.statusKey === "string" ? value.statusKey : void 0);
+    return true;
+  }
+  #acceptNoticeFrame(key) {
+    if (this.#seenNoticeFrames.has(key))
+      return false;
+    this.#seenNoticeFrames.add(key);
+    if (this.#seenNoticeFrames.size > 512)
+      this.#seenNoticeFrames.delete(this.#seenNoticeFrames.values().next().value);
+    return true;
+  }
+  #publishProgress(progress, statusKey) {
+    if (this.#activeTurn?.settlement === "pending") {
+      this.#activeTurn.onEvent(progress);
+      return;
+    }
+    if (statusKey !== void 0) {
+      const previous = this.#pendingProgress.findIndex((pending) => pending.statusKey === statusKey);
+      if (previous >= 0)
+        this.#pendingProgress.splice(previous, 1);
+    }
+    if (this.#pendingProgress.length >= 128) {
+      this.#pendingProgress.shift();
+      this.#omittedProgress += 1;
+    }
+    this.#pendingProgress.push({
+      event: progress,
+      ...statusKey !== void 0 ? { statusKey } : {}
+    });
+  }
+  #drainProgress(onEvent) {
+    if (this.#omittedProgress > 0) {
+      onEvent({
+        type: "progress.message",
+        itemId: hostItemIdSchema.parse(`pi-progress-${randomUUID6()}`),
+        text: `Pi notifications: ${this.#omittedProgress} earlier updates were not retained while idle. Persisted notifications remain available in conversation history.`
+      });
+      this.#omittedProgress = 0;
+    }
+    for (const pending of this.#pendingProgress.splice(0))
+      onEvent(pending.event);
+  }
   #emitAutonomousTurn(active, result) {
     const handler = this.#autonomousTurnHandler;
-    if (active.origin !== "autonomous" || !active.autonomousEvents || !handler) {
+    if (active.origin !== "autonomous" || !active.autonomousEvents || !active.autonomousRunId) {
       return;
     }
     try {
-      handler({
+      const turn = {
         nativeTurnKey: active.nativeTurnKey,
         events: [...active.autonomousEvents],
         result
-      });
+      };
+      if (this.#autonomousLifecycleHandler)
+        this.#autonomousLifecycleHandler({
+          type: "completed",
+          runId: active.autonomousRunId,
+          turn
+        });
+      else
+        handler?.(turn);
     } catch (error51) {
       this.#fail(new PiRpcFaultError("protocolError", `Pi autonomous Turn handler failed: ${message2(error51)}`));
     }
@@ -21192,31 +22036,73 @@ var PiRpcSession = class {
       isError: value.isError
     });
   }
-  async #confirmSettledTurn(active) {
+  #isSettlementCurrent(active, generation) {
+    return this.#activeTurn === active && active.runGeneration === generation && active.settlement === "confirming";
+  }
+  #waitForNextRun(generation) {
+    if (this.#runGeneration > generation)
+      return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const finish = (error51) => {
+        clearTimeout(timer);
+        this.#runWaiters.delete(waiter);
+        if (error51)
+          reject(error51);
+        else
+          resolve();
+      };
+      const waiter = {
+        check: () => {
+          if (this.#runGeneration > generation)
+            finish();
+        },
+        reject: (error51) => finish(error51)
+      };
+      const timer = setTimeout(() => finish(new PiRpcFaultError("protocolError", "Pi RPC agent_settled state is still Streaming without a subsequent agent_start")), this.#options.commandTimeoutMs);
+      this.#runWaiters.add(waiter);
+    });
+  }
+  #drainDeferredRunFrames() {
+    const frames = this.#deferredRunFrames;
+    this.#deferredRunFrames = [];
+    this.#deferredRunBytes = 0;
+    for (const frame of frames) {
+      if (this.#closed || this.#failed)
+        break;
+      this.#handle(frame.value, frame.generation);
+    }
+  }
+  async #confirmSettledTurn(active, generation) {
     try {
       const response = await this.#send("get_state", {});
       const state2 = parseSessionState(response);
-      if (parseSessionStreaming(response)) {
-        throw new PiRpcFaultError("protocolError", "Pi RPC agent_settled state is still Streaming");
-      }
-      if (this.#activeTurn !== active)
+      if (!this.#isSettlementCurrent(active, generation))
+        return;
+      if (parseSessionStreaming(response))
+        await this.#waitForNextRun(generation);
+      if (!this.#isSettlementCurrent(active, generation))
         return;
-      if (active.origin === "autonomous") {
+      if (active.origin === "autonomous" && active.autonomousMessage) {
         const history = await this.getEntries();
         const snapshot = mapPiSnapshot(history, { sessionId: state2.sessionId, model: null });
-        const turn = snapshot.turns.at(-1);
+        if (!this.#isSettlementCurrent(active, generation))
+          return;
         const entries = activePiEntries(history);
-        const start = entries.findIndex((entry) => entry.id === turn?.nativeTurnRef.nativeTurnKey);
-        const firstAssistant = entries.slice(start + 1).find((entry) => isRecord8(entry.message) && entry.message.role === "assistant")?.message;
         const live = active.autonomousMessage;
         const responseId = assistantMessageId(live);
-        const matches = isRecord8(firstAssistant) && (responseId ? assistantMessageId(firstAssistant) === responseId : typeof live?.timestamp === "number" && firstAssistant.timestamp === live.timestamp);
-        if (!turn || turn.input.length !== 0 || !matches) {
+        const matches = snapshot.turns.filter((turn2) => {
+          if (turn2.input.length !== 0)
+            return false;
+          const start = entries.findIndex((entry) => entry.id === turn2.nativeTurnRef.nativeTurnKey);
+          const firstAssistant = entries.slice(start + 1).find((entry) => isRecord9(entry.message) && entry.message.role === "assistant")?.message;
+          return isRecord9(firstAssistant) && (responseId ? assistantMessageId(firstAssistant) === responseId : typeof live?.timestamp === "number" && firstAssistant.timestamp === live.timestamp);
+        });
+        const turn = matches.length === 1 ? matches[0] : void 0;
+        if (!turn)
           throw new PiRpcFaultError("protocolError", "Pi autonomous Turn has no matching persisted custom Entry");
-        }
         active.nativeTurnKey = turn.nativeTurnRef.nativeTurnKey;
       }
-      if (this.#activeTurn !== active)
+      if (!this.#isSettlementCurrent(active, generation))
         return;
       this.#state = state2;
       active.settlement = "confirmed";
@@ -21242,7 +22128,13 @@ var PiRpcSession = class {
     }
     this.#activeTurn = null;
     if (active.origin === "autonomous") {
-      if (active.failure) {
+      if (active.cancellation === "accepted") {
+        this.#emitAutonomousTurn(active, {
+          status: "cancelled",
+          text: active.text,
+          reason: "Cancelled by user"
+        });
+      } else if (active.failure) {
         this.#emitAutonomousTurn(active, active.nativeCancellationObserved ? {
           status: "cancelled",
           text: active.text,
@@ -21257,6 +22149,7 @@ var PiRpcSession = class {
       } else {
         this.#emitAutonomousTurn(active, { status: "succeeded", text: active.text });
       }
+      this.#drainDeferredRunFrames();
       return;
     }
     if (active.cancellation === "accepted") {
@@ -21268,20 +22161,56 @@ var PiRpcSession = class {
     } else {
       active.resolve({ text: active.text, cancelled: false });
     }
+    this.#drainDeferredRunFrames();
+  }
+  #emitContent(active, reasoning, delta) {
+    if (delta.length === 0)
+      return;
+    const messageId = active.assistantMessageId;
+    if (messageId === null)
+      throw new Error("Pi content arrived outside an Assistant message");
+    if (reasoning) {
+      active.reasoningMessageOpen = true;
+      active.sawStreamedMessageReasoning = true;
+    } else {
+      active.text += delta;
+      active.sawStreamedMessageText = true;
+    }
+    active.onEvent({
+      type: reasoning ? "reasoning.delta" : "text.delta",
+      messageId,
+      ...nativeMessageIdentity(active),
+      delta
+    });
   }
   #startAssistantMessage(active, value) {
+    if (active.origin === "autonomous" && !active.autonomousMessage && isRecord9(value))
+      active.autonomousMessage = value;
     if (active.assistantMessageId !== null && active.reasoningMessageOpen) {
       active.onEvent({ type: "reasoning.completed", messageId: active.assistantMessageId });
     }
-    const messageId = assistantMessageId(value) ?? randomUUID5();
+    const nativeResponseId = assistantMessageId(value);
+    const messageId = nativeResponseId ?? randomUUID6();
     active.assistantMessageId = messageId;
+    active.assistantNativeMessageIdentity = piMessageIdentity(this.state.sessionId, value, this.#messageTimestampCounts);
+    active.textStream = new PiContentStream("text");
+    active.reasoningStream = new PiContentStream("reasoning");
     active.sawStreamedMessageText = false;
     active.sawStreamedMessageReasoning = false;
     active.reasoningMessageOpen = false;
     return messageId;
   }
   #ensureAssistantMessage(active, value) {
-    return active.assistantMessageId ?? this.#startAssistantMessage(active, value);
+    if (active.assistantMessageId === null)
+      return this.#startAssistantMessage(active, value);
+    if (!active.sawStreamedMessageText && !active.sawStreamedMessageReasoning) {
+      const nativeResponseId = assistantMessageId(value);
+      if (nativeResponseId) {
+        active.assistantMessageId = nativeResponseId;
+        active.assistantNativeMessageIdentity ??= { responseId: nativeResponseId };
+      }
+    }
+    return active.assistantMessageId;
   }
   #finalizeAssistantMessage(active, value) {
     const finalText = assistantText(value);
@@ -21294,29 +22223,33 @@ var PiRpcSession = class {
       return;
     }
     active.failure = failure;
-    if (active.origin === "autonomous" && isRecord8(value) && value.stopReason === "aborted") {
+    if (active.origin === "autonomous" && piAssistantWasAborted(value)) {
       active.nativeCancellationObserved = true;
     }
     this.#latestCacheHitRatePercent = cacheHitRatePercent;
     const messageId = this.#ensureAssistantMessage(active, value);
-    if (!active.sawStreamedMessageReasoning && finalReasoning.length > 0) {
-      active.reasoningMessageOpen = true;
-      active.onEvent({ type: "reasoning.delta", messageId, delta: finalReasoning });
+    const content = value.content;
+    if (failure === null || !active.sawStreamedMessageReasoning) {
+      this.#emitContent(active, true, active.reasoningStream.finalize(content.flatMap((part, index) => {
+        const text3 = extractReasoningText(part);
+        return text3 === null ? [] : [{ index, text: text3 }];
+      })));
     }
     if (active.reasoningMessageOpen && active.failure === null) {
       active.onEvent({ type: "reasoning.completed", messageId });
     }
-    if (!active.sawStreamedMessageText && finalText.length > 0) {
-      active.text += finalText;
-      active.onEvent({ type: "text.delta", messageId, delta: finalText });
+    if (failure === null || !active.sawStreamedMessageText) {
+      this.#emitContent(active, false, active.textStream.finalize(content.flatMap((part, index) => isRecord9(part) && part.type === "text" && typeof part.text === "string" ? [{ index, text: part.text }] : [])));
     }
     active.assistantMessageId = null;
+    active.assistantNativeMessageIdentity = void 0;
     active.sawStreamedMessageText = false;
     active.sawStreamedMessageReasoning = false;
     active.reasoningMessageOpen = false;
     active.lastFinalizedMessageText = finalText;
     active.lastFinalizedMessageReasoning = finalReasoning;
-    active.onEvent({ type: "message.completed", messageId });
+    const phase = piAssistantPhase(value);
+    active.onEvent({ type: "message.completed", messageId, ...phase ? { phase } : {} });
   }
   #write(value) {
     const child = this.#child;
@@ -21334,7 +22267,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-${randomUUID5()}`;
+    const id = `codexhost-${randomUUID6()}`;
     return new Promise((resolve, reject) => {
       const pending = {
         command: type,
@@ -21424,9 +22357,16 @@ var PiRpcSession = class {
     } else {
       active.reject(error51);
     }
+    this.#drainDeferredRunFrames();
   }
   #rejectAll(error51) {
+    for (const waiter of this.#runWaiters)
+      waiter.reject(error51);
+    this.#deferredRunFrames = [];
+    this.#deferredRunBytes = 0;
     this.#subagents.close(error51);
+    this.#gotgenesHandler = void 0;
+    this.#gotgenesLatest = void 0;
     for (const pending of this.#pending.values()) {
       if (pending.timeout)
         clearTimeout(pending.timeout);
@@ -21462,7 +22402,7 @@ var piCommandCatalog = harnessCommandCatalogSchema.parse({
   ]
 });
 var DEFAULT_TOOL_OUTPUT_LIMIT = 64e3;
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function errorMessage(error51) {
@@ -21477,7 +22417,9 @@ var PiAdapterFaultError = class extends Error {
   }
 };
 function normalizedError(error51, fallbackCode) {
-  if (isRecord9(error51) && error51.code === "ENOENT") {
+  if (error51 instanceof PiRpcBusyError)
+    return { code: "sessionBusy", message: error51.message, retryable: true };
+  if (isRecord10(error51) && error51.code === "ENOENT") {
     return { code: "notInstalled", message: errorMessage(error51), retryable: false };
   }
   if (error51 instanceof PiAdapterFaultError)
@@ -21540,7 +22482,7 @@ function nativeModelForHistory(state2) {
   return nativeModelFromState(state2);
 }
 function sessionFileFromRef(ref) {
-  if (ref.harnessId !== piHarnessId2 || !isRecord9(ref.locator) || typeof ref.locator.sessionFile !== "string" || ref.locator.sessionFile.length === 0) {
+  if (ref.harnessId !== piHarnessId2 || !isRecord10(ref.locator) || typeof ref.locator.sessionFile !== "string" || ref.locator.sessionFile.length === 0) {
     throw new Error("Pi Native Session Ref has no resumable Session file");
   }
   return ref.locator.sessionFile;
@@ -21555,83 +22497,29 @@ function toolFailure(toolName) {
 function nativeText(value) {
   if (typeof value === "string")
     return value;
-  if (!isRecord9(value) || !Array.isArray(value.content))
+  if (!isRecord10(value) || !Array.isArray(value.content))
     return "";
-  return value.content.filter((content) => isRecord9(content) && content.type === "text" && typeof content.text === "string").map(({ text: text2 }) => text2).join("");
+  return value.content.filter((content) => isRecord10(content) && content.type === "text" && typeof content.text === "string").map(({ text: text3 }) => text3).join("");
 }
 function boundedOutput(value, limit) {
-  const text2 = nativeText(value);
-  if (text2.length === 0)
+  const text3 = nativeText(value);
+  if (text3.length === 0)
     return void 0;
-  const truncated = text2.length > limit;
+  const truncated = text3.length > limit;
   return {
-    content: [{ type: "text", text: truncated ? text2.slice(0, limit) : text2 }],
+    content: [{ type: "text", text: truncated ? text3.slice(0, limit) : text3 }],
     ...truncated ? { truncated: true } : {}
   };
 }
 function outputText(output) {
-  return output?.content.filter((content) => content.type === "text").map(({ text: text2 }) => text2).join("") ?? "";
-}
-function stringField(value, key) {
-  if (!isRecord9(value))
-    return void 0;
-  const field2 = value[key];
-  if (typeof field2 === "string" && field2.length > 0)
-    return field2;
-  if (isRecord9(value.input)) {
-    const nested = value.input[key];
-    if (typeof nested === "string" && nested.length > 0)
-      return nested;
-  }
-  if (isRecord9(value.arguments)) {
-    const nested = value.arguments[key];
-    if (typeof nested === "string" && nested.length > 0)
-      return nested;
-  }
-  return void 0;
+  return output?.content.filter((content) => content.type === "text").map(({ text: text3 }) => text3).join("") ?? "";
 }
 function numberField(value, key) {
-  if (!isRecord9(value))
+  if (!isRecord10(value))
     return void 0;
   const field2 = value[key];
   return typeof field2 === "number" || field2 === null ? field2 : void 0;
 }
-function normalizeToolName(name) {
-  const lower = name.toLowerCase();
-  switch (lower) {
-    case "bash":
-    case "exec":
-    case "terminal":
-    case "run":
-      return "bash";
-    case "read":
-    case "read_file":
-    case "fileread":
-      return "Read";
-    case "edit":
-    case "edit_file":
-    case "fileedit":
-      return "Edit";
-    case "write":
-    case "write_file":
-    case "filewrite":
-      return "Write";
-    case "grep":
-    case "grep_search":
-      return "Grep";
-    case "find":
-    case "glob":
-    case "find_files":
-      return "Glob";
-    case "todo":
-      return "Todo";
-    case "web_search":
-    case "websearch":
-      return "WebSearch";
-    default:
-      return name.length > 0 ? `${name[0]?.toUpperCase() ?? ""}${name.slice(1)}` : name;
-  }
-}
 function delay(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
@@ -21659,6 +22547,8 @@ var PiHarnessSession = class {
   #configuring = false;
   #phase = "open";
   #pendingAutonomousTurns = [];
+  #pendingAutonomousLifecycle = [];
+  #pendingAutonomousLifecycleBytes = 0;
   #starting = null;
   #state = {};
   #transport = null;
@@ -21707,13 +22597,20 @@ var PiHarnessSession = class {
     return this.#transport?.state.sessionId === id;
   }
   async readSubagentHistory(cwd) {
-    if (this.#phase !== "open" || path15.resolve(cwd) !== path15.resolve(this.#cwd)) {
+    if (this.#phase !== "open" || path16.resolve(cwd) !== path16.resolve(this.#cwd)) {
       throw new Error("Pi Subagent parent workspace or Session is unavailable");
     }
     return (await this.#ensureTransport()).getEntries();
   }
+  async readGotgenesChild(id, cwd) {
+    const history = await this.readSubagentHistory(cwd);
+    const transport = this.#transport;
+    if (!transport)
+      throw new Error("Pi parent Session is closed");
+    return readGotgenesChild(history, transport.state.sessionId, id, this.#subagents.gotgenes.records.get(id));
+  }
   async inspectSubagent(id, cwd) {
-    if (this.#phase !== "open" || path15.resolve(cwd) !== path15.resolve(this.#cwd)) {
+    if (this.#phase !== "open" || path16.resolve(cwd) !== path16.resolve(this.#cwd)) {
       throw new Error("Pi Subagent parent workspace or Session is unavailable");
     }
     const transport = await this.#ensureTransport();
@@ -21781,7 +22678,7 @@ var PiHarnessSession = class {
         }
       };
     }
-    if (this.#acceptingTurn || this.#active || this.#configuring) {
+    if (this.#acceptingTurn || this.#active || this.#configuring || this.#transport?.isBusy) {
       return {
         ok: false,
         error: {
@@ -21791,8 +22688,8 @@ var PiHarnessSession = class {
         }
       };
     }
-    const text2 = command.input.map((input) => input.text).join("\n");
-    if (text2.length === 0) {
+    const text3 = command.input.map((input) => input.text).join("\n");
+    if (text3.length === 0) {
       return {
         ok: false,
         error: {
@@ -21822,6 +22719,9 @@ var PiHarnessSession = class {
       } catch (error51) {
         return { ok: false, error: normalizedError(error51, "protocolError") };
       }
+      if (this.#active || transport.isBusy || this.#pendingAutonomousLifecycle.length > 0 || this.#pendingAutonomousTurns.length > 0) {
+        return { ok: false, error: normalizedError(new PiRpcBusyError(), "sessionBusy") };
+      }
       let resolveCompletion = () => void 0;
       const completion = new Promise((resolve) => {
         resolveCompletion = resolve;
@@ -21842,21 +22742,27 @@ var PiHarnessSession = class {
         interactions: /* @__PURE__ */ new Map(),
         interactionByNativeId: /* @__PURE__ */ new Map(),
         cancellationRequested: false,
+        settling: false,
         beforeNativeTurnKeys: new Set(beforeHistory.turns.map((turn) => turn.nativeTurnRef.nativeTurnKey)),
+        progressItems: /* @__PURE__ */ new Set(),
         completion,
         resolveCompletion
       };
       this.#active = active;
       this.#event({ type: "turn.started", turnId: command.turnId });
       this.#event({ type: "item.started", turnId: command.turnId, item });
-      void transport.runTurn(text2, (event) => this.#handleTurnEvent(active, event)).then(async (result) => {
+      void transport.runTurn(text3, (event) => this.#handleTurnEvent(active, event)).then(async (result) => {
+        active.settling = true;
         try {
           const identity = await this.#completedTurnIdentity(active, transport);
           this.#completeTurn(active, result.cancelled ? {
             status: "cancelled",
             reason: "Cancelled by user",
-            checkpoint: identity.checkpoint
-          } : { status: "succeeded", checkpoint: identity.checkpoint }, result.text, identity.nativeTurnRef);
+            ...identity.checkpoint ? { checkpoint: identity.checkpoint } : {}
+          } : {
+            status: "succeeded",
+            ...identity.checkpoint ? { checkpoint: identity.checkpoint } : {}
+          }, result.text, identity.nativeTurnRef);
         } catch (error51) {
           this.#completeTurn(active, {
             status: "failed",
@@ -21864,6 +22770,7 @@ var PiHarnessSession = class {
           });
         }
       }).catch(async (error51) => {
+        active.settling = true;
         let identity;
         try {
           identity = await this.#completedTurnIdentity(active, transport);
@@ -21872,12 +22779,14 @@ var PiHarnessSession = class {
         this.#completeTurn(active, {
           status: "failed",
           error: normalizedError(error51, "nativeFailure"),
-          ...identity ? { checkpoint: identity.checkpoint } : {}
+          ...identity?.checkpoint ? { checkpoint: identity.checkpoint } : {}
         }, void 0, identity?.nativeTurnRef);
       });
       return { ok: true, value: { turnId: command.turnId } };
     } finally {
       this.#acceptingTurn = false;
+      if (this.#transport)
+        this.#drainPendingAutonomousTurns(this.#transport);
     }
   }
   close() {
@@ -22005,6 +22914,8 @@ var PiHarnessSession = class {
       return { ok: true, value: { completed: true } };
     } finally {
       this.#configuring = false;
+      if (this.#transport)
+        this.#drainPendingAutonomousTurns(this.#transport);
     }
   }
   async #selectThinking(command) {
@@ -22079,6 +22990,8 @@ var PiHarnessSession = class {
       return { ok: true, value: { completed: true } };
     } finally {
       this.#configuring = false;
+      if (this.#transport)
+        this.#drainPendingAutonomousTurns(this.#transport);
     }
   }
   async #cancel(command) {
@@ -22089,6 +23002,12 @@ var PiHarnessSession = class {
         error: invalidState("Pi Turn Cancel must reference the active Turn")
       };
     }
+    if (active.settling) {
+      return {
+        ok: false,
+        error: invalidState("Pi Turn has finished native execution and is recording its completion")
+      };
+    }
     if (active.cancellationRequested) {
       return { ok: true, value: { cancellationRequested: true } };
     }
@@ -22203,7 +23122,9 @@ var PiHarnessSession = class {
         interactions: /* @__PURE__ */ new Map(),
         interactionByNativeId: /* @__PURE__ */ new Map(),
         cancellationRequested: false,
+        settling: false,
         beforeNativeTurnKeys: /* @__PURE__ */ new Set(),
+        progressItems: /* @__PURE__ */ new Set(),
         completion,
         resolveCompletion
       };
@@ -22236,6 +23157,8 @@ var PiHarnessSession = class {
       return { ok: true, value: { turnId: command.turnId } };
     } finally {
       this.#acceptingTurn = false;
+      if (this.#transport)
+        this.#drainPendingAutonomousTurns(this.#transport);
     }
   }
   async #ensureTransport() {
@@ -22286,6 +23209,8 @@ var PiHarnessSession = class {
       return transport;
     }).catch(async (error51) => {
       this.#pendingAutonomousTurns = this.#pendingAutonomousTurns.filter((pending) => pending.transport !== transport);
+      this.#pendingAutonomousLifecycle = this.#pendingAutonomousLifecycle.filter((pending) => pending.transport !== transport);
+      this.#pendingAutonomousLifecycleBytes = this.#pendingAutonomousLifecycle.reduce((total, pending) => total + pending.bytes, 0);
       await transport.close().catch(() => void 0);
       if (this.#phase === "open")
         this.#fault(error51);
@@ -22298,6 +23223,11 @@ var PiHarnessSession = class {
     return starting;
   }
   #bindAutonomousTurnHandler(transport) {
+    transport.setGotgenesStatusHandler?.((records, owner) => {
+      if (this.#phase !== "open")
+        return;
+      this.#subagents.observeGotgenes(records, owner === "requested" && this.#active && !this.#active.settling ? { turnId: this.#active.command.turnId, nextItemId: () => this.#newItemId() } : void 0);
+    });
     transport.setSubagentStatusHandler?.((runs) => {
       if (this.#phase !== "open")
         return;
@@ -22309,12 +23239,16 @@ var PiHarnessSession = class {
     transport.setUsageHandler?.((observation) => {
       if (this.#phase !== "open")
         return;
-      const record7 = piUsageRecord(observation.message, observation);
-      if (record7?.kind === "request")
-        this.#event({ type: "usage.request", request: record7.request });
-      else if (record7?.kind === "missing")
+      const record9 = piUsageRecord(observation.message, observation);
+      if (record9?.kind === "request")
+        this.#event({ type: "usage.request", request: record9.request });
+      else if (record9?.kind === "missing")
         this.#event({ type: "usage.history", complete: false });
     });
+    if (transport.setAutonomousTurnLifecycleHandler) {
+      transport.setAutonomousTurnLifecycleHandler((update) => this.#handleAutonomousLifecycle(transport, update));
+      return;
+    }
     transport.setAutonomousTurnHandler((turn) => {
       if (this.#phase !== "open")
         return;
@@ -22326,6 +23260,20 @@ var PiHarnessSession = class {
     });
   }
   #drainPendingAutonomousTurns(transport) {
+    if (this.#phase !== "open" || this.#acceptingTurn || this.#configuring)
+      return;
+    for (; ; ) {
+      const pending2 = this.#pendingAutonomousLifecycle[0];
+      if (!pending2 || pending2.transport !== transport || this.#active && this.#active.autonomousRunId !== pending2.update.runId)
+        break;
+      this.#pendingAutonomousLifecycle.shift();
+      this.#pendingAutonomousLifecycleBytes -= pending2.bytes;
+      this.#applyAutonomousLifecycle(transport, pending2.update);
+      if (this.#phase !== "open")
+        return;
+    }
+    if (this.#active)
+      return;
     if (this.#pendingSubagentStatus) {
       this.#subagents.observe(this.#pendingSubagentStatus);
       this.#pendingSubagentStatus = null;
@@ -22338,6 +23286,52 @@ var PiHarnessSession = class {
       this.#handleAutonomousTurn(transport, candidate.turn);
     }
   }
+  #handleAutonomousLifecycle(transport, update) {
+    if (this.#phase === "closing" && this.#transport === transport && update.type !== "started" && this.#active?.autonomousRunId === update.runId) {
+      this.#applyAutonomousLifecycle(transport, update);
+      return;
+    }
+    if (this.#phase !== "open")
+      return;
+    if (this.#transport !== transport || this.#acceptingTurn || this.#configuring || this.#pendingAutonomousLifecycle.length > 0 || this.#active && this.#active.autonomousRunId !== update.runId) {
+      const bytes = Buffer.byteLength(JSON.stringify(update));
+      if (this.#pendingAutonomousLifecycleBytes + bytes > 8 * 1024 * 1024) {
+        this.#fault(new PiAdapterFaultError({
+          code: "protocolError",
+          message: "Pi autonomous lifecycle exceeded its ordered event buffer bound",
+          retryable: false
+        }));
+        return;
+      }
+      this.#pendingAutonomousLifecycle.push({ transport, update, bytes });
+      this.#pendingAutonomousLifecycleBytes += bytes;
+      if (this.#transport === transport)
+        this.#drainPendingAutonomousTurns(transport);
+      return;
+    }
+    this.#applyAutonomousLifecycle(transport, update);
+  }
+  #applyAutonomousLifecycle(transport, update) {
+    if (update.type === "started" && !this.#active) {
+      this.#startAutonomousHostTurn(update.runId);
+      return;
+    }
+    const active = this.#active;
+    if (!active || active.autonomousRunId !== update.runId || update.type === "started") {
+      this.#fault(new PiAdapterFaultError({
+        code: "protocolError",
+        message: "Pi autonomous event has no matching active run",
+        retryable: false
+      }));
+      return;
+    }
+    if (update.type === "event")
+      this.#handleTurnEvent(active, update.event);
+    else {
+      active.settling = true;
+      this.#finishAutonomousHostTurn(transport, active, update.turn);
+    }
+  }
   #handleAutonomousTurn(transport, turn) {
     if (this.#phase !== "open")
       return;
@@ -22349,7 +23343,7 @@ var PiHarnessSession = class {
       }));
       return;
     }
-    if (this.#active || this.#acceptingTurn || this.#configuring) {
+    if (this.#active && !this.#active.settling) {
       this.#fault(new PiAdapterFaultError({
         code: "protocolError",
         message: "Pi autonomous Turn overlapped another Host operation",
@@ -22357,7 +23351,22 @@ var PiHarnessSession = class {
       }));
       return;
     }
-    const turnId = hostTurnIdSchema.parse(randomUUID6());
+    if (this.#active || this.#acceptingTurn || this.#configuring) {
+      if (this.#pendingAutonomousTurns.length >= 128) {
+        this.#fault(new PiAdapterFaultError({
+          code: "protocolError",
+          message: "Pi autonomous completion queue exceeded its bound",
+          retryable: false
+        }));
+      } else
+        this.#pendingAutonomousTurns.push({ transport, turn });
+      return;
+    }
+    const active = this.#startAutonomousHostTurn();
+    this.#finishAutonomousHostTurn(transport, active, turn);
+  }
+  #startAutonomousHostTurn(runId) {
+    const turnId = hostTurnIdSchema.parse(randomUUID7());
     let resolveCompletion = () => void 0;
     const completion = new Promise((resolve) => {
       resolveCompletion = resolve;
@@ -22369,6 +23378,7 @@ var PiHarnessSession = class {
     };
     const active = {
       command: { type: "turn.start", turnId, input: [] },
+      ...runId ? { autonomousRunId: runId } : {},
       agentItem: item,
       agentMessageId: null,
       compactionItem: null,
@@ -22378,10 +23388,19 @@ var PiHarnessSession = class {
       interactions: /* @__PURE__ */ new Map(),
       interactionByNativeId: /* @__PURE__ */ new Map(),
       cancellationRequested: false,
+      settling: false,
       beforeNativeTurnKeys: /* @__PURE__ */ new Set(),
+      progressItems: /* @__PURE__ */ new Set(),
       completion,
       resolveCompletion
     };
+    this.#active = active;
+    this.#event({ type: "turn.autonomous.started", turnId, input: [] });
+    this.#event({ type: "turn.started", turnId });
+    this.#event({ type: "item.started", turnId, item });
+    return active;
+  }
+  #finishAutonomousHostTurn(transport, active, turn) {
     const nativeTurnRef = turn.nativeTurnKey ? nativeTurnRefSchema.parse({
       harnessId: this.harnessId,
       nativeSessionId: transport.state.sessionId,
@@ -22394,10 +23413,6 @@ var PiHarnessSession = class {
       checkpointId: nativeTurnRef.nativeTurnKey,
       formatVersion: 1
     }) : void 0;
-    this.#active = active;
-    this.#event({ type: "turn.autonomous.started", turnId, input: [] });
-    this.#event({ type: "turn.started", turnId });
-    this.#event({ type: "item.started", turnId, item });
     try {
       for (const event of turn.events)
         this.#handleTurnEvent(active, event);
@@ -22467,17 +23482,35 @@ var PiHarnessSession = class {
     if (this.#active !== active || this.#phase === "closed" || this.#phase === "faulted")
       return;
     switch (event.type) {
+      case "progress.message": {
+        if (active.progressItems.has(event.itemId))
+          return;
+        active.progressItems.add(event.itemId);
+        const item = {
+          type: "agentMessage",
+          itemId: event.itemId,
+          text: event.text,
+          phase: "commentary"
+        };
+        this.#event({ type: "item.started", turnId: active.command.turnId, item });
+        this.#completeItem(active, item, { status: "succeeded" });
+        return;
+      }
       case "text.delta":
-        this.#activateAgentMessage(active, event.messageId);
+        this.#activateAgentMessage(active, event.messageId, event.nativeMessageIdentity);
+        active.sawAssistantMessage = true;
         this.#appendText(active, event.delta);
         return;
       case "reasoning.delta":
-        this.#appendReasoning(active, event.delta);
+        this.#activateAgentMessage(active, event.messageId, event.nativeMessageIdentity);
+        this.#appendReasoning(active, event.delta, event.nativeMessageIdentity);
         return;
       case "reasoning.completed":
         this.#completeReasoning(active, { status: "succeeded" });
         return;
       case "message.completed":
+        if (event.phase && active.agentMessageId === event.messageId && active.agentItem)
+          active.agentItem = { ...active.agentItem, phase: event.phase };
         void this.#refreshUsage(active.command.turnId);
         return;
       case "compaction.started":
@@ -22535,7 +23568,7 @@ var PiHarnessSession = class {
     if (active.interactionByNativeId.has(request.requestId)) {
       throw new Error("Pi Interaction started more than once");
     }
-    const interactionId = hostInteractionIdSchema.parse(randomUUID6());
+    const interactionId = hostInteractionIdSchema.parse(randomUUID7());
     const question = request.method === "select" ? {
       id: "answer",
       type: "choice",
@@ -22592,17 +23625,21 @@ var PiHarnessSession = class {
       reason
     });
   }
-  #activateAgentMessage(active, messageId) {
+  #activateAgentMessage(active, messageId, nativeMessageIdentity2) {
     if (active.agentMessageId === messageId)
       return;
+    const nativeItemId = piMessageItemId(nativeMessageIdentity2, "assistant");
+    if (nativeItemId && active.agentMessageId === null && active.agentItem?.text === "") {
+      this.#completeAgentItem(active, { status: "succeeded" }, true);
+    }
     if (active.agentMessageId !== null) {
       this.#completeReasoning(active, { status: "succeeded" });
-      this.#completeAgentItem(active, { status: "succeeded" }, false);
+      this.#completeAgentItem(active, { status: "succeeded" }, true);
     }
     if (!active.agentItem) {
       active.agentItem = {
         type: "agentMessage",
-        itemId: this.#newItemId(),
+        itemId: nativeItemId ?? this.#newItemId(),
         text: ""
       };
       this.#event({
@@ -22612,18 +23649,17 @@ var PiHarnessSession = class {
       });
     }
     active.agentMessageId = messageId;
-    active.sawAssistantMessage = true;
   }
-  #appendText(active, text2) {
+  #appendText(active, text3) {
     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 + text2 };
+    active.agentItem = { ...active.agentItem, text: active.agentItem.text + text3 };
     this.#event({
       type: "item.updated",
       turnId: active.command.turnId,
       itemId: active.agentItem.itemId,
-      update: { type: "text.append", text: text2 }
+      update: { type: "text.append", text: text3 }
     });
   }
   #completeAgentItem(active, outcome, completeEmpty) {
@@ -22634,13 +23670,13 @@ var PiHarnessSession = class {
     active.agentItem = null;
     this.#completeItem(active, item, outcome);
   }
-  #appendReasoning(active, text2) {
-    if (text2.length === 0)
+  #appendReasoning(active, text3, nativeMessageIdentity2) {
+    if (text3.length === 0)
       return;
     if (!active.reasoningItem) {
       active.reasoningItem = {
         type: "reasoning",
-        itemId: this.#newItemId(),
+        itemId: piMessageItemId(nativeMessageIdentity2, "reasoning") ?? this.#newItemId(),
         text: ""
       };
       this.#event({
@@ -22651,13 +23687,13 @@ var PiHarnessSession = class {
     }
     active.reasoningItem = {
       ...active.reasoningItem,
-      text: active.reasoningItem.text + text2
+      text: active.reasoningItem.text + text3
     };
     this.#event({
       type: "item.updated",
       turnId: active.command.turnId,
       itemId: active.reasoningItem.itemId,
-      update: { type: "text.append", text: text2 }
+      update: { type: "text.append", text: text3 }
     });
   }
   #completeReasoning(active, outcome) {
@@ -22670,13 +23706,12 @@ var PiHarnessSession = class {
   #startTool(active, event) {
     if (active.tools.has(event.callId))
       throw new Error("Pi Tool started more than once");
-    const normalizedName = normalizeToolName(event.toolName);
-    const command = normalizedName === "bash" ? stringField(event.arguments, "command") ?? stringField(event.arguments, "cmd") ?? stringField(event.arguments, "script") ?? stringField(event.arguments, "commandLine") ?? stringField(event.arguments, "command_line") : void 0;
-    const item = command ? {
+    const shell = piToolCommand(event.toolName, event.arguments);
+    const item = shell ? {
       type: "commandExecution",
       itemId: this.#newItemId(),
-      command,
-      cwd: stringField(event.arguments, "cwd") ?? this.#cwd
+      command: shell.command,
+      cwd: shell.cwd ?? this.#cwd
     } : {
       type: "toolExecution",
       itemId: this.#newItemId(),
@@ -22794,14 +23829,17 @@ var PiHarnessSession = class {
       sessionId: transport.state.sessionId,
       model: nativeModelForHistory(transport.state)
     });
-    const created = snapshot.turns.filter((turn2) => !active.beforeNativeTurnKeys.has(turn2.nativeTurnRef.nativeTurnKey));
+    const created = snapshot.turns.filter((turn2) => turn2.input.length > 0 && !active.beforeNativeTurnKeys.has(turn2.nativeTurnRef.nativeTurnKey));
     if (created.length !== 1) {
       throw new Error(`Pi Turn persisted ${created.length} new User Entries; exactly one is required`);
     }
     const turn = created[0];
-    if (!turn?.checkpoint)
-      throw new Error("Pi Turn has no terminal Checkpoint identity");
-    return { nativeTurnRef: turn.nativeTurnRef, checkpoint: turn.checkpoint };
+    if (!turn)
+      throw new Error("Pi Turn has no persisted User identity");
+    return {
+      nativeTurnRef: turn.nativeTurnRef,
+      ...turn.checkpoint ? { checkpoint: turn.checkpoint } : {}
+    };
   }
   #completeTurn(active, outcome, finalText, nativeTurnRef) {
     if (this.#active !== active)
@@ -22830,14 +23868,20 @@ var PiHarnessSession = class {
     });
     active.resolveCompletion();
     queueMicrotask(() => {
-      if (this.#phase === "open")
-        void this.#refreshUsage(active.command.turnId);
+      if (this.#phase !== "open")
+        return;
+      if (this.#transport)
+        this.#drainPendingAutonomousTurns(this.#transport);
+      void this.#refreshUsage(active.command.turnId);
     });
   }
   #fault(error51) {
     if (this.#phase === "closed" || this.#phase === "faulted")
       return;
     const normalized = normalizedError(error51, "internalError");
+    this.#pendingAutonomousTurns = [];
+    this.#pendingAutonomousLifecycle = [];
+    this.#pendingAutonomousLifecycleBytes = 0;
     if (this.#active) {
       this.#completeTurn(this.#active, { status: "failed", error: normalized });
     }
@@ -22846,6 +23890,9 @@ var PiHarnessSession = class {
     this.#channel.end();
   }
   async #close() {
+    this.#pendingAutonomousTurns = [];
+    this.#pendingAutonomousLifecycle = [];
+    this.#pendingAutonomousLifecycleBytes = 0;
     if (this.#phase === "closed")
       return;
     const wasFaulted = this.#phase === "faulted";
@@ -22878,7 +23925,7 @@ var PiHarnessSession = class {
     this.#channel.emit({ kind: "event", event });
   }
   #newItemId() {
-    return hostItemIdSchema.parse(randomUUID6());
+    return hostItemIdSchema.parse(randomUUID7());
   }
 };
 var PiAdapter = class {
@@ -22893,12 +23940,15 @@ var PiAdapter = class {
         if (this.#closePromise || parent.harnessId !== this.harnessId) {
           return { ok: false, error: invalidState("Pi Subagent parent is unavailable") };
         }
+        const gotgenes = parseGotgenesId(nativeSubagentId);
         const workflow = parsePiWorkflowSubagentId(nativeSubagentId);
-        if (!workflow)
+        if (!workflow && !gotgenes)
           parsePiSubagentId(nativeSubagentId);
         const live = [...this.#sessions].find((session) => session.ownsNativeSession(parent.nativeSessionId));
         let reply;
         if (live) {
+          if (gotgenes)
+            return await live.readGotgenesChild(gotgenes, cwd);
           if (workflow)
             return await readPiWorkflowChild(await live.readSubagentHistory(cwd), parent.nativeSessionId, workflow);
           reply = await live.inspectSubagent(nativeSubagentId, cwd);
@@ -22910,6 +23960,8 @@ var PiAdapter = class {
           if (transport.state.sessionId !== parent.nativeSessionId)
             throw new Error("Pi Subagent parent identity mismatch");
           await transport.verifySessionCwd(cwd);
+          if (gotgenes)
+            return await readGotgenesChild(await transport.getEntries(), parent.nativeSessionId, gotgenes);
           if (workflow)
             return await readPiWorkflowChild(await transport.getEntries(), parent.nativeSessionId, workflow);
           if (!transport.inspectSubagent)