@hachej/boring-agent 0.1.64 → 0.1.66

package/dist/chunk-HHW2UNBK.js

@@ -0,0 +1,1812 @@
+import {
+  noopTelemetry,
+  safeCapture
+} from "./chunk-AQBXNPMD.js";
+import {
+  createLogger
+} from "./chunk-AJZHR626.js";
+import {
+  ErrorCode
+} from "./chunk-XZKU7FBV.js";
+
+// src/server/harness/pi-coding-agent/createHarness.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { extname, join as join2 } from "path";
+import {
+  createAgentSession,
+  SessionManager,
+  AuthStorage,
+  ModelRegistry,
+  DefaultResourceLoader,
+  SettingsManager as SettingsManager2,
+  getAgentDir as getAgentDir2,
+  loadSkills
+} from "@mariozechner/pi-coding-agent";
+
+// src/server/harness/pi-coding-agent/tool-adapter.ts
+var BORING_TOOL_ERROR_MARKER = "__boringToolError";
+function markToolResultErrorDetails(details) {
+  return details && typeof details === "object" && !Array.isArray(details) ? { ...details, [BORING_TOOL_ERROR_MARKER]: true } : { [BORING_TOOL_ERROR_MARKER]: true, details };
+}
+function unmarkToolResultErrorDetails(details) {
+  if (!details || typeof details !== "object" || Array.isArray(details)) return { isMarked: false, details };
+  const record = { ...details };
+  if (record[BORING_TOOL_ERROR_MARKER] !== true) return { isMarked: false, details };
+  delete record[BORING_TOOL_ERROR_MARKER];
+  if (Object.keys(record).length === 1 && "details" in record) return { isMarked: true, details: record.details };
+  return { isMarked: true, details: record };
+}
+function toolTelemetryProperties(toolName, sessionId, status, startedAt, result) {
+  const properties = {
+    toolName,
+    status,
+    durationMs: Date.now() - startedAt
+  };
+  if (sessionId) properties.sessionId = sessionId;
+  const errorCode = result?.details?.code;
+  if (status === "error") {
+    properties.errorCode = ErrorCode.safeParse(errorCode).success ? errorCode : ErrorCode.enum.TOOL_EXECUTION_ERROR;
+  }
+  return properties;
+}
+function adaptToolForPi(tool, sessionId, telemetry = noopTelemetry, getRunContext) {
+  return {
+    name: tool.name,
+    label: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+    promptSnippet: tool.promptSnippet ?? tool.description,
+    async execute(toolCallId, params, signal, onUpdate, _ctx) {
+      const startedAt = Date.now();
+      let emittedFailure = false;
+      try {
+        const runContext = getRunContext?.();
+        const result = await tool.execute(params, {
+          toolCallId,
+          abortSignal: signal ?? new AbortController().signal,
+          onUpdate: onUpdate ? (partial) => onUpdate({ content: [{ type: "text", text: partial }], details: void 0 }) : void 0,
+          sessionId,
+          userId: runContext?.userId,
+          userEmail: runContext?.userEmail,
+          userEmailVerified: runContext?.userEmailVerified,
+          workspaceId: runContext?.workspaceId,
+          requestId: runContext?.requestId
+        });
+        safeCapture(telemetry, {
+          name: result.isError ? "agent.tool.failed" : "agent.tool.completed",
+          properties: toolTelemetryProperties(
+            tool.name,
+            sessionId,
+            result.isError ? "error" : "ok",
+            startedAt,
+            result
+          )
+        });
+        if (result.isError) {
+          emittedFailure = true;
+          return {
+            content: result.content,
+            details: markToolResultErrorDetails(result.details)
+          };
+        }
+        return {
+          content: result.content,
+          details: result.details
+        };
+      } catch (error) {
+        if (!emittedFailure) {
+          safeCapture(telemetry, {
+            name: "agent.tool.failed",
+            properties: toolTelemetryProperties(tool.name, sessionId, "error", startedAt)
+          });
+        }
+        throw error;
+      }
+    }
+  };
+}
+function adaptToolsForPi(tools, sessionId, telemetry, getRunContext) {
+  return tools.map((tool) => adaptToolForPi(tool, sessionId, telemetry, getRunContext));
+}
+
+// src/server/harness/pi-coding-agent/piFollowUpQueueCompat.ts
+function createPiFollowUpQueueCompat() {
+  let queue = [];
+  const seenNonces = /* @__PURE__ */ new Set();
+  function record(text, options) {
+    const nonce = options?.clientNonce;
+    if (nonce && seenNonces.has(nonce)) return false;
+    queue.push({
+      text,
+      displayText: options?.displayText ?? text,
+      clientNonce: options?.clientNonce,
+      clientSeq: options?.clientSeq
+    });
+    if (nonce) seenNonces.add(nonce);
+    return true;
+  }
+  function clear(piSession, options) {
+    syncWithPi(piSession);
+    const removed = removeNativeFollowUp(options);
+    if (!options?.clientNonce && options?.clientSeq === void 0) {
+      removePiQueuedFollowUp(piSession);
+      return;
+    }
+    for (const item of removed) removePiQueuedFollowUp(piSession, item.request.text, item.textOrdinal);
+  }
+  function syncWithPi(piSession) {
+    if (!queue.length) return;
+    const piTexts = readPiQueuedFollowUpTexts(piSession);
+    if (piTexts.length === 0) {
+      queue = [];
+      return;
+    }
+    if (piTexts.length >= queue.length) return;
+    const remaining = [];
+    let searchEnd = queue.length;
+    for (let index = piTexts.length - 1; index >= 0; index -= 1) {
+      const text = piTexts[index];
+      let matchIndex = -1;
+      for (let queueIndex = searchEnd - 1; queueIndex >= 0; queueIndex -= 1) {
+        const item = queue[queueIndex];
+        if (item.text === text || item.displayText === text) {
+          matchIndex = queueIndex;
+          break;
+        }
+      }
+      if (matchIndex < 0) break;
+      remaining.unshift(queue[matchIndex]);
+      searchEnd = matchIndex;
+    }
+    if (remaining.length !== piTexts.length) return;
+    queue = remaining;
+  }
+  function removeNativeFollowUp(options) {
+    if (!queue.length) {
+      if (!hasFollowUpSelector(options)) seenNonces.clear();
+      return [];
+    }
+    const removed = [];
+    const next = [];
+    const textCounts = /* @__PURE__ */ new Map();
+    for (const request of queue) {
+      const textOrdinal = textCounts.get(request.text) ?? 0;
+      textCounts.set(request.text, textOrdinal + 1);
+      if (matchesFollowUpSelector(request, options)) removed.push({ request, textOrdinal });
+      else next.push(request);
+    }
+    queue = next;
+    if (queue.length === 0) seenNonces.clear();
+    return removed;
+  }
+  return { record, clear };
+}
+function removePiQueuedFollowUp(piSession, text, textOrdinal = 0) {
+  const queue = piQueueAccess(piSession);
+  if (!text) {
+    queue.clearAll();
+    return;
+  }
+  if (queue.queuedMessages) {
+    removeFirstMatchingOrdinal(queue.queuedMessages, (message) => userMessageText(message) === text, textOrdinal);
+  }
+  if (queue.followUpMessages) {
+    removeFirstMatchingOrdinal(queue.followUpMessages, (message) => message === text, textOrdinal);
+  }
+  queue.emitUpdate();
+}
+function readPiQueuedFollowUpTexts(piSession) {
+  const queue = piQueueAccess(piSession);
+  if (queue.queuedMessages) {
+    return queue.queuedMessages.map(userMessageText).filter((text) => text.length > 0);
+  }
+  if (queue.followUpMessages) return [...queue.followUpMessages];
+  return [];
+}
+function piQueueAccess(piSession) {
+  const session = piSession;
+  const followUpMessages = Array.isArray(session._followUpMessages) ? session._followUpMessages : void 0;
+  const queuedMessages = Array.isArray(session.agent?.followUpQueue?.messages) ? session.agent.followUpQueue.messages : void 0;
+  return {
+    followUpMessages,
+    queuedMessages,
+    clearAll() {
+      session.agent?.clearFollowUpQueue?.();
+      if (followUpMessages) followUpMessages.length = 0;
+      session._emitQueueUpdate?.();
+    },
+    emitUpdate() {
+      session._emitQueueUpdate?.();
+    }
+  };
+}
+function userMessageText(message) {
+  const content = message.content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => part.type === "text" && typeof part.text === "string" ? part.text : "").join("");
+}
+function removeFirstMatchingOrdinal(items, matches, ordinal) {
+  let seen = 0;
+  const index = items.findIndex((item) => {
+    if (!matches(item)) return false;
+    if (seen++ !== ordinal) return false;
+    return true;
+  });
+  if (index >= 0) items.splice(index, 1);
+}
+function hasFollowUpSelector(options) {
+  return Boolean(options?.clientNonce) || options?.clientSeq !== void 0;
+}
+function matchesFollowUpSelector(item, options) {
+  if (!hasFollowUpSelector(options)) return true;
+  if (options?.clientNonce) return item.clientNonce === options.clientNonce;
+  return options?.clientSeq !== void 0 && item.clientSeq === options.clientSeq;
+}
+
+// src/server/pi-chat/PiAgentSessionAdapter.ts
+function normalizePromptInput(input) {
+  if (typeof input === "string") return { text: input };
+  return input;
+}
+function createPiAgentSessionAdapter(session, options = {}) {
+  const followUpQueue = createPiFollowUpQueueCompat();
+  const adapter = {
+    readSnapshot() {
+      return {
+        state: session.state,
+        messages: session.messages,
+        isStreaming: session.isStreaming,
+        isRetrying: session.isRetrying,
+        retryAttempt: session.retryAttempt,
+        pendingMessageCount: session.pendingMessageCount,
+        steeringMessages: session.getSteeringMessages(),
+        followUpMessages: session.getFollowUpMessages(),
+        followUpMode: session.followUpMode,
+        sessionId: options.sessionId ?? session.sessionId,
+        sessionName: session.sessionName
+      };
+    },
+    currentModel() {
+      const model = session.model;
+      return typeof model?.provider === "string" && typeof model?.id === "string" ? { provider: model.provider, id: model.id } : void 0;
+    },
+    subscribe(listener) {
+      return session.subscribe(listener);
+    },
+    async prompt(input) {
+      const { text, options: options2 } = normalizePromptInput(input);
+      await session.prompt(text, options2);
+    },
+    async followUp(text, followUpOptions) {
+      const accepted = followUpQueue.record(text, followUpOptions);
+      if (!accepted) return;
+      await session.followUp(text);
+    },
+    clearFollowUp(selector) {
+      followUpQueue.clear(session, selector);
+    },
+    async abort() {
+      await session.abort();
+    }
+  };
+  if (typeof session.abortRetry === "function") {
+    adapter.abortRetry = () => session.abortRetry?.();
+  }
+  if (options.continueQueuedFollowUp) {
+    adapter.continueQueuedFollowUp = options.continueQueuedFollowUp;
+  }
+  return adapter;
+}
+
+// src/server/harness/pi-coding-agent/sessions.ts
+import { randomUUID } from "crypto";
+import {
+  readdir,
+  readFile,
+  stat as fsStat,
+  rm,
+  mkdir,
+  writeFile,
+  appendFile,
+  rename,
+  open
+} from "fs/promises";
+import { closeSync, openSync, readFileSync, readSync, readdirSync, writeFileSync } from "fs";
+import { join, basename, resolve } from "path";
+import { homedir } from "os";
+
+// src/server/config/env.ts
+function getEnv(name) {
+  return process.env[name];
+}
+function getEnvSnapshot() {
+  return { ...process.env };
+}
+function setEnvDefault(name, value) {
+  if (process.env[name] !== void 0) return false;
+  process.env[name] = value;
+  return true;
+}
+
+// src/server/harness/pi-coding-agent/sessions.ts
+import {
+  parseSessionEntries,
+  CURRENT_SESSION_VERSION
+} from "@mariozechner/pi-coding-agent";
+function sessionBaseDir(explicitRoot) {
+  const explicit = explicitRoot?.trim();
+  if (explicit) return resolve(explicit);
+  const configured = getEnv(SESSION_ROOT_ENV)?.trim();
+  return configured ? resolve(configured) : join(homedir(), ".pi", "agent", "sessions");
+}
+function defaultSessionDir(cwd, explicitRoot) {
+  const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+  return join(sessionBaseDir(explicitRoot), safePath);
+}
+var SAFE_ID = /^[a-zA-Z0-9_-]+$/;
+var SAFE_SESSION_NAMESPACE = /^[a-zA-Z0-9_-]+$/;
+var SESSION_ROOT_ENV = "BORING_AGENT_SESSION_ROOT";
+var SUMMARY_PREFIX_BYTES = 64 * 1024;
+var DEFAULT_LEGACY_WORKSPACE_ID = "default";
+function sessionDirForNamespace(namespace, explicitRoot) {
+  const safeNamespace = namespace.trim();
+  if (!SAFE_SESSION_NAMESPACE.test(safeNamespace)) {
+    throw new Error("session namespace must contain only letters, numbers, underscores, and dashes");
+  }
+  return join(sessionBaseDir(explicitRoot), safeNamespace);
+}
+function normalizeListOptions(options) {
+  return {
+    limit: options?.limit === void 0 ? void 0 : Math.max(0, options.limit),
+    offset: Math.max(0, options?.offset ?? 0),
+    includeId: options?.includeId
+  };
+}
+var PiSessionStore = class {
+  cwd;
+  sessionDir;
+  allowLegacyUnscopedAccess;
+  prefixCache = /* @__PURE__ */ new Map();
+  listInFlight = /* @__PURE__ */ new Map();
+  constructor(cwd, options) {
+    this.cwd = cwd;
+    if (typeof options === "string") {
+      this.sessionDir = options;
+      this.allowLegacyUnscopedAccess = true;
+      return;
+    }
+    this.allowLegacyUnscopedAccess = true;
+    this.sessionDir = options?.sessionDir ?? (options?.sessionNamespace ? sessionDirForNamespace(options.sessionNamespace, options.sessionRoot) : defaultSessionDir(options?.storageCwd ?? cwd, options?.sessionRoot));
+  }
+  getSessionDir() {
+    return this.sessionDir;
+  }
+  async list(ctx, options) {
+    const normalizedOptions = normalizeListOptions(options);
+    const inFlightKey = JSON.stringify([
+      ctx.workspaceId,
+      ctx.userId ?? null,
+      normalizedOptions.limit ?? null,
+      normalizedOptions.offset,
+      normalizedOptions.includeId ?? null
+    ]);
+    const inFlight = this.listInFlight.get(inFlightKey);
+    if (inFlight) return inFlight;
+    const promise = this.listUncached(ctx, normalizedOptions);
+    this.listInFlight.set(inFlightKey, promise);
+    try {
+      return await promise;
+    } finally {
+      if (this.listInFlight.get(inFlightKey) === promise) this.listInFlight.delete(inFlightKey);
+    }
+  }
+  async listUncached(ctx, options) {
+    const files = await readdir(this.sessionDir).catch(() => []);
+    const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+    const filepaths = jsonlFiles.map((f) => join(this.sessionDir, f));
+    const fileStats = await Promise.all(filepaths.map(async (filepath) => {
+      try {
+        return { filepath, stat: await fsStat(filepath) };
+      } catch {
+        return null;
+      }
+    }));
+    const existingFiles = fileStats.filter((item) => item !== null);
+    const referencedPiFiles = await this.referencedPiFiles(existingFiles);
+    const visibleFiles = await Promise.all(existingFiles.filter(({ filepath }) => !referencedPiFiles.has(resolve(filepath))).map(async (file) => ({
+      ...file,
+      sortMtimeMs: await this.sessionSortMtimeMs(file)
+    })));
+    visibleFiles.sort((a, b) => b.sortMtimeMs - a.sortMtimeMs);
+    const { offset, limit } = options;
+    const pageSummaries = await this.summarizeVisiblePage(visibleFiles, { ctx, offset, limit });
+    const includeId = options.includeId;
+    if (!includeId || pageSummaries.some((summary) => summary.id === includeId)) return pageSummaries;
+    const includeSummary = await this.summarizeIncludedSession(ctx, includeId, referencedPiFiles);
+    return includeSummary ? [...pageSummaries, includeSummary] : pageSummaries;
+  }
+  async create(ctx, init) {
+    await mkdir(this.sessionDir, { recursive: true });
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const header = {
+      type: "session",
+      version: CURRENT_SESSION_VERSION,
+      id,
+      timestamp: now,
+      cwd: this.cwd,
+      boringSessionCtx: normalizeSessionCtx(ctx) ?? {}
+    };
+    const lines = [JSON.stringify(header)];
+    if (init?.title) {
+      const infoEntry = {
+        type: "session_info",
+        id: randomUUID(),
+        parentId: null,
+        timestamp: now,
+        name: init.title
+      };
+      lines.push(JSON.stringify(infoEntry));
+    }
+    const filepath = join(this.sessionDir, `${id}.jsonl`);
+    await writeFile(filepath, lines.join("\n") + "\n", "utf-8");
+    return {
+      id,
+      title: init?.title ?? "New session",
+      createdAt: now,
+      updatedAt: now,
+      turnCount: 0
+    };
+  }
+  async load(ctx, sessionId) {
+    const resolved = await this.resolveSessionTranscript(ctx, sessionId);
+    const title = extractTitle(resolved.sessionEntries) ?? extractTitle(resolved.linkedEntries) ?? "New session";
+    const turnCount = countUserTurns(resolved.transcriptEntries);
+    const updatedAtMs = Math.max(resolved.fileStat.mtime.getTime(), resolved.linkedMtimeMs ?? 0);
+    return {
+      id: resolved.resolvedSessionId,
+      title,
+      createdAt: resolved.header?.timestamp ?? resolved.fileStat.birthtime.toISOString(),
+      updatedAt: new Date(updatedAtMs).toISOString(),
+      turnCount
+    };
+  }
+  /**
+   * Returns the persisted pi message objects in file order so callers can run
+   * them through buildPiChatHistory — the same canonical projection the live
+   * event path uses. This is the cold-load counterpart to the live snapshot.
+   */
+  async loadEntries(ctx, sessionId) {
+    const resolved = await this.resolveSessionTranscript(ctx, sessionId);
+    const messages = resolved.transcriptEntries.filter((entry) => entry.type === "message").map((entry) => entry.message);
+    return { id: resolved.resolvedSessionId, messages };
+  }
+  async resolveSessionTranscript(ctx, sessionId) {
+    const filepath = await this.resolveSessionFile(sessionId, ctx);
+    let content;
+    try {
+      content = await readFile(filepath, "utf-8");
+    } catch {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const fileEntries = safeParseEntries(content);
+    if (fileEntries.some((e) => e.type === "ui_snapshot")) {
+      const compacted = fileEntries.filter((e) => e.type !== "ui_snapshot").map((e) => JSON.stringify(e)).join("\n") + "\n";
+      const tmp = `${filepath}.compact-${randomUUID()}`;
+      try {
+        await writeFile(tmp, compacted, "utf-8");
+        await rename(tmp, filepath);
+      } catch {
+        await rm(tmp, { force: true }).catch(() => {
+        });
+      }
+    }
+    const header = fileEntries.find(
+      (e) => e.type === "session"
+    );
+    if (!this.headerBelongsToCtx(header, ctx)) throw new Error(`Session not found: ${sessionId}`);
+    const sessionEntries = fileEntries.filter(
+      (e) => e.type !== "session" && e.type !== "ui_snapshot"
+    );
+    const fileStat = await fsStat(filepath);
+    const linkedPiFile = extractPiSessionFilePath(fileEntries);
+    const linked = linkedPiFile && resolve(linkedPiFile) !== resolve(filepath) ? await this.readLinkedPiSession(linkedPiFile) : null;
+    const linkedEntries = linked?.entries.filter(
+      (e) => e.type !== "session"
+    ) ?? [];
+    const transcriptEntries = linkedEntries.length > 0 ? linkedEntries : sessionEntries;
+    return {
+      resolvedSessionId: header?.id ?? sessionId,
+      header,
+      sessionEntries,
+      linkedEntries,
+      transcriptEntries,
+      fileStat,
+      linkedMtimeMs: linked?.mtime.getTime()
+    };
+  }
+  // Synchronous variant used during session initialization so that no async
+  // I/O hop is introduced before createAgentSession (which would break test
+  // timing when fake timers are in use). The file is tiny (metadata only).
+  loadPiSessionFileSync(ctx, sessionId) {
+    if (!SAFE_ID.test(sessionId)) return null;
+    try {
+      const direct = join(this.sessionDir, `${sessionId}.jsonl`);
+      let filepath = direct;
+      let content;
+      try {
+        content = readFileSync(direct, "utf-8");
+      } catch {
+        const files = readdirSync(this.sessionDir).filter(
+          (f) => f.endsWith(`_${sessionId}.jsonl`) || f === `${sessionId}.jsonl`
+        );
+        if (files.length === 0) return null;
+        filepath = join(this.sessionDir, files[0]);
+        content = readFileSync(filepath, "utf-8");
+      }
+      const entries = safeParseEntries(content);
+      const header = entries.find((entry) => entry.type === "session");
+      if (!this.headerBelongsToCtx(header, ctx)) return null;
+      const linkedPiFile = extractPiSessionFilePath(entries);
+      if (linkedPiFile) return linkedPiFile;
+      if (!isTimestampNamedPiSessionFile(filepath, sessionId)) return null;
+      const existingWrapper = this.findWrapperReferencingNativeSessionSync(filepath);
+      if (existingWrapper) {
+        const existingEntries = parseJsonlPrefixEntries(readJsonlPrefixSync(existingWrapper));
+        if (extractSessionHeaderId(existingEntries) !== sessionId) return null;
+        const wrapperHeader = existingEntries.find((entry) => entry.type === "session");
+        if (!this.headerBelongsToCtx(wrapperHeader, ctx)) return null;
+        return extractPiSessionFilePath(existingEntries);
+      }
+      this.ensureWrapperForNativeSessionSync(sessionId, filepath, entries, ctx);
+      return filepath;
+    } catch {
+      return null;
+    }
+  }
+  async loadPiSessionFile(ctx, sessionId) {
+    if (!SAFE_ID.test(sessionId)) return null;
+    try {
+      const direct = join(this.sessionDir, `${sessionId}.jsonl`);
+      let filepath = direct;
+      let content;
+      try {
+        content = await readFile(direct, "utf-8");
+      } catch {
+        const files = await readdir(this.sessionDir).catch(() => []);
+        const match = files.find(
+          (f) => f.endsWith(`_${sessionId}.jsonl`) || f === `${sessionId}.jsonl`
+        );
+        if (!match) return null;
+        filepath = join(this.sessionDir, match);
+        content = await readFile(filepath, "utf-8");
+      }
+      const entries = safeParseEntries(content);
+      const header = entries.find((entry) => entry.type === "session");
+      if (!this.headerBelongsToCtx(header, ctx)) return null;
+      const linkedPiFile = extractPiSessionFilePath(entries);
+      if (linkedPiFile) return linkedPiFile;
+      if (!isTimestampNamedPiSessionFile(filepath, sessionId)) return null;
+      const existingWrapper = await this.findWrapperReferencingNativeSession(filepath);
+      if (existingWrapper) {
+        const wrapperSessionId = await this.readSessionFileId(existingWrapper);
+        if (wrapperSessionId !== sessionId) return null;
+        const wrapperEntries = parseJsonlPrefixEntries(await readJsonlPrefix(existingWrapper));
+        const wrapperHeader = wrapperEntries.find((entry) => entry.type === "session");
+        if (!this.headerBelongsToCtx(wrapperHeader, ctx)) return null;
+        return extractPiSessionFilePath(wrapperEntries);
+      }
+      return await this.ensureWrapperForNativeSession(sessionId, filepath, ctx);
+    } catch {
+      return null;
+    }
+  }
+  async savePiSessionFile(ctx, sessionId, piFilePath) {
+    const filepath = await this.resolveSessionFile(sessionId, ctx);
+    const entry = JSON.stringify({
+      type: "pi_session_file",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      path: piFilePath
+    });
+    await appendFile(filepath, entry + "\n");
+  }
+  async delete(ctx, sessionId) {
+    const filepath = await this.resolveSessionFile(sessionId, ctx).catch(
+      () => null
+    );
+    if (!filepath) return;
+    const fileSessionId = await this.readSessionFileId(filepath);
+    if (fileSessionId && fileSessionId !== sessionId) return;
+    const linkedPiFile = await this.linkedPiFileFor(filepath);
+    await rm(filepath, { force: true });
+    this.prefixCache.delete(filepath);
+    if (linkedPiFile && resolve(linkedPiFile) !== resolve(filepath)) {
+      await rm(linkedPiFile, { force: true });
+      this.prefixCache.delete(linkedPiFile);
+    }
+  }
+  async resolveSessionFile(sessionId, ctx) {
+    if (!SAFE_ID.test(sessionId)) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const direct = join(this.sessionDir, `${sessionId}.jsonl`);
+    try {
+      await fsStat(direct);
+      if (ctx) await this.assertFileBelongsToCtx(direct, ctx, sessionId);
+      return direct;
+    } catch {
+    }
+    const files = await readdir(this.sessionDir).catch(() => []);
+    const match = files.find(
+      (f) => f.endsWith(`_${sessionId}.jsonl`) || f === `${sessionId}.jsonl`
+    );
+    if (!match) throw new Error(`Session not found: ${sessionId}`);
+    const matchedPath = join(this.sessionDir, match);
+    if (!isTimestampNamedPiSessionFile(matchedPath, sessionId)) {
+      if (ctx) await this.assertFileBelongsToCtx(matchedPath, ctx, sessionId);
+      return matchedPath;
+    }
+    const existingWrapper = await this.findWrapperReferencingNativeSession(matchedPath);
+    if (existingWrapper) {
+      const wrapperSessionId = await this.readSessionFileId(existingWrapper);
+      if (wrapperSessionId === sessionId) {
+        if (ctx) await this.assertFileBelongsToCtx(existingWrapper, ctx, sessionId);
+        return existingWrapper;
+      }
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    return this.ensureWrapperForNativeSession(sessionId, matchedPath, ctx);
+  }
+  async assertFileBelongsToCtx(filepath, ctx, sessionId) {
+    const entries = parseJsonlPrefixEntries(await readJsonlPrefix(filepath));
+    const header = entries.find((entry) => entry.type === "session");
+    if (!this.headerBelongsToCtx(header, ctx)) throw new Error(`Session not found: ${sessionId}`);
+  }
+  async readSessionFileId(filepath) {
+    try {
+      const entries = parseJsonlPrefixEntries(await readJsonlPrefix(filepath));
+      return extractSessionHeaderId(entries);
+    } catch {
+      return null;
+    }
+  }
+  async linkedPiFileFor(filepath) {
+    try {
+      const content = await readFile(filepath, "utf-8");
+      return extractPiSessionFilePath(safeParseEntries(content));
+    } catch {
+      return null;
+    }
+  }
+  async referencedPiFiles(files) {
+    const referenced = /* @__PURE__ */ new Set();
+    await Promise.all(files.map(async ({ filepath, stat }) => {
+      try {
+        const piFilePath = (await this.readPrefixCache(filepath, stat)).referencedPiFile;
+        if (piFilePath && resolve(piFilePath) !== resolve(filepath)) {
+          referenced.add(resolve(piFilePath));
+        }
+      } catch {
+      }
+    }));
+    return referenced;
+  }
+  async sessionSortMtimeMs({ filepath, stat }) {
+    let sortMtimeMs = stat.mtime.getTime();
+    try {
+      const linkedPiFile = (await this.readPrefixCache(filepath, stat)).referencedPiFile;
+      if (linkedPiFile && resolve(linkedPiFile) !== resolve(filepath)) {
+        const linkedStat = await fsStat(linkedPiFile);
+        sortMtimeMs = Math.max(sortMtimeMs, linkedStat.mtime.getTime());
+      }
+    } catch {
+    }
+    return sortMtimeMs;
+  }
+  async summarizeFile(ctx, filepath, existingStat) {
+    try {
+      const fileStat = existingStat ?? await fsStat(filepath);
+      const cached = this.cachedPrefix(filepath, fileStat);
+      if (cached && "summary" in cached && cached.sessionCtx !== void 0 && this.storedCtxBelongsToCtx(cached.sessionCtx, ctx) && await this.cachedSummaryIsFresh(filepath, cached)) {
+        return cached.summary ?? null;
+      }
+      const content = await readJsonlPrefix(filepath);
+      const firstNewline = content.indexOf("\n");
+      if (firstNewline === -1) return null;
+      const header = JSON.parse(
+        content.slice(0, firstNewline)
+      );
+      if (header.type !== "session") return null;
+      const sessionCtx = readHeaderSessionCtx(header);
+      if (!this.storedCtxBelongsToCtx(sessionCtx, ctx)) return null;
+      const entries = parseJsonlPrefixEntries(content);
+      const sessionEntries = entries.filter(
+        (e) => e.type !== "session"
+      );
+      const linkedPiFile = extractPiSessionFilePath(entries);
+      const linked = linkedPiFile && resolve(linkedPiFile) !== resolve(filepath) ? await this.readLinkedPiSessionSummary(linkedPiFile) : null;
+      const linkedEntries = linked?.entries.filter(
+        (e) => e.type !== "session"
+      ) ?? [];
+      const title = extractTitle(sessionEntries) ?? extractTitle(linkedEntries) ?? firstUserMessage(linkedEntries) ?? firstUserMessage(sessionEntries) ?? "New session";
+      const turnCount = [...sessionEntries, ...linkedEntries].filter(
+        (e) => e.type === "message" && e.message?.role === "user"
+      ).length;
+      const updatedAtMs = Math.max(fileStat.mtime.getTime(), linked?.mtime.getTime() ?? 0);
+      const summary = {
+        id: header.id,
+        title,
+        createdAt: header.timestamp,
+        updatedAt: new Date(updatedAtMs).toISOString(),
+        turnCount
+      };
+      this.prefixCache.set(filepath, {
+        mtimeMs: fileStat.mtime.getTime(),
+        size: Number(fileStat.size),
+        referencedPiFile: linkedPiFile,
+        sessionCtx,
+        ...linked ? { linkedMtimeMs: linked.mtime.getTime(), linkedSize: linked.size } : {},
+        summary
+      });
+      return summary;
+    } catch {
+      return null;
+    }
+  }
+  cachedPrefix(filepath, fileStat) {
+    const cached = this.prefixCache.get(filepath);
+    if (!cached) return void 0;
+    if (cached.mtimeMs !== fileStat.mtime.getTime() || cached.size !== Number(fileStat.size)) return void 0;
+    return cached;
+  }
+  async cachedSummaryIsFresh(filepath, cached) {
+    const linkedPiFile = cached.referencedPiFile;
+    if (!linkedPiFile || resolve(linkedPiFile) === resolve(filepath)) return true;
+    try {
+      const linkedStat = await fsStat(linkedPiFile);
+      return cached.linkedMtimeMs === linkedStat.mtime.getTime() && cached.linkedSize === Number(linkedStat.size);
+    } catch {
+      return cached.linkedMtimeMs === void 0 && cached.linkedSize === void 0;
+    }
+  }
+  async readPrefixCache(filepath, fileStat) {
+    const cached = this.cachedPrefix(filepath, fileStat);
+    if (cached) return cached;
+    const content = await readJsonlPrefix(filepath);
+    const entries = parseJsonlPrefixEntries(content);
+    const entry = {
+      mtimeMs: fileStat.mtime.getTime(),
+      size: Number(fileStat.size),
+      referencedPiFile: extractPiSessionFilePath(entries),
+      sessionCtx: readHeaderSessionCtx(entries.find((item) => item.type === "session"))
+    };
+    this.prefixCache.set(filepath, entry);
+    return entry;
+  }
+  async summarizeVisiblePage(visibleFiles, options) {
+    if (options.limit === 0) return [];
+    const page = [];
+    let validSeen = 0;
+    let index = 0;
+    const batchSize = options.limit === void 0 ? Math.max(1, visibleFiles.length) : Math.max(1, options.limit);
+    while (index < visibleFiles.length && (options.limit === void 0 || page.length < options.limit)) {
+      const batch = visibleFiles.slice(index, index + batchSize);
+      index += batch.length;
+      const summaries = await Promise.all(
+        batch.map(({ filepath, stat }) => this.summarizeFile(options.ctx, filepath, stat))
+      );
+      for (const summary of summaries) {
+        if (!summary) continue;
+        if (validSeen < options.offset) {
+          validSeen += 1;
+          continue;
+        }
+        if (options.limit !== void 0 && page.length >= options.limit) break;
+        page.push(summary);
+        validSeen += 1;
+      }
+    }
+    return page;
+  }
+  async summarizeIncludedSession(ctx, sessionId, referencedPiFiles) {
+    try {
+      const filepath = await this.resolveSessionFile(sessionId, ctx);
+      if (referencedPiFiles.has(resolve(filepath))) return null;
+      return this.summarizeFile(ctx, filepath);
+    } catch {
+      return null;
+    }
+  }
+  findWrapperReferencingNativeSessionSync(nativePath) {
+    const resolvedNativePath = resolve(nativePath);
+    try {
+      const files = readdirSync(this.sessionDir).filter((file) => file.endsWith(".jsonl"));
+      for (const file of files) {
+        const filepath = join(this.sessionDir, file);
+        if (resolve(filepath) === resolvedNativePath) continue;
+        try {
+          const linkedPiFile = extractPiSessionFilePath(parseJsonlPrefixEntries(readJsonlPrefixSync(filepath)));
+          if (linkedPiFile && resolve(linkedPiFile) === resolvedNativePath) return filepath;
+        } catch {
+        }
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  async findWrapperReferencingNativeSession(nativePath) {
+    const resolvedNativePath = resolve(nativePath);
+    const files = await readdir(this.sessionDir).catch(() => []);
+    for (const file of files) {
+      if (!file.endsWith(".jsonl")) continue;
+      const filepath = join(this.sessionDir, file);
+      if (resolve(filepath) === resolvedNativePath) continue;
+      try {
+        const linkedPiFile = extractPiSessionFilePath(parseJsonlPrefixEntries(await readJsonlPrefix(filepath)));
+        if (linkedPiFile && resolve(linkedPiFile) === resolvedNativePath) return filepath;
+      } catch {
+      }
+    }
+    return null;
+  }
+  ensureWrapperForNativeSessionSync(sessionId, nativePath, entries, ctx) {
+    const wrapperPath = join(this.sessionDir, `${sessionId}.jsonl`);
+    if (resolve(wrapperPath) === resolve(nativePath)) return wrapperPath;
+    try {
+      readFileSync(wrapperPath, "utf-8");
+      return wrapperPath;
+    } catch {
+    }
+    try {
+      writeFileSync(
+        wrapperPath,
+        buildNativePiSessionWrapper(sessionId, this.cwd, nativePath, entries, ctx),
+        { encoding: "utf-8", flag: "wx" }
+      );
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    this.prefixCache.delete(wrapperPath);
+    return wrapperPath;
+  }
+  async ensureWrapperForNativeSession(sessionId, nativePath, ctx) {
+    const wrapperPath = join(this.sessionDir, `${sessionId}.jsonl`);
+    if (resolve(wrapperPath) === resolve(nativePath)) return wrapperPath;
+    try {
+      await fsStat(wrapperPath);
+      return wrapperPath;
+    } catch {
+    }
+    const entries = parseJsonlPrefixEntries(await readJsonlPrefix(nativePath));
+    try {
+      await writeFile(
+        wrapperPath,
+        buildNativePiSessionWrapper(sessionId, this.cwd, nativePath, entries, ctx),
+        { encoding: "utf-8", flag: "wx" }
+      );
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    this.prefixCache.delete(wrapperPath);
+    return wrapperPath;
+  }
+  async readLinkedPiSession(filepath) {
+    try {
+      const [fileStat, content] = await Promise.all([
+        fsStat(filepath),
+        readFile(filepath, "utf-8")
+      ]);
+      return { entries: safeParseEntries(content), mtime: fileStat.mtime, size: Number(fileStat.size) };
+    } catch {
+      return null;
+    }
+  }
+  async readLinkedPiSessionSummary(filepath) {
+    try {
+      const [fileStat, content] = await Promise.all([
+        fsStat(filepath),
+        readJsonlPrefix(filepath)
+      ]);
+      return { entries: parseJsonlPrefixEntries(content), mtime: fileStat.mtime, size: Number(fileStat.size) };
+    } catch {
+      return null;
+    }
+  }
+  headerBelongsToCtx(header, ctx) {
+    return header ? this.storedCtxBelongsToCtx(readHeaderSessionCtx(header), ctx) : isEmptySessionCtx(ctx);
+  }
+  storedCtxBelongsToCtx(storedCtx, ctx) {
+    if (storedCtx === null) return this.allowLegacyUnscopedAccess && isLegacyUnscopedCtx(ctx);
+    return sameSessionCtx(storedCtx, ctx);
+  }
+};
+async function readJsonlPrefix(filepath, maxBytes = SUMMARY_PREFIX_BYTES) {
+  const handle = await open(filepath, "r");
+  try {
+    const buffer = Buffer.alloc(maxBytes);
+    const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+    let content = buffer.subarray(0, bytesRead).toString("utf-8");
+    if (bytesRead === maxBytes) {
+      const lastNewline = content.lastIndexOf("\n");
+      if (lastNewline >= 0) content = content.slice(0, lastNewline + 1);
+    }
+    return content;
+  } finally {
+    await handle.close();
+  }
+}
+function readJsonlPrefixSync(filepath, maxBytes = SUMMARY_PREFIX_BYTES) {
+  const fd = openSync(filepath, "r");
+  try {
+    const buffer = Buffer.alloc(maxBytes);
+    const bytesRead = readSync(fd, buffer, 0, maxBytes, 0);
+    let content = buffer.subarray(0, bytesRead).toString("utf-8");
+    if (bytesRead === maxBytes) {
+      const lastNewline = content.lastIndexOf("\n");
+      if (lastNewline >= 0) content = content.slice(0, lastNewline + 1);
+    }
+    return content;
+  } finally {
+    closeSync(fd);
+  }
+}
+function extractPiSessionFilePath(entries) {
+  let piFilePath = null;
+  for (const e of entries) {
+    const rec = e;
+    if (rec.type === "pi_session_file" && typeof rec.path === "string") {
+      piFilePath = rec.path;
+    }
+  }
+  return piFilePath;
+}
+function readHeaderSessionCtx(header) {
+  if (!header || !Object.prototype.hasOwnProperty.call(header, "boringSessionCtx")) return null;
+  const raw = header.boringSessionCtx;
+  if (!raw || typeof raw !== "object") return {};
+  return normalizeSessionCtx(raw) ?? {};
+}
+function normalizeSessionCtx(ctx) {
+  if (!ctx?.workspaceId && !ctx?.userId) return void 0;
+  return {
+    ...ctx.workspaceId ? { workspaceId: ctx.workspaceId } : {},
+    ...ctx.userId ? { 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 isLegacyUnscopedCtx(ctx) {
+  return isEmptySessionCtx(ctx) || ctx?.workspaceId === DEFAULT_LEGACY_WORKSPACE_ID && !ctx.userId;
+}
+function buildNativePiSessionWrapper(sessionId, cwd, piFilePath, entries, ctx) {
+  const nativeHeader = entries.find((entry) => entry.type === "session");
+  const timestamp = nativeHeader?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  const header = {
+    type: "session",
+    version: CURRENT_SESSION_VERSION,
+    id: sessionId,
+    timestamp,
+    cwd: nativeHeader?.cwd ?? cwd,
+    ...ctx !== void 0 ? { boringSessionCtx: normalizeSessionCtx(ctx) ?? {} } : {}
+  };
+  return [
+    header,
+    {
+      type: "pi_session_file",
+      timestamp,
+      path: piFilePath
+    }
+  ].map((line) => JSON.stringify(line)).join("\n") + "\n";
+}
+function extractSessionHeaderId(entries) {
+  const header = entries.find((entry) => entry.type === "session");
+  return header?.id ?? null;
+}
+function isTimestampNamedPiSessionFile(filepath, sessionId) {
+  return basename(filepath).endsWith(`_${sessionId}.jsonl`);
+}
+function countUserTurns(entries) {
+  return entries.filter(
+    (e) => e.type === "message" && e.message?.role === "user"
+  ).length;
+}
+function extractTitle(entries) {
+  const last = entries.filter((e) => e.type === "session_info").pop();
+  return last?.name;
+}
+function firstUserMessage(entries) {
+  for (const e of entries) {
+    if (e.type !== "message") continue;
+    const msg = e.message;
+    if (msg?.role !== "user") continue;
+    const text = textFromPiContent(msg.content);
+    if (text) return text.slice(0, 80);
+  }
+}
+function safeParseEntries(content) {
+  try {
+    return parseSessionEntries(content);
+  } catch {
+    const results = [];
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        results.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return results;
+  }
+}
+function parseJsonlPrefixEntries(content) {
+  const entries = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return entries;
+}
+function textFromPiContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => {
+    const item = part;
+    return item?.type === "text" && typeof item.text === "string" ? item.text : "";
+  }).join("");
+}
+
+// src/server/models/modelConfig.ts
+import { getAgentDir, SettingsManager } from "@mariozechner/pi-coding-agent";
+var INFOMANIAK_PROVIDER = "infomaniak";
+var INFOMANIAK_API_BASE = "https://api.infomaniak.com";
+var DEFAULT_CUSTOM_MODEL_MAX_TOKENS = 16384;
+var DEFAULT_CUSTOM_MODEL_CONTEXT_WINDOW = 2e5;
+var DEFAULT_INFOMANIAK_MODELS = [
+  "moonshotai/Kimi-K2.6",
+  "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-FP8",
+  "Qwen/Qwen3.5-122B-A10B-FP8"
+];
+function clean(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function readPositiveInt(name, fallback) {
+  const raw = clean(getEnv(name));
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+function readBoolean(name, fallback) {
+  const raw = clean(getEnv(name))?.toLowerCase();
+  if (!raw) return fallback;
+  if (["1", "true", "yes", "on"].includes(raw)) return true;
+  if (["0", "false", "no", "off"].includes(raw)) return false;
+  return fallback;
+}
+function readModelInput(name) {
+  const raw = clean(getEnv(name));
+  if (!raw) return ["text"];
+  const parsed = raw.split(",").map((part) => part.trim()).filter((part) => part === "text" || part === "image");
+  return parsed.length > 0 ? parsed : ["text"];
+}
+function readMaxTokensField(name, fallback = "max_completion_tokens") {
+  const raw = clean(getEnv(name));
+  return raw === "max_tokens" || raw === "max_completion_tokens" ? raw : fallback;
+}
+function buildOpenAICompletionsCompat(envPrefix, defaults = {}) {
+  return {
+    supportsStore: readBoolean(`${envPrefix}_SUPPORTS_STORE`, defaults.supportsStore ?? false),
+    supportsDeveloperRole: readBoolean(`${envPrefix}_SUPPORTS_DEVELOPER_ROLE`, defaults.supportsDeveloperRole ?? true),
+    supportsReasoningEffort: readBoolean(`${envPrefix}_SUPPORTS_REASONING_EFFORT`, defaults.supportsReasoningEffort ?? true),
+    supportsUsageInStreaming: readBoolean(`${envPrefix}_SUPPORTS_USAGE_IN_STREAMING`, defaults.supportsUsageInStreaming ?? true),
+    maxTokensField: readMaxTokensField(`${envPrefix}_MAX_TOKENS_FIELD`, defaults.maxTokensField)
+  };
+}
+function readApiKeyEnv(candidates) {
+  for (const candidate of candidates) {
+    const envName = clean(candidate);
+    if (envName && clean(getEnv(envName))) return envName;
+  }
+  return void 0;
+}
+function buildOpenAICompatibleProviderConfig(opts) {
+  return {
+    baseUrl: opts.baseUrl,
+    apiKey: opts.apiKeyEnv,
+    api: "openai-completions",
+    models: opts.models.map((model) => ({
+      id: model.id,
+      name: model.name ?? model.id,
+      api: "openai-completions",
+      reasoning: readBoolean(`${opts.envPrefix}_REASONING`, true),
+      input: readModelInput(`${opts.envPrefix}_INPUT`),
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: readPositiveInt(
+        `${opts.envPrefix}_CONTEXT_WINDOW`,
+        DEFAULT_CUSTOM_MODEL_CONTEXT_WINDOW
+      ),
+      maxTokens: readPositiveInt(
+        `${opts.envPrefix}_MAX_TOKENS`,
+        DEFAULT_CUSTOM_MODEL_MAX_TOKENS
+      ),
+      compat: buildOpenAICompletionsCompat(opts.envPrefix, opts.compatDefaults)
+    }))
+  };
+}
+function readInfomaniakBaseUrl() {
+  const explicit = clean(getEnv("BORING_AGENT_INFOMANIAK_BASE_URL"));
+  if (explicit) return explicit;
+  const productId = clean(getEnv("BORING_AGENT_INFOMANIAK_PRODUCT_ID"));
+  if (!productId) return void 0;
+  return `${INFOMANIAK_API_BASE}/2/ai/${productId}/openai/v1`;
+}
+function readInfomaniakModelIds() {
+  const configured = clean(getEnv("BORING_AGENT_INFOMANIAK_MODELS"))?.split(",").map((part) => part.trim()).filter(Boolean);
+  const ids = configured?.length ? configured : [...DEFAULT_INFOMANIAK_MODELS];
+  const legacyModel = clean(getEnv("BORING_AGENT_INFOMANIAK_MODEL"));
+  if (legacyModel && !ids.includes(legacyModel)) ids.push(legacyModel);
+  return Array.from(new Set(ids));
+}
+function readInfomaniakProvider() {
+  const modelIds = readInfomaniakModelIds();
+  const defaultModelId = clean(getEnv("BORING_AGENT_INFOMANIAK_MODEL")) ?? clean(getEnv("BORING_AGENT_DEFAULT_MODEL_ID")) ?? modelIds[0];
+  const baseUrl = readInfomaniakBaseUrl();
+  const apiKeyEnv = readApiKeyEnv([
+    clean(getEnv("BORING_AGENT_INFOMANIAK_API_KEY_ENV")) ?? "",
+    "INFOMANIAK_API_TOKEN",
+    "BORING_AGENT_INFOMANIAK_API_KEY"
+  ]);
+  if (!defaultModelId || !baseUrl || !apiKeyEnv) return void 0;
+  const provider = clean(getEnv("BORING_AGENT_INFOMANIAK_PROVIDER")) ?? INFOMANIAK_PROVIDER;
+  const modelName = clean(getEnv("BORING_AGENT_INFOMANIAK_MODEL_NAME"));
+  const models = modelIds.map((id) => {
+    const model = { id };
+    if (id === defaultModelId && modelName) model.name = modelName;
+    return model;
+  });
+  if (!models.some((model) => model.id === defaultModelId)) {
+    models.push({ id: defaultModelId, name: modelName });
+  }
+  return {
+    provider,
+    models: models.map((model) => ({ provider, id: model.id })),
+    defaultModel: { provider, id: defaultModelId },
+    config: buildOpenAICompatibleProviderConfig({
+      models,
+      apiKeyEnv,
+      baseUrl,
+      envPrefix: "BORING_AGENT_INFOMANIAK",
+      // Infomaniak's OpenAI-compatible chat endpoint rejects OpenAI's newer
+      // `developer` role (surfacing as "400 Unexpected message role"). Hosts
+      // can opt back in with BORING_AGENT_INFOMANIAK_SUPPORTS_DEVELOPER_ROLE=1.
+      compatDefaults: { supportsDeveloperRole: false, supportsReasoningEffort: false }
+    })
+  };
+}
+function readCustomProvider() {
+  const provider = clean(getEnv("BORING_AGENT_CUSTOM_MODEL_PROVIDER"));
+  const modelId = clean(getEnv("BORING_AGENT_CUSTOM_MODEL_ID"));
+  const baseUrl = clean(getEnv("BORING_AGENT_CUSTOM_MODEL_BASE_URL"));
+  const apiKeyEnv = readApiKeyEnv([
+    clean(getEnv("BORING_AGENT_CUSTOM_MODEL_API_KEY_ENV")) ?? "",
+    "BORING_AGENT_CUSTOM_MODEL_API_KEY"
+  ]);
+  if (!provider || !modelId || !baseUrl || !apiKeyEnv) return void 0;
+  const modelName = clean(getEnv("BORING_AGENT_CUSTOM_MODEL_NAME"));
+  const model = { id: modelId };
+  if (modelName) model.name = modelName;
+  return {
+    provider,
+    models: [{ provider, id: modelId }],
+    defaultModel: { provider, id: modelId },
+    config: buildOpenAICompatibleProviderConfig({
+      models: [model],
+      apiKeyEnv,
+      baseUrl,
+      envPrefix: "BORING_AGENT_CUSTOM_MODEL"
+    })
+  };
+}
+function registerConfiguredModelProviders(registry) {
+  const registered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const provider of [readInfomaniakProvider(), readCustomProvider()]) {
+    if (!provider) continue;
+    if (seen.has(provider.provider)) continue;
+    registry.registerProvider(provider.provider, provider.config);
+    registered.push(...provider.models);
+    seen.add(provider.provider);
+  }
+  return registered;
+}
+function readPiSettingsDefaultModel() {
+  try {
+    const settings = SettingsManager.create(process.cwd(), getAgentDir());
+    const provider = clean(settings.getDefaultProvider());
+    const id = clean(settings.getDefaultModel());
+    return provider && id ? { provider, id } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readConfiguredDefaultModel() {
+  const encoded = clean(getEnv("BORING_AGENT_DEFAULT_MODEL"));
+  if (encoded) {
+    const idx = encoded.indexOf(":");
+    if (idx > 0 && idx < encoded.length - 1) {
+      return { provider: encoded.slice(0, idx), id: encoded.slice(idx + 1) };
+    }
+  }
+  const explicitProvider = clean(getEnv("BORING_AGENT_DEFAULT_MODEL_PROVIDER"));
+  const explicitId = clean(getEnv("BORING_AGENT_DEFAULT_MODEL_ID"));
+  if (explicitProvider && explicitId) {
+    return { provider: explicitProvider, id: explicitId };
+  }
+  return readPiSettingsDefaultModel() ?? readInfomaniakProvider()?.defaultModel ?? readCustomProvider()?.defaultModel;
+}
+
+// src/server/piPackages.ts
+var PI_PACKAGE_RESOURCE_FILTERS = [
+  "extensions",
+  "skills",
+  "prompts",
+  "themes"
+];
+function sortedFilterValues(source) {
+  return Object.fromEntries(
+    PI_PACKAGE_RESOURCE_FILTERS.map((filter) => {
+      const value = source[filter];
+      return [filter, value ? [...value].sort() : value];
+    })
+  );
+}
+function hasResourceFilters(source) {
+  return PI_PACKAGE_RESOURCE_FILTERS.some((filter) => source[filter] !== void 0);
+}
+function piPackageSourceKey(source) {
+  if (typeof source === "string") return JSON.stringify({ source });
+  if (!hasResourceFilters(source)) return JSON.stringify({ source: source.source });
+  return JSON.stringify({
+    source: source.source,
+    ...sortedFilterValues(source)
+  });
+}
+function compactPiPackages(sources) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const source of sources) {
+    if (!source) continue;
+    const key = piPackageSourceKey(source);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(source);
+  }
+  return result;
+}
+function mergePiPackageSources(base = [], additional = []) {
+  return compactPiPackages([...base, ...additional]);
+}
+
+// src/server/harness/pi-coding-agent/createHarness.ts
+var WORKSPACE_PATHS_GUIDELINE = [
+  "## Workspace paths",
+  "",
+  '- The "Current working directory" line in this prompt is the workspace root. Tool path arguments must be relative to it (e.g. `README.md`, `src/foo.ts`).',
+  "- Never pass an absolute path or a path that walks outside the workspace (no leading `/`, no `..` that escapes the root). The sandbox will reject it and the call is wasted.",
+  "- For `find`/`grep`/`ls`: omit the `path` argument to search from the workspace root. Pass `path` only when you need to restrict to a subdirectory, and only as a workspace-relative path.",
+  "- For `read`/`edit`/`write`: pass workspace-relative paths only."
+].join("\n");
+var PYTHON_RUNTIME_GUIDELINE = [
+  "## Python runtime",
+  "",
+  "- Python 3 and the Astral `uv` package manager are available on PATH.",
+  "- Run scripts with `python3`.",
+  "- Install/manage packages with `uv pip install <pkg>` (fast; targets the workspace venv at `.boring-agent/venv`). `uv` is the canonical package manager here \u2014 don't assume only `pip`.",
+  "- Create venvs with `uv venv` if needed."
+].join("\n");
+function composeSystemPromptAppend(hostAppend) {
+  return [WORKSPACE_PATHS_GUIDELINE, PYTHON_RUNTIME_GUIDELINE, hostAppend?.trim()].filter(Boolean).join("\n\n");
+}
+function withPiHarnessDefaults(pi) {
+  const { noContextFiles = true, noSkills = true, ...rest } = pi ?? {};
+  return { ...rest, noContextFiles, noSkills };
+}
+function buildDynamicPromptExtension(source) {
+  return (pi) => {
+    pi.on("before_agent_start", async (event) => {
+      const extra = (await source())?.trim();
+      if (!extra) return;
+      return { systemPrompt: `${event.systemPrompt}
+
+${extra}` };
+    });
+  };
+}
+function buildToolErrorResultExtension() {
+  return (pi) => {
+    pi.on("tool_result", async (event) => {
+      const marked = unmarkToolResultErrorDetails(event.details);
+      if (!marked.isMarked) return;
+      return {
+        details: marked.details,
+        isError: true
+      };
+    });
+  };
+}
+function modelUnavailableError(input) {
+  return Object.assign(new Error("Requested model is not available."), {
+    statusCode: 400,
+    code: ErrorCode.enum.TOOL_INVALID_INPUT,
+    details: { provider: input.model?.provider, model: input.model?.id }
+  });
+}
+function meteredSlashCommandPromptError(command) {
+  return Object.assign(new Error("Slash command prompt execution is disabled while metering is configured."), {
+    statusCode: 409,
+    code: ErrorCode.enum.METERING_UNSUPPORTED_COMMAND,
+    details: { command }
+  });
+}
+function meteredExtensionCommandContext(ctx, command) {
+  const block = () => {
+    throw meteredSlashCommandPromptError(command);
+  };
+  const guarded = Object.defineProperties({}, Object.getOwnPropertyDescriptors(ctx));
+  guarded.compact = block;
+  guarded.newSession = async () => block();
+  guarded.fork = async () => block();
+  guarded.navigateTree = async () => block();
+  guarded.switchSession = async () => block();
+  return guarded;
+}
+function resolveRequestedModel(modelRegistry, input, options = {}) {
+  const requestedId = input.model?.id;
+  if (!input.model || !requestedId) return void 0;
+  const model = modelRegistry.find(input.model.provider, requestedId);
+  const available = modelRegistry.getAvailable();
+  const hasAuth = Boolean(model) && available.some(
+    (m) => m.provider === model.provider && m.id === model.id
+  );
+  if (!model || !hasAuth) {
+    if (options.strict) throw modelUnavailableError(input);
+    return void 0;
+  }
+  return model;
+}
+function resolveDefaultModel(modelRegistry) {
+  const configured = readConfiguredDefaultModel();
+  if (configured) {
+    const model = modelRegistry.find(configured.provider, configured.id);
+    if (model) return model;
+  }
+  return void 0;
+}
+function sessionCtxForInput(input, ctx) {
+  return normalizeSessionCtx2(input.ctx ?? { workspaceId: ctx.workspaceId }) ?? {};
+}
+function sessionCtxFromRunContext(ctx) {
+  return normalizeSessionCtx2({ workspaceId: ctx.workspaceId, userId: ctx.userId }) ?? {};
+}
+function normalizeSessionCtx2(ctx) {
+  if (!ctx?.workspaceId && !ctx?.userId) return void 0;
+  return {
+    ...ctx.workspaceId ? { workspaceId: ctx.workspaceId } : {},
+    ...ctx.userId ? { userId: ctx.userId } : {}
+  };
+}
+function sessionCacheKey(sessionId, ctx) {
+  return JSON.stringify([sessionId, ctx.workspaceId ?? "", ctx.userId ?? ""]);
+}
+function readSettingsFileIfPresent(path) {
+  return existsSync(path) ? readFileSync2(path, "utf-8") : void 0;
+}
+function mergeInjectedProjectPackages(settingsJson, piPackages) {
+  const settings = settingsJson ? JSON.parse(settingsJson) : {};
+  const configuredPackages = Array.isArray(settings.packages) ? settings.packages : [];
+  return JSON.stringify({
+    ...settings,
+    packages: mergePiPackageSources(configuredPackages, piPackages)
+  });
+}
+function createResourceSettingsManager(cwd, agentDir, piPackages) {
+  if (piPackages.length === 0) return SettingsManager2.create(cwd, agentDir);
+  const globalSettingsPath = join2(agentDir, "settings.json");
+  const projectSettingsPath = join2(cwd, ".pi", "settings.json");
+  let globalSettingsOverrideJson;
+  let projectSettingsOverrideJson;
+  const storage = {
+    withLock(scope, fn) {
+      if (scope === "global") {
+        const current2 = globalSettingsOverrideJson ?? readSettingsFileIfPresent(globalSettingsPath);
+        const next2 = fn(current2);
+        if (next2 !== void 0) globalSettingsOverrideJson = next2;
+        return;
+      }
+      const current = projectSettingsOverrideJson ?? mergeInjectedProjectPackages(readSettingsFileIfPresent(projectSettingsPath), piPackages);
+      const next = fn(current);
+      if (next !== void 0) projectSettingsOverrideJson = next;
+    }
+  };
+  return SettingsManager2.fromStorage(storage);
+}
+async function applyRequestedSessionOptions(handle, input, options = {}) {
+  const requestedModel = resolveRequestedModel(handle.modelRegistry, input, { strict: options.strictModelResolution });
+  if (requestedModel) {
+    const current = handle.piSession.model;
+    if (!current || current.provider !== requestedModel.provider || current.id !== requestedModel.id) {
+      await handle.piSession.setModel(requestedModel);
+    }
+  }
+  if (input.thinkingLevel) {
+    handle.piSession.setThinkingLevel(input.thinkingLevel);
+  }
+}
+var log = createLogger("pi-harness");
+function deriveSourcePlugin(sourceInfo) {
+  if (!sourceInfo) return void 0;
+  const path = typeof sourceInfo.path === "string" ? sourceInfo.path : "";
+  const source = typeof sourceInfo.source === "string" ? sourceInfo.source : "";
+  const runtimePlugin = path.match(/[/\\]\.pi[/\\]extensions[/\\]([^/\\]+)/);
+  if (runtimePlugin) return runtimePlugin[1];
+  const provisionedSkill = path.match(/[/\\]\.boring-agent[/\\]skills[/\\]([^/\\]+)/);
+  if (provisionedSkill) return provisionedSkill[1];
+  if (source.startsWith("npm:")) return source.slice(4) || void 0;
+  if (source.startsWith("git/")) return source.split("/").filter(Boolean).pop();
+  const fileExtension = path.match(/[/\\]extensions[/\\]([^/\\]+)\.[cm]?[tj]sx?$/);
+  if (fileExtension) return fileExtension[1];
+  return void 0;
+}
+function normalizeSlashCommandInfo(command) {
+  const sourcePlugin = deriveSourcePlugin(command.sourceInfo);
+  return {
+    name: command.name,
+    ...command.description ? { description: command.description } : {},
+    source: command.source,
+    ...sourcePlugin ? { sourcePlugin } : {}
+  };
+}
+function rememberQueuedFollowUpRunContexts(piSession, state, getRunContext) {
+  const agent = piSession.agent;
+  if (!agent || typeof agent.followUp !== "function") return () => {
+  };
+  const originalFollowUp = agent.followUp;
+  const wrappedFollowUp = function(message) {
+    const ctx = getRunContext();
+    if (ctx && message && typeof message === "object") state.queuedFollowUpContexts.set(message, ctx);
+    return originalFollowUp.call(this, message);
+  };
+  agent.followUp = wrappedFollowUp;
+  return () => {
+    if (agent.followUp === wrappedFollowUp) agent.followUp = originalFollowUp;
+  };
+}
+function updateRunContextStateFromPiEvent(state, event, activateRunContext) {
+  if (event.type !== "message_start") return;
+  const message = event.message;
+  if (!message || typeof message !== "object") return;
+  const ctx = state.queuedFollowUpContexts.get(message);
+  if (!ctx) return;
+  state.queuedFollowUpContexts.delete(message);
+  activateRunContext(ctx);
+}
+function createPiCodingAgentHarness(opts) {
+  const pi = withPiHarnessDefaults(opts.pi);
+  const sessionStore = new PiSessionStore(opts.runtimeCwd ?? opts.cwd, {
+    sessionNamespace: opts.sessionNamespace,
+    sessionRoot: opts.sessionRoot,
+    sessionDir: opts.sessionDir,
+    storageCwd: opts.cwd
+  });
+  const piSessions = /* @__PURE__ */ new Map();
+  const runContextStorage = new AsyncLocalStorage();
+  const effectiveSkillPaths = [];
+  const effectivePackages = [];
+  const effectiveExtensionPaths = [];
+  const refreshEffectiveResources = () => {
+    const dynamic = pi.getHotReloadableResources?.() ?? {};
+    effectiveSkillPaths.splice(
+      0,
+      effectiveSkillPaths.length,
+      ...pi.additionalSkillPaths ?? [],
+      ...dynamic.additionalSkillPaths ?? []
+    );
+    effectivePackages.splice(
+      0,
+      effectivePackages.length,
+      ...mergePiPackageSources(pi.packages ?? [], dynamic.packages ?? [])
+    );
+    effectiveExtensionPaths.splice(
+      0,
+      effectiveExtensionPaths.length,
+      ...pi.extensionPaths ?? [],
+      ...dynamic.extensionPaths ?? []
+    );
+  };
+  refreshEffectiveResources();
+  const piSessionCreations = /* @__PURE__ */ new Map();
+  async function getOrCreatePiSession(sessionId, input, ctx) {
+    const sessionCtx = sessionCtxForInput(input, ctx);
+    const sessionKey = sessionCacheKey(sessionId, sessionCtx);
+    const existing = piSessions.get(sessionKey);
+    if (existing) {
+      await applyRequestedSessionOptions(existing, input, { strictModelResolution: pi.strictModelResolution });
+      return existing;
+    }
+    const inFlight = piSessionCreations.get(sessionKey);
+    if (inFlight) {
+      const handle = await inFlight;
+      await applyRequestedSessionOptions(handle, input, { strictModelResolution: pi.strictModelResolution });
+      return handle;
+    }
+    const creation = createPiSession(sessionId, sessionCtx, input, ctx);
+    piSessionCreations.set(sessionKey, creation);
+    try {
+      return await creation;
+    } finally {
+      if (piSessionCreations.get(sessionKey) === creation) piSessionCreations.delete(sessionKey);
+    }
+  }
+  async function bindRunContext(ctx, run) {
+    return await runContextStorage.run(ctx, run);
+  }
+  function createRunBoundAdapter(handle, sessionId, ctx) {
+    const adapter = createPiAgentSessionAdapter(handle.piSession, {
+      sessionId,
+      ...handle.piSession.agent && typeof handle.piSession.agent.continue === "function" ? { continueQueuedFollowUp: () => handle.piSession.agent.continue() } : {}
+    });
+    return {
+      ...adapter,
+      prompt: (promptInput) => bindRunContext(ctx, () => adapter.prompt(promptInput)),
+      followUp: (text, options) => bindRunContext(ctx, () => adapter.followUp(text, options)),
+      clearFollowUp: (options) => adapter.clearFollowUp(options),
+      ...adapter.continueQueuedFollowUp ? { continueQueuedFollowUp: () => bindRunContext(ctx, () => adapter.continueQueuedFollowUp()) } : {}
+    };
+  }
+  async function createPiSession(sessionId, sessionCtx, input, ctx) {
+    const authStorage = AuthStorage.create();
+    const modelRegistry = ModelRegistry.create(authStorage);
+    registerConfiguredModelProviders(modelRegistry);
+    const savedPiFile = sessionStore.loadPiSessionFileSync(sessionCtx, sessionId);
+    let sessionManager;
+    let isNewPiSession = false;
+    const runtimeCwd = opts.runtimeCwd ?? ctx.workdir;
+    const nativeSessionDir = sessionStore.getSessionDir();
+    if (savedPiFile) {
+      try {
+        sessionManager = SessionManager.open(savedPiFile, void 0, runtimeCwd);
+      } catch {
+        sessionManager = SessionManager.create(runtimeCwd, nativeSessionDir);
+        isNewPiSession = true;
+      }
+    } else {
+      sessionManager = SessionManager.create(runtimeCwd, nativeSessionDir);
+      isNewPiSession = true;
+    }
+    const resolvedModel = resolveRequestedModel(modelRegistry, input, { strict: pi.strictModelResolution });
+    const model = resolvedModel ?? resolveDefaultModel(modelRegistry);
+    refreshEffectiveResources();
+    const composedSystemPromptAppend = composeSystemPromptAppend(opts.systemPromptAppend);
+    const dynamicPromptExtension = opts.systemPromptDynamic ? buildDynamicPromptExtension(opts.systemPromptDynamic) : void 0;
+    const agentDir = getAgentDir2();
+    const toolErrorResultExtension = buildToolErrorResultExtension();
+    const extensionFactories = [
+      toolErrorResultExtension,
+      ...dynamicPromptExtension ? [dynamicPromptExtension] : [],
+      ...pi.extensionFactories ?? []
+    ];
+    const settingsManager = createResourceSettingsManager(
+      opts.cwd,
+      agentDir,
+      effectivePackages
+    );
+    const resourceLoader = new DefaultResourceLoader({
+      cwd: opts.cwd,
+      agentDir,
+      settingsManager,
+      appendSystemPromptOverride: (base) => [...base, composedSystemPromptAppend],
+      ...effectiveExtensionPaths.length ? { additionalExtensionPaths: effectiveExtensionPaths } : {},
+      ...extensionFactories.length ? { extensionFactories } : {},
+      ...pi.noContextFiles ? { noContextFiles: true } : {},
+      ...pi.noSkills ? { noSkills: true } : {},
+      ...effectiveSkillPaths.length ? { additionalSkillPaths: effectiveSkillPaths } : {},
+      // skillsOverride REPLACES Pi's resolved skill set, which includes
+      // skills contributed by host-declared pi packages (e.g.
+      // @hachej/boring-pi → boring-plugin-authoring). Only trigger it for
+      // the explicit `noSkills` opt-out, where the host wants a clean slate.
+      // Passing additionalSkillPaths is not, by itself, a request to throw
+      // away package skills — those should keep flowing through Pi's loader
+      // and merge with the additional paths.
+      ...pi.noSkills ? {
+        skillsOverride: () => loadSkills({
+          cwd: opts.cwd,
+          agentDir,
+          skillPaths: effectiveSkillPaths,
+          includeDefaults: false
+        })
+      } : {}
+    });
+    await resourceLoader?.reload();
+    const runContextState = { queuedFollowUpContexts: /* @__PURE__ */ new WeakMap() };
+    const { session: piSession } = await createAgentSession({
+      cwd: runtimeCwd,
+      // Suppress Pi's built-in filesystem/shell tools while keeping Boring's
+      // adapted tool catalog active. Do NOT pass an explicit empty tool-name
+      // allowlist: in the current Pi SDK that disables custom tools too.
+      noTools: "builtin",
+      customTools: adaptToolsForPi(opts.tools, input.sessionId, opts.telemetry, () => runContextStorage.getStore()),
+      model,
+      thinkingLevel: input.thinkingLevel ?? "off",
+      sessionManager,
+      authStorage,
+      modelRegistry,
+      ...resourceLoader ? { resourceLoader } : {}
+    });
+    if (isNewPiSession) {
+      const piFile = sessionManager.getSessionFile();
+      if (piFile) {
+        sessionStore.savePiSessionFile(sessionCtx, sessionId, piFile).catch(() => {
+        });
+      }
+    }
+    const restoreFollowUpContextWrapper = rememberQueuedFollowUpRunContexts(piSession, runContextState, () => runContextStorage.getStore());
+    const unsubscribePiRunContextListener = piSession.subscribe((event) => updateRunContextStateFromPiEvent(runContextState, event, (ctx2) => runContextStorage.enterWith(ctx2)));
+    const unsubscribeRunContextListener = () => {
+      unsubscribePiRunContextListener();
+      restoreFollowUpContextWrapper();
+    };
+    const handle = {
+      piSession,
+      modelRegistry,
+      sessionManager,
+      resourceLoader,
+      sessionId,
+      sessionCtx,
+      runContextState,
+      unsubscribeRunContextListener
+    };
+    piSessions.set(sessionCacheKey(sessionId, sessionCtx), handle);
+    return handle;
+  }
+  async function reloadPiSession(sessionId) {
+    const handles = piSessionHandlesFor(sessionId);
+    if (handles.length === 0) return false;
+    refreshEffectiveResources();
+    await Promise.all(handles.map((handle) => handle.piSession.reload()));
+    return true;
+  }
+  function disposePiSession(sessionId, ctx) {
+    if (ctx) {
+      const key = sessionCacheKey(sessionId, ctx);
+      const handle = piSessions.get(key);
+      if (!handle) return;
+      handle.unsubscribeRunContextListener();
+      handle.piSession.dispose();
+      piSessions.delete(key);
+      return;
+    }
+    for (const [key, handle] of piSessions) {
+      if (handle.sessionId !== sessionId) continue;
+      handle.unsubscribeRunContextListener();
+      handle.piSession.dispose();
+      piSessions.delete(key);
+    }
+  }
+  function piSessionHandlesFor(sessionId) {
+    return [...piSessions.values()].filter((handle) => handle.sessionId === sessionId);
+  }
+  async function getOrCreatePiSessionForCommand(sessionId, ctx) {
+    const sessionCtx = sessionCtxFromRunContext(ctx);
+    const existing = piSessions.get(sessionCacheKey(sessionId, sessionCtx));
+    if (existing) return existing;
+    return getOrCreatePiSession(sessionId, { sessionId, content: "", ctx: sessionCtx }, ctx);
+  }
+  const originalDelete = sessionStore.delete.bind(sessionStore);
+  sessionStore.delete = async (ctx, sessionId) => {
+    await originalDelete(ctx, sessionId);
+    disposePiSession(sessionId, ctx);
+  };
+  return {
+    id: "pi-coding-agent",
+    placement: "server",
+    sessions: sessionStore,
+    /**
+     * Pi exposes the resolved system prompt as a getter on AgentSession.
+     * Sessions are created lazily on the first prompt, so callers may see
+     * `undefined` for a session that hasn't been written to yet — that's
+     * the expected pre-first-turn state, not an error.
+     */
+    getSystemPrompt(sessionId) {
+      return piSessionHandlesFor(sessionId)[0]?.piSession.systemPrompt;
+    },
+    hasPiSession(sessionId, ctx) {
+      return ctx ? piSessions.has(sessionCacheKey(sessionId, ctx)) : piSessionHandlesFor(sessionId).length > 0;
+    },
+    /**
+     * Surface Pi's skill/extension load diagnostics for a session so silent
+     * load failures (bad SKILL.md, extension import errors) reach the UI and
+     * the agent. Returns [] when the session has no live pi session yet.
+     * The resourceLoader getters are synchronous.
+     */
+    getResourceDiagnostics(sessionId) {
+      const handle = piSessionHandlesFor(sessionId)[0];
+      if (!handle) return [];
+      const out = [];
+      const seen = /* @__PURE__ */ new Set();
+      const push = (entry) => {
+        const key = `${entry.source}
+${entry.message}`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        out.push(entry);
+      };
+      for (const diagnostic of handle.resourceLoader.getSkills().diagnostics) {
+        push({
+          source: "pi-skills",
+          message: diagnostic.path && !diagnostic.message.includes(diagnostic.path) ? `${diagnostic.message} (${diagnostic.path})` : diagnostic.message,
+          ...diagnostic.path ? { path: diagnostic.path } : {}
+        });
+      }
+      for (const error of handle.resourceLoader.getExtensions().errors) {
+        push({
+          source: "pi-extensions",
+          message: error.error.includes(error.path) ? error.error : `${error.error} (${error.path})`,
+          path: error.path
+        });
+      }
+      return out;
+    },
+    reloadSession: reloadPiSession,
+    async getSlashCommands(sessionId, ctx) {
+      const handle = await getOrCreatePiSessionForCommand(sessionId, ctx);
+      return handle.resourceLoader.getExtensions().runtime.getCommands().map(normalizeSlashCommandInfo);
+    },
+    async executeSlashCommand(sessionId, name, args, ctx) {
+      const handle = await getOrCreatePiSessionForCommand(sessionId, ctx);
+      await bindRunContext(ctx, async () => {
+        const command = handle.piSession.extensionRunner.getCommand(name);
+        if (command) {
+          const commandContext = handle.piSession.extensionRunner.createCommandContext();
+          await command.handler(args, ctx.allowPromptDispatch === false ? meteredExtensionCommandContext(commandContext, name) : commandContext);
+          return;
+        }
+        const knownCommand = handle.resourceLoader.getExtensions().runtime.getCommands().some((candidate) => candidate.name === name);
+        if (!knownCommand) throw new Error(`command '${name}' not registered in session '${sessionId}'`);
+        if (ctx.allowPromptDispatch === false) throw meteredSlashCommandPromptError(name);
+        const text = args.trim() ? `/${name} ${args}` : `/${name}`;
+        await handle.piSession.prompt(text);
+      });
+    },
+    async getPiSessionAdapter(input, ctx) {
+      if (!input.sessionId) throw new Error("sessionId is required to create a Pi session adapter");
+      const handle = await getOrCreatePiSession(input.sessionId, input, ctx);
+      return createRunBoundAdapter(handle, input.sessionId, ctx);
+    }
+  };
+}
+
+export {
+  getEnv,
+  getEnvSnapshot,
+  setEnvDefault,
+  PiSessionStore,
+  registerConfiguredModelProviders,
+  readConfiguredDefaultModel,
+  PI_PACKAGE_RESOURCE_FILTERS,
+  piPackageSourceKey,
+  compactPiPackages,
+  mergePiPackageSources,
+  withPiHarnessDefaults,
+  createResourceSettingsManager,
+  deriveSourcePlugin,
+  createPiCodingAgentHarness
+};