@peakflo/agent-harness 0.0.0-stage → 0.2.2-rc.1

package/dist/adapters/pi-adapter.js

@@ -0,0 +1,1468 @@
+"use strict";
+/**
+ * Pi coding-agent adapter.
+ *
+ * Pi exposes a JSONL RPC protocol over stdin/stdout. The harness keeps one Pi
+ * process per live turn and converts Pi events to the shared adapter shape.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PiAdapter = exports.PI_MCP_SERVER_ALIASES = exports.MAX_PI_MCP_SERVER_SLUG_LENGTH = exports.MAX_PI_NAME_LENGTH = void 0;
+exports.findPiNodeRuntime = findPiNodeRuntime;
+exports.sanitizePiSessionName = sanitizePiSessionName;
+exports.sanitizePiMcpServerName = sanitizePiMcpServerName;
+exports.withProviderNameLimitHint = withProviderNameLimitHint;
+exports.buildPiMcpConfigDocument = buildPiMcpConfigDocument;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const string_decoder_1 = require("string_decoder");
+const util_1 = require("util");
+const coding_agent_adapter_1 = require("./coding-agent-adapter");
+const model_gateway_1 = require("./model-gateway");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const RPC_TIMEOUT_MS = 15_000;
+const MAX_BUFFERED_PARTS = 1_000;
+const MINIMUM_PI_VERSION = [0, 80, 5];
+const PI_PERMISSION_MODE_ENV = 'PEAKFLO_PI_PERMISSION_MODE';
+const TERMINAL_ERROR_SETTLE_GRACE_MS = 1_000;
+const piInstanceIdCache = new Map();
+/**
+ * Most model providers cap function/tool `name` at 64 characters. Pi forwards
+ * MCP tools as `<server>_<tool>`-style names, so a long MCP server name (e.g.
+ * "[Workflo] Organisation Workspace") plus a long tool name overflows the
+ * limit and the whole turn fails with "name must be at most 64 characters".
+ * Keep server slugs short to leave room for the tool suffix.
+ */
+exports.MAX_PI_NAME_LENGTH = 64;
+exports.MAX_PI_MCP_SERVER_SLUG_LENGTH = 24;
+/**
+ * Electron's main macOS executable belongs to the foreground application
+ * bundle. Reusing it as Node makes LaunchServices register every Pi process as
+ * another foreground 20x application, which adds a Dock icon. Electron's
+ * standard Helper.app is an LSUIElement and exposes the same bundled Node
+ * runtime without participating in the Dock.
+ */
+function findPiNodeRuntime(platform, electronExecutable, pathExists = fs_1.existsSync) {
+    if (platform !== 'darwin')
+        return electronExecutable;
+    const executableName = (0, path_1.basename)(electronExecutable);
+    const contentsDirectory = (0, path_1.dirname)((0, path_1.dirname)(electronExecutable));
+    const helperExecutable = (0, path_1.join)(contentsDirectory, 'Frameworks', `${executableName} Helper.app`, 'Contents', 'MacOS', `${executableName} Helper`);
+    return pathExists(helperExecutable) ? helperExecutable : null;
+}
+/**
+ * Short Pi-side aliases for MCP servers whose display names are too long to
+ * fit the provider 64-char tool-name limit. The alias is only used in the
+ * Pi `--mcp-config` file — display names in settings, docs, and other
+ * backends are untouched.
+ */
+exports.PI_MCP_SERVER_ALIASES = {
+    '[Workflo] Organisation Workspace': 'workflo',
+    '[Workflo] MCP Dev Server': 'workflo-dev'
+};
+function slugifyPiName(value, maxLength) {
+    return (value
+        .toLowerCase()
+        .replace(/[^a-z0-9-_]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^[-_]+|[-_]+$/g, '')
+        .slice(0, maxLength)
+        .replace(/-+$/g, '') || 'mcp');
+}
+/**
+ * Generic rule for bracket-prefixed servers ("[Workflo] My tasks" →
+ * "workflo-my-tasks"). Returns null when the name has no bracket prefix so
+ * the caller falls back to plain slugification.
+ */
+function slugifyBracketPrefix(name) {
+    const match = /^\[([^\]]+)\]\s*(.*)$/.exec(name);
+    if (!match)
+        return null;
+    const combined = `${match[1]}-${match[2]}`.trim();
+    if (!combined.replace(/-/g, ''))
+        return null;
+    return slugifyPiName(combined, exports.MAX_PI_MCP_SERVER_SLUG_LENGTH);
+}
+function sanitizePiSessionName(taskId) {
+    const slug = taskId
+        .replace(/[^a-zA-Z0-9-_]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^[-_]+|[-_]+$/g, '')
+        .slice(0, exports.MAX_PI_NAME_LENGTH)
+        .replace(/-+$/g, '');
+    return slug || 'pi-session';
+}
+function sanitizePiMcpServerName(name, used) {
+    // Exact aliases first (e.g. "[Workflo] Organisation Workspace" → "workflo").
+    const alias = exports.PI_MCP_SERVER_ALIASES[name];
+    const base = alias ??
+        slugifyBracketPrefix(name) ??
+        slugifyPiName(name, exports.MAX_PI_MCP_SERVER_SLUG_LENGTH);
+    if (!used.has(base)) {
+        used.add(base);
+        return base;
+    }
+    for (let index = 2; index < 1000; index++) {
+        const suffix = `-${index}`;
+        const candidate = `${base.slice(0, exports.MAX_PI_MCP_SERVER_SLUG_LENGTH - suffix.length)}${suffix}`;
+        if (!used.has(candidate)) {
+            used.add(candidate);
+            return candidate;
+        }
+    }
+    const fallback = `mcp-${used.size + 1}`;
+    used.add(fallback);
+    return fallback;
+}
+function withProviderNameLimitHint(error) {
+    if (!/name must be at most 64/i.test(error))
+        return error;
+    return `${error}\n\nHint: a tool name exceeded the provider 64-character limit. The Peakflo harness keeps MCP tools behind short namespace proxies. Stop and start the agent to rebuild its tool list.`;
+}
+/**
+ * Build the pi-mcp-adapter document used by Peakflo harness sessions.
+ *
+ * Keep MCP servers behind namespace proxy tools (`mcp__<server>`). Direct MCP
+ * tools concatenate the server and tool names; a 24-character server slug and
+ * a 50-character generated workflow tool already produce a 76-character name.
+ * Providers commonly reject the entire request when any tool exceeds 64
+ * characters, before the model can call a tool.
+ */
+function buildPiMcpConfigDocument(servers, onRename) {
+    const usedSlugs = new Set();
+    const mcpServers = Object.fromEntries(Object.entries(servers).map(([name, server]) => {
+        const slug = sanitizePiMcpServerName(name, usedSlugs);
+        if (slug !== name)
+            onRename?.(name, slug);
+        if (server.type === 'stdio') {
+            return [
+                slug,
+                {
+                    command: server.command,
+                    args: server.args ?? [],
+                    env: server.env ?? {}
+                }
+            ];
+        }
+        return [
+            slug,
+            {
+                url: server.url,
+                headers: server.headers ?? {}
+            }
+        ];
+    }));
+    return {
+        settings: {
+            // This must be explicit because MCP_DIRECT_TOOLS and user-level Pi
+            // settings can otherwise expose every `<server>_<tool>` directly.
+            directTools: false
+        },
+        mcpServers
+    };
+}
+const PI_PERMISSION_EXTENSION_SOURCE = `\
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const READ_ONLY_TOOLS = new Set(["read", "grep", "find", "ls"]);
+
+function inputSummary(input: unknown): string {
+  try {
+    return JSON.stringify(input, null, 2).slice(0, 4000);
+  } catch {
+    return String(input).slice(0, 4000);
+  }
+}
+
+export default function permissions(pi: ExtensionAPI) {
+  pi.on("tool_call", async (event, ctx) => {
+    if (process.env.${PI_PERMISSION_MODE_ENV} === "allow" || READ_ONLY_TOOLS.has(event.toolName)) return;
+    const approved = await ctx.ui.confirm(
+      \`Allow \${event.toolName}?\`,
+      inputSummary(event.input),
+    );
+    if (!approved) return { block: true, reason: \`\${event.toolName} was declined.\` };
+  });
+}
+`;
+function textFromContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((block) => !!block && typeof block === 'object')
+        .filter((block) => block.type === 'text')
+        .map((block) => String(block.text ?? ''))
+        .join('');
+}
+function resultText(result) {
+    if (!result || typeof result !== 'object')
+        return '';
+    const content = result.content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((block) => !!block && typeof block === 'object')
+        .map((block) => block.type === 'text' ? String(block.text ?? '') : JSON.stringify(block))
+        .join('\n');
+}
+class PiAdapter {
+    modelGateway;
+    sessions = new Map();
+    piExecutablePath = null;
+    onDataAvailable;
+    constructor(modelGateway) {
+        this.modelGateway = modelGateway;
+    }
+    agentDirectory() {
+        return process.env.PI_CODING_AGENT_DIR || (0, path_1.join)((0, os_1.homedir)(), '.pi', 'agent');
+    }
+    /** Identity of the Pi session store that can honour native session files. */
+    backendInstanceId() {
+        const directory = this.agentDirectory();
+        const cached = piInstanceIdCache.get(directory);
+        if (cached)
+            return cached;
+        const marker = (0, path_1.join)(directory, '.pf-backend-instance-id');
+        const readExisting = () => {
+            try {
+                return (0, fs_1.readFileSync)(marker, 'utf8').trim() || null;
+            }
+            catch {
+                return null;
+            }
+        };
+        const existing = readExisting();
+        if (existing) {
+            piInstanceIdCache.set(directory, existing);
+            return existing;
+        }
+        const minted = (0, crypto_1.randomUUID)();
+        try {
+            (0, fs_1.mkdirSync)(directory, { recursive: true, mode: 0o700 });
+            (0, fs_1.writeFileSync)(marker, minted, { flag: 'wx', mode: 0o600 });
+            piInstanceIdCache.set(directory, minted);
+            return minted;
+        }
+        catch (error) {
+            if (error.code === 'EEXIST') {
+                const winner = readExisting();
+                if (winner) {
+                    piInstanceIdCache.set(directory, winner);
+                    return winner;
+                }
+            }
+            // An unpersisted id matches no later checkpoint, which safely forces a
+            // replay instead of resuming a session file from uncertain storage.
+            return minted;
+        }
+    }
+    async initialize() {
+        await this.findPiExecutable();
+    }
+    async findPiExecutable() {
+        if (this.piExecutablePath)
+            return this.piExecutablePath;
+        const isWin = process.platform === 'win32';
+        try {
+            const { stdout } = await execFileAsync(isWin ? 'where' : 'which', ['pi'], {
+                timeout: 10_000,
+                windowsHide: true
+            });
+            this.piExecutablePath = stdout.trim().split(/\r?\n/)[0];
+            return this.piExecutablePath;
+        }
+        catch {
+            const home = (0, os_1.homedir)();
+            const candidates = isWin
+                ? [
+                    (0, path_1.join)(home, 'AppData', 'Roaming', 'npm', 'pi.cmd'),
+                    (0, path_1.join)(home, 'AppData', 'Roaming', 'npm', 'pi.exe')
+                ]
+                : [
+                    '/opt/homebrew/bin/pi',
+                    '/usr/local/bin/pi',
+                    (0, path_1.join)(home, '.local', 'bin', 'pi'),
+                    (0, path_1.join)(home, '.npm-global', 'bin', 'pi'),
+                    (0, path_1.join)(home, '.volta', 'bin', 'pi')
+                ];
+            const found = candidates.find(fs_1.existsSync);
+            if (!found) {
+                throw new Error('Pi CLI not found. Install it with: npm install -g --ignore-scripts @earendil-works/pi-coding-agent');
+            }
+            this.piExecutablePath = found;
+            return found;
+        }
+    }
+    /**
+     * Install or update the Peakflo provider in Pi's normal models file. The key
+     * remains an environment reference; the harness supplies the session-scoped
+     * value only to the child process.
+     */
+    installPeakfloGateway() {
+        const gateway = this.modelGateway.readModelGatewayConfig();
+        if (!gateway)
+            return null;
+        const agentDir = this.agentDirectory();
+        const modelsPath = (0, path_1.join)(agentDir, 'models.json');
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(modelsPath), { recursive: true });
+        let root = {};
+        if ((0, fs_1.existsSync)(modelsPath)) {
+            try {
+                root = JSON.parse((0, fs_1.readFileSync)(modelsPath, 'utf8'));
+            }
+            catch (error) {
+                throw new Error(`Pi models file is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const providers = { ...(root.providers ?? {}) };
+        providers[model_gateway_1.ENTERPRISE_AI_GATEWAY_PROVIDER_ID] =
+            (0, model_gateway_1.buildPiAiGatewayProviderConfig)(gateway);
+        const temporaryPath = `${modelsPath}.pf-harness-${process.pid}.tmp`;
+        (0, fs_1.writeFileSync)(temporaryPath, `${JSON.stringify({ ...root, providers }, null, 2)}\n`, { mode: 0o600 });
+        (0, fs_1.chmodSync)(temporaryPath, 0o600);
+        (0, fs_1.renameSync)(temporaryPath, modelsPath);
+        (0, fs_1.chmodSync)(modelsPath, 0o600);
+        return { apiKey: gateway.apiKey, providerModels: gateway.models ?? [] };
+    }
+    buildMcpConfig(config) {
+        if (!config.mcpServers || Object.keys(config.mcpServers).length === 0)
+            return undefined;
+        const dir = (0, path_1.join)((0, os_1.homedir)(), '.pf-agent-harness', 'pi-mcp');
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+        const path = (0, path_1.join)(dir, `${sanitizePiSessionName(config.taskId)}-${(0, crypto_1.randomUUID)()}.json`);
+        // Pi forwards MCP tools to the model as <server>_<tool> names, which most
+        // providers cap at 64 characters. Sanitize server keys so a long display
+        // name (e.g. "[Workflo] Organisation Workspace") cannot overflow the limit.
+        const document = buildPiMcpConfigDocument(config.mcpServers, (name, slug) => {
+            console.warn(`[PiAdapter] Renamed MCP server "${name}" to "${slug}" to fit the provider 64-char tool name limit`);
+        });
+        (0, fs_1.writeFileSync)(path, `${JSON.stringify(document, null, 2)}\n`, {
+            mode: 0o600
+        });
+        (0, fs_1.chmodSync)(path, 0o600);
+        return path;
+    }
+    installPermissionExtension() {
+        const dir = (0, path_1.join)((0, os_1.homedir)(), '.pf-agent-harness', 'pi');
+        const path = (0, path_1.join)(dir, 'permissions.ts');
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+        const current = (0, fs_1.existsSync)(path) ? (0, fs_1.readFileSync)(path, 'utf8') : '';
+        if (current !== PI_PERMISSION_EXTENSION_SOURCE) {
+            const temporaryPath = `${path}.${process.pid}.tmp`;
+            (0, fs_1.writeFileSync)(temporaryPath, PI_PERMISSION_EXTENSION_SOURCE, {
+                mode: 0o600
+            });
+            (0, fs_1.chmodSync)(temporaryPath, 0o600);
+            (0, fs_1.renameSync)(temporaryPath, path);
+        }
+        (0, fs_1.chmodSync)(path, 0o600);
+        return path;
+    }
+    processEnv(config, gateway) {
+        const env = {
+            ...process.env,
+            ...(config.environment ?? {}),
+            ...(config.secretEnvVars ?? {}),
+            ...(gateway ? { PEAKFLO_AI_GATEWAY_API_KEY: gateway.apiKey } : {}),
+            [PI_PERMISSION_MODE_ENV]: config.permissionMode ?? 'ask'
+        };
+        delete env.AI_AGENT;
+        delete env.PI_CODING_AGENT;
+        // A parent shell may set this globally. pi-mcp-adapter gives the variable
+        // precedence over its config, which would undo `directTools: false` and
+        // recreate overlong provider-facing names.
+        delete env.MCP_DIRECT_TOOLS;
+        return env;
+    }
+    buildSkillFiles(config) {
+        if (!config.skills || config.skills.length === 0)
+            return { paths: [] };
+        const directory = (0, path_1.join)((0, os_1.homedir)(), '.pf-agent-harness', 'pi-skills', `${sanitizePiSessionName(config.taskId)}-${(0, crypto_1.randomUUID)()}`);
+        (0, fs_1.mkdirSync)(directory, { recursive: true, mode: 0o700 });
+        (0, fs_1.chmodSync)(directory, 0o700);
+        const used = new Set();
+        const paths = config.skills.map((skill) => {
+            const base = slugifyPiName(skill.name, 48);
+            let fileName = `${base}.md`;
+            let suffix = 2;
+            while (used.has(fileName))
+                fileName = `${base}-${suffix++}.md`;
+            used.add(fileName);
+            const path = (0, path_1.join)(directory, fileName);
+            const content = skill.content.endsWith('\n')
+                ? skill.content
+                : `${skill.content}\n`;
+            (0, fs_1.writeFileSync)(path, content, { mode: 0o600 });
+            (0, fs_1.chmodSync)(path, 0o600);
+            return path;
+        });
+        return { directory, paths };
+    }
+    /**
+     * Pi's npm launcher uses `#!/usr/bin/env node`. Launching it directly would
+     * therefore make Pi depend on whichever Node happens to be first on the
+     * desktop app's PATH. Recent Pi releases require Node >=22.19 and use zstd
+     * APIs that are absent from older runtimes. On Linux, run the launcher with
+     * Electron's main executable. On macOS, use Electron's LSUIElement helper;
+     * launching the foreground app executable creates another Dock icon for
+     * every Pi session. Both expose the same bundled Node runtime.
+     *
+     * Windows npm launchers are .cmd files, so they must continue to run through
+     * the shell.
+     */
+    piInvocation(executable, args, env) {
+        if (process.platform === 'win32') {
+            return { command: executable, args, env, shell: true };
+        }
+        const nodeRuntime = findPiNodeRuntime(process.platform, process.execPath);
+        if (!nodeRuntime) {
+            // A valid Electron macOS package always contains Helper.app. If a custom
+            // package does not, prefer Pi's shebang-selected Node over spawning the
+            // foreground Electron app and reintroducing a Dock icon.
+            return { command: executable, args, env, shell: false };
+        }
+        return {
+            command: nodeRuntime,
+            args: [executable, ...args],
+            env: { ...env, ELECTRON_RUN_AS_NODE: '1' },
+            shell: false
+        };
+    }
+    createSessionState(id, child, config, mcpConfigPath, skillDirectory) {
+        return {
+            id,
+            projectionId: (0, crypto_1.randomUUID)(),
+            process: child,
+            config,
+            status: 'idle',
+            lastError: null,
+            pending: new Map(),
+            parts: [],
+            allMessages: [],
+            stdoutBuffer: '',
+            stdoutDecoder: new string_decoder_1.StringDecoder('utf8'),
+            textByBlock: new Map(),
+            reasoningByBlock: new Map(),
+            toolParts: new Map(),
+            pendingUiRequests: new Map(),
+            turn: 0,
+            assistantMessageOrdinal: 0,
+            pendingTurnError: null,
+            pendingTurnErrorMonotonicTime: null,
+            sawAgentActivity: false,
+            promptMayBeCommandOnly: false,
+            closing: false,
+            mcpConfigPath,
+            skillDirectory
+        };
+    }
+    splitModel(model) {
+        if (!model)
+            return {};
+        const separator = model.indexOf('/');
+        if (separator < 0)
+            return { modelId: model };
+        return {
+            provider: model.slice(0, separator),
+            modelId: model.slice(separator + 1)
+        };
+    }
+    async applySelection(session, config) {
+        if (config.model && config.model !== 'default') {
+            const { provider, modelId } = this.splitModel(config.model);
+            if (!provider || !modelId) {
+                throw new Error(`Pi model must use provider/model format: ${config.model}`);
+            }
+            await this.command(session, { type: 'set_model', provider, modelId });
+        }
+        if (config.reasoningEffort) {
+            await this.command(session, {
+                type: 'set_thinking_level',
+                level: config.reasoningEffort
+            });
+        }
+    }
+    async spawnSession(config, resumeId) {
+        const executable = await this.findPiExecutable();
+        const gateway = this.installPeakfloGateway();
+        const mcpConfigPath = this.buildMcpConfig(config);
+        const skills = this.buildSkillFiles(config);
+        const permissionExtension = this.installPermissionExtension();
+        const args = [
+            '--mode',
+            'rpc',
+            '--approve',
+            '--name',
+            sanitizePiSessionName(config.taskId),
+            '--extension',
+            permissionExtension
+        ];
+        if (config.systemPrompt?.trim()) {
+            args.push('--append-system-prompt', config.systemPrompt.trim());
+        }
+        if (resumeId)
+            args.push('--session', resumeId);
+        if (mcpConfigPath)
+            args.push('--mcp-config', mcpConfigPath);
+        for (const skillPath of skills.paths)
+            args.push('--skill', skillPath);
+        const invocation = this.piInvocation(executable, args, this.processEnv(config, gateway));
+        const child = (0, child_process_1.spawn)(invocation.command, invocation.args, {
+            cwd: config.workspaceDir,
+            env: invocation.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+            shell: invocation.shell,
+            detached: process.platform !== 'win32'
+        });
+        const tempId = resumeId || (0, crypto_1.randomUUID)();
+        const session = this.createSessionState(tempId, child, config, mcpConfigPath, skills.directory);
+        this.sessions.set(tempId, session);
+        this.attachProcess(session);
+        try {
+            const state = await this.command(session, { type: 'get_state' });
+            const realId = typeof state.data?.sessionFile === 'string'
+                ? state.data.sessionFile
+                : typeof state.data?.sessionId === 'string'
+                    ? state.data.sessionId
+                    : tempId;
+            session.id = realId;
+            if (realId !== tempId) {
+                this.sessions.delete(tempId);
+                this.sessions.set(realId, session);
+            }
+            await this.applySelection(session, config);
+            return session;
+        }
+        catch (error) {
+            this.sessions.delete(tempId);
+            this.sessions.delete(session.id);
+            await this.terminateProcess(session);
+            if (mcpConfigPath && (0, fs_1.existsSync)(mcpConfigPath))
+                (0, fs_1.unlinkSync)(mcpConfigPath);
+            if (skills.directory && (0, fs_1.existsSync)(skills.directory))
+                (0, fs_1.rmSync)(skills.directory, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    async createSession(config) {
+        const session = await this.spawnSession(config);
+        return session.id;
+    }
+    async resumeSession(sessionId, config) {
+        const session = await this.spawnSession(config, sessionId);
+        const response = await this.command(session, { type: 'get_messages' });
+        const messages = Array.isArray(response.data?.messages)
+            ? response.data.messages
+            : [];
+        session.allMessages = this.convertMessages(messages);
+        return session.allMessages;
+    }
+    attachProcess(session) {
+        session.process.stdout.on('data', (chunk) => {
+            this.consumeStdout(session, typeof chunk === 'string' ? chunk : session.stdoutDecoder.write(chunk));
+        });
+        session.process.stdout.on('end', () => {
+            this.consumeStdout(session, session.stdoutDecoder.end(), true);
+        });
+        session.process.stderr.on('data', (chunk) => {
+            const length = chunk.toString().trim().length;
+            if (length > 0)
+                console.warn(`[PiAdapter/${session.id}] Pi wrote ${length} character(s) to stderr`);
+        });
+        session.process.on('error', (error) => {
+            session.status = 'error';
+            session.lastError = error.message;
+            this.rejectPending(session, error);
+            this.onDataAvailable?.(session.id);
+        });
+        session.process.on('exit', (code, signal) => {
+            if (!session.closing && session.status === 'busy') {
+                session.status = 'error';
+                session.lastError = `Pi exited before the turn completed (${signal || `code ${code}`})`;
+            }
+            this.rejectPending(session, new Error(session.lastError ||
+                (session.closing ? 'Pi process closed' : 'Pi process exited')));
+            this.onDataAvailable?.(session.id);
+        });
+    }
+    consumeStdout(session, chunk, flush = false) {
+        session.stdoutBuffer += chunk;
+        while (session.stdoutBuffer.includes('\n')) {
+            const newline = session.stdoutBuffer.indexOf('\n');
+            const line = session.stdoutBuffer.slice(0, newline);
+            session.stdoutBuffer = session.stdoutBuffer.slice(newline + 1);
+            this.handleJsonlLine(session, line);
+        }
+        if (flush && session.stdoutBuffer.length > 0) {
+            const line = session.stdoutBuffer;
+            session.stdoutBuffer = '';
+            this.handleJsonlLine(session, line);
+        }
+    }
+    handleJsonlLine(session, rawLine) {
+        const line = rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine;
+        if (!line.trim())
+            return;
+        try {
+            this.handleEvent(session, JSON.parse(line));
+        }
+        catch (error) {
+            console.warn('[PiAdapter] Invalid RPC output:', error);
+        }
+    }
+    rejectPending(session, error) {
+        for (const request of session.pending.values()) {
+            clearTimeout(request.timer);
+            request.reject(error);
+        }
+        session.pending.clear();
+    }
+    handleEvent(session, event) {
+        if (event.type === 'response') {
+            const response = event;
+            if (response.id) {
+                const pending = session.pending.get(response.id);
+                if (pending) {
+                    clearTimeout(pending.timer);
+                    session.pending.delete(response.id);
+                    if (response.success)
+                        pending.resolve(response);
+                    else
+                        pending.reject(new Error(response.error || `Pi ${response.command} failed`));
+                    return;
+                }
+            }
+            if (response.command === 'prompt' && !response.success) {
+                session.status = 'error';
+                session.lastError = response.error || 'Pi rejected the prompt';
+            }
+            else if (response.command === 'prompt' &&
+                response.success &&
+                session.promptMayBeCommandOnly &&
+                !session.sawAgentActivity) {
+                void this.command(session, { type: 'get_state' })
+                    .then((state) => {
+                    const pendingMessageCount = typeof state.data?.pendingMessageCount === 'number'
+                        ? state.data.pendingMessageCount
+                        : 0;
+                    if (state.data?.isStreaming !== true &&
+                        pendingMessageCount === 0 &&
+                        !session.sawAgentActivity) {
+                        session.status =
+                            session.pendingUiRequests.size > 0 ? 'busy' : 'idle';
+                        this.onDataAvailable?.(session.id);
+                    }
+                })
+                    .catch(() => undefined);
+            }
+            this.onDataAvailable?.(session.id);
+            return;
+        }
+        switch (event.type) {
+            case 'agent_start':
+                session.status = 'busy';
+                session.lastError = null;
+                session.pendingTurnError = null;
+                session.pendingTurnErrorMonotonicTime = null;
+                session.turn++;
+                session.assistantMessageOrdinal = 0;
+                session.sawAgentActivity = true;
+                break;
+            case 'agent_settled': {
+                this.cancelPendingUiRequests(session, 'This request is no longer active.');
+                if (session.pendingTurnError)
+                    this.settlePendingTurnError(session);
+                else
+                    session.status = 'idle';
+                session.promptMayBeCommandOnly = false;
+                break;
+            }
+            case 'message_start': {
+                const message = event.message;
+                if (message?.role === 'assistant')
+                    session.assistantMessageOrdinal++;
+                break;
+            }
+            case 'message_update':
+                this.handleMessageUpdate(session, event.assistantMessageEvent);
+                break;
+            case 'message_end': {
+                const message = event.message;
+                this.reconcileAssistantMessage(session, message);
+                if (message?.role === 'assistant' && message.stopReason === 'error') {
+                    session.pendingTurnError =
+                        message.errorMessage || 'Pi model request failed';
+                    session.pendingTurnErrorMonotonicTime = performance.now();
+                }
+                break;
+            }
+            case 'tool_execution_start':
+                this.handleToolEvent(session, event, 'running');
+                break;
+            case 'tool_execution_update':
+                this.handleToolEvent(session, event, 'running');
+                break;
+            case 'tool_execution_end':
+                this.handleToolEvent(session, event, event.isError ? 'error' : 'completed');
+                break;
+            case 'auto_retry_start':
+                session.status = 'busy';
+                session.pendingTurnErrorMonotonicTime = null;
+                break;
+            case 'auto_retry_end':
+                session.pendingTurnError =
+                    event.success === true
+                        ? null
+                        : String(event.finalError || 'Pi retry failed');
+                session.pendingTurnErrorMonotonicTime =
+                    event.success === true ? null : performance.now();
+                break;
+            case 'compaction_end':
+                if (event.result)
+                    session.pendingTurnError = null;
+                else if (event.aborted !== true && event.errorMessage) {
+                    session.parts.push({
+                        id: `pi-compaction-error-${session.turn}-${(0, crypto_1.randomUUID)()}`,
+                        type: coding_agent_adapter_1.MessagePartType.ERROR,
+                        text: String(event.errorMessage)
+                    });
+                }
+                break;
+            case 'extension_error':
+                session.parts.push({
+                    id: `pi-extension-error-${(0, crypto_1.randomUUID)()}`,
+                    type: coding_agent_adapter_1.MessagePartType.ERROR,
+                    text: String(event.error || 'Pi extension failed')
+                });
+                break;
+            case 'extension_ui_request':
+                this.handleExtensionUiRequest(session, event);
+                break;
+        }
+        if (session.parts.length > MAX_BUFFERED_PARTS) {
+            session.parts.splice(0, session.parts.length - MAX_BUFFERED_PARTS);
+        }
+        this.onDataAvailable?.(session.id);
+    }
+    handleExtensionUiRequest(session, event) {
+        const method = event.method;
+        const id = event.id;
+        if (method === 'notify') {
+            const message = String(event.message || event.title || 'Pi notification');
+            session.parts.push({
+                id: `pi-notify-${(0, crypto_1.randomUUID)()}`,
+                type: coding_agent_adapter_1.MessagePartType.TEXT,
+                text: message
+            });
+            return;
+        }
+        if (typeof id !== 'string' ||
+            (method !== 'confirm' &&
+                method !== 'select' &&
+                method !== 'input' &&
+                method !== 'editor'))
+            return;
+        const request = {
+            id,
+            method,
+            title: String(event.title ||
+                (method === 'confirm' ? 'Permission Required' : 'Input Required')),
+            message: this.uiRequestMessage(method, event),
+            options: Array.isArray(event.options)
+                ? event.options.filter((option) => typeof option === 'string')
+                : []
+        };
+        if (method === 'confirm' && session.config.permissionMode === 'allow') {
+            this.sendRecord(session, {
+                type: 'extension_ui_response',
+                id,
+                confirmed: true
+            });
+            return;
+        }
+        session.pendingUiRequests.set(id, request);
+        session.status = 'busy';
+        if (method !== 'confirm') {
+            session.parts.push({
+                id: `pi-question-${id}`,
+                type: coding_agent_adapter_1.MessagePartType.QUESTION,
+                tool: {
+                    name: 'question',
+                    status: 'running',
+                    title: request.title,
+                    requestId: request.id,
+                    questions: [
+                        {
+                            header: request.title,
+                            question: request.message,
+                            options: request.options.map((label) => ({
+                                label,
+                                description: label
+                            }))
+                        }
+                    ]
+                }
+            });
+        }
+    }
+    uiRequestMessage(method, event) {
+        const message = String(event.message ||
+            event.placeholder ||
+            event.title ||
+            'Pi needs your response');
+        const prefill = method === 'editor' && typeof event.prefill === 'string'
+            ? event.prefill.slice(0, 2_000)
+            : '';
+        return prefill ? `${message}\n\nCurrent value:\n${prefill}` : message;
+    }
+    cancelPendingUiRequests(session, output, notifyPi = false) {
+        for (const request of session.pendingUiRequests.values()) {
+            if (notifyPi) {
+                try {
+                    this.sendRecord(session, {
+                        type: 'extension_ui_response',
+                        id: request.id,
+                        cancelled: true
+                    });
+                }
+                catch {
+                    // The process may have closed while the turn was being stopped.
+                }
+            }
+            session.parts.push({
+                id: request.method === 'confirm'
+                    ? `question-${request.id}`
+                    : `pi-question-${request.id}`,
+                type: coding_agent_adapter_1.MessagePartType.QUESTION,
+                update: true,
+                tool: {
+                    name: request.method === 'confirm' ? 'permission' : 'question',
+                    status: 'cancelled',
+                    requestId: request.id,
+                    output
+                }
+            });
+        }
+        session.pendingUiRequests.clear();
+    }
+    handleMessageUpdate(session, update) {
+        if (!update)
+            return;
+        const index = String(update.contentIndex ?? 0);
+        const key = `${session.projectionId}:${session.turn}:${session.assistantMessageOrdinal}:${index}`;
+        if (update.type === 'text_delta') {
+            const text = (session.textByBlock.get(key) || '') + String(update.delta || '');
+            session.textByBlock.set(key, text);
+            session.parts.push({
+                id: `pi-text-${key}`,
+                type: coding_agent_adapter_1.MessagePartType.TEXT,
+                role: coding_agent_adapter_1.MessageRole.ASSISTANT,
+                text,
+                update: true
+            });
+        }
+        else if (update.type === 'text_end') {
+            const text = String(update.content ?? session.textByBlock.get(key) ?? '');
+            session.textByBlock.set(key, text);
+            session.parts.push({
+                id: `pi-text-${key}`,
+                type: coding_agent_adapter_1.MessagePartType.TEXT,
+                role: coding_agent_adapter_1.MessageRole.ASSISTANT,
+                text,
+                update: true
+            });
+        }
+        else if (update.type === 'thinking_delta') {
+            const text = (session.reasoningByBlock.get(key) || '') + String(update.delta || '');
+            session.reasoningByBlock.set(key, text);
+            session.parts.push({
+                id: `pi-reasoning-${key}`,
+                type: coding_agent_adapter_1.MessagePartType.REASONING,
+                role: coding_agent_adapter_1.MessageRole.ASSISTANT,
+                text,
+                update: true
+            });
+        }
+        else if (update.type === 'thinking_end') {
+            const text = String(update.content ??
+                update.thinking ??
+                session.reasoningByBlock.get(key) ??
+                '');
+            session.reasoningByBlock.set(key, text);
+            session.parts.push({
+                id: `pi-reasoning-${key}`,
+                type: coding_agent_adapter_1.MessagePartType.REASONING,
+                role: coding_agent_adapter_1.MessageRole.ASSISTANT,
+                text,
+                update: true
+            });
+        }
+    }
+    reconcileAssistantMessage(session, message) {
+        if (message?.role !== 'assistant')
+            return;
+        const blocks = typeof message.content === 'string'
+            ? [{ type: 'text', text: message.content }]
+            : Array.isArray(message.content)
+                ? message.content
+                : [];
+        blocks.forEach((block, index) => {
+            const key = `${session.projectionId}:${session.turn}:${session.assistantMessageOrdinal}:${index}`;
+            if (block.type === 'text') {
+                const text = String(block.text ?? '');
+                session.textByBlock.set(key, text);
+                session.parts.push({
+                    id: `pi-text-${key}`,
+                    type: coding_agent_adapter_1.MessagePartType.TEXT,
+                    role: coding_agent_adapter_1.MessageRole.ASSISTANT,
+                    text,
+                    update: true
+                });
+            }
+            else if (block.type === 'thinking') {
+                const text = String(block.thinking ?? '');
+                session.reasoningByBlock.set(key, text);
+                session.parts.push({
+                    id: `pi-reasoning-${key}`,
+                    type: coding_agent_adapter_1.MessagePartType.REASONING,
+                    role: coding_agent_adapter_1.MessageRole.ASSISTANT,
+                    text,
+                    update: true
+                });
+            }
+        });
+    }
+    handleToolEvent(session, event, status) {
+        const id = String(event.toolCallId || (0, crypto_1.randomUUID)());
+        const existing = session.toolParts.get(id);
+        const output = resultText(event.result ?? event.partialResult);
+        const tool = {
+            name: String(event.toolName || existing?.tool?.name || 'tool'),
+            status,
+            input: event.args ?? existing?.tool?.input,
+            output: output || existing?.tool?.output,
+            error: status === 'error' ? output || 'Tool failed' : undefined
+        };
+        const part = {
+            id: `pi-tool-${id}`,
+            type: coding_agent_adapter_1.MessagePartType.TOOL,
+            tool,
+            update: !!existing
+        };
+        session.toolParts.set(id, part);
+        session.parts.push(part);
+    }
+    command(session, command) {
+        if (session.process.exitCode !== null || !session.process.stdin.writable) {
+            return Promise.reject(new Error('Pi process is not running'));
+        }
+        const id = (0, crypto_1.randomUUID)();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                session.pending.delete(id);
+                reject(new Error(`Pi RPC command timed out: ${String(command.type)}`));
+            }, RPC_TIMEOUT_MS);
+            session.pending.set(id, { resolve, reject, timer });
+            session.process.stdin.write(`${JSON.stringify({ ...command, id })}\n`, (error) => {
+                if (!error)
+                    return;
+                clearTimeout(timer);
+                session.pending.delete(id);
+                reject(error);
+            });
+        });
+    }
+    sendRecord(session, record) {
+        if (session.process.exitCode !== null || !session.process.stdin.writable) {
+            throw new Error('Pi process is not running');
+        }
+        session.process.stdin.write(`${JSON.stringify(record)}\n`, (error) => {
+            if (!error)
+                return;
+            session.status = 'error';
+            session.lastError = error.message;
+            this.onDataAvailable?.(session.id);
+        });
+    }
+    async sendPrompt(sessionId, parts, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session not found: ${sessionId}`);
+        const message = parts
+            .filter((part) => part.type === coding_agent_adapter_1.MessagePartType.TEXT && part.text)
+            .map((part) => part.text)
+            .join('\n');
+        if (!message)
+            throw new Error('No text content in prompt parts');
+        const wasBusy = session.status === 'busy';
+        session.status = 'busy';
+        session.lastError = null;
+        session.sawAgentActivity = false;
+        session.promptMayBeCommandOnly = message.trimStart().startsWith('/');
+        this.sendRecord(session, {
+            type: 'prompt',
+            message,
+            // A message sent from the task composer while Pi is already running is
+            // user steering, not deferred work. Pi delivers `steer` after the current
+            // tool finishes and before the next model call; `followUp` would wait for
+            // the whole run to settle and lets a misdirected turn continue unchecked.
+            ...(wasBusy ? { streamingBehavior: 'steer' } : {})
+        });
+    }
+    /**
+     * THE LONG-TURNS SOFT WARNING'S DELIVERY MECHANISM.
+     *
+     * Reuses exactly the `streamingBehavior: 'steer'` path `sendPrompt` already
+     * takes for a message sent while Pi is busy — Pi delivers it after the
+     * current tool finishes and before the next model call. Deliberately does
+     * NOT touch `session.status`/`sawAgentActivity`/`promptMayBeCommandOnly`:
+     * those are `sendPrompt`'s own bookkeeping for a NEW prompt, and a steer
+     * into an already-running turn must not reset them.
+     */
+    async steerTurn(sessionId, text, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session || session.status !== 'busy' || !text) {
+            return false;
+        }
+        try {
+            this.sendRecord(session, {
+                type: 'prompt',
+                message: text,
+                streamingBehavior: 'steer'
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getStatus(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return { type: coding_agent_adapter_1.SessionStatusType.ERROR, message: 'Session not found' };
+        // Some providers end the model stream with stopReason=error but omit the
+        // final agent_settled event. Confirm Pi is no longer streaming so that a
+        // terminal provider error cannot leave the task BUSY forever. A retry keeps
+        // isStreaming=true (and auto_retry_start clears/replaces the pending error).
+        if (session.pendingTurnError &&
+            session.pendingTurnErrorMonotonicTime !== null &&
+            performance.now() - session.pendingTurnErrorMonotonicTime >=
+                TERMINAL_ERROR_SETTLE_GRACE_MS &&
+            session.status === 'busy') {
+            try {
+                const state = await this.command(session, { type: 'get_state' });
+                const pendingMessageCount = typeof state.data?.pendingMessageCount === 'number'
+                    ? state.data.pendingMessageCount
+                    : 0;
+                if (state.data?.isStreaming !== true && pendingMessageCount === 0) {
+                    this.settlePendingTurnError(session);
+                }
+            }
+            catch {
+                // Keep polling; process exit/error handling remains authoritative.
+            }
+        }
+        if (session.lastError)
+            return { type: coding_agent_adapter_1.SessionStatusType.ERROR, message: session.lastError };
+        if (session.pendingUiRequests.size > 0) {
+            return {
+                type: coding_agent_adapter_1.SessionStatusType.WAITING_APPROVAL,
+                message: 'Pi is waiting for input'
+            };
+        }
+        return {
+            type: session.status === 'busy'
+                ? coding_agent_adapter_1.SessionStatusType.BUSY
+                : coding_agent_adapter_1.SessionStatusType.IDLE
+        };
+    }
+    settlePendingTurnError(session) {
+        if (!session.pendingTurnError)
+            return;
+        const error = withProviderNameLimitHint(session.pendingTurnError);
+        session.pendingTurnError = null;
+        session.pendingTurnErrorMonotonicTime = null;
+        session.lastError = error;
+        session.status = 'error';
+        session.parts.push({
+            id: `pi-error-${session.projectionId}:${session.turn}`,
+            type: coding_agent_adapter_1.MessagePartType.ERROR,
+            text: error
+        });
+    }
+    async pollMessages(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return [];
+        return session.parts.splice(0);
+    }
+    getPendingApproval(sessionId) {
+        const session = this.sessions.get(sessionId);
+        const request = session
+            ? Array.from(session.pendingUiRequests.values()).find((item) => item.method === 'confirm')
+            : undefined;
+        if (!request)
+            return null;
+        return {
+            requestId: request.id,
+            toolCallId: request.id,
+            question: [request.title, request.message].filter(Boolean).join('\n\n'),
+            options: [
+                { optionId: 'approved', name: 'Yes', kind: 'allow_once' },
+                { optionId: 'abort', name: 'No', kind: 'reject_once' }
+            ]
+        };
+    }
+    async respondToApproval(sessionId, approved, _optionId, requestId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session not found: ${sessionId}`);
+        const request = requestId
+            ? session.pendingUiRequests.get(requestId)
+            : Array.from(session.pendingUiRequests.values()).find((item) => item.method === 'confirm');
+        if (request?.method !== 'confirm')
+            return false;
+        this.sendRecord(session, {
+            type: 'extension_ui_response',
+            id: request.id,
+            confirmed: approved
+        });
+        session.pendingUiRequests.delete(request.id);
+        session.parts.push({
+            id: `question-${request.id}`,
+            type: coding_agent_adapter_1.MessagePartType.QUESTION,
+            update: true,
+            tool: {
+                name: 'permission',
+                status: approved ? 'completed' : 'cancelled',
+                requestId: request.id,
+                output: approved ? 'Approved' : 'Declined'
+            }
+        });
+        session.status = 'busy';
+        this.onDataAvailable?.(session.id);
+        return true;
+    }
+    async respondToQuestion(sessionId, answers, _config, requestId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session not found: ${sessionId}`);
+        // The runner receives the transcript part id (`pi-question-<requestId>`),
+        // while Pi's JSONL protocol addresses the underlying request id. Accept
+        // either form so a stale card can never fall through to a newer request.
+        const piRequestId = requestId?.startsWith('pi-question-')
+            ? requestId.slice('pi-question-'.length)
+            : requestId;
+        const request = piRequestId
+            ? session.pendingUiRequests.get(piRequestId)
+            : Array.from(session.pendingUiRequests.values()).find((item) => item.method !== 'confirm');
+        // A restored transcript or another client can submit a response after Pi
+        // has already consumed the request. Treat that response as stale.
+        if (!request || request.method === 'confirm') {
+            if (!request && piRequestId) {
+                return {
+                    handled: false,
+                    resolutionPart: {
+                        id: `pi-question-${piRequestId}`,
+                        type: coding_agent_adapter_1.MessagePartType.QUESTION,
+                        update: true,
+                        tool: {
+                            name: 'question',
+                            status: 'cancelled',
+                            requestId: piRequestId,
+                            output: 'This request expired when the session ended. Restart the turn to continue.'
+                        }
+                    }
+                };
+            }
+            return false;
+        }
+        const value = answers[request.title] ??
+            answers[request.message] ??
+            answers.answer ??
+            Object.values(answers)[0] ??
+            '';
+        this.sendRecord(session, {
+            type: 'extension_ui_response',
+            id: request.id,
+            value
+        });
+        session.pendingUiRequests.delete(request.id);
+        session.parts.push({
+            id: `pi-question-${request.id}`,
+            type: coding_agent_adapter_1.MessagePartType.QUESTION,
+            update: true,
+            tool: {
+                name: 'question',
+                status: 'completed',
+                title: request.title,
+                requestId: request.id,
+                output: value
+            }
+        });
+        session.status = 'busy';
+        this.onDataAvailable?.(session.id);
+        return true;
+    }
+    async getRunningTools(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return [];
+        return Array.from(session.toolParts.values()).flatMap((part) => {
+            if (part.tool?.status !== 'running')
+                return [];
+            return [
+                {
+                    partId: part.id || `pi-tool-${part.tool.name}`,
+                    toolName: part.tool.name,
+                    ...(part.tool.input && typeof part.tool.input === 'object'
+                        ? { input: part.tool.input }
+                        : {})
+                }
+            ];
+        });
+    }
+    convertMessages(messages) {
+        return messages.flatMap((message, index) => {
+            if (message.role !== 'user' && message.role !== 'assistant')
+                return [];
+            const text = textFromContent(message.content);
+            if (!text)
+                return [];
+            return [
+                {
+                    id: `pi-history-${message.timestamp ?? index}`,
+                    role: message.role === 'user' ? coding_agent_adapter_1.MessageRole.USER : coding_agent_adapter_1.MessageRole.ASSISTANT,
+                    parts: [
+                        {
+                            id: `pi-history-part-${message.timestamp ?? index}`,
+                            type: coding_agent_adapter_1.MessagePartType.TEXT,
+                            text
+                        }
+                    ]
+                }
+            ];
+        });
+    }
+    async getAllMessages(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return [];
+        try {
+            const response = await this.command(session, { type: 'get_messages' });
+            const messages = Array.isArray(response.data?.messages)
+                ? response.data.messages
+                : [];
+            session.allMessages = this.convertMessages(messages);
+        }
+        catch {
+            // Use the last successful snapshot when the process has already ended.
+        }
+        return session.allMessages;
+    }
+    async abortPrompt(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        this.cancelPendingUiRequests(session, 'This request was cancelled when the turn stopped.', true);
+        await this.command(session, { type: 'clear_queue' }).catch(() => undefined);
+        await this.command(session, { type: 'abort' });
+        session.status = 'idle';
+    }
+    async terminateProcess(session) {
+        session.closing = true;
+        if (session.process.exitCode !== null || !session.process.pid)
+            return;
+        if (process.platform === 'win32') {
+            await execFileAsync('taskkill', ['/PID', String(session.process.pid), '/T', '/F'], {
+                timeout: 5_000,
+                windowsHide: true
+            }).catch(() => session.process.kill());
+            return;
+        }
+        const processGroup = -session.process.pid;
+        try {
+            process.kill(processGroup, 'SIGTERM');
+        }
+        catch {
+            session.process.kill();
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1_000));
+        if (session.process.exitCode !== null)
+            return;
+        try {
+            process.kill(processGroup, 'SIGKILL');
+        }
+        catch {
+            // The process group exited during the grace period.
+        }
+    }
+    async destroySession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        for (const request of session.pendingUiRequests.values()) {
+            try {
+                this.sendRecord(session, {
+                    type: 'extension_ui_response',
+                    id: request.id,
+                    cancelled: true
+                });
+            }
+            catch {
+                break;
+            }
+        }
+        session.pendingUiRequests.clear();
+        await this.terminateProcess(session);
+        this.sessions.delete(sessionId);
+        if (session.mcpConfigPath && (0, fs_1.existsSync)(session.mcpConfigPath)) {
+            (0, fs_1.unlinkSync)(session.mcpConfigPath);
+        }
+        if (session.skillDirectory && (0, fs_1.existsSync)(session.skillDirectory)) {
+            (0, fs_1.rmSync)(session.skillDirectory, { recursive: true, force: true });
+        }
+    }
+    /**
+     * SessionRunner creates one adapter per turn. Stop every process owned by
+     * this adapter after the turn while leaving Pi's session files intact for
+     * native resume on the next turn.
+     */
+    async stopServer() {
+        for (const sessionId of Array.from(this.sessions.keys())) {
+            await this.destroySession(sessionId);
+        }
+    }
+    async registerMcpServer(_serverName, _mcpConfig, _workspaceDir) {
+        // MCP servers are supplied per process through pi-mcp-adapter.
+    }
+    async checkHealth() {
+        try {
+            const executable = await this.findPiExecutable();
+            const invocation = this.piInvocation(executable, ['--version'], {
+                ...process.env
+            });
+            const { stdout, stderr } = await execFileAsync(invocation.command, invocation.args, {
+                env: invocation.env,
+                timeout: 10_000,
+                shell: invocation.shell,
+                windowsHide: true
+            });
+            const match = `${stdout}\n${stderr}`.match(/(\d+)\.(\d+)\.(\d+)/);
+            if (!match)
+                return {
+                    available: false,
+                    reason: 'Could not determine the Pi version'
+                };
+            const installed = match.slice(1, 4).map(Number);
+            for (let index = 0; index < MINIMUM_PI_VERSION.length; index++) {
+                if (installed[index] > MINIMUM_PI_VERSION[index])
+                    break;
+                if (installed[index] < MINIMUM_PI_VERSION[index]) {
+                    return {
+                        available: false,
+                        reason: `Pi ${MINIMUM_PI_VERSION.join('.')} or newer is required`
+                    };
+                }
+            }
+            return { available: true };
+        }
+        catch (error) {
+            return {
+                available: false,
+                reason: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async getProviders(_serverUrl, directory) {
+        const executable = await this.findPiExecutable();
+        const gateway = this.installPeakfloGateway();
+        const config = {
+            agentId: 'pi-discovery',
+            taskId: 'pi-discovery',
+            workspaceDir: directory || process.cwd(),
+            permissionMode: 'allow'
+        };
+        const invocation = this.piInvocation(executable, ['--mode', 'rpc', '--no-session', '--approve'], this.processEnv(config, gateway));
+        const child = (0, child_process_1.spawn)(invocation.command, invocation.args, {
+            cwd: config.workspaceDir,
+            env: invocation.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+            shell: invocation.shell,
+            detached: process.platform !== 'win32'
+        });
+        const session = this.createSessionState(`pi-discovery-${(0, crypto_1.randomUUID)()}`, child, config);
+        this.attachProcess(session);
+        try {
+            const [state, available] = await Promise.all([
+                this.command(session, { type: 'get_state' }),
+                this.command(session, { type: 'get_available_models' })
+            ]);
+            const models = Array.isArray(available.data?.models)
+                ? available.data.models
+                : [];
+            const providers = new Map();
+            for (const model of models) {
+                if (!model || typeof model !== 'object')
+                    continue;
+                const record = model;
+                if (typeof record.provider !== 'string' ||
+                    typeof record.id !== 'string')
+                    continue;
+                const provider = providers.get(record.provider) ?? {
+                    id: record.provider,
+                    name: record.provider === model_gateway_1.ENTERPRISE_AI_GATEWAY_PROVIDER_ID
+                        ? model_gateway_1.ENTERPRISE_AI_GATEWAY_PROVIDER_NAME
+                        : record.provider,
+                    models: []
+                };
+                if (!provider.models.some((item) => item.id === record.id)) {
+                    provider.models.push({
+                        id: record.id,
+                        name: typeof record.name === 'string' ? record.name : record.id
+                    });
+                }
+                providers.set(record.provider, provider);
+            }
+            const defaultModel = state.data?.model;
+            const defaultProvider = defaultModel && typeof defaultModel === 'object'
+                ? defaultModel.provider
+                : undefined;
+            const defaultModelId = defaultModel && typeof defaultModel === 'object'
+                ? defaultModel.id
+                : undefined;
+            return {
+                providers: Array.from(providers.values()),
+                default: typeof defaultProvider === 'string' &&
+                    typeof defaultModelId === 'string'
+                    ? { [defaultProvider]: defaultModelId }
+                    : {}
+            };
+        }
+        catch (error) {
+            if (!gateway)
+                throw error;
+            return {
+                providers: [
+                    {
+                        id: model_gateway_1.ENTERPRISE_AI_GATEWAY_PROVIDER_ID,
+                        name: model_gateway_1.ENTERPRISE_AI_GATEWAY_PROVIDER_NAME,
+                        models: gateway.providerModels
+                    }
+                ],
+                default: {}
+            };
+        }
+        finally {
+            await this.terminateProcess(session);
+        }
+    }
+}
+exports.PiAdapter = PiAdapter;