@agentknight/sdk 0.9.35

package/dist/chunks/pi-adapter-GSDVA7EG.js

@@ -0,0 +1,1177 @@
+import {
+  latestPreviewItems
+} from "./chunk-MVUOCZFL.js";
+import {
+  AgentSessionRenameError,
+  UnsupportedAgentOperationError,
+  validateSessionName
+} from "./chunk-SJHJER3B.js";
+import {
+  InteractionRequestSchema,
+  REASONING_EFFORTS,
+  SESSION_TIMELINE_PAGE_SIZE
+} from "./chunk-ZKAN2FO7.js";
+
+// src/pi-adapter.ts
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { open, readdir, realpath, stat } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import {
+  DefaultResourceLoader,
+  ModelRuntime,
+  ProjectTrustStore,
+  SessionManager,
+  SettingsManager,
+  VERSION,
+  createAgentSession,
+  getAgentDir,
+  hasTrustRequiringProjectResources
+} from "@earendil-works/pi-coding-agent";
+
+// src/pi-timeline.ts
+import { createHash } from "node:crypto";
+var FINAL_REVISION = 1e9;
+var PI_PROMPT_SOURCE_ENTRY = "agentknight.prompt-source.v1";
+function key(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 32);
+}
+var PiTimeline = class {
+  constructor(sessionId, entries = []) {
+    this.sessionId = sessionId;
+    this.#turnId = `pi:${sessionId}`;
+    for (const entry of entries) {
+      if (entry.type !== "custom" || entry.customType !== PI_PROMPT_SOURCE_ENTRY) continue;
+      const data = entry.data;
+      if (typeof data !== "object" || data === null || !("projectionId" in data) || typeof data.projectionId !== "string" || !("messageId" in data) || typeof data.messageId !== "string" || data.messageId.length === 0 || data.messageId.length > 256) continue;
+      this.#promptSources.set(data.projectionId, data.messageId);
+    }
+    for (const entry of entries) {
+      if (entry.type === "message") {
+        const id = this.#nextMessageId(entry.message);
+        this.#message(entry.message, id, true);
+      } else if (entry.type === "compaction" || entry.type === "branch_summary") {
+        this.notice(`pi:${entry.id}`, entry.timestamp, "info", "Summary", entry.summary);
+      } else if (entry.type === "custom_message" && entry.display) {
+        const id = `pi:${entry.id}`;
+        const content = this.#text(entry.content, id, entry.timestamp);
+        this.notice(id, entry.timestamp, "info", entry.customType, content);
+      }
+    }
+  }
+  sessionId;
+  items = /* @__PURE__ */ new Map();
+  #counts = /* @__PURE__ */ new Map();
+  #activeMessages = /* @__PURE__ */ new Map();
+  #promptSources = /* @__PURE__ */ new Map();
+  #turnId;
+  event(event, acknowledgedMessageId) {
+    const previous = new Map(this.items);
+    if (event.type === "message_start" || event.type === "message_update" || event.type === "message_end") {
+      const signature = this.#signature(event.message);
+      let id = this.#activeMessages.get(signature);
+      if (!id) {
+        id = this.#nextMessageId(event.message);
+        this.#activeMessages.set(signature, id);
+      }
+      if (event.message.role === "user" && acknowledgedMessageId) this.#promptSources.set(id, acknowledgedMessageId);
+      this.#message(event.message, id, event.type === "message_end");
+      if (event.type === "message_end") this.#activeMessages.delete(signature);
+    } else if (event.type === "tool_execution_start" || event.type === "tool_execution_update" || event.type === "tool_execution_end") {
+      this.#tool(
+        event.toolCallId,
+        event.toolName,
+        event.type === "tool_execution_end" ? event.isError ? "failed" : "completed" : "running"
+      );
+      if (event.type === "tool_execution_end") {
+        this.#text(event.result.content, this.#toolId(event.toolCallId), this.items.get(this.#toolId(event.toolCallId)).timestamp);
+      }
+    }
+    return [...this.items.values()].filter((item) => previous.get(item.id) !== item);
+  }
+  notice(id, timestamp, severity, title, content) {
+    return this.#put({
+      id,
+      revision: FINAL_REVISION,
+      turnId: this.#turnId,
+      timestamp,
+      sourceEventIds: [id],
+      kind: "notice",
+      actor: "system",
+      severity,
+      title: title.trim().slice(0, 256) || "PI",
+      content: content.slice(0, 4096)
+    });
+  }
+  #signature(message) {
+    return `${message.role}:${message.timestamp}`;
+  }
+  #nextMessageId(message) {
+    const signature = this.#signature(message);
+    const index = this.#counts.get(signature) ?? 0;
+    this.#counts.set(signature, index + 1);
+    return `pi:${key(`${this.sessionId}:${signature}:${index}`)}`;
+  }
+  #message(message, id, final) {
+    const timestamp = new Date(message.timestamp).toISOString();
+    if (message.role === "user") this.#turnId = id;
+    if (message.role === "user" || message.role === "assistant") {
+      const content = this.#text(message.content, id, timestamp);
+      const limit = message.role === "user" ? 1e5 : 5e5;
+      if (content.length > limit) {
+        this.notice(`${id}:truncated`, timestamp, "warning", "Content truncated", "The PI message exceeds the timeline content limit.");
+      }
+      const base = {
+        id,
+        revision: final ? FINAL_REVISION : 1,
+        turnId: this.#turnId,
+        timestamp,
+        sourceEventIds: [id],
+        sourceMessageIds: [id, ...this.#promptSources.has(id) ? [this.#promptSources.get(id)] : []],
+        content: content.slice(0, limit)
+      };
+      if (message.role === "user") {
+        this.#put({ ...base, kind: "human-message", actor: "human", attachments: [] });
+      } else {
+        this.#put({
+          ...base,
+          kind: "assistant-message",
+          actor: "assistant",
+          final,
+          ...message.model ? { model: message.model.slice(0, 256) } : {}
+        });
+        for (const part of message.content) {
+          if (part.type === "toolCall") this.#tool(part.id, part.name, "running", timestamp);
+        }
+        if (final && message.stopReason === "error") {
+          this.notice(`${id}:error`, timestamp, "error", "PI request failed", message.errorMessage ?? "The model returned an error.");
+        } else if (final && message.stopReason === "aborted") {
+          this.notice(`${id}:aborted`, timestamp, "warning", "Aborted", message.errorMessage ?? "The request was aborted.");
+        }
+      }
+    } else if (message.role === "toolResult") {
+      this.#tool(message.toolCallId, message.toolName, message.isError ? "failed" : "completed", timestamp);
+      this.#text(message.content, this.#toolId(message.toolCallId), timestamp);
+    } else if (message.role === "bashExecution") {
+      this.notice(id, timestamp, message.exitCode === 0 ? "info" : "error", message.command, message.output);
+    } else if (message.role === "custom") {
+      if (message.display) this.notice(id, timestamp, "info", message.customType, this.#text(message.content, id, timestamp));
+    } else if (message.role === "compactionSummary" || message.role === "branchSummary") {
+      this.notice(id, timestamp, "info", "Summary", message.summary);
+    } else {
+      this.notice(`${id}:unsupported`, timestamp, "warning", "Unsupported PI message", "This native message type cannot be displayed.");
+    }
+  }
+  #text(content, id, timestamp) {
+    if (typeof content === "string") return content;
+    if (content.some((part) => part.type !== "text" && part.type !== "thinking" && part.type !== "toolCall")) {
+      this.notice(`${id}:unsupported`, timestamp, "warning", "Unsupported PI content", "This message contains media that cannot be displayed by this adapter.");
+    }
+    return content.filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
+  }
+  #toolId(toolCallId) {
+    return `pi:tool:${key(`${this.sessionId}:${toolCallId}`)}`;
+  }
+  #tool(toolCallId, name, status, timestamp) {
+    const id = this.#toolId(toolCallId);
+    const existing = this.items.get(id);
+    if (existing?.kind === "activity-group" && existing.status !== "running" && status === "running") return;
+    const startedAt = existing?.timestamp ?? timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+    this.#put({
+      id,
+      revision: status === "running" ? 1 : FINAL_REVISION,
+      turnId: existing?.turnId ?? this.#turnId,
+      timestamp: startedAt,
+      sourceEventIds: [id],
+      kind: "activity-group",
+      actor: "assistant",
+      status,
+      steps: [{ id, kind: "tool", name: name.trim().slice(0, 256) || "tool", status, timestamp: startedAt }]
+    });
+  }
+  #put(item) {
+    const previous = this.items.get(item.id);
+    if (previous) {
+      if (JSON.stringify({ ...previous, revision: 0 }) === JSON.stringify({ ...item, revision: 0 })) return previous;
+      item.revision = Math.max(item.revision, previous.revision + 1);
+    }
+    this.items.set(item.id, item);
+    return item;
+  }
+};
+
+// src/pi-adapter.ts
+var PiOpeningCancelledError = class extends Error {
+  constructor() {
+    super("PI project trust resolution was cancelled or unavailable.");
+  }
+};
+var isMissing = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+var modelId = (model) => `${model.provider}/${model.id}`;
+var PiCodingAgentAdapter = class {
+  agentId = "pi";
+  sdkVersion = VERSION;
+  agentModes = ["interactive"];
+  supportsReasoningEffort = true;
+  supportsSessionListUpdates = true;
+  supportsAssistantPreview = true;
+  supportsSessionDelete = false;
+  supportsFileAttachments = false;
+  #agentDirectory;
+  #timeout;
+  #dependencies;
+  #sessions = /* @__PURE__ */ new Map();
+  #runtimes = /* @__PURE__ */ new Map();
+  #prepared = /* @__PURE__ */ new Map();
+  #startingPrompts = /* @__PURE__ */ new Map();
+  #openingNotices = /* @__PURE__ */ new Map();
+  #opening = /* @__PURE__ */ new Map();
+  #cancelledOpenings = /* @__PURE__ */ new Set();
+  #pending = /* @__PURE__ */ new Map();
+  #modelRuntime;
+  #modelRefresh;
+  #callbacks;
+  #started = false;
+  #stopping = false;
+  constructor(options = {}, dependencies = {}) {
+    this.#agentDirectory = resolve(options.agentDirectory ?? getAgentDir());
+    this.#timeout = options.interactionTimeoutMs ?? 12e4;
+    if (!Number.isFinite(this.#timeout) || this.#timeout <= 0) throw new Error("PI interaction timeout must be positive.");
+    this.#dependencies = dependencies;
+  }
+  async start() {
+    if (this.#started) return;
+    this.#stopping = false;
+    this.#modelRuntime = this.#dependencies.modelRuntime ?? await ModelRuntime.create({
+      authPath: join(this.#agentDirectory, "auth.json"),
+      modelsPath: join(this.#agentDirectory, "models.json"),
+      modelsStorePath: join(this.#agentDirectory, "cache", "models.json"),
+      allowModelNetwork: true,
+      modelRefreshTimeoutMs: 15e3
+    });
+    await this.#modelRuntime.getAvailable();
+    this.#checkRegistry();
+    await this.#refreshSessions();
+    if (this.#stopping) throw new Error("PI adapter stopped during startup.");
+    this.#started = true;
+  }
+  async stop() {
+    this.#stopping = true;
+    this.#started = false;
+    const modelRefresh = this.#modelRefresh;
+    modelRefresh?.controller.abort(new Error("PI adapter stopped during model refresh."));
+    for (const startup of this.#startingPrompts.values()) {
+      startup.cancelled = true;
+      startup.queue = [];
+    }
+    this.#dismissPending();
+    if (modelRefresh) await Promise.allSettled([modelRefresh.work]);
+    const errors = [];
+    const opening = await Promise.allSettled([
+      ...this.#opening.values(),
+      ...[...this.#startingPrompts.values()].map((startup) => startup.work)
+    ]);
+    for (const result of opening) {
+      if (result.status === "rejected" && !(result.reason instanceof PiOpeningCancelledError)) errors.push(result.reason);
+    }
+    for (const [id, runtime] of this.#runtimes) {
+      try {
+        await this.#abort(runtime);
+      } catch (error) {
+        errors.push(error);
+      } finally {
+        runtime.unsubscribe();
+        runtime.session.dispose();
+        this.#runtimes.delete(id);
+      }
+    }
+    this.#sessions.clear();
+    this.#prepared.clear();
+    this.#openingNotices.clear();
+    this.#modelRuntime = void 0;
+    if (errors.length) throw new AggregateError(errors, "PI shutdown failed.");
+  }
+  async canUpgrade() {
+    return this.#started && !this.#stopping && this.#opening.size === 0 && this.#startingPrompts.size === 0 && this.#pending.size === 0 && this.#modelRefresh === void 0 && [...this.#runtimes.values()].every((runtime) => !runtime.busy && !runtime.aborting && runtime.queue.length === 0 && runtime.primarySource === void 0 && runtime.steeringSources.length === 0 && runtime.followUpSources.length === 0 && runtime.session.isIdle === true && runtime.session.isStreaming === false && runtime.session.isCompacting === false && runtime.session.isRetrying === false && runtime.session.isBashRunning === false && runtime.session.hasPendingBashMessages === false && runtime.session.pendingMessageCount === 0);
+  }
+  async listModels() {
+    this.#assertStarted();
+    if (this.#modelRefresh) return this.#modelRefresh.work;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(new Error("PI model refresh timed out.")), 15e3);
+    timeout.unref();
+    const refresh = {
+      controller,
+      work: this.#listModels(controller.signal)
+    };
+    this.#modelRefresh = refresh;
+    try {
+      return await refresh.work;
+    } finally {
+      clearTimeout(timeout);
+      if (this.#modelRefresh === refresh) this.#modelRefresh = void 0;
+    }
+  }
+  async #listModels(signal) {
+    const registry = this.#modelRuntime;
+    if (!registry) throw new Error("PI model runtime is unavailable.");
+    const result = await registry.refresh({ allowNetwork: true, force: true, signal });
+    if (result.aborted || signal.aborted) {
+      throw new Error("PI model refresh was cancelled or timed out.", { cause: signal.reason });
+    }
+    if (result.errors.size > 0) {
+      throw new AggregateError(
+        [...result.errors.values()],
+        `PI model refresh failed: ${[...result.errors.keys()].join(", ")}`
+      );
+    }
+    this.#assertStarted();
+    const settings = this.#settings(process.cwd());
+    const preferred = `${settings.getDefaultProvider()}/${settings.getDefaultModel()}`;
+    const models = await registry.getAvailable(void 0, { signal });
+    if (signal.aborted) throw new Error("PI model refresh was cancelled or timed out.", { cause: signal.reason });
+    this.#assertStarted();
+    this.#checkRegistry();
+    const defaultId = models.some((model) => modelId(model) === preferred) ? preferred : modelId(models[0]);
+    return models.map((model) => {
+      const supportedReasoningEfforts = REASONING_EFFORTS.filter((level) => getSupportedThinkingLevels(model).some((supported) => supported === level));
+      const defaultReasoningEffort = this.#thinking(model, "default", settings);
+      return {
+        id: modelId(model),
+        name: model.name.slice(0, 260),
+        isDefault: modelId(model) === defaultId,
+        supportedReasoningEfforts,
+        ...supportedReasoningEfforts.some((level) => level === defaultReasoningEffort) ? { defaultReasoningEffort } : {}
+      };
+    });
+  }
+  async listSessions(userId, machineId) {
+    this.#assertStarted();
+    await this.#refreshSessions();
+    return [...this.#sessions.values()].sort((a, b) => b.modified.getTime() - a.modified.getTime()).map((info) => this.#summary(info, userId, machineId));
+  }
+  async createSession(options) {
+    this.#assertStarted();
+    this.#validateMode(options.agentMode);
+    const model = this.#model(options.modelId);
+    const cwd = resolve(options.workingDirectory);
+    if (!(await stat(cwd)).isDirectory()) throw new Error(`PI workspace is not a directory: ${cwd}`);
+    this.#assertStarted();
+    const settings = this.#settings(cwd);
+    const thinking = options.reasoningEffort === void 0 || options.reasoningEffort === "default" ? "default" : this.#thinking(model, options.reasoningEffort, settings);
+    const sessionDirectory = join(this.#agentDirectory, "sessions", `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`);
+    const manager = SessionManager.create(cwd, sessionDirectory);
+    const header = manager.getHeader();
+    const info = {
+      id: manager.getSessionId(),
+      path: manager.getSessionFile(),
+      cwd,
+      created: new Date(header.timestamp),
+      modified: new Date(header.timestamp),
+      messageCount: 0,
+      firstMessage: "",
+      allMessagesText: ""
+    };
+    this.#sessions.set(info.id, info);
+    this.#prepared.set(info.id, { manager, modelId: modelId(model), thinking });
+    this.#callbacks?.onSessionInventoryChanged(info.id);
+    return this.#summary(info, options.userId, options.machineId);
+  }
+  async getSessionConfiguration(sessionId) {
+    this.#assertStarted();
+    const runtime = this.#runtimes.get(sessionId);
+    if (runtime) return this.#configuration(runtime);
+    const manager = await this.#openKnownSession(sessionId);
+    const context = manager.buildSessionContext();
+    const prepared = this.#prepared.get(sessionId);
+    if (prepared) {
+      return {
+        modelId: prepared.modelId,
+        agentMode: "interactive",
+        reasoningEffort: prepared.thinking === "default" ? this.#thinking(this.#model(prepared.modelId), "default", this.#settings(manager.getCwd())) : prepared.thinking,
+        configOptions: this.#configOptions(manager.getCwd())
+      };
+    }
+    return {
+      ...context.model ? { modelId: `${context.model.provider}/${context.model.modelId}` } : {},
+      agentMode: "interactive",
+      reasoningEffort: context.thinkingLevel,
+      configOptions: this.#configOptions(manager.getCwd())
+    };
+  }
+  async renameSession(sessionId, name, assertAccess) {
+    const requested = validateSessionName(name);
+    this.#assertStarted();
+    assertAccess?.();
+    let runtime = this.#runtimes.get(sessionId);
+    const opening = this.#opening.get(sessionId);
+    if (!runtime && opening) runtime = await opening;
+    const manager = runtime?.session.sessionManager ?? await this.#openKnownSession(sessionId);
+    const pending = this.#opening.get(sessionId);
+    runtime = pending ? await pending : this.#runtimes.get(sessionId);
+    this.#assertStarted();
+    assertAccess?.();
+    let confirmed;
+    if (runtime) {
+      runtime.session.setSessionName(requested);
+      confirmed = runtime.session.sessionName;
+    } else {
+      manager.appendSessionInfo(requested);
+      confirmed = manager.getSessionName();
+    }
+    this.#assertStarted();
+    assertAccess?.();
+    if (confirmed !== requested) {
+      throw new AgentSessionRenameError("SESSION_RENAME_FAILED", "PI did not confirm the requested session name.");
+    }
+    const info = this.#sessions.get(sessionId);
+    if (info) info.name = confirmed;
+    this.#callbacks?.onSessionInventoryChanged(sessionId);
+    return confirmed;
+  }
+  async configureSession(sessionId, options) {
+    this.#validateMode(options.agentMode);
+    const option = options.configOption;
+    if (option && (options.modelId !== void 0 || options.agentMode !== void 0 || options.reasoningEffort !== void 0)) {
+      throw new UnsupportedAgentOperationError("pi", "combined native setting and session configuration changes");
+    }
+    if (option && (option.id !== "defaultProjectTrust" || !["ask", "always", "never"].includes(option.value))) {
+      throw new UnsupportedAgentOperationError("pi", `configuration ${option.id}=${option.value}`);
+    }
+    const current = await this.getSessionConfiguration(sessionId);
+    if (option) {
+      const settings = this.#settings(process.cwd());
+      const value = option.value;
+      if (value !== "ask" && value !== "always" && value !== "never") {
+        throw new UnsupportedAgentOperationError("pi", `project trust ${value}`);
+      }
+      settings.setDefaultProjectTrust(value);
+      await settings.flush();
+      this.#checkSettings(settings);
+      if (this.#settings(process.cwd()).getDefaultProjectTrust() !== value) {
+        throw new Error("PI project trust setting could not be saved.");
+      }
+      for (const id of this.#sessions.keys()) this.#callbacks?.onSessionInventoryChanged(id);
+    }
+    if ((options.modelId === void 0 || options.modelId === current.modelId) && (options.reasoningEffort === void 0 || options.reasoningEffort === current.reasoningEffort)) {
+      return { ...current, configOptions: this.#configOptions(process.cwd()) };
+    }
+    const runtime = await this.#runtime(sessionId);
+    const model = options.modelId === void 0 ? runtime.session.model : this.#model(options.modelId);
+    if (!model) throw new Error("No PI model is selected.");
+    const thinking = options.reasoningEffort === void 0 ? void 0 : this.#thinking(model, options.reasoningEffort, runtime.session.settingsManager);
+    const modelChanged = !runtime.session.model || modelId(model) !== modelId(runtime.session.model);
+    const thinkingChanged = thinking !== void 0 && thinking !== runtime.session.thinkingLevel;
+    if (!modelChanged && !thinkingChanged) return this.#configuration(runtime);
+    if (runtime.busy || runtime.session.isStreaming) throw new Error("PI session configuration cannot change while a prompt is running.");
+    if (modelChanged) await runtime.session.setModel(model);
+    if (thinking !== void 0 && (modelChanged || thinkingChanged)) runtime.session.setThinkingLevel(thinking);
+    this.#callbacks?.onSessionInventoryChanged(sessionId);
+    return this.#configuration(runtime);
+  }
+  async getSessionEnvironment(sessionId) {
+    this.#assertStarted();
+    const runtime = this.#runtimes.get(sessionId);
+    if (!runtime) {
+      await this.#openKnownSession(sessionId);
+      return { tools: [], slashCommands: [], skills: [] };
+    }
+    const { session } = runtime;
+    const active = new Set(session.getActiveToolNames());
+    return {
+      tools: session.getAllTools().filter((tool) => active.has(tool.name)).map((tool) => ({
+        name: tool.name.slice(0, 260),
+        description: tool.description.slice(0, 4096)
+      })),
+      slashCommands: [],
+      skills: []
+    };
+  }
+  async getSessionRemoteStatus(_sessionId) {
+    throw new UnsupportedAgentOperationError("pi", "remote session status");
+  }
+  async setSessionRemote(_sessionId, _enabled) {
+    throw new UnsupportedAgentOperationError("pi", "remote session toggling");
+  }
+  async readSessionTimelinePage(sessionId, options = {}) {
+    this.#assertStarted();
+    const runtime = this.#runtimes.get(sessionId);
+    const timeline = new PiTimeline(
+      sessionId,
+      (runtime?.session.sessionManager ?? await this.#openKnownSession(sessionId)).getBranch()
+    );
+    for (const source of [this.#openingNotices.get(sessionId), runtime?.timeline]) {
+      if (!source) continue;
+      for (const item of source.items.values()) {
+        const persisted = timeline.items.get(item.id);
+        if (!persisted || persisted.revision < item.revision) timeline.items.set(item.id, item);
+      }
+    }
+    const items = [...timeline.items.values()];
+    const pageSize = options.pageSize ?? SESSION_TIMELINE_PAGE_SIZE;
+    if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > SESSION_TIMELINE_PAGE_SIZE) throw new Error("Invalid PI timeline page size.");
+    const signature = createHash2("sha256").update(sessionId).update(items.map((item) => item.id).join("\n")).digest("hex").slice(0, 16);
+    let end = items.length;
+    let cursorStatus = "ok";
+    if (options.cursor) {
+      const match = /^pi:([a-f0-9]{16}):([0-9]+)$/.exec(options.cursor);
+      if (!match || match[1] !== signature || Number(match[2]) > items.length) cursorStatus = "expired";
+      else end = Number(match[2]);
+    }
+    const start = Math.max(0, end - pageSize);
+    return {
+      items: options.metadataOnly ? options.assistantPreview === true ? latestPreviewItems(items) : [] : items.slice(start, end),
+      cursor: `pi:${signature}:${options.metadataOnly ? end : start}`,
+      hasMore: options.metadataOnly ? options.assistantPreview !== true && end > 0 : start > 0,
+      cursorStatus
+    };
+  }
+  async watchSession(sessionId, watched) {
+    this.#assertStarted();
+    if (watched && !this.#runtimes.has(sessionId)) await this.#openKnownSession(sessionId);
+  }
+  setSessionCallbacks(callbacks) {
+    this.#callbacks = callbacks;
+  }
+  async sendPrompt(sessionId, prompt, mode, attachments, _persistInteractions, fileAttachments) {
+    if (attachments?.length) throw new UnsupportedAgentOperationError("pi", "image attachments");
+    if (fileAttachments?.length) throw new UnsupportedAgentOperationError("pi", "file attachments");
+    if (!prompt.trim()) throw new Error("PI prompt must not be empty.");
+    if (mode !== "enqueue" && mode !== "immediate") throw new UnsupportedAgentOperationError("pi", `prompt delivery mode ${mode}`);
+    this.#assertStarted();
+    let runtime = this.#runtimes.get(sessionId);
+    if (!runtime) {
+      const configuration = await this.getSessionConfiguration(sessionId);
+      this.#assertStarted();
+      if (!configuration.modelId) throw new Error("No PI model is selected.");
+      this.#model(configuration.modelId);
+      runtime = this.#runtimes.get(sessionId);
+    }
+    if (this.#cancelledOpenings.has(sessionId)) throw new Error("PI session is being aborted.");
+    const message = { id: randomUUID(), text: prompt, mode };
+    const startup = this.#startingPrompts.get(sessionId);
+    if (startup) {
+      if (startup.cancelled) throw new Error("PI session is being aborted.");
+      startup.queue.push(message);
+      return { messageId: message.id, deliveryState: "queued" };
+    }
+    if (!runtime) {
+      this.#startPrompts(sessionId, message);
+      return { messageId: message.id, deliveryState: "processing" };
+    }
+    if (runtime.aborting) throw new Error("PI session is being aborted.");
+    if (!runtime.session.model) throw new Error("No PI model is selected.");
+    this.#model(modelId(runtime.session.model));
+    const queued = runtime.busy || runtime.session.isStreaming;
+    runtime.queue.push(message);
+    if (queued) this.#dispatchQueued(runtime);
+    else this.#runNext(runtime);
+    return { messageId: message.id, deliveryState: queued ? "queued" : "processing" };
+  }
+  async abortSession(sessionId) {
+    this.#assertStarted();
+    const startup = this.#startingPrompts.get(sessionId);
+    const opening = this.#opening.get(sessionId);
+    if (startup || opening) {
+      if (startup) {
+        startup.cancelled = true;
+        startup.queue = [];
+      }
+      this.#cancelledOpenings.add(sessionId);
+      this.#dismissPending(sessionId);
+      try {
+        await opening;
+      } catch (error) {
+        if (!(error instanceof PiOpeningCancelledError)) throw error;
+      } finally {
+        try {
+          await startup?.work;
+        } finally {
+          this.#cancelledOpenings.delete(sessionId);
+        }
+      }
+    }
+    const runtime = this.#runtimes.get(sessionId);
+    if (runtime) await this.#abort(runtime);
+    else await this.#openKnownSession(sessionId);
+  }
+  respondPermission(_permissionRequestId, _decision, _feedback) {
+    return false;
+  }
+  async respondInteraction(interactionRequestId, response) {
+    const pending = this.#pending.get(interactionRequestId);
+    if (!pending || pending.request.kind !== response.kind) return false;
+    if (pending.request.kind === "user_input" && response.kind === "user_input") {
+      if (!pending.request.allowFreeform && (response.wasFreeform || !pending.request.choices.includes(response.answer))) {
+        throw new Error("PI interaction response is not one of the offered choices.");
+      }
+    }
+    pending.finish(response);
+    return true;
+  }
+  replayPendingInteractions() {
+    for (const [id, pending] of this.#pending) this.#publishInteraction(id, pending);
+  }
+  #assertStarted() {
+    if (!this.#started || this.#stopping) throw new Error("PI adapter is not running.");
+  }
+  #checkRegistry() {
+    const registry = this.#modelRuntime;
+    if (!registry) throw new Error("PI adapter has not initialized its model registry.");
+    if (registry.getError()) throw new Error(`Invalid PI model configuration: ${registry.getError()}`);
+    if (registry.getAvailableSnapshot().length === 0) {
+      throw new Error("No authenticated PI models are available. Configure PI provider credentials with the PI CLI or provider environment variables.");
+    }
+    return registry;
+  }
+  #model(id) {
+    const registry = this.#checkRegistry();
+    const model = registry.getModels().find((candidate) => modelId(candidate) === id);
+    if (!model) throw new Error(`Unknown PI model: ${id}`);
+    if (!registry.getAvailableSnapshot().some((candidate) => modelId(candidate) === id)) throw new Error(`Authentication is missing or the PI model is unavailable: ${id}`);
+    return model;
+  }
+  #settings(cwd) {
+    const disk = SettingsManager.create(cwd, this.#agentDirectory, { projectTrusted: false });
+    this.#checkSettings(disk);
+    return disk;
+  }
+  #checkSettings(settings) {
+    const errors = settings.drainErrors();
+    if (errors.length) throw new AggregateError(errors.map((item) => item.error), "Unable to read or save PI settings.");
+  }
+  #configOptions(cwd) {
+    return [{
+      id: "defaultProjectTrust",
+      name: "Project trust",
+      value: this.#settings(cwd).getDefaultProjectTrust(),
+      options: ["ask", "always", "never"].map((value) => ({ value, name: value }))
+    }];
+  }
+  #thinking(model, effort, settings) {
+    const supported = getSupportedThinkingLevels(model);
+    if (effort !== "default") {
+      if (!supported.some((level) => level === effort)) throw new UnsupportedAgentOperationError("pi", `reasoning effort ${effort} for ${modelId(model)}`);
+      return effort;
+    }
+    const preferred = settings.getDefaultThinkingLevel() ?? "medium";
+    return supported.includes(preferred) ? preferred : supported.includes("medium") ? "medium" : supported[0] ?? "off";
+  }
+  #validateMode(mode) {
+    if (mode !== void 0 && mode !== "interactive") throw new UnsupportedAgentOperationError("pi", `agent mode ${mode}`);
+  }
+  #configuration(runtime) {
+    return {
+      ...runtime.session.model ? { modelId: modelId(runtime.session.model) } : {},
+      agentMode: "interactive",
+      reasoningEffort: runtime.session.thinkingLevel,
+      configOptions: this.#configOptions(runtime.session.sessionManager.getCwd())
+    };
+  }
+  #summary(info, userId, machineId) {
+    return {
+      userId,
+      machineId,
+      sessionId: info.id,
+      renameSupported: true,
+      summary: (info.name ?? info.firstMessage).slice(0, 4096),
+      workingDirectory: info.cwd,
+      isRemote: false,
+      createdAt: info.created.toISOString(),
+      modifiedAt: info.modified.toISOString()
+    };
+  }
+  async #refreshSessions() {
+    const root = join(this.#agentDirectory, "sessions");
+    let directories;
+    try {
+      directories = await readdir(root, { withFileTypes: true });
+    } catch (error) {
+      if (!isMissing(error)) throw error;
+      directories = [];
+    }
+    const lists = await Promise.all(directories.filter((entry) => entry.isDirectory()).map((entry) => SessionManager.listAll(join(root, entry.name))));
+    const next = /* @__PURE__ */ new Map();
+    for (const info of lists.flat()) {
+      if (next.has(info.id) && next.get(info.id).path !== info.path) throw new Error(`Duplicate PI native session ID: ${info.id}`);
+      next.set(info.id, info);
+    }
+    for (const id of this.#prepared.keys()) {
+      const info = this.#sessions.get(id);
+      if (!next.has(id) && info) next.set(id, info);
+    }
+    for (const [id, runtime] of this.#runtimes) {
+      if (!next.has(id) && this.#sessions.has(id)) next.set(id, this.#sessions.get(id));
+      const info = next.get(id);
+      if (info && runtime.busy) info.modified = /* @__PURE__ */ new Date();
+    }
+    this.#sessions.clear();
+    for (const [id, info] of next) this.#sessions.set(id, info);
+  }
+  async #openKnownSession(sessionId) {
+    const prepared = this.#prepared.get(sessionId);
+    if (prepared) return prepared.manager;
+    let info = this.#sessions.get(sessionId);
+    if (!info) {
+      await this.#refreshSessions();
+      info = this.#sessions.get(sessionId);
+    }
+    if (!info) throw new Error(`Unknown PI session: ${sessionId}`);
+    const handle = await open(info.path, "r");
+    try {
+      const buffer = Buffer.alloc(64 * 1024);
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+      const firstLine = buffer.subarray(0, bytesRead).toString("utf8").split("\n", 1)[0];
+      const header = JSON.parse(firstLine);
+      if (typeof header !== "object" || header === null || !("type" in header) || header.type !== "session" || !("id" in header) || header.id !== sessionId || !("cwd" in header) || typeof header.cwd !== "string" || header.cwd !== info.cwd) {
+        throw new Error(`PI session header does not match the known session: ${sessionId}`);
+      }
+    } finally {
+      await handle.close();
+    }
+    const manager = SessionManager.open(info.path, dirname(info.path));
+    if (manager.getSessionId() !== sessionId) throw new Error(`PI session changed while opening: ${sessionId}`);
+    return manager;
+  }
+  async #runtime(sessionId) {
+    this.#assertStarted();
+    const existing = this.#runtimes.get(sessionId);
+    if (existing) return existing;
+    let opening = this.#opening.get(sessionId);
+    if (!opening) {
+      opening = (async () => {
+        const manager = await this.#openKnownSession(sessionId);
+        if (!(await stat(manager.getCwd())).isDirectory()) throw new Error(`PI workspace is not a directory: ${manager.getCwd()}`);
+        const prepared = this.#prepared.get(sessionId);
+        if (prepared) {
+          const runtime2 = await this.#createRuntime(manager, this.#model(prepared.modelId), prepared.thinking, this.#settings(manager.getCwd()));
+          this.#runtimes.set(sessionId, runtime2);
+          this.#prepared.delete(sessionId);
+          return runtime2;
+        }
+        const context = manager.buildSessionContext();
+        if (!context.model) throw new Error(`PI session has no saved model: ${sessionId}`);
+        const model = this.#model(`${context.model.provider}/${context.model.modelId}`);
+        const supported = getSupportedThinkingLevels(model);
+        if (!supported.some((level) => level === context.thinkingLevel)) throw new Error(`PI session has unsupported saved thinking level: ${context.thinkingLevel}`);
+        const runtime = await this.#createRuntime(manager, model, context.thinkingLevel, this.#settings(manager.getCwd()));
+        this.#runtimes.set(sessionId, runtime);
+        return runtime;
+      })();
+      this.#opening.set(sessionId, opening);
+    }
+    try {
+      return await opening;
+    } finally {
+      if (this.#opening.get(sessionId) === opening) this.#opening.delete(sessionId);
+    }
+  }
+  async #createRuntime(manager, model, thinking, settings) {
+    const sessionId = manager.getSessionId();
+    this.#assertOpening(sessionId);
+    const cancellation = (pi) => {
+      const cancelled = () => this.#stopping || this.#cancelledOpenings.has(sessionId) || this.#runtimes.get(sessionId)?.aborting === true;
+      pi.on("session_before_compact", () => cancelled() ? { cancel: true } : void 0);
+      pi.on("session_before_tree", () => cancelled() ? { cancel: true } : void 0);
+    };
+    const loader = new DefaultResourceLoader({
+      cwd: manager.getCwd(),
+      agentDir: this.#agentDirectory,
+      settingsManager: settings,
+      extensionFactories: [cancellation]
+    });
+    await loader.reload({
+      resolveProjectTrust: ({ extensionsResult }) => this.#resolveProjectTrust(sessionId, manager.getCwd(), settings, extensionsResult)
+    });
+    this.#assertOpening(sessionId);
+    this.#checkSettings(settings);
+    const extensions = loader.getExtensions();
+    if (extensions.errors.length) {
+      throw new AggregateError(extensions.errors.map((error) => new Error(`${error.path}: ${error.error}`)), "Unable to load PI extensions.");
+    }
+    const result = await (this.#dependencies.createSession ?? createAgentSession)({
+      cwd: manager.getCwd(),
+      agentDir: this.#agentDirectory,
+      modelRuntime: this.#modelRuntime,
+      model,
+      thinkingLevel: thinking === "default" ? this.#thinking(model, "default", settings) : thinking,
+      sessionManager: manager,
+      settingsManager: settings,
+      resourceLoader: loader
+    });
+    const session = result.session;
+    try {
+      this.#assertOpening(sessionId);
+      if (result.modelFallbackMessage) throw new Error(result.modelFallbackMessage);
+      if (session.sessionId !== sessionId) throw new Error("PI SDK returned a different native session ID.");
+      const runtime = {
+        session,
+        timeline: new PiTimeline(sessionId, manager.getBranch()),
+        unsubscribe: () => {
+        },
+        busy: false,
+        aborting: false,
+        queue: [],
+        work: void 0,
+        dispatch: Promise.resolve(),
+        primarySource: void 0,
+        steeringSources: [],
+        followUpSources: []
+      };
+      const transformContext = session.agent.transformContext;
+      session.agent.transformContext = async (messages, signal) => {
+        const checkCancellation = () => {
+          if (runtime.aborting || this.#stopping || this.#cancelledOpenings.has(sessionId)) {
+            session.agent.abort();
+            throw new Error("PI request cancelled.");
+          }
+        };
+        checkCancellation();
+        const transformed = transformContext ? await transformContext(messages, signal) : messages;
+        checkCancellation();
+        return transformed;
+      };
+      runtime.unsubscribe = session.subscribe((event) => this.#event(runtime, event));
+      await session.bindExtensions({
+        uiContext: this.#ui(sessionId, session.extensionRunner.getUIContext().theme),
+        mode: "rpc",
+        onError: (error) => this.#error(runtime, new Error(`PI extension ${error.event}: ${error.error}`))
+      });
+      if (this.#stopping || this.#cancelledOpenings.has(sessionId)) {
+        runtime.unsubscribe();
+        throw new PiOpeningCancelledError();
+      }
+      return runtime;
+    } catch (error) {
+      session.dispose();
+      throw error;
+    }
+  }
+  #event(runtime, event) {
+    const id = runtime.session.sessionId;
+    try {
+      const source = event.type === "message_start" && event.message.role === "user" ? this.#claimPromptSource(runtime, event.message.content) : void 0;
+      for (const item of runtime.timeline.event(event, source?.id)) {
+        if (item.kind === "human-message" && source) {
+          runtime.session.sessionManager.appendCustomEntry(PI_PROMPT_SOURCE_ENTRY, {
+            projectionId: item.id,
+            messageId: source.id
+          });
+        }
+        this.#callbacks?.onConversationItem(id, item);
+      }
+      if ((runtime.aborting || this.#stopping) && (event.type === "compaction_start" || event.type === "auto_retry_start")) {
+        queueMicrotask(() => this.#cancelBackgroundOperations(runtime));
+      }
+      if (event.type === "agent_start") {
+        this.#callbacks?.onSessionActivity?.(id, "working", (/* @__PURE__ */ new Date()).toISOString());
+        this.#dispatchQueued(runtime);
+      } else if (event.type === "agent_end") {
+        this.#callbacks?.onSessionInventoryChanged(id);
+      } else if (event.type === "session_info_changed") {
+        const info = this.#sessions.get(id);
+        if (info) {
+          if (event.name === void 0) delete info.name;
+          else info.name = event.name;
+        }
+        this.#callbacks?.onSessionInventoryChanged(id);
+      } else if (event.type === "message_end" && event.message.role === "assistant" && event.message.stopReason === "error") {
+        this.#callbacks?.onSyncError(id, new Error(event.message.errorMessage ?? "PI model request failed."));
+      } else if (event.type === "auto_retry_start") {
+        this.#notice(runtime, "warning", "Retrying", `${event.attempt}/${event.maxAttempts}: ${event.errorMessage}`);
+      } else if (event.type === "auto_retry_end" && !event.success) {
+        this.#error(runtime, new Error(event.finalError ?? "PI retries exhausted."));
+      } else if (event.type === "compaction_end" && event.errorMessage) {
+        this.#error(runtime, new Error(event.errorMessage));
+      }
+    } catch (error) {
+      this.#callbacks?.onSyncError(id, error);
+    }
+  }
+  #startPrompts(sessionId, message) {
+    const startup = { queue: [message], cancelled: false, work: Promise.resolve() };
+    this.#startingPrompts.set(sessionId, startup);
+    let handedOff = false;
+    startup.work = Promise.resolve().then(async () => {
+      if (startup.cancelled || this.#stopping) return;
+      this.#callbacks?.onSessionActivity?.(sessionId, "working", (/* @__PURE__ */ new Date()).toISOString());
+      const runtime = await this.#runtime(sessionId);
+      if (startup.cancelled || this.#stopping) return;
+      runtime.queue.push(...startup.queue);
+      startup.queue = [];
+      this.#startingPrompts.delete(sessionId);
+      handedOff = true;
+      this.#runNext(runtime);
+    }).catch((error) => {
+      if (startup.cancelled || this.#stopping) return;
+      this.#openingNotice(sessionId, "error", "PI request failed", error instanceof Error ? error.message : String(error));
+      this.#callbacks?.onSyncError(sessionId, error);
+    }).finally(() => {
+      startup.queue = [];
+      if (this.#startingPrompts.get(sessionId) === startup) this.#startingPrompts.delete(sessionId);
+      if (!handedOff) this.#callbacks?.onSessionActivity?.(sessionId, "idle", (/* @__PURE__ */ new Date()).toISOString());
+      this.#callbacks?.onSessionInventoryChanged(sessionId);
+    });
+  }
+  #runNext(runtime) {
+    if (runtime.busy || runtime.aborting || this.#stopping) return;
+    const prompt = runtime.queue.shift();
+    if (!prompt) return;
+    runtime.busy = true;
+    this.#callbacks?.onSessionActivity?.(runtime.session.sessionId, "working", (/* @__PURE__ */ new Date()).toISOString());
+    runtime.work = Promise.resolve().then(() => {
+      if (runtime.aborting || this.#stopping) return;
+      runtime.primarySource = prompt;
+      return runtime.session.prompt(prompt.text, {
+        expandPromptTemplates: false,
+        source: "rpc",
+        // PI awaits compaction/extensions before Agent.prompt; cancellation must survive preflight.
+        preflightResult: (accepted) => {
+          if (accepted && (runtime.aborting || this.#stopping)) throw new Error("PI prompt was aborted before execution.");
+        }
+      });
+    }).catch((error) => {
+      this.#error(runtime, error);
+    }).finally(async () => {
+      await runtime.dispatch;
+      if (runtime.primarySource?.id === prompt.id) runtime.primarySource = void 0;
+      runtime.busy = false;
+      this.#callbacks?.onSessionActivity?.(runtime.session.sessionId, "idle", (/* @__PURE__ */ new Date()).toISOString());
+      this.#callbacks?.onSessionInventoryChanged(runtime.session.sessionId);
+      this.#runNext(runtime);
+    });
+  }
+  #dispatchQueued(runtime) {
+    if (!runtime.session.isStreaming || runtime.aborting || this.#stopping) return;
+    runtime.dispatch = runtime.dispatch.then(async () => {
+      while (runtime.queue.length && runtime.session.isStreaming && !runtime.aborting && !this.#stopping) {
+        const prompt = runtime.queue.shift();
+        const sources = prompt.mode === "immediate" ? runtime.steeringSources : runtime.followUpSources;
+        sources.push(prompt);
+        try {
+          if (prompt.mode === "immediate") await runtime.session.steer(prompt.text);
+          else await runtime.session.followUp(prompt.text);
+        } catch (error) {
+          const index = sources.findIndex((source) => source.id === prompt.id);
+          if (index !== -1) sources.splice(index, 1);
+          this.#error(runtime, error);
+        }
+      }
+    });
+  }
+  async #abort(runtime) {
+    runtime.aborting = true;
+    runtime.queue = [];
+    this.#dismissPending(runtime.session.sessionId);
+    runtime.session.clearQueue();
+    this.#cancelBackgroundOperations(runtime);
+    try {
+      await runtime.session.abort();
+      await runtime.dispatch;
+      await runtime.work;
+      runtime.session.clearQueue();
+    } finally {
+      runtime.primarySource = void 0;
+      runtime.steeringSources = [];
+      runtime.followUpSources = [];
+      runtime.aborting = false;
+      runtime.busy = false;
+      this.#callbacks?.onSessionActivity?.(runtime.session.sessionId, "idle", (/* @__PURE__ */ new Date()).toISOString());
+    }
+  }
+  #cancelBackgroundOperations(runtime) {
+    runtime.session.abortCompaction();
+    runtime.session.abortBranchSummary();
+    runtime.session.abortRetry();
+  }
+  #claimPromptSource(runtime, content) {
+    const text = typeof content === "string" ? content : content.filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
+    if (runtime.primarySource?.text === text) {
+      const source = runtime.primarySource;
+      runtime.primarySource = void 0;
+      return source;
+    }
+    for (const sources of [runtime.steeringSources, runtime.followUpSources]) {
+      const index = sources.findIndex((source) => source.text === text);
+      if (index !== -1) return sources.splice(index, 1)[0];
+    }
+    return void 0;
+  }
+  #notice(runtime, severity, title, content) {
+    const item = runtime.timeline.notice(`pi:${randomUUID()}`, (/* @__PURE__ */ new Date()).toISOString(), severity, title, content);
+    this.#callbacks?.onConversationItem(runtime.session.sessionId, item);
+  }
+  #openingNotice(sessionId, severity, title, content) {
+    let timeline = this.#openingNotices.get(sessionId);
+    if (!timeline) {
+      timeline = new PiTimeline(sessionId, []);
+      this.#openingNotices.set(sessionId, timeline);
+    }
+    this.#callbacks?.onConversationItem(
+      sessionId,
+      timeline.notice(`pi:${randomUUID()}`, (/* @__PURE__ */ new Date()).toISOString(), severity, title, content)
+    );
+  }
+  #error(runtime, error) {
+    this.#notice(runtime, "error", "PI request failed", error instanceof Error ? error.message : String(error));
+    this.#callbacks?.onSyncError(runtime.session.sessionId, error);
+  }
+  async #resolveProjectTrust(sessionId, cwd, settings, extensions) {
+    this.#checkSettings(settings);
+    this.#assertOpening(sessionId);
+    if (extensions.errors.length) {
+      throw new AggregateError(extensions.errors.map((error) => new Error(`${error.path}: ${error.error}`)), "Unable to load PI project trust extensions.");
+    }
+    if (!hasTrustRequiringProjectResources(cwd)) return true;
+    const store = new ProjectTrustStore(this.#agentDirectory);
+    const context = {
+      cwd,
+      mode: "rpc",
+      hasUI: this.#callbacks?.onInteractionRequest !== void 0,
+      ui: this.#dialogUI(sessionId)
+    };
+    for (const extension of extensions.extensions) {
+      for (const handler of extension.handlers.get("project_trust") ?? []) {
+        let result;
+        try {
+          result = await handler({ type: "project_trust", cwd }, context);
+        } catch (cause) {
+          throw new Error(`PI extension ${extension.path} project_trust failed.`, { cause });
+        }
+        this.#assertOpening(sessionId);
+        if (typeof result !== "object" || result === null || !("trusted" in result) || result.trusted !== "yes" && result.trusted !== "no" && result.trusted !== "undecided") {
+          throw new Error(`PI extension ${extension.path} returned an invalid project trust decision.`);
+        }
+        if (result.trusted === "undecided") continue;
+        const trusted = result.trusted === "yes";
+        if ("remember" in result && result.remember === true) store.set(cwd, trusted);
+        return trusted;
+      }
+    }
+    const saved = store.get(cwd);
+    if (saved !== null) return saved;
+    const defaultTrust = settings.getDefaultProjectTrust();
+    if (defaultTrust !== "ask") return defaultTrust === "always";
+    const path = await realpath(cwd);
+    const parent = dirname(path);
+    const choices = [
+      { label: "Trust", trusted: true, updates: [{ path, decision: true }] },
+      ...parent !== path ? [{
+        label: `Trust parent folder (${parent})`,
+        trusted: true,
+        updates: [{ path: parent, decision: true }, { path, decision: null }]
+      }] : [],
+      { label: "Trust (this session only)", trusted: true, updates: [] },
+      { label: "Do not trust", trusted: false, updates: [{ path, decision: false }] },
+      { label: "Do not trust (this session only)", trusted: false, updates: [] }
+    ];
+    const response = await context.ui.select(`Trust project folder?
+${cwd}`, choices.map((choice2) => choice2.label));
+    const choice = choices.find((candidate) => candidate.label === response);
+    this.#assertOpening(sessionId);
+    if (!choice) throw new PiOpeningCancelledError();
+    if (choice.updates.length) store.setMany(choice.updates);
+    return choice.trusted;
+  }
+  #assertOpening(sessionId) {
+    if (this.#stopping || this.#cancelledOpenings.has(sessionId)) throw new PiOpeningCancelledError();
+  }
+  #request(sessionId, request, options = {}) {
+    InteractionRequestSchema.parse(request);
+    if (this.#stopping || this.#cancelledOpenings.has(sessionId) || options.signal?.aborted || this.#runtimes.get(sessionId)?.aborting) return Promise.resolve(void 0);
+    if (!this.#callbacks?.onInteractionRequest) return Promise.resolve(void 0);
+    const id = randomUUID();
+    return new Promise((resolveRequest) => {
+      let done = false;
+      const abort = () => finish(void 0);
+      const timer = setTimeout(abort, Math.min(options.timeout ?? this.#timeout, this.#timeout));
+      timer.unref();
+      const finish = (response) => {
+        if (done) return;
+        done = true;
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", abort);
+        this.#pending.delete(id);
+        resolveRequest(response);
+        this.#callbacks?.onInteractionDismissed?.(sessionId, id);
+      };
+      const pending = { sessionId, request, finish };
+      this.#pending.set(id, pending);
+      options.signal?.addEventListener("abort", abort, { once: true });
+      try {
+        this.#publishInteraction(id, pending);
+      } catch (error) {
+        finish(void 0);
+        this.#callbacks?.onSyncError(sessionId, error);
+      }
+    });
+  }
+  #publishInteraction(id, pending) {
+    if (this.#callbacks?.onInteractionRequest) this.#callbacks.onInteractionRequest(pending.sessionId, id, pending.request);
+    else pending.finish(void 0);
+  }
+  #dismissPending(sessionId) {
+    for (const pending of this.#pending.values()) if (sessionId === void 0 || pending.sessionId === sessionId) pending.finish(void 0);
+  }
+  #dialogUI(sessionId) {
+    return {
+      select: async (title, choices, options) => {
+        const response = await this.#request(sessionId, { kind: "user_input", question: title, choices, allowFreeform: false }, options);
+        return response?.kind === "user_input" ? response.answer : void 0;
+      },
+      confirm: async (title, message, options) => {
+        const response = await this.#request(sessionId, {
+          kind: "user_input",
+          question: [title, message].filter(Boolean).join("\n"),
+          choices: ["Confirm", "Cancel"],
+          allowFreeform: false
+        }, options);
+        return response?.kind === "user_input" && response.answer === "Confirm";
+      },
+      input: async (title, _placeholder, options) => {
+        const response = await this.#request(sessionId, { kind: "user_input", question: title, choices: [], allowFreeform: true }, options);
+        return response?.kind === "user_input" ? response.answer : void 0;
+      },
+      notify: (message, severity = "info") => {
+        const runtime = this.#runtimes.get(sessionId);
+        if (runtime) this.#notice(runtime, severity, "PI", message);
+        else this.#openingNotice(sessionId, severity, "PI", message);
+      }
+    };
+  }
+  #ui(sessionId, theme) {
+    const unsupported = () => {
+      throw new UnsupportedAgentOperationError("pi", "terminal extension UI");
+    };
+    return {
+      ...this.#dialogUI(sessionId),
+      onTerminalInput: unsupported,
+      setStatus: unsupported,
+      setWorkingMessage: unsupported,
+      setWorkingVisible: unsupported,
+      setWorkingIndicator: unsupported,
+      setHiddenThinkingLabel: unsupported,
+      setWidget: unsupported,
+      setFooter: unsupported,
+      setHeader: unsupported,
+      setTitle: unsupported,
+      custom: unsupported,
+      pasteToEditor: unsupported,
+      setEditorText: unsupported,
+      getEditorText: unsupported,
+      editor: unsupported,
+      addAutocompleteProvider: unsupported,
+      setEditorComponent: unsupported,
+      getEditorComponent: unsupported,
+      theme,
+      getAllThemes: unsupported,
+      getTheme: unsupported,
+      setTheme: unsupported,
+      getToolsExpanded: unsupported,
+      setToolsExpanded: unsupported
+    };
+  }
+};
+export {
+  PiCodingAgentAdapter
+};