@hachej/boring-agent 0.1.78 → 0.1.80

package/dist/chunk-3WWLQAJB.js

@@ -1,2794 +0,0 @@
-import {
-  AgentFilesystemRequiredError,
-  AgentNotImplementedError,
-  sessionStreamPath
-} from "./chunk-ZUEITFIJ.js";
-import {
-  extractToolUiMetadata,
-  sanitizeToolUiMetadata2 as sanitizeToolUiMetadata
-} from "./chunk-ORURYKNY.js";
-import {
-  createLogger
-} from "./chunk-AJZHR626.js";
-import {
-  ErrorCode
-} from "./chunk-6AEK34XU.js";
-
-// src/server/pi-chat/metering.ts
-var meteringLogger = createLogger("pi-chat-metering");
-var defaultMeteringErrorLogger = (message, error) => {
-  meteringLogger.warn(message, { error });
-};
-function promptRunId(sessionId, clientNonce) {
-  return `pi-run:${sessionId}:prompt:${clientNonce}`;
-}
-function followUpRunId(sessionId, clientNonce, clientSeq) {
-  return `pi-run:${sessionId}:followup:${clientNonce}:${clientSeq}`;
-}
-function followUpMatches(run, selector) {
-  const fu = run.followUp;
-  if (!fu) return false;
-  if (selector.clientNonce !== void 0) return fu.clientNonce === selector.clientNonce;
-  if (selector.clientSeq !== void 0) return fu.clientSeq === selector.clientSeq;
-  return false;
-}
-function takeQueuedFollowUp(state, selector) {
-  const index = state.queued.findIndex((run) => followUpMatches(run, selector));
-  if (index < 0) return void 0;
-  return state.queued.splice(index, 1)[0];
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readTokenCount(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
-}
-function normalizeMeteringUsage(value) {
-  if (!isRecord(value)) return void 0;
-  const cost = isRecord(value.cost) ? value.cost : {};
-  return {
-    input: readTokenCount(value.input),
-    output: readTokenCount(value.output),
-    cacheRead: readTokenCount(value.cacheRead),
-    cacheWrite: readTokenCount(value.cacheWrite),
-    cost: {
-      input: readTokenCount(cost.input),
-      output: readTokenCount(cost.output),
-      cacheRead: readTokenCount(cost.cacheRead),
-      cacheWrite: readTokenCount(cost.cacheWrite),
-      total: readTokenCount(cost.total)
-    }
-  };
-}
-var PiChatMeteringCoordinator = class {
-  sessions = /* @__PURE__ */ new Map();
-  inflightOps = /* @__PURE__ */ new Set();
-  runInstances = 0;
-  sink;
-  logError;
-  constructor(sink, logError) {
-    this.sink = sink;
-    this.logError = logError ?? defaultMeteringErrorLogger;
-  }
-  /** Reserve a prompt run. Throws (fail closed) when the sink rejects. */
-  async reservePrompt(input) {
-    const stateKey = input.stateKey ?? input.sessionId;
-    const state = this.sessionState(stateKey);
-    const runId = promptRunId(input.sessionId, input.clientNonce);
-    const existing = this.findRun(state, runId);
-    if (existing) {
-      await existing.reservation;
-      return "duplicate";
-    }
-    const run = this.createRun(input, "prompt", runId);
-    state.pendingPrompts.push(run);
-    return this.materializeReservation(state, run, input, stateKey);
-  }
-  /** Reserve a follow-up run. Throws (fail closed) when the sink rejects.
-   * Returns 'duplicate' when this selector already has a tracked/consumed run. */
-  async reserveFollowUp(input) {
-    const stateKey = input.stateKey ?? input.sessionId;
-    const state = this.sessionState(stateKey);
-    const runId = followUpRunId(input.sessionId, input.clientNonce, input.clientSeq);
-    const existing = this.findRun(state, runId);
-    if (existing) {
-      await existing.reservation;
-      return "duplicate";
-    }
-    if (state.consumedFollowUpNonces.has(input.clientNonce)) return "duplicate";
-    const run = this.createRun(input, "followup", runId);
-    run.followUp = { clientNonce: input.clientNonce, clientSeq: input.clientSeq };
-    state.queued.push(run);
-    return this.materializeReservation(state, run, input, stateKey);
-  }
-  /**
-   * Acquire the reservation for a freshly-registered run. The reserve is put on
-   * the run's ops chain so a concurrent release/settle is ordered strictly
-   * after the reservation row exists. Returns 'cancelled' (skip execution) when
-   * a concurrent stop/interrupt/delete terminated the run while the reserve was
-   * in flight; throws (fail closed) when the sink rejects.
-   */
-  async materializeReservation(state, run, input, stateKey) {
-    run.reservation = this.applyReservation(run, input);
-    const reserveOp = run.reservation.catch(() => {
-    });
-    run.ops = reserveOp;
-    this.inflightOps.add(reserveOp);
-    void reserveOp.finally(() => this.inflightOps.delete(reserveOp));
-    try {
-      await run.reservation;
-    } catch (err) {
-      this.removeReservingRun(state, run, stateKey);
-      throw err;
-    }
-    return run.terminal ? "cancelled" : "created";
-  }
-  /** True while a non-terminal prompt run exists for this nonce (accept →
-   * agent-end). Used to suppress duplicate-nonce execution for the full run
-   * lifetime, not just until the user message-start is consumed. */
-  hasPromptRun(sessionId, clientNonce) {
-    const state = this.sessions.get(sessionId);
-    if (!state) return false;
-    const run = this.findRun(state, promptRunId(sessionId, clientNonce));
-    return run !== void 0 && !run.terminal;
-  }
-  /** True while a non-terminal follow-up run exists for this selector (queued
-   * or consumed-and-active). Used to suppress duplicate follow-up enqueues. */
-  hasFollowUpRun(sessionId, selector) {
-    const state = this.sessions.get(sessionId);
-    if (!state) return false;
-    if (selector.clientNonce !== void 0 && state.consumedFollowUpNonces.has(selector.clientNonce)) return true;
-    if (state.queued.some((run) => followUpMatches(run, selector))) return true;
-    const active = state.active;
-    return active !== void 0 && !active.terminal && active.followUp !== void 0 && followUpMatches(active, selector);
-  }
-  /** The accepted prompt failed before/without running (sync throw or run rejection). */
-  failPromptRun(sessionId, clientNonce, stateKey = sessionId) {
-    const state = this.sessions.get(stateKey);
-    if (!state) return;
-    const runId = promptRunId(sessionId, clientNonce);
-    const pendingIndex = state.pendingPrompts.findIndex((run) => run.scope.runId === runId);
-    if (pendingIndex >= 0) {
-      const [run] = state.pendingPrompts.splice(pendingIndex, 1);
-      if (run) this.finishRun(run, "error");
-    } else if (state.active?.scope.runId === runId) {
-      this.finishRun(state.active, "error");
-      state.active = void 0;
-    }
-    this.pruneSession(stateKey, state);
-  }
-  /** A queued follow-up was rejected by the adapter before being queued. */
-  failFollowUpRun(sessionId, selector) {
-    const state = this.sessions.get(sessionId);
-    if (!state) return;
-    const run = takeQueuedFollowUp(state, selector);
-    if (!run) return;
-    this.release(run, "run-rejected");
-    this.pruneSession(sessionId, state);
-  }
-  /**
-   * A queued follow-up is being re-posted as a plain prompt (interrupt
-   * fallback for runtimes without continueQueuedFollowUp). No
-   * `followup-consumed` event will arrive, so bind its reservation to the
-   * next agent-start instead.
-   */
-  promoteQueuedToPrompt(sessionId, selector) {
-    const state = this.sessions.get(sessionId);
-    if (!state) return;
-    const run = takeQueuedFollowUp(state, selector);
-    if (!run) return;
-    state.pendingPrompts.push(run);
-  }
-  /**
-   * A promoted-to-prompt follow-up failed before agent-start (the fallback
-   * repost rejected). Release its reservation instead of stranding it in
-   * pendingPrompts, where a later agent-start would otherwise misattribute
-   * usage to it.
-   */
-  failPromotedFollowUp(sessionId, selector, stateKey = sessionId) {
-    const state = this.sessions.get(stateKey);
-    if (!state || selector.clientNonce === void 0 || selector.clientSeq === void 0) return;
-    const runId = followUpRunId(sessionId, selector.clientNonce, selector.clientSeq);
-    const index = state.pendingPrompts.findIndex((run2) => run2.scope.runId === runId);
-    if (index < 0) return;
-    const [run] = state.pendingPrompts.splice(index, 1);
-    if (run) this.release(run, "run-rejected");
-    this.pruneSession(stateKey, state);
-  }
-  /**
-   * Release prompt runs reserved but not yet bound to an agent-start —
-   * e.g. a stop/interrupt landing in the window between acceptance and the
-   * native agent_start. Without this they would sit `active` in the store
-   * until their TTL, holding the user's balance. No charge.
-   */
-  releasePending(sessionId) {
-    const state = this.sessions.get(sessionId);
-    if (!state) return;
-    for (const run of state.pendingPrompts) this.release(run, "cancelled");
-    state.pendingPrompts = [];
-    this.pruneSession(sessionId, state);
-  }
-  /** Queue cleared via selector or entirely; release affected reservations. */
-  releaseQueued(sessionId, selector) {
-    const state = this.sessions.get(sessionId);
-    if (!state) return;
-    if (selector) {
-      const run = takeQueuedFollowUp(state, selector);
-      if (run) this.release(run, "queue-cleared");
-    } else {
-      for (const run of state.queued) this.release(run, "queue-cleared");
-      state.queued = [];
-    }
-    this.pruneSession(sessionId, state);
-  }
-  /** Session deleted: tear down every non-terminal run without charging. */
-  releaseSession(sessionId) {
-    const state = this.sessions.get(sessionId);
-    if (!state) return;
-    for (const run of state.queued) this.release(run, "cancelled");
-    for (const run of state.pendingPrompts) this.release(run, "cancelled");
-    if (state.active) this.finishRun(state.active, "aborted");
-    this.sessions.delete(sessionId);
-  }
-  /**
-   * Feed one native adapter event and its mapped PiChatEvents through the
-   * correlation state machine. Must be called after the mapped events were
-   * published (the mapper assigns turn ids during mapping).
-   */
-  observe(sessionId, nativeEvent, mappedEvents) {
-    const state = this.sessions.get(sessionId);
-    if (!state) return;
-    for (const event of mappedEvents) {
-      switch (event.type) {
-        case "agent-start": {
-          let next = state.pendingPrompts.shift();
-          while (next && next.terminal) next = state.pendingPrompts.shift();
-          if (next) {
-            if (state.active && !state.active.terminal) this.finishRun(state.active, "ok");
-            state.active = next;
-          }
-          break;
-        }
-        case "message-start": {
-          if (event.role === "user" && event.clientSeq !== void 0) {
-            this.consumeFollowUp(state, event);
-          }
-          break;
-        }
-        case "followup-consumed": {
-          this.consumeFollowUp(state, event);
-          break;
-        }
-        case "auto-retry-start": {
-          if (state.active) {
-            state.active.recordedMessageIds.clear();
-            state.active.lastIdlessUsageKey = void 0;
-          }
-          break;
-        }
-        case "agent-end": {
-          this.harvestAgentEndUsage(state, nativeEvent);
-          if (isRecord(nativeEvent) && nativeEvent.willRetry === true) break;
-          if (state.active && !state.active.terminal) this.finishRun(state.active, event.status);
-          state.active = void 0;
-          break;
-        }
-        default:
-          break;
-      }
-    }
-    this.observeMessageEndUsage(state, nativeEvent);
-    this.pruneSession(sessionId, state);
-  }
-  /** Promote a queued follow-up to the active run, settling the previous one. */
-  consumeFollowUp(state, selector) {
-    const run = takeQueuedFollowUp(state, selector);
-    if (!run) return;
-    if (run.followUp?.clientNonce) state.consumedFollowUpNonces.add(run.followUp.clientNonce);
-    if (state.active && !state.active.terminal) this.finishRun(state.active, "ok");
-    state.active = run;
-  }
-  /** Test/diagnostic hook: resolves after every queued sink call settles. */
-  async flush() {
-    while (this.inflightOps.size > 0) {
-      await Promise.all([...this.inflightOps]);
-    }
-  }
-  observeMessageEndUsage(state, nativeEvent) {
-    if (!isRecord(nativeEvent) || nativeEvent.type !== "message_end") return;
-    this.recordAssistantUsage(state, nativeEvent.message);
-  }
-  /**
-   * Some failure/abort paths never emit message_end; the final assistant
-   * message (and its usage) only rides on agent_end's messages array. Runs
-   * with already-recorded usage dedupe via recordedMessageIds.
-   */
-  harvestAgentEndUsage(state, nativeEvent) {
-    if (!isRecord(nativeEvent) || !Array.isArray(nativeEvent.messages)) return;
-    for (let index = nativeEvent.messages.length - 1; index >= 0; index -= 1) {
-      const message = nativeEvent.messages[index];
-      if (!isRecord(message) || message.role !== "assistant") continue;
-      this.recordAssistantUsage(state, message, { isAgentEndFinal: true });
-      return;
-    }
-  }
-  recordAssistantUsage(state, message, opts = {}) {
-    if (!isRecord(message) || message.role !== "assistant") return;
-    const usage = normalizeMeteringUsage(message.usage);
-    if (!usage) return;
-    const run = state.active ?? state.pendingPrompts[0];
-    if (!run || run.terminal) {
-      this.logError("assistant usage arrived with no reserved run; usage not metered", { messageRole: "assistant" });
-      return;
-    }
-    const messageId = typeof message.id === "string" && message.id.length > 0 ? message.id : void 0;
-    if (messageId) {
-      if (run.recordedMessageIds.has(messageId)) return;
-      run.recordedMessageIds.add(messageId);
-    } else {
-      const stopReason2 = typeof message.stopReason === "string" ? message.stopReason : "";
-      const signature = `sig:${usage.input}:${usage.output}:${usage.cacheRead}:${usage.cacheWrite}:${usage.cost.total}:${stopReason2}`;
-      if (opts.isAgentEndFinal && signature === run.lastIdlessUsageKey) return;
-      run.lastIdlessUsageKey = signature;
-    }
-    run.usageCount += 1;
-    const model = typeof message.model === "string" && message.model.length > 0 ? message.model : void 0;
-    const provider = typeof message.provider === "string" && message.provider.length > 0 ? message.provider : void 0;
-    const stopReason = typeof message.stopReason === "string" ? message.stopReason : void 0;
-    const usageId = messageId ? `pi-usage:${run.scope.sessionId}:message:${messageId}` : run.reservationId ? `pi-usage:reservation:${run.reservationId}:${run.usageCount}` : `pi-usage:${run.scope.runId}:${run.instanceId}:${run.usageCount}`;
-    this.enqueue(
-      run,
-      async () => {
-        try {
-          const result = await this.sink.recordUsage({
-            ...run.scope,
-            reservationId: run.reservationId,
-            usageId,
-            messageId,
-            model: model || provider ? { provider, id: model } : void 0,
-            usage,
-            stopReason
-          });
-          if (result.billedMicros > 0) run.billableUsageCount += 1;
-        } catch (error) {
-          const couldBill = usage.input + usage.output + usage.cacheRead + usage.cacheWrite > 0 || usage.cost.total > 0;
-          if (couldBill) run.usageWriteFailed = true;
-          throw error;
-        }
-      },
-      "recordUsage failed"
-    );
-  }
-  /** Build a run synchronously (no await) so it can be registered before the
-   * reserve sink call, closing the concurrent-duplicate race. */
-  createRun(input, kind, runId) {
-    return {
-      scope: {
-        workspaceId: input.workspaceId,
-        userId: input.userId,
-        userEmail: input.userEmail,
-        userEmailVerified: input.userEmailVerified,
-        sessionId: input.sessionId,
-        runId,
-        source: "pi-chat"
-      },
-      kind,
-      reservationId: void 0,
-      instanceId: this.runInstances += 1,
-      usageCount: 0,
-      billableUsageCount: 0,
-      recordedMessageIds: /* @__PURE__ */ new Set(),
-      lastIdlessUsageKey: void 0,
-      usageWriteFailed: false,
-      reservation: Promise.resolve(),
-      terminal: false,
-      ops: Promise.resolve()
-    };
-  }
-  /** Acquire the host reservation; throws (fail closed) on a rejecting sink. */
-  async applyReservation(run, input) {
-    const result = await this.sink.reserveRun({
-      ...run.scope,
-      kind: run.kind,
-      message: input.message,
-      model: input.model
-    });
-    run.reservationId = result?.reservationId;
-  }
-  /** Remove a still-reserving run whose reservation failed, from either list. */
-  removeReservingRun(state, run, sessionId) {
-    const pendingIndex = state.pendingPrompts.indexOf(run);
-    if (pendingIndex >= 0) state.pendingPrompts.splice(pendingIndex, 1);
-    const queuedIndex = state.queued.indexOf(run);
-    if (queuedIndex >= 0) state.queued.splice(queuedIndex, 1);
-    this.pruneSession(sessionId, state);
-  }
-  findRun(state, runId) {
-    if (state.active && !state.active.terminal && state.active.scope.runId === runId) return state.active;
-    const pending = state.pendingPrompts.find((run) => run.scope.runId === runId);
-    if (pending) return pending;
-    return state.queued.find((run) => run.scope.runId === runId);
-  }
-  finishRun(run, status) {
-    if (run.terminal) return;
-    run.terminal = true;
-    this.enqueue(
-      run,
-      () => {
-        if (run.usageWriteFailed) {
-          return this.sink.releaseRun({ ...run.scope, reservationId: run.reservationId, reason: "usage-write-failed" });
-        }
-        if (run.billableUsageCount > 0) {
-          return this.sink.settleRun({ ...run.scope, reservationId: run.reservationId, status });
-        }
-        const didPaidWork = status === "ok";
-        if (didPaidWork) {
-          return this.sink.releaseRun({ ...run.scope, reservationId: run.reservationId, reason: "fallback-hold-charge" });
-        }
-        return this.sink.releaseRun({
-          ...run.scope,
-          reservationId: run.reservationId,
-          reason: status === "error" ? "error-before-usage" : "cancelled"
-        });
-      },
-      "finishRun failed"
-    );
-  }
-  release(run, reason) {
-    if (run.terminal) return;
-    run.terminal = true;
-    this.enqueue(
-      run,
-      () => this.sink.releaseRun({ ...run.scope, reservationId: run.reservationId, reason }),
-      "releaseRun failed"
-    );
-  }
-  enqueue(run, op, failureMessage) {
-    const chained = run.ops.then(op).catch((error) => {
-      this.logError(`${failureMessage} (run ${run.scope.runId})`, error);
-    });
-    run.ops = chained;
-    this.inflightOps.add(chained);
-    void chained.finally(() => this.inflightOps.delete(chained));
-  }
-  sessionState(sessionId) {
-    let state = this.sessions.get(sessionId);
-    if (!state) {
-      state = { pendingPrompts: [], queued: [], consumedFollowUpNonces: /* @__PURE__ */ new Set() };
-      this.sessions.set(sessionId, state);
-    }
-    return state;
-  }
-  pruneSession(sessionId, state) {
-    if (!state.active && state.pendingPrompts.length === 0 && state.queued.length === 0 && state.consumedFollowUpNonces.size === 0) {
-      this.sessions.delete(sessionId);
-    }
-  }
-};
-
-// src/server/events/eventStreamStore.ts
-var COMPONENT_PAD = 16;
-var ZERO_COMPONENT = "0".repeat(COMPONENT_PAD);
-var EventStreamStoreError = class extends Error {
-  code = "INTERNAL_ERROR";
-  constructor(message) {
-    super(message);
-    this.name = "EventStreamStoreError";
-  }
-};
-function formatOffset(seq) {
-  if (seq === -1) return "-1";
-  if (!Number.isInteger(seq) || seq < -1) {
-    throw new EventStreamStoreError(`Invalid event stream sequence: ${seq}.`);
-  }
-  return `${ZERO_COMPONENT}_${String(seq).padStart(COMPONENT_PAD, "0")}`;
-}
-function parseOffset(offset) {
-  if (offset === "-1") return -1;
-  const match = /^\d+_(\d+)$/.exec(offset);
-  const sequence = match?.[1];
-  if (!sequence) {
-    throw new EventStreamStoreError(`Invalid event stream offset: "${offset}".`);
-  }
-  return parseInt(sequence, 10);
-}
-
-// src/server/pi-chat/piChatHistory.ts
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function optionalString(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function messageRole(message) {
-  return optionalString(message.role) ?? optionalString(message.type);
-}
-function messageTimestamp(message) {
-  const timestamp = message.timestamp;
-  if (typeof timestamp === "number" && Number.isFinite(timestamp)) return new Date(timestamp).toISOString();
-  return optionalString(timestamp);
-}
-function entryMessageId(entry, message, index, sessionId) {
-  return optionalString(entry.id) ?? optionalString(message.id) ?? `pi:${sessionId}:message:${index}:${messageRole(message) ?? "unknown"}:${messageTimestamp(message) ?? "no-ts"}`;
-}
-function entryPiEntryId(entry, message) {
-  return optionalString(entry.id) ?? optionalString(message.id);
-}
-function textFromContent(content) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return void 0;
-  const text = content.map((part) => {
-    if (!isRecord2(part)) return "";
-    if (part.type === "text" && typeof part.text === "string") return part.text;
-    return "";
-  }).join("");
-  return text.length > 0 ? text : void 0;
-}
-function filePartsFromContent(content, messageId) {
-  if (!Array.isArray(content)) return [];
-  return content.flatMap((part, index) => {
-    if (!isRecord2(part) || part.type !== "image") return [];
-    const mediaType = optionalString(part.mimeType);
-    return [
-      {
-        type: "file",
-        id: `${messageId}:file:${index}`,
-        ...optionalString(part.filename) ? { filename: optionalString(part.filename) } : {},
-        ...mediaType ? { mediaType } : {},
-        ...imagePartUrl(part, mediaType) ? { url: imagePartUrl(part, mediaType) } : {},
-        ...optionalString(part.path) ? { path: optionalString(part.path) } : {}
-      }
-    ];
-  });
-}
-function imagePartUrl(part, mediaType) {
-  const existing = optionalString(part.url);
-  if (existing) return existing;
-  const data = optionalString(part.data);
-  if (!data) return void 0;
-  if (data.startsWith("data:")) return data;
-  return `data:${mediaType ?? "application/octet-stream"};base64,${data}`;
-}
-function userParts(message, messageId) {
-  const parts = [];
-  const text = textFromContent(message.content);
-  if (text !== void 0) parts.push({ type: "text", id: `${messageId}:text:0`, text });
-  parts.push(...filePartsFromContent(message.content, messageId));
-  return parts;
-}
-function systemParts(message, messageId) {
-  return [{ type: "text", id: `${messageId}:text:0`, text: textFromContent(message.content) ?? optionalString(message.text) ?? "" }];
-}
-function toolInputFromCall(part) {
-  if ("arguments" in part) return part.arguments;
-  if ("input" in part) return part.input;
-  if ("args" in part) return part.args;
-  return void 0;
-}
-function assistantParts(message, messageId) {
-  const content = message.content;
-  if (typeof content === "string") return [{ type: "text", id: `${messageId}:text:0`, text: content }];
-  if (!Array.isArray(content)) return [];
-  return content.flatMap((part, index) => {
-    if (!isRecord2(part)) return [];
-    if (part.type === "text" && typeof part.text === "string") {
-      return [{ type: "text", id: `${messageId}:text:${index}`, text: part.text }];
-    }
-    if ((part.type === "thinking" || part.type === "reasoning") && (typeof part.thinking === "string" || typeof part.text === "string")) {
-      return [
-        {
-          type: "reasoning",
-          id: optionalString(part.id) ?? `${messageId}:reasoning:${index}`,
-          text: typeof part.thinking === "string" ? part.thinking : String(part.text ?? ""),
-          state: "done"
-        }
-      ];
-    }
-    if (part.type === "toolCall") {
-      const toolCallId = optionalString(part.id) ?? `${messageId}:tool:${index}`;
-      const state = part.state === "output-error" ? "output-error" : part.state === "output-available" ? "output-available" : "input-available";
-      return [
-        {
-          type: "tool-call",
-          id: toolCallId,
-          toolName: optionalString(part.name) ?? optionalString(part.toolName) ?? "unknown",
-          input: toolInputFromCall(part),
-          state,
-          output: part.output,
-          errorText: optionalString(part.errorText),
-          ui: extractToolUiMetadata({ details: { ui: part.ui } })
-        }
-      ];
-    }
-    return [];
-  });
-}
-function updateToolResult(messages, message) {
-  const toolCallId = optionalString(message.toolCallId);
-  if (!toolCallId) return;
-  for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
-    const candidate = messages[messageIndex];
-    if (!candidate || candidate.role !== "assistant") continue;
-    const partIndex = candidate.parts.findIndex((part) => part.type === "tool-call" && part.id === toolCallId);
-    if (partIndex < 0) continue;
-    const current = candidate.parts[partIndex];
-    if (current?.type !== "tool-call") return;
-    const nextPart = {
-      ...current,
-      output: toolResultOutput(message),
-      state: message.isError === true ? "output-error" : "output-available",
-      errorText: message.isError === true ? toolResultErrorText(message) : current.errorText,
-      ui: current.ui ?? extractToolUiMetadata({ details: { ui: isRecord2(message.details) ? message.details.ui : void 0 } })
-    };
-    candidate.parts = [...candidate.parts.slice(0, partIndex), nextPart, ...candidate.parts.slice(partIndex + 1)];
-    return;
-  }
-}
-function toolResultOutput(message) {
-  if ("details" in message && message.details !== void 0) {
-    return {
-      content: message.content,
-      details: message.details
-    };
-  }
-  return message.content;
-}
-function toolResultErrorText(message) {
-  const text = textFromContent(message.content);
-  return text ?? optionalString(message.errorText);
-}
-function buildPiChatHistory(entries, options) {
-  const messages = [];
-  entries.forEach((rawEntry, index) => {
-    const entry = isRecord2(rawEntry) && "message" in rawEntry ? { id: optionalString(rawEntry.id), message: rawEntry.message } : { message: rawEntry };
-    if (!isRecord2(entry.message)) return;
-    const role = messageRole(entry.message);
-    if (role === "toolResult") {
-      updateToolResult(messages, entry.message);
-      return;
-    }
-    const id = entryMessageId(entry, entry.message, index, options.sessionId);
-    const piEntryId = entryPiEntryId(entry, entry.message);
-    const base = {
-      id,
-      createdAt: messageTimestamp(entry.message),
-      piEntryId,
-      turnId: optionalString(entry.message.turnId) ?? options.messageTurnIds?.get(id) ?? options.turnId
-    };
-    if (role === "user") {
-      messages.push({ ...base, role: "user", status: "done", parts: userParts(entry.message, id) });
-      return;
-    }
-    if (role === "assistant") {
-      const status = entry.message.stopReason === "aborted" ? "aborted" : entry.message.stopReason === "error" ? "error" : "done";
-      messages.push({ ...base, role: "assistant", status, parts: assistantParts(entry.message, id) });
-      return;
-    }
-    if (role === "system") {
-      messages.push({ ...base, role: "system", status: "done", parts: systemParts(entry.message, id) });
-      return;
-    }
-    if (role === "custom" && entry.message.display !== false) {
-      messages.push({ ...base, role: "system", status: "done", parts: systemParts(entry.message, id) });
-    }
-  });
-  return messages;
-}
-
-// src/server/pi-chat/piChatSnapshot.ts
-function queueId(sessionId, index, text) {
-  return `queue:${sessionId}:followup:${index}:${stableTextHash(text)}`;
-}
-function stableTextHash(text) {
-  let hash = 0;
-  for (let index = 0; index < text.length; index += 1) {
-    hash = hash * 31 + text.charCodeAt(index) >>> 0;
-  }
-  return hash.toString(36);
-}
-function buildPiChatQueuedFollowUps(sessionId, followUpMessages) {
-  return followUpMessages.map((displayText, index) => ({
-    id: queueId(sessionId, index, displayText),
-    kind: "followup",
-    displayText
-  }));
-}
-function statusFromSnapshot(snapshot, error) {
-  if (error) return "error";
-  if (snapshot.isStreaming) return "streaming";
-  return "idle";
-}
-function errorFromSnapshot(snapshot) {
-  const state = snapshot.state;
-  if (typeof state !== "object" || state === null || !("errorMessage" in state)) return void 0;
-  const message = state.errorMessage;
-  if (typeof message !== "string" || message.length === 0) return void 0;
-  return {
-    code: ErrorCode.enum.INTERNAL_ERROR,
-    message,
-    retryable: false
-  };
-}
-function buildPiChatSnapshot(adapter, options) {
-  const piSnapshot = adapter.readSnapshot();
-  const sessionId = options.sessionId ?? piSnapshot.sessionId;
-  const error = options.error ?? errorFromSnapshot(piSnapshot);
-  const status = options.status ?? statusFromSnapshot(piSnapshot, error);
-  return {
-    protocolVersion: 1,
-    sessionId,
-    seq: options.seq,
-    status,
-    activeTurnId: options.activeTurnId,
-    messages: buildPiChatHistory(piSnapshot.messages, {
-      sessionId,
-      messageTurnIds: options.messageTurnIds
-    }),
-    queue: { followUps: buildPiChatQueuedFollowUps(sessionId, piSnapshot.followUpMessages) },
-    followUpMode: "one-at-a-time",
-    error
-  };
-}
-
-// src/server/pi-chat/piChatEvents.ts
-var FILE_CHANGE_OPS = /* @__PURE__ */ new Set(["write", "edit", "unlink", "rename", "mkdir"]);
-var PiChatEventMapper = class {
-  seq;
-  sessionId;
-  activeTurnId;
-  activeAssistantMessageId;
-  pendingUserStarts = [];
-  toolCallMessageIds = /* @__PURE__ */ new Map();
-  endedMessageIds = /* @__PURE__ */ new Set();
-  endedAssistantTurnIds = /* @__PURE__ */ new Set();
-  errorEmittedTurnIds = /* @__PURE__ */ new Set();
-  constructor(options) {
-    this.sessionId = options.sessionId;
-    this.seq = Math.max(0, Math.floor(options.initialSeq ?? 0));
-  }
-  get latestSeq() {
-    return this.seq;
-  }
-  mapSynthetic(event) {
-    return this.event(event);
-  }
-  map(event) {
-    if (!isRecord3(event) || typeof event.type !== "string") return [];
-    switch (event.type) {
-      case "agent_start": {
-        const turnId = optionalString2(event.turnId) ?? this.createTurnId();
-        this.activeTurnId = turnId;
-        this.pendingUserStarts.length = 0;
-        this.endedMessageIds.clear();
-        this.endedAssistantTurnIds.clear();
-        this.errorEmittedTurnIds.clear();
-        return [this.event({ type: "agent-start", turnId })];
-      }
-      case "agent_end": {
-        const turnId = this.activeTurnId ?? this.createTurnId();
-        const status = agentEndStatus(event);
-        const mapped = [
-          ...this.mapAgentEndFinalAssistant(event, turnId),
-          ...this.mapAgentEndError(event, turnId, status),
-          // willRetry marks a non-terminal end (auto-retry coming) so once-per-settle
-          // consumers can ignore it; mirrors mapAgentEndError's own willRetry gate.
-          this.event({ type: "agent-end", turnId, status, ...event.willRetry === true ? { willRetry: true } : {} })
-        ];
-        this.activeAssistantMessageId = void 0;
-        this.toolCallMessageIds.clear();
-        if (status !== "error") this.activeTurnId = void 0;
-        return mapped;
-      }
-      case "message_start":
-        return this.mapMessageStart(event);
-      case "message_update":
-        return this.mapMessageUpdate(event);
-      case "message_end":
-        return this.mapMessageEnd(event);
-      case "tool_execution_end":
-        return this.mapToolExecutionEnd(event);
-      case "queue_update":
-        return [
-          this.event({
-            type: "queue-updated",
-            queue: { followUps: buildPiChatQueuedFollowUps(this.sessionId, readStringArray(event.followUp)) }
-          })
-        ];
-      case "auto_retry_start":
-        this.resetDedupForRetry();
-        return [
-          this.event({
-            type: "auto-retry-start",
-            attempt: numberValue(event.attempt) ?? 0,
-            maxAttempts: numberValue(event.maxAttempts) ?? 0,
-            delayMs: numberValue(event.delayMs) ?? 0,
-            errorMessage: optionalString2(event.errorMessage) ?? ""
-          })
-        ];
-      case "auto_retry_end":
-        return [
-          this.event({
-            type: "auto-retry-end",
-            success: event.success === true,
-            attempt: numberValue(event.attempt) ?? 0,
-            finalError: optionalString2(event.finalError)
-          })
-        ];
-      case "ui_command":
-      case "ui-command":
-        return [this.event({ type: "ui-command", command: event.command ?? event.data ?? {}, displayOnly: true })];
-      default:
-        return [];
-    }
-  }
-  createTurnId() {
-    return `turn:${this.sessionId}:${this.seq + 1}`;
-  }
-  resetDedupForRetry() {
-    this.endedMessageIds.clear();
-    if (this.activeTurnId) this.endedAssistantTurnIds.delete(this.activeTurnId);
-    else this.endedAssistantTurnIds.clear();
-    this.activeAssistantMessageId = void 0;
-    this.toolCallMessageIds.clear();
-  }
-  event(event) {
-    this.seq += 1;
-    return { ...event, seq: this.seq };
-  }
-  mapMessageStart(event) {
-    if (!isRecord3(event.message)) return [];
-    const message = event.message;
-    const rawRole = messageRole2(message);
-    if (rawRole !== "user" && rawRole !== "assistant") return [];
-    const role = rawRole;
-    const messageId = messageIdFrom(message) ?? fallbackMessageId(this.sessionId, role, this.seq + 1);
-    const text = textFromContent2(message.content) ?? optionalString2(message.text);
-    if (role === "assistant") this.activeAssistantMessageId = messageId;
-    if (role === "user" && messageIdFrom(message) === void 0) this.pendingUserStarts.push({ messageId, text });
-    const clientNonce = optionalString2(message.clientNonce);
-    const clientSeq = numberValue(message.clientSeq);
-    const start = this.event({
-      type: "message-start",
-      messageId,
-      role,
-      clientNonce,
-      clientSeq,
-      createdAt: messageTimestamp2(message),
-      text,
-      files: filePartsFromContent2(message.content, messageId)
-    });
-    if (role === "user" && clientNonce !== void 0 && clientSeq !== void 0) {
-      return [start, this.event({ type: "followup-consumed", clientNonce, clientSeq, messageId })];
-    }
-    return [start];
-  }
-  mapMessageUpdate(event) {
-    if (!isRecord3(event.assistantMessageEvent)) return [];
-    const assistantEvent = event.assistantMessageEvent;
-    const messageId = this.messageUpdateId(event, assistantEvent);
-    const partId = partIdFromAssistantEvent(assistantEvent);
-    switch (assistantEvent.type) {
-      case "text_delta":
-        return [this.event({ type: "message-delta", messageId, partId, kind: "text", delta: stringValue(assistantEvent.delta) })];
-      case "text_end":
-        return [this.event({ type: "message-part-end", messageId, partId, kind: "text", text: stringValue(assistantEvent.content) })];
-      case "thinking_delta":
-        return [this.event({ type: "message-delta", messageId, partId, kind: "reasoning", delta: stringValue(assistantEvent.delta) })];
-      case "thinking_end":
-        return [this.event({ type: "message-part-end", messageId, partId, kind: "reasoning", text: stringValue(assistantEvent.content) })];
-      case "toolcall_end":
-        return this.mapToolCallEnd(messageId, assistantEvent);
-      case "done": {
-        const usage = isRecord3(assistantEvent.message) ? assistantEvent.message.usage : void 0;
-        return usage === void 0 ? [] : [this.event({ type: "usage", usage })];
-      }
-      case "error": {
-        const errorMessage = errorMessageFromAssistantError(assistantEvent);
-        if (this.activeTurnId) this.errorEmittedTurnIds.add(this.activeTurnId);
-        return [
-          this.event({
-            type: "error",
-            turnId: this.activeTurnId,
-            retryable: false,
-            error: {
-              code: assistantEvent.reason === "aborted" ? ErrorCode.enum.ABORTED : ErrorCode.enum.INTERNAL_ERROR,
-              message: errorMessage,
-              retryable: false
-            }
-          })
-        ];
-      }
-      default:
-        return [];
-    }
-  }
-  messageUpdateId(event, assistantEvent) {
-    const fromEventMessage = isRecord3(event.message) ? messageIdFrom(event.message) : void 0;
-    const fromPartial = isRecord3(assistantEvent.partial) ? messageIdFrom(assistantEvent.partial) : void 0;
-    const fromFinal = isRecord3(assistantEvent.message) ? messageIdFrom(assistantEvent.message) : void 0;
-    const id = fromEventMessage ?? fromPartial ?? fromFinal ?? this.activeAssistantMessageId ?? fallbackMessageId(this.sessionId, "assistant", this.seq + 1);
-    this.activeAssistantMessageId = id;
-    return id;
-  }
-  mapToolCallEnd(messageId, assistantEvent) {
-    if (!isRecord3(assistantEvent.toolCall)) return [];
-    const toolCall = assistantEvent.toolCall;
-    const toolCallId = optionalString2(toolCall.id) ?? `${messageId}:tool:${partIdFromAssistantEvent(assistantEvent)}`;
-    this.toolCallMessageIds.set(toolCallId, messageId);
-    return [
-      this.event({
-        type: "tool-call",
-        messageId,
-        toolCallId,
-        toolName: optionalString2(toolCall.name) ?? "unknown",
-        input: toolCall.arguments ?? {},
-        ui: sanitizeToolUiMetadata(toolCall.ui)
-      })
-    ];
-  }
-  mapMessageEnd(event) {
-    if (!isRecord3(event.message)) return [];
-    const final = buildPiChatHistory([event.message], { sessionId: this.sessionId, turnId: this.activeTurnId })[0];
-    if (!final) return [];
-    const messageId = this.finalMessageId(final);
-    const canonicalFinal = final.id === messageId ? final : rewriteMessageId(final, messageId);
-    if (this.endedMessageIds.has(messageId)) return [];
-    this.endedMessageIds.add(messageId);
-    if (canonicalFinal.role === "assistant") {
-      if (this.activeTurnId && isTerminalAssistantFinal(canonicalFinal)) this.endedAssistantTurnIds.add(this.activeTurnId);
-      this.activeAssistantMessageId = void 0;
-    }
-    return [this.event({ type: "message-end", messageId, final: canonicalFinal })];
-  }
-  mapAgentEndFinalAssistant(event, turnId) {
-    if (this.endedAssistantTurnIds.has(turnId)) return [];
-    const messages = readRecordArray(event.messages);
-    const lastAssistantIndex = findLastIndex(messages, (message) => messageRole2(message) === "assistant");
-    if (lastAssistantIndex < 0) return [];
-    if (isContentlessTerminalAssistant(messages[lastAssistantIndex])) return [];
-    const finalAssistant = this.buildAgentEndFinalAssistant(messages, lastAssistantIndex, turnId);
-    if (!finalAssistant) return [];
-    if (this.endedMessageIds.has(finalAssistant.id)) return [];
-    this.endedMessageIds.add(finalAssistant.id);
-    this.activeAssistantMessageId = void 0;
-    return [this.event({ type: "message-end", messageId: finalAssistant.id, final: finalAssistant })];
-  }
-  /**
-   * Surfaces a turn failure as an explicit `error` event. Some failures (e.g.
-   * "No API key for provider") never produce an assistant `error` stream
-   * event — the message only rides on agent_end's final assistant entry
-   * (stopReason 'error' + errorMessage), which is also where the snapshot
-   * reads it from. Without this, live clients see an empty assistant message
-   * and an error agent-end but never the error text. Skipped when pi will
-   * auto-retry (auto_retry_* events own that flow) or when an error event was
-   * already emitted for this turn.
-   */
-  mapAgentEndError(event, turnId, status) {
-    if (status !== "error" || event.willRetry === true) return [];
-    if (this.errorEmittedTurnIds.has(turnId)) return [];
-    this.errorEmittedTurnIds.add(turnId);
-    return [
-      this.event({
-        type: "error",
-        turnId,
-        retryable: false,
-        error: {
-          code: ErrorCode.enum.INTERNAL_ERROR,
-          message: agentEndErrorMessage(event),
-          retryable: false
-        }
-      })
-    ];
-  }
-  finalMessageId(final) {
-    if (final.role === "assistant" && this.activeAssistantMessageId) return this.activeAssistantMessageId;
-    if (final.role !== "user") return final.id;
-    const text = messageText(final);
-    const exactIndex = this.pendingUserStarts.findIndex((start) => start.text === text);
-    const fallbackIndex = exactIndex >= 0 ? exactIndex : this.pendingUserStarts.findIndex((start) => start.text === void 0 || text === void 0);
-    if (fallbackIndex < 0) return final.id;
-    const [matched] = this.pendingUserStarts.splice(fallbackIndex, 1);
-    return matched?.messageId ?? final.id;
-  }
-  buildAgentEndFinalAssistant(messages, lastAssistantIndex, turnId) {
-    const rawAssistant = messages[lastAssistantIndex];
-    if (!rawAssistant) return void 0;
-    if (messageIdFrom(rawAssistant) === void 0) {
-      return buildPiChatHistory([{ id: this.activeAssistantMessageId ?? fallbackAgentEndAssistantId(this.sessionId, turnId), message: rawAssistant }], {
-        sessionId: this.sessionId,
-        turnId
-      })[0];
-    }
-    const assistants = buildPiChatHistory(messages, { sessionId: this.sessionId, turnId }).filter((message) => message.role === "assistant");
-    return assistants[assistants.length - 1];
-  }
-  mapToolExecutionEnd(event) {
-    const toolCallId = optionalString2(event.toolCallId);
-    if (!toolCallId) return [];
-    const messageId = this.toolCallMessageIds.get(toolCallId) ?? this.activeAssistantMessageId ?? fallbackMessageId(this.sessionId, "assistant", this.seq + 1);
-    const result = event.result;
-    const mapped = [];
-    for (const fileChange of extractFileChanges(isRecord3(result) ? result.details : void 0)) {
-      mapped.push(this.event({ type: "file-changed", path: fileChange.path, changeType: fileChange.op }));
-    }
-    mapped.push(
-      this.event({
-        type: "tool-result",
-        messageId,
-        toolCallId,
-        output: result ?? {},
-        isError: event.isError === true,
-        errorText: event.isError === true ? toolErrorText(result) : void 0,
-        ui: sanitizeToolUiMetadata(isRecord3(result) && isRecord3(result.details) ? result.details.ui : void 0)
-      })
-    );
-    return mapped;
-  }
-};
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function optionalString2(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function stringValue(value) {
-  return typeof value === "string" ? value : "";
-}
-function numberValue(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
-}
-function readStringArray(value) {
-  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-}
-function readRecordArray(value) {
-  return Array.isArray(value) ? value.filter((item) => isRecord3(item)) : [];
-}
-function findLastIndex(items, predicate) {
-  for (let index = items.length - 1; index >= 0; index -= 1) {
-    if (predicate(items[index])) return index;
-  }
-  return -1;
-}
-function messageRole2(message) {
-  return optionalString2(message.role) ?? optionalString2(message.type);
-}
-function messageIdFrom(message) {
-  return optionalString2(message.id) ?? optionalString2(message.messageId);
-}
-function messageTimestamp2(message) {
-  const timestamp = message.timestamp;
-  if (typeof timestamp === "number" && Number.isFinite(timestamp)) return new Date(timestamp).toISOString();
-  return optionalString2(timestamp);
-}
-function fallbackMessageId(sessionId, role, seq) {
-  return `pi:${sessionId}:event:${seq}:${role}`;
-}
-function fallbackAgentEndAssistantId(sessionId, turnId) {
-  return `pi:${sessionId}:turn:${turnId}:assistant`;
-}
-function textFromContent2(content) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return void 0;
-  const text = content.map((part) => isRecord3(part) && part.type === "text" && typeof part.text === "string" ? part.text : "").join("");
-  return text.length > 0 ? text : void 0;
-}
-function isContentlessTerminalAssistant(message) {
-  if (message.stopReason !== "aborted" && message.stopReason !== "error") return false;
-  return !hasDisplayableAssistantContent(message.content);
-}
-function hasDisplayableAssistantContent(content) {
-  if (typeof content === "string") return content.length > 0;
-  if (!Array.isArray(content)) return false;
-  return content.some((part) => {
-    if (!isRecord3(part)) return false;
-    if (part.type === "toolCall") return true;
-    if (part.type === "text") return typeof part.text === "string" && part.text.length > 0;
-    if (part.type === "thinking" || part.type === "reasoning") {
-      return typeof part.thinking === "string" && part.thinking.length > 0 || typeof part.text === "string" && part.text.length > 0;
-    }
-    return false;
-  });
-}
-function filePartsFromContent2(content, messageId) {
-  if (!Array.isArray(content)) return [];
-  return content.flatMap((part, index) => {
-    if (!isRecord3(part) || part.type !== "image") return [];
-    const mediaType = optionalString2(part.mimeType);
-    const url = imagePartUrl2(part, mediaType);
-    return [{
-      type: "file",
-      id: `${messageId}:file:${index}`,
-      ...optionalString2(part.filename) ? { filename: optionalString2(part.filename) } : {},
-      ...mediaType ? { mediaType } : {},
-      ...url ? { url } : {},
-      ...optionalString2(part.path) ? { path: optionalString2(part.path) } : {}
-    }];
-  });
-}
-function imagePartUrl2(part, mediaType) {
-  const existing = optionalString2(part.url);
-  if (existing) return existing;
-  const data = optionalString2(part.data);
-  if (!data) return void 0;
-  if (data.startsWith("data:")) return data;
-  return `data:${mediaType ?? "application/octet-stream"};base64,${data}`;
-}
-function messageText(message) {
-  const text = message.parts.filter((part) => part.type === "text").map((part) => part.text).join("");
-  return text.length > 0 ? text : void 0;
-}
-function isTerminalAssistantFinal(message) {
-  return message.role === "assistant" && !message.parts.some((part) => part.type === "tool-call");
-}
-function rewriteMessageId(message, id) {
-  return {
-    ...message,
-    id,
-    parts: message.parts.map((part, index) => {
-      if (part.type === "text") return { ...part, id: rewritePartId(part.id, message.id, id, `text:${index}`) };
-      if (part.type === "file") return { ...part, id: rewritePartId(part.id, message.id, id, `file:${index}`) };
-      if (part.type === "reasoning") return { ...part, id: rewritePartId(part.id, message.id, id, `reasoning:${index}`) };
-      return part;
-    })
-  };
-}
-function rewritePartId(partId, previousMessageId, nextMessageId, fallbackSuffix) {
-  if (partId?.startsWith(previousMessageId)) return `${nextMessageId}${partId.slice(previousMessageId.length)}`;
-  return `${nextMessageId}:${fallbackSuffix}`;
-}
-function partIdFromAssistantEvent(assistantEvent) {
-  const contentIndex = assistantEvent.contentIndex;
-  return typeof contentIndex === "number" && Number.isInteger(contentIndex) && contentIndex >= 0 ? String(contentIndex) : "0";
-}
-function agentEndStatus(event) {
-  const messages = Array.isArray(event.messages) ? event.messages : [];
-  const lastAssistant = [...messages].reverse().find((message) => isRecord3(message) && message.role === "assistant");
-  if (lastAssistant?.stopReason === "aborted") return "aborted";
-  if (lastAssistant?.stopReason === "error" || event.willRetry === true) return "error";
-  return "ok";
-}
-function agentEndErrorMessage(event) {
-  const messages = Array.isArray(event.messages) ? event.messages : [];
-  const lastAssistant = [...messages].reverse().find((message) => isRecord3(message) && message.role === "assistant");
-  if (typeof lastAssistant?.errorMessage === "string" && lastAssistant.errorMessage.length > 0) return lastAssistant.errorMessage;
-  return "Agent turn failed.";
-}
-function errorMessageFromAssistantError(assistantEvent) {
-  if (isRecord3(assistantEvent.error) && typeof assistantEvent.error.errorMessage === "string") return assistantEvent.error.errorMessage;
-  return assistantEvent.reason === "aborted" ? "Aborted" : "Unknown error";
-}
-function normalizeFileChangeEntry(value) {
-  if (!isRecord3(value)) return null;
-  const op = value.op;
-  const path = value.path;
-  if (typeof op !== "string" || !FILE_CHANGE_OPS.has(op)) return null;
-  if (typeof path !== "string" || path.length === 0) return null;
-  return { op, path };
-}
-function extractFileChanges(details) {
-  if (!isRecord3(details)) return [];
-  const entries = details.fileChanges;
-  if (Array.isArray(entries)) return entries.map(normalizeFileChangeEntry).filter((entry) => entry !== null);
-  const single = normalizeFileChangeEntry(details.fileChange);
-  return single ? [single] : [];
-}
-function toolErrorText(result) {
-  if (!isRecord3(result)) return void 0;
-  const content = result.content;
-  const text = textFromContent2(content);
-  return text ?? optionalString2(result.errorText);
-}
-
-// src/server/pi-chat/piChatReplayBuffer.ts
-var PI_CHAT_REPLAY_GAP = "replay_gap";
-var PI_CHAT_CURSOR_AHEAD = "cursor_ahead";
-var PiChatReplayBuffer = class {
-  maxEvents;
-  events = [];
-  latest = 0;
-  subscribers = /* @__PURE__ */ new Set();
-  constructor(options = {}) {
-    this.maxEvents = Math.max(1, Math.floor(options.maxEvents ?? 1e3));
-    this.latest = Math.max(0, Math.floor(options.initialLatestSeq ?? 0));
-  }
-  get latestSeq() {
-    return this.latest;
-  }
-  get minReplaySeq() {
-    return this.events[0]?.seq ?? this.latest + 1;
-  }
-  get size() {
-    return this.events.length;
-  }
-  publish(event) {
-    if (event.seq <= this.latest) {
-      throw new Error(`Pi chat event seq must increase monotonically: latest=${this.latest} next=${event.seq}`);
-    }
-    this.latest = event.seq;
-    this.events.push(event);
-    if (this.events.length > this.maxEvents) {
-      this.events.splice(0, this.events.length - this.maxEvents);
-    }
-    for (const subscriber of this.subscribers) {
-      subscriber(event);
-    }
-  }
-  validateCursor(cursor) {
-    const normalizedCursor = Math.floor(cursor);
-    if (!Number.isFinite(cursor) || normalizedCursor !== cursor || cursor < 0) {
-      return { type: PI_CHAT_REPLAY_GAP, latestSeq: this.latest, minReplaySeq: this.minReplaySeq };
-    }
-    if (cursor > this.latest) {
-      return { type: PI_CHAT_CURSOR_AHEAD, latestSeq: this.latest, minReplaySeq: this.minReplaySeq };
-    }
-    if (this.events.length === 0 && this.latest > 0 && cursor < this.latest) {
-      return { type: PI_CHAT_REPLAY_GAP, latestSeq: this.latest, minReplaySeq: this.minReplaySeq };
-    }
-    if (this.events.length > 0 && cursor < this.minReplaySeq - 1) {
-      return { type: PI_CHAT_REPLAY_GAP, latestSeq: this.latest, minReplaySeq: this.minReplaySeq };
-    }
-    return null;
-  }
-  replay(cursor, upperSeq = this.latest) {
-    const error = this.validateCursor(cursor);
-    if (error) return error;
-    const events = this.events.filter((event) => event.seq > cursor && event.seq <= upperSeq);
-    return { type: "ok", events, latestSeq: this.latest, minReplaySeq: this.minReplaySeq };
-  }
-  subscribe(cursor, subscriber, options = {}) {
-    const error = this.validateCursor(cursor);
-    if (error) return error;
-    const replayUpperBound = this.latest;
-    const pendingLiveEvents = [];
-    let replaying = true;
-    const liveSubscriber = (event) => {
-      if (replaying) {
-        pendingLiveEvents.push(event);
-        return;
-      }
-      subscriber(event);
-    };
-    this.subscribers.add(liveSubscriber);
-    let active = true;
-    const unsubscribe = () => {
-      if (!active) return;
-      active = false;
-      this.subscribers.delete(liveSubscriber);
-    };
-    options.beforeReplay?.();
-    const replay = this.replay(cursor, replayUpperBound);
-    if (replay.type !== "ok") {
-      unsubscribe();
-      return replay;
-    }
-    for (const event of replay.events) {
-      subscriber(event);
-    }
-    replaying = false;
-    for (const event of pendingLiveEvents) {
-      subscriber(event);
-    }
-    return {
-      type: "ok",
-      unsubscribe,
-      replayed: replay.events,
-      latestSeq: this.latest,
-      minReplaySeq: this.minReplaySeq
-    };
-  }
-  clearSubscribers() {
-    this.subscribers.clear();
-  }
-};
-
-// src/server/pi-chat/piChatMessageMetadataReconciler.ts
-var PiChatMessageMetadataReconciler = class {
-  promptMetadata = /* @__PURE__ */ new Map();
-  followUpMetadata = /* @__PURE__ */ new Map();
-  consumingFollowUpMetadata = /* @__PURE__ */ new Map();
-  clearSession(sessionId) {
-    this.promptMetadata.delete(sessionId);
-    this.followUpMetadata.delete(sessionId);
-    this.consumingFollowUpMetadata.delete(sessionId);
-  }
-  clearFollowUps(sessionId) {
-    this.followUpMetadata.delete(sessionId);
-  }
-  recordPrompt(sessionId, payload) {
-    const metadata = this.promptMetadata.get(sessionId) ?? [];
-    const displayText = payload.displayMessage ?? payload.message;
-    const files = filePartsFromPromptPayload(payload);
-    metadata.push({
-      displayText,
-      ...displayText !== payload.message ? { serverText: payload.message } : {},
-      clientNonce: payload.clientNonce,
-      recordedAt: Date.now(),
-      ...files ? { files } : {}
-    });
-    this.promptMetadata.set(sessionId, metadata);
-  }
-  removePrompt(sessionId, selector) {
-    const metadata = this.promptMetadata.get(sessionId);
-    if (!metadata) return;
-    const index = selector.clientNonce ? metadata.findIndex((entry) => entry.clientNonce === selector.clientNonce) : metadata.findIndex((entry) => matchesMetadataText(entry, selector.displayText));
-    if (index < 0) return;
-    metadata.splice(index, 1);
-    if (metadata.length > 0) this.promptMetadata.set(sessionId, metadata);
-    else this.promptMetadata.delete(sessionId);
-  }
-  hasPrompt(sessionId, selector) {
-    const metadata = this.promptMetadata.get(sessionId);
-    if (!metadata) return false;
-    if (selector.clientNonce) return metadata.some((entry) => entry.clientNonce === selector.clientNonce);
-    return metadata.some((entry) => matchesMetadataText(entry, selector.displayText));
-  }
-  recordFollowUp(sessionId, payload) {
-    const metadata = this.followUpMetadata.get(sessionId) ?? [];
-    const displayText = payload.displayMessage ?? payload.message;
-    metadata.push({
-      displayText,
-      ...displayText !== payload.message ? { serverText: payload.message } : {},
-      clientNonce: payload.clientNonce,
-      clientSeq: payload.clientSeq,
-      recordedAt: Date.now()
-    });
-    this.followUpMetadata.set(sessionId, metadata);
-  }
-  removeFollowUp(sessionId, selector) {
-    this.removeFollowUpFrom(this.consumingFollowUpMetadata, sessionId, selector);
-    this.removeFollowUpFrom(this.followUpMetadata, sessionId, selector);
-  }
-  recordConsumingFollowUp(sessionId, followUp, serverText) {
-    const metadata = this.consumingFollowUpMetadata.get(sessionId) ?? [];
-    metadata.push({
-      displayText: followUp.displayText,
-      ...serverText && serverText !== followUp.displayText ? { serverText } : {},
-      clientNonce: followUp.clientNonce,
-      clientSeq: followUp.clientSeq,
-      recordedAt: Date.now()
-    });
-    this.consumingFollowUpMetadata.set(sessionId, metadata);
-  }
-  findFollowUpForQueueItem(sessionId, followUp) {
-    const entries = [
-      ...this.consumingFollowUpMetadata.get(sessionId) ?? [],
-      ...this.followUpMetadata.get(sessionId) ?? []
-    ];
-    return entries.find((entry) => matchesFollowUpSelector(entry, followUp)) ?? entries.find((entry) => matchesMetadataText(entry, followUp.displayText));
-  }
-  enrichSnapshot(sessionId, snapshot) {
-    const messages = this.enrichSnapshotMessages(sessionId, snapshot.messages);
-    const followUps = this.enrichQueuedFollowUps(sessionId, snapshot.queue.followUps);
-    this.syncFromQueue(sessionId, followUps);
-    return { ...snapshot, messages, queue: { followUps } };
-  }
-  enrichEvent(sessionId, event) {
-    if (event.type === "queue-updated") {
-      const followUps = this.enrichQueuedFollowUps(sessionId, event.queue.followUps);
-      this.syncFromQueue(sessionId, followUps);
-      return { ...event, queue: { followUps } };
-    }
-    if (event.type === "message-start" && event.role === "user" && !hasFollowUpSelector(event)) {
-      const promptMetadata = this.findPrompt(sessionId, event.text);
-      if (promptMetadata) return withMessageStartMetadata(event, promptMetadata);
-      const metadata = this.findFollowUp(sessionId, event.text);
-      if (metadata) return withMessageStartMetadata(event, metadata);
-    }
-    if (event.type === "message-end" && event.final.role === "user" && !hasMessageSelector(event.final)) {
-      const text = messageText2(event.final);
-      const promptMetadata = this.findPrompt(sessionId, text);
-      if (promptMetadata) return { ...event, final: withMessageSelector(event.final, promptMetadata) };
-      const metadata = this.findFollowUp(sessionId, text);
-      if (metadata) return { ...event, final: withMessageSelector(event.final, metadata) };
-    }
-    return event;
-  }
-  consumeEvent(sessionId, event) {
-    this.consumeFollowUpFromEvent(sessionId, event);
-    this.consumePromptFromEvent(sessionId, event);
-  }
-  enrichQueuedFollowUps(sessionId, followUps) {
-    const metadata = this.followUpMetadata.get(sessionId) ?? [];
-    if (metadata.length === 0) return followUps;
-    const followUpTextCounts = countTexts(followUps.map((followUp) => followUp.displayText));
-    const metadataTextCounts = countMetadataTexts(metadata);
-    return followUps.map((followUp, index) => {
-      if (hasFollowUpSelector(followUp)) return followUp;
-      const indexed = metadata[index];
-      if (matchesMetadataText(indexed, followUp.displayText)) return withQueuedSelector(followUp, indexed);
-      if ((followUpTextCounts.get(followUp.displayText) ?? 0) !== 1) return followUp;
-      if ((metadataTextCounts.get(followUp.displayText) ?? 0) !== 1) return followUp;
-      const matched = metadata.find((entry) => matchesMetadataText(entry, followUp.displayText));
-      return matched ? withQueuedSelector(followUp, matched) : followUp;
-    });
-  }
-  syncFromTexts(sessionId, followUps) {
-    if (followUps.length === 0) {
-      this.followUpMetadata.delete(sessionId);
-      return;
-    }
-    const metadata = this.enrichQueuedFollowUps(sessionId, buildPiChatQueuedFollowUps(sessionId, followUps));
-    this.syncFromQueue(sessionId, metadata);
-  }
-  enrichSnapshotMessages(sessionId, messages) {
-    const followUpMetadata = [
-      ...this.consumingFollowUpMetadata.get(sessionId) ?? [],
-      ...this.followUpMetadata.get(sessionId) ?? []
-    ];
-    const promptMetadata = [...this.promptMetadata.get(sessionId) ?? []];
-    if (followUpMetadata.length === 0 && promptMetadata.length === 0) return messages;
-    return messages.map((message) => {
-      if (message.role !== "user" || hasMessageSelector(message)) return message;
-      const text = messageText2(message);
-      const prompt = takeFirstMessageMetadata(promptMetadata, text, message);
-      if (prompt) return withMessageSelector(message, prompt);
-      const followUp = takeFirstMessageMetadata(followUpMetadata, text, message);
-      return followUp ? withMessageSelector(message, followUp) : message;
-    });
-  }
-  removeFollowUpFrom(source, sessionId, selector) {
-    const metadata = source.get(sessionId);
-    if (!metadata) return;
-    const index = metadata.findIndex((entry) => matchesFollowUpSelector(entry, selector));
-    if (index < 0) return;
-    metadata.splice(index, 1);
-    if (metadata.length > 0) source.set(sessionId, metadata);
-    else source.delete(sessionId);
-  }
-  consumeFollowUpFromEvent(sessionId, event) {
-    if (event.type === "followup-consumed") {
-      this.removeFollowUp(sessionId, event);
-      return;
-    }
-    if (event.type !== "message-start" || event.role !== "user") return;
-    if (hasFollowUpSelector(event)) {
-      this.removeFollowUp(sessionId, event);
-      return;
-    }
-    this.removeFirstFollowUpByText(sessionId, event.text);
-  }
-  findFollowUp(sessionId, text) {
-    if (!text) return void 0;
-    const consuming = this.consumingFollowUpMetadata.get(sessionId)?.find((entry) => matchesMetadataText(entry, text));
-    if (consuming) return consuming;
-    return this.followUpMetadata.get(sessionId)?.find((entry) => matchesMetadataText(entry, text));
-  }
-  findPrompt(sessionId, text) {
-    if (!text) return void 0;
-    return this.promptMetadata.get(sessionId)?.find((entry) => matchesMetadataText(entry, text));
-  }
-  consumePromptFromEvent(sessionId, event) {
-    if (event.type === "message-start" && event.role === "user") {
-      if (event.clientSeq !== void 0) return;
-      const prompt = event.clientNonce ? this.promptMetadata.get(sessionId)?.find((entry) => entry.clientNonce === event.clientNonce) : this.findPrompt(sessionId, event.text);
-      if (prompt?.serverText) return;
-      if (event.clientNonce) {
-        this.removePrompt(sessionId, { clientNonce: event.clientNonce });
-        return;
-      }
-      this.removePrompt(sessionId, { displayText: event.text });
-      return;
-    }
-    if (event.type !== "message-end" || event.final.role !== "user") return;
-    if (event.final.clientSeq !== void 0) return;
-    if (event.final.clientNonce) {
-      this.removePrompt(sessionId, { clientNonce: event.final.clientNonce });
-      return;
-    }
-    this.removePrompt(sessionId, { displayText: messageText2(event.final) });
-  }
-  removeFirstFollowUpByText(sessionId, text) {
-    if (!text) return;
-    if (this.removeFirstFollowUpByTextFrom(this.consumingFollowUpMetadata, sessionId, text)) return;
-    this.removeFirstFollowUpByTextFrom(this.followUpMetadata, sessionId, text);
-  }
-  removeFirstFollowUpByTextFrom(source, sessionId, text) {
-    const metadata = source.get(sessionId);
-    if (!metadata) return false;
-    const index = metadata.findIndex((entry) => matchesMetadataText(entry, text));
-    if (index < 0) return false;
-    metadata.splice(index, 1);
-    if (metadata.length > 0) source.set(sessionId, metadata);
-    else source.delete(sessionId);
-    return true;
-  }
-  syncFromQueue(sessionId, followUps) {
-    const previous = this.followUpMetadata.get(sessionId) ?? [];
-    const recordedAt = Date.now();
-    const metadata = followUps.filter(hasFollowUpSelector).map((followUp) => {
-      const previousMatch = previous.find((entry) => matchesFollowUpSelector(entry, followUp));
-      return {
-        displayText: followUp.displayText,
-        ...previousMatch?.serverText ? { serverText: previousMatch.serverText } : {},
-        clientNonce: followUp.clientNonce,
-        clientSeq: followUp.clientSeq,
-        recordedAt: previousMatch?.recordedAt ?? recordedAt
-      };
-    });
-    if (metadata.length > 0) this.followUpMetadata.set(sessionId, metadata);
-    else this.followUpMetadata.delete(sessionId);
-  }
-};
-function hasFollowUpSelector(payload) {
-  return Boolean(payload.clientNonce) || payload.clientSeq !== void 0;
-}
-function followUpSelector(followUp) {
-  return {
-    ...followUp.clientNonce ? { clientNonce: followUp.clientNonce } : {},
-    ...followUp.clientSeq !== void 0 ? { clientSeq: followUp.clientSeq } : {}
-  };
-}
-function hasMessageSelector(message) {
-  return Boolean(message.clientNonce) || message.clientSeq !== void 0;
-}
-function matchesFollowUpSelector(entry, selector) {
-  if (selector.clientNonce) return entry.clientNonce === selector.clientNonce;
-  return selector.clientSeq !== void 0 && entry.clientSeq === selector.clientSeq;
-}
-function matchesMetadataText(entry, text) {
-  if (!entry || !text) return false;
-  return entry.displayText === text || entry.serverText === text;
-}
-function withMessageStartMetadata(event, metadata) {
-  return {
-    ...event,
-    text: metadata.displayText,
-    ...metadata.clientNonce ? { clientNonce: metadata.clientNonce } : {},
-    ...metadata.clientSeq !== void 0 ? { clientSeq: metadata.clientSeq } : {},
-    ...metadata.files && metadata.files.length > 0 ? { files: metadata.files } : {}
-  };
-}
-function withMessageSelector(message, metadata) {
-  return {
-    ...withMessageFiles(withMessageDisplayText(message, metadata.displayText), metadata.files),
-    ...metadata.clientNonce ? { clientNonce: metadata.clientNonce } : {},
-    ...metadata.clientSeq !== void 0 ? { clientSeq: metadata.clientSeq } : {}
-  };
-}
-function withMessageDisplayText(message, displayText) {
-  let replaced = false;
-  const parts = message.parts.flatMap((part) => {
-    if (part.type !== "text") return [part];
-    if (replaced) return [];
-    replaced = true;
-    return [{ ...part, text: displayText }];
-  });
-  return { ...message, parts };
-}
-function withMessageFiles(message, files) {
-  if (!files || files.length === 0) return message;
-  const nonFileParts = message.parts.filter((part) => part.type !== "file");
-  return { ...message, parts: [...nonFileParts, ...files] };
-}
-function filePartsFromPromptPayload(payload) {
-  if (!payload.attachments || payload.attachments.length === 0) return void 0;
-  return payload.attachments.map((attachment, index) => ({
-    type: "file",
-    id: `prompt:${payload.clientNonce}:file:${index}`,
-    filename: attachment.filename,
-    mediaType: attachment.mediaType,
-    url: attachment.url,
-    path: attachment.path
-  }));
-}
-function withQueuedSelector(followUp, metadata) {
-  return {
-    ...followUp,
-    displayText: metadata.displayText,
-    ...metadata.clientNonce ? { clientNonce: metadata.clientNonce } : {},
-    ...metadata.clientSeq !== void 0 ? { clientSeq: metadata.clientSeq } : {}
-  };
-}
-function countTexts(texts) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const text of texts) counts.set(text, (counts.get(text) ?? 0) + 1);
-  return counts;
-}
-function countMetadataTexts(entries) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    counts.set(entry.displayText, (counts.get(entry.displayText) ?? 0) + 1);
-    if (entry.serverText) counts.set(entry.serverText, (counts.get(entry.serverText) ?? 0) + 1);
-  }
-  return counts;
-}
-function messageText2(message) {
-  let text = "";
-  for (const part of message.parts) {
-    if (part.type !== "text") continue;
-    text += text ? `
-${part.text}` : part.text;
-  }
-  return text === "" ? void 0 : text;
-}
-function takeFirstMessageMetadata(metadata, text, message) {
-  if (!text) return void 0;
-  const createdAt = messageCreatedAtMs(message);
-  if (createdAt === void 0) return void 0;
-  const index = metadata.findIndex((entry2) => {
-    if (!matchesMetadataText(entry2, text)) return false;
-    return entry2.recordedAt !== void 0 && createdAt >= entry2.recordedAt;
-  });
-  if (index < 0) return void 0;
-  const [entry] = metadata.splice(index, 1);
-  return entry;
-}
-function messageCreatedAtMs(message) {
-  if (!message.createdAt) return void 0;
-  const timestamp = Date.parse(message.createdAt);
-  return Number.isFinite(timestamp) ? timestamp : void 0;
-}
-
-// src/server/pi-chat/harnessPiChatService.ts
-var MAX_PROMPT_IMAGE_BYTES = 10 * 1024 * 1024;
-var PROMPT_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".avif", ".gif", ".jpg", ".jpeg", ".png", ".webp"]);
-var HarnessPiChatService = class {
-  harness;
-  sessionStore;
-  workdir;
-  workspace;
-  eventStore;
-  allowAttachments;
-  channels = /* @__PURE__ */ new Map();
-  // Single-flight guard so concurrent cold callers (e.g. two browser tabs each
-  // opening /events while the session is still being created) converge on one
-  // LiveSessionChannel instead of racing through ensureChannel and orphaning
-  // the loser's adapter subscription.
-  channelCreations = /* @__PURE__ */ new Map();
-  messageMetadata = new PiChatMessageMetadataReconciler();
-  activePromptRuns = /* @__PURE__ */ new Map();
-  syntheticPromptFailures = /* @__PURE__ */ new Map();
-  activeSyntheticPromptErrors = /* @__PURE__ */ new Map();
-  metering;
-  constructor(options) {
-    this.harness = options.harness;
-    this.sessionStore = options.sessionStore;
-    this.workdir = options.workdir;
-    this.workspace = options.workspace;
-    this.eventStore = options.eventStore;
-    this.allowAttachments = options.allowAttachments !== false;
-    this.metering = options.metering ? new PiChatMeteringCoordinator(options.metering, options.meteringLogger) : void 0;
-  }
-  /** Test/diagnostic hook: resolves once queued metering sink calls settle. */
-  async flushMetering() {
-    await this.metering?.flush();
-  }
-  async listSessions(ctx, options) {
-    return this.sessionStore.list(toSessionCtx(ctx), options);
-  }
-  async createSession(ctx, init) {
-    return this.sessionStore.create(toSessionCtx(ctx), init);
-  }
-  async deleteSession(ctx, sessionId) {
-    const sessionCtx = toSessionCtx(ctx);
-    const sessionKey = sessionCacheKey(sessionId, sessionCtx);
-    try {
-      await this.sessionStore.load(sessionCtx, sessionId);
-    } catch (error) {
-      throw normalizeSessionAccessError(error, sessionId);
-    }
-    const channel = this.channels.get(sessionKey);
-    if (channel) {
-      const activeRun = this.activePromptRuns.get(sessionKey);
-      await channel.adapter.abort();
-      await activeRun?.catch(() => {
-      });
-    }
-    channel?.unsubscribe();
-    this.channels.delete(sessionKey);
-    this.metering?.releaseSession(sessionKey);
-    this.messageMetadata.clearSession(sessionKey);
-    this.syntheticPromptFailures.delete(sessionKey);
-    this.activeSyntheticPromptErrors.delete(sessionKey);
-    await this.sessionStore.delete(sessionCtx, sessionId);
-  }
-  async readState(ctx, sessionId) {
-    const sessionKey = this.sessionKey(ctx, sessionId);
-    const channel = this.channels.get(sessionKey);
-    if (!channel && !this.harnessMayHaveLiveSession(ctx, sessionId)) {
-      const persisted = await this.readPersistedState(ctx, sessionId);
-      if (persisted) return persisted;
-    }
-    const adapter = await this.getAdapter(ctx, sessionId, "");
-    const snapshot = this.messageMetadata.enrichSnapshot(sessionKey, buildPiChatSnapshot(adapter, {
-      seq: channel?.buffer.latestSeq ?? 0,
-      sessionId,
-      activeTurnId: channel?.activeTurnId,
-      messageTurnIds: channel?.messageTurnIds
-    }));
-    return this.enrichSyntheticPromptFailures(sessionKey, snapshot);
-  }
-  harnessMayHaveLiveSession(ctx, sessionId) {
-    return typeof this.harness.hasPiSession === "function" ? this.harness.hasPiSession(sessionId, toSessionCtx(ctx)) : true;
-  }
-  async readPersistedState(ctx, sessionId) {
-    if (!this.sessionStore.loadEntries) return null;
-    try {
-      const { id, messages } = await this.sessionStore.loadEntries(toSessionCtx(ctx), sessionId);
-      return {
-        protocolVersion: 1,
-        sessionId: id,
-        seq: await this.readDurableLatestPiChatSeq(sessionStreamPath(this.sessionKey(ctx, id))),
-        status: "idle",
-        messages: buildPiChatHistory(messages, { sessionId: id }),
-        queue: { followUps: [] },
-        followUpMode: "one-at-a-time"
-      };
-    } catch {
-      return null;
-    }
-  }
-  async subscribe(ctx, sessionId, cursor, subscriber) {
-    const channel = await this.getChannel(ctx, sessionId);
-    const result = channel.buffer.subscribe(cursor, subscriber);
-    if (result.type !== "ok") return result;
-    return { type: "ok", unsubscribe: result.unsubscribe, closed: channel.closed };
-  }
-  async prompt(ctx, sessionId, payload) {
-    this.assertAttachmentsAllowed(payload);
-    const sessionKey = this.sessionKey(ctx, sessionId);
-    const adapter = await this.getAdapter(ctx, sessionId, payload);
-    const channel = await this.ensureChannel(ctx, sessionId, adapter);
-    const outcome = await this.metering?.reservePrompt({
-      workspaceId: ctx.workspaceId,
-      userId: ctx.authSubject,
-      userEmail: ctx.authEmail,
-      userEmailVerified: ctx.authEmailVerified,
-      sessionId,
-      stateKey: sessionKey,
-      clientNonce: payload.clientNonce,
-      message: payload.message,
-      model: adapter.currentModel?.() ?? payload.model
-    }) ?? "created";
-    if (outcome === "duplicate") {
-      return {
-        accepted: true,
-        cursor: this.channels.get(sessionKey)?.buffer.latestSeq ?? 0,
-        clientNonce: payload.clientNonce,
-        duplicate: true
-      };
-    }
-    if (outcome === "cancelled") throw promptCancelledError();
-    this.messageMetadata.recordPrompt(sessionKey, payload);
-    const receiptCursor = nextPromptReceiptCursor(channel);
-    try {
-      const input = await toPiPromptInput(payload, this.workspace);
-      const run = this.trackActiveRun(sessionKey, this.runAndDrainPublishQueue(channel, adapter.prompt(input)));
-      run.catch((error) => {
-        this.metering?.failPromptRun(sessionId, payload.clientNonce, sessionKey);
-        if (!this.messageMetadata.hasPrompt(sessionKey, { clientNonce: payload.clientNonce, displayText: payload.displayMessage ?? payload.message })) return;
-        this.publishPromptRunError(sessionKey, sessionId, channel, payload, error);
-      });
-    } catch (err) {
-      this.metering?.failPromptRun(sessionId, payload.clientNonce, sessionKey);
-      this.messageMetadata.removePrompt(sessionKey, { clientNonce: payload.clientNonce });
-      throw err;
-    }
-    return { accepted: true, cursor: receiptCursor, clientNonce: payload.clientNonce };
-  }
-  assertAttachmentsAllowed(payload) {
-    if (this.allowAttachments || !payload.attachments || payload.attachments.length === 0) return;
-    throw new AgentFilesystemRequiredError();
-  }
-  async followUp(ctx, sessionId, payload) {
-    const sessionKey = this.sessionKey(ctx, sessionId);
-    const adapter = await this.getAdapter(ctx, sessionId, payload.message);
-    const channel = await this.ensureChannel(ctx, sessionId, adapter);
-    const outcome = await this.metering?.reserveFollowUp({
-      workspaceId: ctx.workspaceId,
-      userId: ctx.authSubject,
-      userEmail: ctx.authEmail,
-      userEmailVerified: ctx.authEmailVerified,
-      sessionId,
-      stateKey: sessionKey,
-      clientNonce: payload.clientNonce,
-      clientSeq: payload.clientSeq,
-      message: payload.message,
-      model: adapter.currentModel?.()
-    }) ?? "created";
-    if (outcome === "duplicate") {
-      return {
-        accepted: true,
-        queued: true,
-        cursor: this.channels.get(sessionKey)?.buffer.latestSeq ?? 0,
-        clientNonce: payload.clientNonce,
-        clientSeq: payload.clientSeq,
-        duplicate: true
-      };
-    }
-    if (outcome === "cancelled") throw promptCancelledError();
-    this.messageMetadata.recordFollowUp(sessionKey, payload);
-    try {
-      await adapter.followUp(payload.message, {
-        displayText: payload.displayMessage ?? payload.message,
-        clientNonce: payload.clientNonce,
-        clientSeq: payload.clientSeq
-      });
-    } catch (err) {
-      this.metering?.failFollowUpRun(sessionKey, payload);
-      this.messageMetadata.removeFollowUp(sessionKey, payload);
-      throw err;
-    }
-    await this.drainPublishQueue(channel);
-    return { accepted: true, queued: true, cursor: this.channels.get(sessionKey)?.buffer.latestSeq ?? 0, clientNonce: payload.clientNonce, clientSeq: payload.clientSeq };
-  }
-  async clearQueue(ctx, sessionId, payload) {
-    const sessionKey = this.sessionKey(ctx, sessionId);
-    const adapter = await this.getAdapter(ctx, sessionId, "");
-    if (hasFollowUpSelector(payload)) {
-      const before = adapter.readSnapshot().followUpMessages.length;
-      adapter.clearFollowUp(payload);
-      await this.drainPublishQueue(this.channels.get(sessionKey));
-      const after = adapter.readSnapshot().followUpMessages.length;
-      if (after < before) {
-        this.messageMetadata.removeFollowUp(sessionKey, payload);
-        this.metering?.releaseQueued(sessionKey, payload);
-      }
-      return { accepted: true, cursor: this.channels.get(sessionKey)?.buffer.latestSeq ?? 0, cleared: Math.max(0, before - after) };
-    }
-    const clearedQueue = this.clearAllFollowUps(adapter, sessionId, sessionKey);
-    await this.drainPublishQueue(this.channels.get(sessionKey));
-    this.metering?.releaseQueued(sessionKey);
-    return { accepted: true, cursor: this.channels.get(sessionKey)?.buffer.latestSeq ?? 0, cleared: clearedQueue.length };
-  }
-  async interrupt(ctx, sessionId, _payload) {
-    const sessionKey = this.sessionKey(ctx, sessionId);
-    const adapter = await this.getAdapter(ctx, sessionId, "");
-    const snapshot = adapter.readSnapshot();
-    const wasActive = snapshot.isStreaming || snapshot.isRetrying;
-    const nextFollowUp = wasActive ? this.nextFollowUpForInterrupt(sessionId, sessionKey, adapter) : void 0;
-    const activeRun = this.activePromptRuns.get(sessionKey);
-    adapter.abortRetry?.();
-    if (wasActive) await adapter.abort();
-    await this.drainPublishQueue(this.channels.get(sessionKey));
-    await activeRun?.catch(() => {
-    });
-    this.metering?.releasePending(sessionKey);
-    if (nextFollowUp) await this.autoPostInterruptedFollowUp(sessionId, sessionKey, adapter, nextFollowUp);
-    return { accepted: true, cursor: this.channels.get(sessionKey)?.buffer.latestSeq ?? 0 };
-  }
-  async stop(ctx, sessionId, _payload) {
-    const sessionKey = this.sessionKey(ctx, sessionId);
-    const adapter = await this.getAdapter(ctx, sessionId, "");
-    const clearedQueue = this.clearAllFollowUps(adapter, sessionId, sessionKey);
-    this.metering?.releaseQueued(sessionKey);
-    this.metering?.releasePending(sessionKey);
-    await adapter.abort();
-    await this.drainPublishQueue(this.channels.get(sessionKey));
-    return { accepted: true, stopped: true, cursor: this.channels.get(sessionKey)?.buffer.latestSeq ?? 0, clearedQueue: buildPiChatQueuedFollowUps(sessionId, clearedQueue) };
-  }
-  clearAllFollowUps(adapter, sessionId, sessionKey) {
-    const before = [...adapter.readSnapshot().followUpMessages];
-    adapter.clearFollowUp();
-    const after = adapter.readSnapshot().followUpMessages;
-    this.messageMetadata.syncFromTexts(sessionKey, after);
-    return removedFollowUps(before, after);
-  }
-  nextFollowUpForInterrupt(sessionId, sessionKey, adapter) {
-    const followUps = this.messageMetadata.enrichQueuedFollowUps(
-      sessionKey,
-      buildPiChatQueuedFollowUps(sessionId, adapter.readSnapshot().followUpMessages)
-    );
-    return followUps[0];
-  }
-  async autoPostInterruptedFollowUp(sessionId, sessionKey, adapter, followUp) {
-    const metadata = this.messageMetadata.findFollowUpForQueueItem(sessionKey, followUp);
-    this.messageMetadata.recordConsumingFollowUp(sessionKey, followUp, metadata?.serverText);
-    if (adapter.continueQueuedFollowUp) {
-      try {
-        await this.trackActiveRun(sessionKey, this.runAndDrainPublishQueue(this.channels.get(sessionKey), adapter.continueQueuedFollowUp()));
-      } catch (err) {
-        this.metering?.failFollowUpRun(sessionKey, followUp);
-        throw err;
-      }
-      return;
-    }
-    if (!this.canClearAutoPostedFollowUpForFallback(adapter, followUp)) {
-      throw new AutoPostFollowUpError("Cannot auto-post queued follow-up because this runtime cannot safely remove only the consumed queued item.");
-    }
-    this.clearAutoPostedFollowUpForFallback(sessionId, sessionKey, adapter, followUp);
-    this.metering?.promoteQueuedToPrompt(sessionKey, followUp);
-    try {
-      await this.runPrompt(sessionKey, adapter, metadata?.serverText ?? followUp.displayText);
-    } catch (err) {
-      this.metering?.failPromotedFollowUp(sessionId, followUp, sessionKey);
-      await adapter.followUp(metadata?.serverText ?? followUp.displayText, {
-        displayText: followUp.displayText,
-        clientNonce: followUp.clientNonce,
-        clientSeq: followUp.clientSeq
-      });
-      if (followUp.clientNonce && followUp.clientSeq !== void 0) {
-        this.messageMetadata.recordFollowUp(sessionKey, {
-          message: metadata?.serverText ?? followUp.displayText,
-          displayMessage: followUp.displayText,
-          clientNonce: followUp.clientNonce,
-          clientSeq: followUp.clientSeq
-        });
-      }
-      throw err;
-    }
-  }
-  async runPrompt(sessionKey, adapter, input) {
-    await this.trackActiveRun(sessionKey, this.runAndDrainPublishQueue(this.channels.get(sessionKey), adapter.prompt(input)));
-  }
-  async trackActiveRun(sessionKey, run) {
-    this.activePromptRuns.set(sessionKey, run);
-    try {
-      await run;
-    } finally {
-      if (this.activePromptRuns.get(sessionKey) === run) this.activePromptRuns.delete(sessionKey);
-    }
-  }
-  clearAutoPostedFollowUpForFallback(sessionId, sessionKey, adapter, followUp) {
-    if (adapter.readSnapshot().followUpMessages.length <= 1) {
-      this.clearAllFollowUps(adapter, sessionId, sessionKey);
-      return true;
-    }
-    if (hasFollowUpSelector(followUp)) {
-      adapter.clearFollowUp(followUpSelector(followUp));
-      return true;
-    }
-    return false;
-  }
-  canClearAutoPostedFollowUpForFallback(adapter, followUp) {
-    return hasFollowUpSelector(followUp) || adapter.readSnapshot().followUpMessages.length <= 1;
-  }
-  enrichSyntheticPromptFailures(sessionKey, snapshot) {
-    const failures = this.syntheticPromptFailures.get(sessionKey);
-    if (!failures || failures.length === 0) return snapshot;
-    const activeError = this.activeSyntheticPromptErrors.get(sessionKey);
-    return {
-      ...snapshot,
-      status: activeError ? "error" : snapshot.status,
-      error: activeError ?? snapshot.error,
-      messages: mergeSyntheticMessages(snapshot.messages, failures.map((failure) => failure.message))
-    };
-  }
-  publishChannelEvents(sessionId, channel, events, afterPublish) {
-    if (!this.eventStore) {
-      const publishedEvents = [];
-      for (const event of events) {
-        const enriched = this.messageMetadata.enrichEvent(channel.sessionKey, event);
-        publishedEvents.push(enriched);
-        this.publishChannelEventSync(channel, enriched);
-      }
-      afterPublish?.(publishedEvents);
-      return;
-    }
-    const next = channel.publishQueue.then(async () => {
-      const publishedEvents = [];
-      for (const event of events) {
-        const enriched = this.messageMetadata.enrichEvent(channel.sessionKey, event);
-        publishedEvents.push(enriched);
-        await this.eventStore?.appendAgentEvent(sessionId, enriched, { idempotencyKey: String(enriched.seq), streamPath: channel.streamPath });
-        this.publishChannelEventSync(channel, enriched);
-      }
-      afterPublish?.(publishedEvents);
-    }).catch((error) => {
-      channel.rejectClosed(error);
-      throw error;
-    });
-    channel.publishQueue = next;
-    next.catch(() => {
-    });
-  }
-  publishChannelEventSync(channel, event) {
-    const sessionKey = channel.sessionKey;
-    if (event.type === "agent-start") {
-      channel.activeTurnId = event.turnId;
-      this.activeSyntheticPromptErrors.delete(sessionKey);
-    }
-    if (event.type === "message-start" && channel.activeTurnId) {
-      channel.messageTurnIds.set(event.messageId, channel.activeTurnId);
-    }
-    if (event.type === "message-end" && channel.activeTurnId) {
-      channel.messageTurnIds.set(event.messageId, channel.activeTurnId);
-      channel.messageTurnIds.set(event.final.id, channel.activeTurnId);
-    }
-    if (event.type === "agent-end" && channel.activeTurnId === event.turnId) channel.activeTurnId = void 0;
-    this.messageMetadata.consumeEvent(sessionKey, event);
-    channel.buffer.publish(event);
-  }
-  publishPromptRunError(sessionKey, sessionId, channel, payload, error) {
-    if (!channel) return;
-    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-    const messageId = `prompt-error:${payload.clientNonce}:user`;
-    const message = promptPayloadMessage(payload, messageId, createdAt, channel.activeTurnId);
-    const messageEvent = channel.mapper.mapSynthetic({
-      type: "message-start",
-      messageId,
-      role: "user",
-      clientNonce: payload.clientNonce,
-      text: payload.displayMessage ?? payload.message,
-      files: promptPayloadFileParts(payload, messageId),
-      createdAt
-    });
-    const promptError = {
-      code: ErrorCode.enum.INTERNAL_ERROR,
-      message: error instanceof Error && error.message ? error.message : "Prompt failed before the agent run completed.",
-      retryable: false
-    };
-    const errorEvent = channel.mapper.mapSynthetic({
-      type: "error",
-      turnId: channel.activeTurnId,
-      retryable: false,
-      error: promptError
-    });
-    this.publishChannelEvents(sessionId, channel, [messageEvent, errorEvent], () => {
-      const failures = this.syntheticPromptFailures.get(sessionKey) ?? [];
-      failures.push({ message, error: promptError });
-      this.syntheticPromptFailures.set(sessionKey, failures);
-      this.activeSyntheticPromptErrors.set(sessionKey, promptError);
-      channel.activeTurnId = void 0;
-    });
-  }
-  async runAndDrainPublishQueue(channel, run) {
-    let runError;
-    try {
-      await run;
-    } catch (error) {
-      runError = error;
-    }
-    try {
-      await this.drainPublishQueue(channel);
-    } catch (error) {
-      if (runError === void 0) throw error;
-    }
-    if (runError !== void 0) throw runError;
-  }
-  async drainPublishQueue(channel) {
-    await channel?.publishQueue;
-  }
-  async getAdapter(ctx, sessionId, input, options) {
-    if (!this.harness.getPiSessionAdapter) throw new Error("pi-native harness adapter unavailable");
-    if (options?.authorize !== false) await this.assertCanAccessSession(ctx, sessionId);
-    const message = typeof input === "string" ? input : input.message;
-    const sendInput = {
-      sessionId,
-      content: message,
-      message,
-      ctx: toSessionCtx(ctx),
-      ...typeof input !== "string" && input.model ? { model: input.model } : {},
-      ...typeof input !== "string" && input.thinkingLevel ? { thinkingLevel: input.thinkingLevel } : {},
-      ...typeof input !== "string" && input.attachments ? { attachments: input.attachments } : {}
-    };
-    return this.harness.getPiSessionAdapter(sendInput, {
-      abortSignal: new AbortController().signal,
-      workdir: this.workdir,
-      workspaceId: ctx.workspaceId,
-      requestId: ctx.requestId,
-      userId: ctx.authSubject,
-      userEmail: ctx.authEmail,
-      userEmailVerified: ctx.authEmailVerified
-    });
-  }
-  async getChannel(ctx, sessionId) {
-    await this.assertCanAccessSession(ctx, sessionId);
-    const sessionKey = this.sessionKey(ctx, sessionId);
-    const existing = this.channels.get(sessionKey);
-    if (existing) return existing;
-    return this.createChannelOnce(sessionKey, sessionId, () => this.getAdapter(ctx, sessionId, "", { authorize: false }));
-  }
-  async ensureChannel(ctx, sessionId, adapter) {
-    const sessionKey = this.sessionKey(ctx, sessionId);
-    const existing = this.channels.get(sessionKey);
-    if (existing) return existing;
-    return this.createChannelOnce(sessionKey, sessionId, async () => adapter);
-  }
-  /**
-   * Resolve (or create) the single LiveSessionChannel for a session, coalescing
-   * concurrent cold callers onto one in-flight creation. Without this guard two
-   * tabs opening /events on a not-yet-live session both fall through the channel
-   * cache miss, build separate channels + adapter subscriptions, and the second
-   * `this.channels.set` orphans the first — so the first tab's stream silently
-   * stops receiving events.
-   */
-  async createChannelOnce(sessionKey, sessionId, resolveAdapter) {
-    const inFlight = this.channelCreations.get(sessionKey);
-    if (inFlight) return inFlight;
-    const creation = (async () => {
-      const existing = this.channels.get(sessionKey);
-      if (existing) return existing;
-      const adapter = await resolveAdapter();
-      return this.buildChannel(sessionKey, sessionId, adapter);
-    })();
-    this.channelCreations.set(sessionKey, creation);
-    try {
-      return await creation;
-    } finally {
-      if (this.channelCreations.get(sessionKey) === creation) this.channelCreations.delete(sessionKey);
-    }
-  }
-  async buildChannel(sessionKey, sessionId, adapter) {
-    const existing = this.channels.get(sessionKey);
-    if (existing) return existing;
-    const streamPath = sessionStreamPath(sessionKey);
-    await this.eventStore?.createStream(streamPath);
-    const initialSeq = await this.readDurableLatestPiChatSeq(streamPath);
-    const buffer = new PiChatReplayBuffer({ initialLatestSeq: initialSeq });
-    const mapper = new PiChatEventMapper({ sessionId, initialSeq: buffer.latestSeq });
-    const closed = deferred();
-    closed.promise.catch(() => {
-    });
-    const channel = {
-      sessionKey,
-      streamPath,
-      buffer,
-      adapter,
-      unsubscribe: () => {
-      },
-      mapper,
-      publishQueue: Promise.resolve(),
-      closed: closed.promise,
-      rejectClosed: closed.reject,
-      messageTurnIds: /* @__PURE__ */ new Map()
-    };
-    const unsubscribe = adapter.subscribe((event) => {
-      const mappedEvents = mapper.map(event);
-      this.publishChannelEvents(sessionId, channel, mappedEvents, (enrichedEvents) => {
-        this.metering?.observe(sessionKey, event, enrichedEvents);
-      });
-    });
-    channel.unsubscribe = unsubscribe;
-    this.channels.set(sessionKey, channel);
-    return channel;
-  }
-  async readDurableLatestPiChatSeq(streamPath) {
-    if (!this.eventStore) return 0;
-    const meta = await this.eventStore.getStreamMeta(streamPath);
-    if (!meta) return 0;
-    const tailIndex = parseOffset(meta.nextOffset);
-    if (tailIndex < 0) return 0;
-    const tail = await this.eventStore.readEvents(streamPath, {
-      offset: formatOffset(tailIndex - 1),
-      limit: 1
-    });
-    const envelope = tail.events[0]?.data;
-    const seq = envelope?.chunk?.seq;
-    return typeof seq === "number" && Number.isInteger(seq) && seq >= 0 ? seq : tailIndex + 1;
-  }
-  async assertCanAccessSession(ctx, sessionId) {
-    try {
-      await this.sessionStore.load(toSessionCtx(ctx), sessionId);
-    } catch (error) {
-      throw normalizeSessionAccessError(error, sessionId);
-    }
-  }
-  sessionKey(ctx, sessionId) {
-    return sessionCacheKey(sessionId, toSessionCtx(ctx));
-  }
-};
-var AutoPostFollowUpError = class extends Error {
-};
-function promptCancelledError() {
-  return Object.assign(new Error("request cancelled before execution"), {
-    statusCode: 409,
-    code: ErrorCode.enum.ABORTED,
-    retryable: true
-  });
-}
-function deferred() {
-  let resolve2;
-  let reject;
-  const promise = new Promise((nextResolve, nextReject) => {
-    resolve2 = nextResolve;
-    reject = nextReject;
-  });
-  return { promise, resolve: resolve2, reject };
-}
-function normalizeSessionAccessError(error, sessionId) {
-  if (error?.code === ErrorCode.enum.SESSION_NOT_FOUND || isPlainSessionNotFound(error, sessionId)) {
-    return Object.assign(new Error("session not found"), {
-      code: ErrorCode.enum.SESSION_NOT_FOUND
-    });
-  }
-  return error;
-}
-function isPlainSessionNotFound(error, sessionId) {
-  return error instanceof Error && (error.message === "session not found" || error.message === `Session not found: ${sessionId}`);
-}
-function nextPromptReceiptCursor(channel) {
-  return (channel?.buffer.latestSeq ?? 0) + 1;
-}
-function promptPayloadFileParts(payload, messageId) {
-  if (!payload.attachments || payload.attachments.length === 0) return void 0;
-  return payload.attachments.map((attachment, index) => ({
-    type: "file",
-    id: `${messageId}:file:${index}`,
-    filename: attachment.filename,
-    mediaType: attachment.mediaType,
-    url: attachment.url,
-    path: attachment.path
-  }));
-}
-function promptPayloadMessage(payload, messageId, createdAt, turnId) {
-  const displayText = payload.displayMessage ?? payload.message;
-  return {
-    id: messageId,
-    role: "user",
-    status: "done",
-    clientNonce: payload.clientNonce,
-    createdAt,
-    turnId,
-    parts: [
-      ...displayText ? [{ type: "text", id: `${messageId}:text:0`, text: displayText }] : [],
-      ...promptPayloadFileParts(payload, messageId) ?? []
-    ]
-  };
-}
-function mergeSyntheticMessages(messages, syntheticMessages) {
-  const existingIds = new Set(messages.map((message) => message.id));
-  const merged = [...messages];
-  for (const synthetic of syntheticMessages) {
-    if (existingIds.has(synthetic.id)) continue;
-    const syntheticTime = messageTime(synthetic);
-    const insertAt = syntheticTime === void 0 ? -1 : merged.findIndex((message) => {
-      const timestamp = messageTime(message);
-      return timestamp !== void 0 && timestamp > syntheticTime;
-    });
-    if (insertAt < 0) merged.push(synthetic);
-    else merged.splice(insertAt, 0, synthetic);
-  }
-  return merged;
-}
-function messageTime(message) {
-  if (!message.createdAt) return void 0;
-  const timestamp = Date.parse(message.createdAt);
-  return Number.isFinite(timestamp) ? timestamp : void 0;
-}
-async function toPiPromptInput(payload, workspace) {
-  const images = await promptImagesFromAttachments(payload.attachments, workspace);
-  if (images.length === 0) return payload.message;
-  return { text: payload.message, options: { images } };
-}
-async function promptImagesFromAttachments(attachments, workspace) {
-  const images = [];
-  for (const attachment of attachments ?? []) {
-    const match = attachment.url.match(/^data:(image\/[^;]+);base64,(.+)$/);
-    if (match) {
-      const [, mimeType, data] = match;
-      images.push({ type: "image", mimeType, data });
-      continue;
-    }
-    if (!workspace?.readBinaryFile || !isWorkspaceImageAttachment(attachment)) continue;
-    try {
-      const stat = await workspace.stat(attachment.path);
-      if (stat.kind !== "file" || stat.size <= 0 || stat.size > MAX_PROMPT_IMAGE_BYTES) continue;
-      const bytes = await workspace.readBinaryFile(attachment.path);
-      if (bytes.byteLength <= 0 || bytes.byteLength > MAX_PROMPT_IMAGE_BYTES) continue;
-      const detectedMimeType = detectPromptImageMimeType(bytes);
-      if (!detectedMimeType) continue;
-      images.push({
-        type: "image",
-        mimeType: detectedMimeType,
-        data: Buffer.from(bytes).toString("base64")
-      });
-    } catch {
-    }
-  }
-  return images;
-}
-function isWorkspaceImageAttachment(attachment) {
-  if (!attachment.mediaType?.startsWith("image/") || !attachment.path) return false;
-  const lowerPath = attachment.path.toLowerCase();
-  return [...PROMPT_IMAGE_EXTENSIONS].some((ext) => lowerPath.endsWith(ext));
-}
-function detectPromptImageMimeType(bytes) {
-  const buffer = Buffer.from(bytes);
-  if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
-    return "image/png";
-  }
-  if (buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) {
-    return "image/jpeg";
-  }
-  if (buffer.length >= 6) {
-    const gif = buffer.subarray(0, 6).toString("ascii");
-    if (gif === "GIF87a" || gif === "GIF89a") return "image/gif";
-  }
-  if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
-    return "image/webp";
-  }
-  if (buffer.length >= 12 && buffer.subarray(4, 8).toString("ascii") === "ftyp") {
-    const brand = buffer.subarray(8, 12).toString("ascii");
-    if (brand === "avif" || brand === "avis") return "image/avif";
-  }
-  return null;
-}
-function removedFollowUps(before, after) {
-  const afterCounts = /* @__PURE__ */ new Map();
-  for (const text of after) afterCounts.set(text, (afterCounts.get(text) ?? 0) + 1);
-  const removed = [];
-  for (const text of before) {
-    const count = afterCounts.get(text) ?? 0;
-    if (count > 0) {
-      afterCounts.set(text, count - 1);
-      continue;
-    }
-    removed.push(text);
-  }
-  return removed;
-}
-function toSessionCtx(ctx) {
-  return { workspaceId: ctx.workspaceId, userId: ctx.authSubject };
-}
-function sessionCacheKey(sessionId, ctx) {
-  return JSON.stringify([sessionId, ctx.workspaceId ?? "", ctx.userId ?? ""]);
-}
-
-// src/server/runtime/pureRuntime.ts
-import { chmod, mkdir, mkdtemp } from "fs/promises";
-import { tmpdir } from "os";
-import { join, resolve } from "path";
-var PURE_RUNTIME_CWD_NAME = ".runtime-none";
-var defaultPureRuntimeCwd;
-async function createPureRuntimeCwd(sessionRoot) {
-  const explicitRoot = sessionRoot?.trim();
-  if (!explicitRoot) {
-    defaultPureRuntimeCwd ??= createDefaultPureRuntimeCwd();
-    return defaultPureRuntimeCwd;
-  }
-  const cwd = join(resolve(explicitRoot), PURE_RUNTIME_CWD_NAME);
-  await mkdir(cwd, { recursive: true, mode: 448 });
-  await chmod(cwd, 448);
-  return cwd;
-}
-async function createDefaultPureRuntimeCwd() {
-  const cwd = await mkdtemp(join(tmpdir(), "boring-agent-pure-"));
-  await chmod(cwd, 448);
-  return cwd;
-}
-
-// src/server/createAgent.ts
-var DEFAULT_WORKDIR = "";
-var DEFAULT_LIVE_BUFFER_SIZE = 1e3;
-function createAgent(config) {
-  return createAgentRuntimeBridge(config).agent;
-}
-function createAgentRuntimeBridge(config, options = {}) {
-  if (config.sessions && !config.harnessFactory) {
-    throw new Error("createAgent sessions override requires a harnessFactory that uses the same SessionStore");
-  }
-  const runtimeLoader = createRuntimeLoader(config, options);
-  const getRuntime = runtimeLoader.get;
-  const live = new AgentLiveEventBuffer(DEFAULT_LIVE_BUFFER_SIZE);
-  const sessionContexts = /* @__PURE__ */ new Map();
-  const startedSessions = /* @__PURE__ */ new Map();
-  const sendLocks = /* @__PURE__ */ new Map();
-  const sessions = createFacadeSessionStore(config.sessions, getRuntime, live, sessionContexts, startedSessions);
-  const readiness = createReadiness(config);
-  async function ensureSession(input, runtime) {
-    if (input.sessionId) {
-      const ctx = await authorizeSessionAccess(runtime, input.sessionId, input.ctx, sessionContexts);
-      return { sessionId: input.sessionId, sessionKey: sessionCacheKey2(input.sessionId, ctx), ctx };
-    }
-    const service = runtime.service;
-    const created = await service.createSession?.(toPiRequestContext(input.ctx), {
-      title: contentToText(input.content ?? input.message).slice(0, 80) || void 0
-    });
-    if (!created) throw new Error("agent session creation is unavailable");
-    rememberSessionCtx(sessionContexts, created.id, input.ctx);
-    return { sessionId: created.id, sessionKey: sessionCacheKey2(created.id, input.ctx), ctx: input.ctx };
-  }
-  async function ensureBridge(sessionKey, sessionId, ctx, service) {
-    const state = live.ensure(sessionKey);
-    if (state.bridge || state.closed) return state;
-    state.bridgePromise ??= (async () => {
-      const subscribeFrom = state.latestIndex === 0 ? 0 : Number.MAX_SAFE_INTEGER;
-      let result = await service.subscribe(toPiRequestContext(ctx), sessionId, subscribeFrom, (chunk) => {
-        live.publish(sessionKey, sessionId, chunk);
-      });
-      if (result.type !== "ok") {
-        result = await service.subscribe(toPiRequestContext(ctx), sessionId, result.latestSeq, (chunk) => {
-          live.publish(sessionKey, sessionId, chunk);
-        });
-      }
-      if (result.type !== "ok") throw new AgentNotImplementedError("Historical pi-chat replay is not implemented until T1.");
-      state.bridge = result;
-      result.closed?.finally(() => live.close(sessionKey)).catch(() => live.close(sessionKey));
-      return state;
-    })();
-    try {
-      return await state.bridgePromise;
-    } finally {
-      state.bridgePromise = void 0;
-    }
-  }
-  async function start(input) {
-    assertFilesystemAttachmentsAllowed(config, input);
-    const runtime = await getRuntime();
-    const { sessionId, sessionKey, ctx } = await ensureSession(input, runtime);
-    startedSessions.set(sessionKey, { sessionId, ctx });
-    await ensureBridge(sessionKey, sessionId, ctx, runtime.service);
-    const startIndex = live.latestIndex(sessionKey);
-    await runtime.service.prompt(toPiRequestContext(ctx), sessionId, toPromptPayload(input));
-    return { sessionId, startIndex };
-  }
-  const agent = {
-    sessions,
-    readiness,
-    start,
-    stream(sessionId, options2) {
-      return authorizedStream(sessionId, options2);
-    },
-    async *send(input) {
-      const release = input.sessionId ? await acquireSessionLock(sendLocks, sessionCacheKey2(input.sessionId, input.ctx)) : void 0;
-      try {
-        const receipt = await start(input);
-        let turnId;
-        for await (const event of authorizedStream(receipt.sessionId, { startIndex: receipt.startIndex, ctx: input.ctx })) {
-          yield event;
-          if (event.chunk.type === "agent-start") turnId = event.chunk.turnId;
-          if (isSendTerminalEvent(event, turnId)) break;
-        }
-      } finally {
-        release?.();
-      }
-    },
-    async resolveInput(_sessionId, _requestId, _response) {
-      throw new AgentNotImplementedError("resolveInput is not implemented until T1.");
-    },
-    async interrupt(sessionId, ctx) {
-      const runtime = await getRuntime();
-      const accessCtx = await authorizeSessionAccess(runtime, sessionId, ctx, sessionContexts);
-      return runtime.service.interrupt(toPiRequestContext(accessCtx), sessionId, {});
-    },
-    async stop(sessionId, ctx) {
-      const runtime = await getRuntime();
-      const accessCtx = await authorizeSessionAccess(runtime, sessionId, ctx, sessionContexts);
-      const receipt = await runtime.service.stop(toPiRequestContext(accessCtx), sessionId, {});
-      const sessionKey = sessionCacheKey2(sessionId, accessCtx);
-      live.close(sessionKey);
-      startedSessions.delete(sessionKey);
-      return receipt;
-    },
-    async dispose() {
-      const runtime = await runtimeLoader.current();
-      let stopError;
-      try {
-        if (runtime) {
-          await Promise.all([...startedSessions.values()].map(
-            (started) => runtime.service.stop(toPiRequestContext(started.ctx), started.sessionId, {})
-          ));
-        }
-      } catch (error) {
-        stopError = error;
-      } finally {
-        live.dispose();
-        startedSessions.clear();
-        sessionContexts.clear();
-        if (config.runtime !== "none") await config.runtime.dispose?.();
-      }
-      if (stopError) throw stopError;
-    }
-  };
-  return {
-    agent,
-    getRuntime,
-    currentRuntime: runtimeLoader.current
-  };
-  async function* authorizedStream(sessionId, options2) {
-    const runtime = await getRuntime();
-    const accessCtx = await authorizeSessionAccess(runtime, sessionId, options2.ctx, sessionContexts);
-    yield* live.stream(sessionCacheKey2(sessionId, accessCtx), options2.startIndex);
-  }
-}
-function createRuntimeLoader(config, options) {
-  let runtimePromise;
-  return {
-    get() {
-      runtimePromise ??= createRuntime(config, options);
-      return runtimePromise;
-    },
-    current() {
-      return runtimePromise;
-    }
-  };
-}
-async function createRuntime(config, options) {
-  const harnessFactory = config.harnessFactory ?? (await import("./createHarness-RZUU6MJQ.js")).createPiCodingAgentHarness;
-  const pureRuntimeCwd = config.runtime === "none" ? await createPureRuntimeCwd(config.sessionStorageRoot) : void 0;
-  const harnessInput = {
-    tools: config.tools ?? [],
-    cwd: pureRuntimeCwd ?? config.workdir ?? DEFAULT_WORKDIR,
-    runtimeCwd: pureRuntimeCwd ?? options.harness?.runtimeCwd ?? options.service?.workdir ?? config.workdir,
-    sessionStorageCwd: pureRuntimeCwd ? DEFAULT_WORKDIR : void 0,
-    systemPromptAppend: config.systemPromptAppend,
-    systemPromptDynamic: config.systemPromptDynamic,
-    sessionRoot: config.sessionStorageRoot,
-    telemetry: config.telemetry
-  };
-  const harness = await harnessFactory(harnessInput);
-  const sessionStore = config.sessions ?? harness.sessions;
-  return {
-    harness,
-    sessionStore,
-    service: new HarnessPiChatService({
-      harness,
-      sessionStore,
-      workdir: pureRuntimeCwd ?? options.service?.workdir ?? config.workdir ?? DEFAULT_WORKDIR,
-      workspace: options.service?.workspace,
-      eventStore: options.service?.eventStore,
-      allowAttachments: config.runtime !== "none",
-      metering: config.metering
-    })
-  };
-}
-function assertFilesystemAttachmentsAllowed(config, input) {
-  if (config.runtime !== "none" || !input.attachments || input.attachments.length === 0) return;
-  throw new AgentFilesystemRequiredError();
-}
-function createReadiness(config) {
-  const requirements = [...config.readinessRequirements ?? []];
-  return {
-    requirements,
-    async status() {
-      return requirements.map((key) => ({
-        key,
-        ready: false,
-        message: "readiness status is not available in the core facade"
-      }));
-    }
-  };
-}
-function createFacadeSessionStore(baseStore, getRuntime, live, sessionContexts, startedSessions) {
-  const store = async () => baseStore ?? (await getRuntime()).harness.sessions;
-  return {
-    async list(ctx, options) {
-      const summaries = await (await store()).list(ctx, options);
-      return summaries.filter((summary) => canAccessStoredSessionCtx(summary.id, ctx, sessionContexts));
-    },
-    async create(ctx, init) {
-      const created = await (await store()).create(ctx, init);
-      rememberSessionCtx(sessionContexts, created.id, ctx);
-      return created;
-    },
-    async load(ctx, sessionId) {
-      const runtime = await getRuntime();
-      const accessCtx = await authorizeSessionAccess(runtime, sessionId, ctx, sessionContexts);
-      return (await store()).load(accessCtx ?? {}, sessionId);
-    },
-    async delete(ctx, sessionId) {
-      const runtime = await getRuntime();
-      const accessCtx = await authorizeSessionAccess(runtime, sessionId, ctx, sessionContexts);
-      await runtime.service.deleteSession(toPiRequestContext(accessCtx), sessionId);
-      const sessionKey = sessionCacheKey2(sessionId, accessCtx);
-      live.close(sessionKey);
-      sessionContexts.delete(sessionKey);
-      startedSessions.delete(sessionKey);
-    }
-  };
-}
-function toPiRequestContext(ctx) {
-  return {
-    workspaceId: ctx?.workspaceId,
-    authSubject: ctx?.userId,
-    requestId: "agent-core"
-  };
-}
-function toPromptPayload(input) {
-  return {
-    message: contentToText(input.content ?? input.message),
-    clientNonce: `agent:${Date.now()}:${Math.random().toString(36).slice(2)}`,
-    ...input.model ? { model: input.model } : {},
-    ...input.thinkingLevel ? { thinkingLevel: input.thinkingLevel } : {},
-    ...input.attachments ? { attachments: input.attachments } : {}
-  };
-}
-function contentToText(content) {
-  if (content === void 0) return "";
-  if (typeof content === "string") return content;
-  return content.map((part) => part.text).filter((text) => typeof text === "string" && text.length > 0).join("\n");
-}
-async function loadSession(store, ctx, sessionId) {
-  try {
-    await store.load(ctx, sessionId);
-  } catch (error) {
-    throw normalizeSessionLoadError(error, sessionId);
-  }
-}
-async function assertLoadedSessionVisible(store, ctx, sessionId) {
-  const summaries = await store.list(ctx, { includeId: sessionId });
-  if (!summaries.some((summary) => summary.id === sessionId)) {
-    throw stableAgentError(ErrorCode.enum.UNAUTHORIZED, "session context mismatch");
-  }
-}
-function normalizeSessionLoadError(error, sessionId) {
-  if (error?.code === ErrorCode.enum.SESSION_NOT_FOUND || isPlainSessionNotFound2(error, sessionId)) {
-    return stableAgentError(ErrorCode.enum.SESSION_NOT_FOUND, "session not found");
-  }
-  return error;
-}
-async function authorizeSessionAccess(runtime, sessionId, callerCtx, sessionContexts) {
-  const requestedKey = sessionCacheKey2(sessionId, callerCtx);
-  const hasStoredCtx = sessionContexts.has(requestedKey);
-  const storedCtx = sessionContexts.get(requestedKey);
-  if (hasStoredCtx && callerCtx && !sameSessionCtx(callerCtx, storedCtx)) {
-    throw stableAgentError(ErrorCode.enum.UNAUTHORIZED, "session context mismatch");
-  }
-  if (hasStoredCtx && !callerCtx && !isEmptySessionCtx(storedCtx)) {
-    throw stableAgentError(ErrorCode.enum.UNAUTHORIZED, "session context required");
-  }
-  const accessCtx = callerCtx ?? storedCtx ?? {};
-  await loadSession(runtime.sessionStore, accessCtx, sessionId);
-  if (!hasStoredCtx) {
-    await assertLoadedSessionVisible(runtime.sessionStore, accessCtx, sessionId);
-    rememberSessionCtx(sessionContexts, sessionId, accessCtx);
-  }
-  return accessCtx;
-}
-function rememberSessionCtx(sessionContexts, sessionId, ctx) {
-  sessionContexts.set(sessionCacheKey2(sessionId, ctx), isEmptySessionCtx(ctx) ? void 0 : { workspaceId: ctx?.workspaceId, userId: ctx?.userId });
-}
-function sameSessionCtx(a, b) {
-  return (a?.workspaceId ?? "") === (b?.workspaceId ?? "") && (a?.userId ?? "") === (b?.userId ?? "");
-}
-function isEmptySessionCtx(ctx) {
-  return !ctx?.workspaceId && !ctx?.userId;
-}
-function canAccessStoredSessionCtx(sessionId, callerCtx, sessionContexts) {
-  const sessionKey = sessionCacheKey2(sessionId, callerCtx);
-  if (!sessionContexts.has(sessionKey)) return true;
-  const storedCtx = sessionContexts.get(sessionKey);
-  return sameSessionCtx(callerCtx, storedCtx);
-}
-function sessionCacheKey2(sessionId, ctx) {
-  return JSON.stringify([sessionId, ctx?.workspaceId ?? "", ctx?.userId ?? ""]);
-}
-function stableAgentError(code, message) {
-  return Object.assign(new Error(message), { code });
-}
-async function acquireSessionLock(locks, sessionId) {
-  const previous = locks.get(sessionId) ?? Promise.resolve();
-  let release;
-  const current = previous.catch(() => {
-  }).then(() => new Promise((resolve2) => {
-    release = resolve2;
-  }));
-  locks.set(sessionId, current);
-  await previous.catch(() => {
-  });
-  return () => {
-    release();
-    if (locks.get(sessionId) === current) locks.delete(sessionId);
-  };
-}
-function isPlainSessionNotFound2(error, sessionId) {
-  return error instanceof Error && (error.message === "session not found" || error.message === `Session not found: ${sessionId}` || error.message === `missing session ${sessionId}`);
-}
-function isSendTerminalEvent(event, turnId) {
-  const chunk = event.chunk;
-  if (chunk.type === "error") return !chunk.turnId || chunk.turnId === turnId;
-  return chunk.type === "agent-end" && chunk.willRetry !== true && chunk.turnId === turnId;
-}
-var AgentLiveEventBuffer = class {
-  constructor(maxEvents) {
-    this.maxEvents = maxEvents;
-  }
-  maxEvents;
-  sessions = /* @__PURE__ */ new Map();
-  eventIndexes = /* @__PURE__ */ new Map();
-  latestIndex(sessionKey) {
-    return this.eventIndexes.get(sessionKey) ?? 0;
-  }
-  ensure(sessionKey) {
-    let state = this.sessions.get(sessionKey);
-    if (!state || state.closed) {
-      const latestIndex = this.latestIndex(sessionKey);
-      state = {
-        events: [],
-        subscribers: /* @__PURE__ */ new Set(),
-        latestIndex,
-        evictedThroughIndex: latestIndex - 1,
-        closed: false
-      };
-      this.sessions.set(sessionKey, state);
-    }
-    return state;
-  }
-  publish(sessionKey, sessionId, chunk) {
-    const state = this.ensure(sessionKey);
-    if (state.closed) return;
-    const eventIndex = this.latestIndex(sessionKey);
-    this.eventIndexes.set(sessionKey, eventIndex + 1);
-    const event = {
-      v: 1,
-      eventIndex,
-      timestamp: Date.now(),
-      sessionId,
-      chunk
-    };
-    state.latestIndex = event.eventIndex + 1;
-    state.events.push(event);
-    if (state.events.length > this.maxEvents) {
-      const evicted = state.events.splice(0, state.events.length - this.maxEvents);
-      state.evictedThroughIndex = evicted[evicted.length - 1]?.eventIndex ?? state.evictedThroughIndex;
-    }
-    for (const subscriber of state.subscribers) subscriber.push(event);
-  }
-  stream(sessionKey, startIndex) {
-    const state = this.ensure(sessionKey);
-    this.assertReplayable(state, startIndex);
-    return {
-      [Symbol.asyncIterator]: () => {
-        this.assertReplayable(state, startIndex);
-        return createLiveIterator(state, startIndex);
-      }
-    };
-  }
-  close(sessionKey) {
-    const state = this.sessions.get(sessionKey);
-    if (!state) return;
-    state.closed = true;
-    state.bridge?.unsubscribe();
-    for (const subscriber of state.subscribers) subscriber.close();
-    state.subscribers.clear();
-  }
-  dispose() {
-    for (const [sessionId] of this.sessions) this.close(sessionId);
-    this.sessions.clear();
-  }
-  assertReplayable(state, startIndex) {
-    if (!Number.isInteger(startIndex) || startIndex < 0) {
-      throw cursorOutOfRangeError("startIndex must be a non-negative integer", {
-        startIndex,
-        latestIndex: state.latestIndex
-      });
-    }
-    if (startIndex <= state.evictedThroughIndex) {
-      throw new AgentNotImplementedError("Historical stream replay is not implemented until T1.");
-    }
-    if (startIndex > state.latestIndex) {
-      throw cursorOutOfRangeError(`startIndex ${startIndex} is ahead of next eventIndex ${state.latestIndex}`, {
-        startIndex,
-        latestIndex: state.latestIndex
-      });
-    }
-  }
-};
-function cursorOutOfRangeError(message, details) {
-  return Object.assign(new RangeError(message), {
-    code: ErrorCode.enum.CURSOR_OUT_OF_RANGE,
-    details
-  });
-}
-function createLiveIterator(state, startIndex) {
-  const queued = [];
-  const waiters = [];
-  let active = true;
-  const subscriber = {
-    push(event) {
-      if (!active) return;
-      const waiter = waiters.shift();
-      if (waiter) waiter({ value: event, done: false });
-      else queued.push(event);
-    },
-    close() {
-      if (!active) return;
-      active = false;
-      while (waiters.length > 0) waiters.shift()?.({ value: void 0, done: true });
-    }
-  };
-  state.subscribers.add(subscriber);
-  queued.push(...state.events.filter((event) => event.eventIndex >= startIndex));
-  return {
-    async next() {
-      if (queued.length > 0) return { value: queued.shift(), done: false };
-      if (!active || state.closed) return { value: void 0, done: true };
-      return new Promise((resolve2) => waiters.push(resolve2));
-    },
-    async return() {
-      active = false;
-      state.subscribers.delete(subscriber);
-      while (waiters.length > 0) waiters.shift()?.({ value: void 0, done: true });
-      return { value: void 0, done: true };
-    }
-  };
-}
-
-export {
-  PI_CHAT_REPLAY_GAP,
-  PI_CHAT_CURSOR_AHEAD,
-  normalizeMeteringUsage,
-  createAgent,
-  createAgentRuntimeBridge
-};