@agent-link/agent 0.1.323 → 0.1.325

package/dist/pi.js

@@ -0,0 +1,1742 @@
+/**
+ * Persistent PI RPC driver and PI-owned session history operations.
+ *
+ * PI is intentionally integrated through its public JSONL RPC protocol and
+ * session file format. No PI runtime package is imported by AgentLink.
+ */
+import { randomUUID } from 'crypto';
+import { spawn } from 'child_process';
+import { appendFileSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, } from 'fs';
+import { homedir, platform } from 'os';
+import { basename, isAbsolute, join, relative, resolve, } from 'path';
+import { StringDecoder } from 'string_decoder';
+import { piCapabilities, } from './backends/types.js';
+import { CONFIG_DIR } from './config.js';
+import { getCleanEnv, resetCachedExecutablePath, resolveWindowsNpmWrapper, } from './sdk.js';
+import { getProvider, resolveProviderCommand } from './providers.js';
+const conversations = new Map();
+const sendFns = new Set();
+const THINKING_LEVELS = new Set(['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
+const MODEL_PART_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/;
+const SESSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*[A-Za-z0-9]$|^[A-Za-z0-9]$/;
+const MIME_PATTERN = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i;
+const IMAGE_MIME_PATTERN = /^image\/(?:png|jpeg|gif|webp)$/i;
+const TURN_HEARTBEAT_INTERVAL_MS = 15_000;
+const RPC_TIMEOUT_MS = 30_000;
+const ABORT_TIMEOUT_MS = 5_000;
+const MAX_STDERR_CHARS = 64 * 1024;
+const MAX_ATTACHMENTS = 5;
+const MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+const PI_SESSION_LIST_LIMIT = 150;
+const ATTACHMENT_DIR = join(CONFIG_DIR, 'tmp-attachments', 'pi');
+function sendFn(message) {
+    for (const fn of sendFns) {
+        try {
+            fn(message);
+        }
+        catch { /* subscriber failures are isolated */ }
+    }
+}
+export function addPiSendFn(fn) {
+    sendFns.add(fn);
+    return () => { sendFns.delete(fn); };
+}
+function generateTurnId() {
+    return `turn_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function sessionRef(sessionId) {
+    return {
+        backendType: 'pi',
+        backendSessionId: sessionId,
+        backendThreadId: sessionId,
+        providerSessionId: sessionId || null,
+    };
+}
+function createState(conversationId, workDir, providerId = 'pi') {
+    return {
+        conversationId,
+        child: null,
+        childProviderId: null,
+        piSessionId: null,
+        lastPiSessionId: null,
+        sessionFile: null,
+        workDir,
+        providerId,
+        turnActive: false,
+        turnId: null,
+        stateVersion: 0,
+        heartbeatTimer: null,
+        model: null,
+        thinking: null,
+        availableModels: [],
+        sessionNotified: false,
+        cancelRequested: false,
+        protocolFailed: false,
+        stderrBuffer: '',
+        pendingRpc: new Map(),
+        attachmentPaths: new Set(),
+        turnAttachmentPaths: new Map(),
+        launching: null,
+        setupPromise: null,
+    };
+}
+export function getPiConversation(conversationId) {
+    return conversations.get(conversationId);
+}
+export function getPiConversations() {
+    return conversations;
+}
+export function createPiPlaceholder(conversationId, options = {}) {
+    if (conversations.has(conversationId))
+        return;
+    conversations.set(conversationId, createState(conversationId, options.workDir || process.cwd(), options.providerId || 'pi'));
+}
+export function rebindPiConversation(piSessionId, newConversationId, providerId = 'pi', workDir) {
+    for (const [oldConversationId, state] of conversations) {
+        if ((state.piSessionId === piSessionId || state.lastPiSessionId === piSessionId)
+            && state.providerId === providerId
+            && (!workDir || normalizePathForCompare(state.workDir) === normalizePathForCompare(workDir))
+            && oldConversationId !== newConversationId) {
+            const displaced = conversations.get(newConversationId);
+            if (displaced && displaced !== state)
+                cleanupPiConversation(newConversationId);
+            conversations.delete(oldConversationId);
+            state.conversationId = newConversationId;
+            conversations.set(newConversationId, state);
+            return true;
+        }
+    }
+    return false;
+}
+function startPiTurn(state) {
+    state.turnActive = true;
+    state.cancelRequested = false;
+    state.lastUsage = undefined;
+    state.turnId = generateTurnId();
+    state.stateVersion++;
+    sendFn({
+        type: 'turn_started',
+        conversationId: state.conversationId,
+        claudeSessionId: state.piSessionId,
+        turnId: state.turnId,
+        stateVersion: state.stateVersion,
+    });
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        event: {
+            type: 'turn_started',
+            session: sessionRef(state.piSessionId || 'pending'),
+            turnId: state.turnId,
+        },
+    });
+    if (!state.heartbeatTimer) {
+        state.heartbeatTimer = setInterval(() => {
+            if (!state.turnActive) {
+                if (state.heartbeatTimer)
+                    clearInterval(state.heartbeatTimer);
+                state.heartbeatTimer = null;
+                return;
+            }
+            sendFn({
+                type: 'turn_heartbeat',
+                conversationId: state.conversationId,
+                claudeSessionId: state.piSessionId,
+                turnId: state.turnId,
+                stateVersion: state.stateVersion,
+                phase: 'running',
+                lastActivityAt: Date.now(),
+            });
+        }, TURN_HEARTBEAT_INTERVAL_MS);
+    }
+}
+function cleanPiAttachments(state, turnId) {
+    const paths = turnId
+        ? state.turnAttachmentPaths.get(turnId) || new Set()
+        : state.attachmentPaths;
+    for (const filePath of paths) {
+        try {
+            rmSync(filePath, { force: true });
+        }
+        catch { /* best effort */ }
+        state.attachmentPaths.delete(filePath);
+    }
+    if (turnId)
+        state.turnAttachmentPaths.delete(turnId);
+    else
+        state.turnAttachmentPaths.clear();
+    try {
+        if (existsSync(ATTACHMENT_DIR) && readdirSync(ATTACHMENT_DIR).length === 0) {
+            rmSync(ATTACHMENT_DIR, { force: true });
+        }
+    }
+    catch { /* best effort */ }
+}
+function finishPiTurn(state, outcome) {
+    if (!state.turnActive)
+        return;
+    state.turnActive = false;
+    state.stateVersion++;
+    if (state.heartbeatTimer) {
+        clearInterval(state.heartbeatTimer);
+        state.heartbeatTimer = null;
+    }
+    cleanPiAttachments(state, state.turnId);
+    const ref = sessionRef(state.piSessionId || '');
+    if (outcome === 'cancelled') {
+        sendFn({
+            type: 'backend_event',
+            conversationId: state.conversationId,
+            event: { type: 'turn_cancelled', session: ref },
+        });
+        sendFn({
+            type: 'execution_cancelled',
+            conversationId: state.conversationId,
+            claudeSessionId: state.piSessionId,
+            turnId: state.turnId,
+            stateVersion: state.stateVersion,
+        });
+    }
+    else {
+        sendFn({
+            type: 'backend_event',
+            conversationId: state.conversationId,
+            event: {
+                type: 'turn_completed',
+                session: ref,
+                ...(state.lastUsage ? { usage: state.lastUsage } : {}),
+            },
+        });
+        sendFn({
+            type: 'turn_completed',
+            conversationId: state.conversationId,
+            workDir: state.workDir,
+            claudeSessionId: state.piSessionId,
+            turnId: state.turnId,
+            stateVersion: state.stateVersion,
+            ...(state.lastUsage ? { usage: state.lastUsage } : {}),
+        });
+    }
+    state.cancelRequested = false;
+}
+function emitPiError(state, message) {
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        event: {
+            type: 'error',
+            ...(state.piSessionId ? { session: sessionRef(state.piSessionId) } : {}),
+            message,
+        },
+    });
+}
+function failPiTurn(state, message) {
+    emitPiError(state, message);
+    finishPiTurn(state, 'completed');
+}
+function appendBoundedDiagnostics(state, chunk) {
+    state.stderrBuffer = (state.stderrBuffer + chunk).slice(-MAX_STDERR_CHARS);
+}
+function rejectPendingRpc(state, error) {
+    for (const pending of state.pendingRpc.values()) {
+        clearTimeout(pending.timer);
+        pending.reject(error);
+    }
+    state.pendingRpc.clear();
+}
+function terminatePiChild(state) {
+    const child = state.child;
+    state.child = null;
+    state.childProviderId = null;
+    rejectPendingRpc(state, new Error('PI RPC process was terminated'));
+    if (!child)
+        return;
+    try {
+        child.stdin?.end();
+    }
+    catch { /* already closed */ }
+    try {
+        child.kill('SIGTERM');
+    }
+    catch { /* already exited */ }
+}
+function protocolFailure(state, message) {
+    if (state.protocolFailed)
+        return;
+    state.protocolFailed = true;
+    const error = new Error(`PI RPC protocol error: ${message}`);
+    rejectPendingRpc(state, error);
+    if (state.turnActive)
+        failPiTurn(state, error.message);
+    else
+        emitPiError(state, error.message);
+    terminatePiChild(state);
+}
+function sendRpcCommand(state, command, timeoutMs = RPC_TIMEOUT_MS) {
+    const child = state.child;
+    if (!child?.stdin || child.stdin.destroyed) {
+        return Promise.reject(new Error('PI RPC process is not available'));
+    }
+    const id = `agentlink-${randomUUID()}`;
+    return new Promise((resolveResponse, rejectResponse) => {
+        const timer = setTimeout(() => {
+            state.pendingRpc.delete(id);
+            rejectResponse(new Error(`PI RPC ${command.type} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref?.();
+        state.pendingRpc.set(id, {
+            command: command.type,
+            resolve: resolveResponse,
+            reject: rejectResponse,
+            timer,
+        });
+        try {
+            child.stdin.write(`${JSON.stringify({ ...command, id })}\n`, 'utf8', (error) => {
+                if (!error)
+                    return;
+                const pending = state.pendingRpc.get(id);
+                if (!pending)
+                    return;
+                clearTimeout(pending.timer);
+                state.pendingRpc.delete(id);
+                pending.reject(error);
+            });
+        }
+        catch (error) {
+            const pending = state.pendingRpc.get(id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                state.pendingRpc.delete(id);
+            }
+            rejectResponse(error);
+        }
+    });
+}
+function writeRpcRecord(state, record) {
+    const stdin = state.child?.stdin;
+    if (!stdin || stdin.destroyed)
+        return;
+    try {
+        stdin.write(`${JSON.stringify(record)}\n`, 'utf8');
+    }
+    catch { /* process exit handles failure */ }
+}
+function handleRpcResponse(state, record) {
+    const id = record.id;
+    const command = record.command;
+    if (typeof id !== 'string' || typeof command !== 'string' || typeof record.success !== 'boolean') {
+        protocolFailure(state, 'malformed response record');
+        return;
+    }
+    const pending = state.pendingRpc.get(id);
+    if (!pending) {
+        protocolFailure(state, `unexpected response id ${id}`);
+        return;
+    }
+    if (pending.command !== command) {
+        protocolFailure(state, `response command mismatch for ${id}`);
+        return;
+    }
+    clearTimeout(pending.timer);
+    state.pendingRpc.delete(id);
+    if (record.success) {
+        pending.resolve(record);
+    }
+    else {
+        pending.reject(new Error(typeof record.error === 'string' ? record.error : `PI RPC ${command} failed`));
+    }
+}
+function numberOrUndefined(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function usageFromAssistantMessage(state, message) {
+    const usage = asRecord(message.usage);
+    if (!usage)
+        return undefined;
+    const cost = asRecord(usage.cost);
+    return {
+        provider: 'pi',
+        model: state.model || (typeof message.provider === 'string' && typeof message.model === 'string'
+            ? `${message.provider}/${message.model}`
+            : undefined),
+        inputTokens: numberOrUndefined(usage.input),
+        outputTokens: numberOrUndefined(usage.output),
+        cacheReadInputTokens: numberOrUndefined(usage.cacheRead),
+        cacheCreationInputTokens: numberOrUndefined(usage.cacheWrite),
+        totalCostUsd: numberOrUndefined(cost?.total),
+    };
+}
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function textValue(value) {
+    return typeof value === 'string' ? value : '';
+}
+function handlePiEvent(state, event) {
+    const eventType = textValue(event.type);
+    const ref = sessionRef(state.piSessionId || 'pending');
+    switch (eventType) {
+        case 'message_update': {
+            const update = asRecord(event.assistantMessageEvent);
+            if (!update || typeof update.type !== 'string') {
+                protocolFailure(state, 'message_update is missing assistantMessageEvent');
+                return;
+            }
+            if (update.type === 'text_delta' || update.type === 'thinking_delta') {
+                if (typeof update.delta !== 'string') {
+                    protocolFailure(state, `${update.type} is missing delta`);
+                    return;
+                }
+                sendFn({
+                    type: 'backend_event',
+                    conversationId: state.conversationId,
+                    event: {
+                        type: update.type === 'text_delta' ? 'text_delta' : 'reasoning_delta',
+                        session: ref,
+                        text: update.delta,
+                    },
+                });
+            }
+            break;
+        }
+        case 'message_end': {
+            const message = asRecord(event.message);
+            if (message?.role === 'assistant') {
+                const usage = usageFromAssistantMessage(state, message);
+                if (usage) {
+                    state.lastUsage = usage;
+                    sendFn({
+                        type: 'backend_event',
+                        conversationId: state.conversationId,
+                        event: { type: 'usage_update', session: ref, usage },
+                    });
+                }
+                if (message.stopReason === 'error' || (typeof message.errorMessage === 'string' && message.errorMessage)) {
+                    emitPiError(state, textValue(message.errorMessage) || 'PI assistant response failed');
+                }
+            }
+            else if (message?.role === 'bashExecution') {
+                sendFn({
+                    type: 'backend_event',
+                    conversationId: state.conversationId,
+                    event: {
+                        type: 'process_exited',
+                        session: ref,
+                        processId: textValue(message.id) || 'pi-bash',
+                        exitCode: numberOrUndefined(message.exitCode) ?? (message.cancelled === true ? -1 : 0),
+                    },
+                });
+            }
+            break;
+        }
+        case 'tool_execution_start': {
+            const id = textValue(event.toolCallId);
+            const name = textValue(event.toolName);
+            if (!id || !name) {
+                protocolFailure(state, 'tool_execution_start is missing tool identity');
+                return;
+            }
+            sendFn({
+                type: 'backend_event',
+                conversationId: state.conversationId,
+                event: {
+                    type: 'tool_started',
+                    session: ref,
+                    tool: { id, name, itemKind: name, input: event.args, status: 'in_progress' },
+                },
+            });
+            break;
+        }
+        case 'tool_execution_update': {
+            const id = textValue(event.toolCallId);
+            const name = textValue(event.toolName);
+            if (!id || !name) {
+                protocolFailure(state, 'tool_execution_update is missing tool identity');
+                return;
+            }
+            sendFn({
+                type: 'backend_event',
+                conversationId: state.conversationId,
+                event: {
+                    type: 'tool_updated',
+                    session: ref,
+                    tool: { id, name, itemKind: name, input: event.args, output: event.partialResult, status: 'in_progress' },
+                },
+            });
+            break;
+        }
+        case 'tool_execution_end': {
+            const id = textValue(event.toolCallId);
+            const name = textValue(event.toolName);
+            if (!id || !name) {
+                protocolFailure(state, 'tool_execution_end is missing tool identity');
+                return;
+            }
+            sendFn({
+                type: 'backend_event',
+                conversationId: state.conversationId,
+                event: {
+                    type: 'tool_completed',
+                    session: ref,
+                    tool: {
+                        id,
+                        name,
+                        itemKind: name,
+                        output: event.result,
+                        isError: event.isError === true,
+                        status: event.isError === true ? 'error' : 'completed',
+                    },
+                },
+            });
+            break;
+        }
+        case 'bash_execution_update': {
+            const delta = textValue(event.delta);
+            if (delta) {
+                sendFn({
+                    type: 'backend_event',
+                    conversationId: state.conversationId,
+                    event: {
+                        type: 'process_output',
+                        session: ref,
+                        processId: textValue(event.id) || 'pi-bash',
+                        chunk: delta,
+                    },
+                });
+            }
+            break;
+        }
+        case 'compaction_start':
+            sendFn({
+                type: 'backend_event',
+                conversationId: state.conversationId,
+                event: { type: 'compact_started', session: ref },
+            });
+            break;
+        case 'compaction_end':
+            sendFn({
+                type: 'backend_event',
+                conversationId: state.conversationId,
+                event: { type: 'compact_completed', session: ref },
+            });
+            if (typeof event.errorMessage === 'string' && event.errorMessage) {
+                emitPiError(state, event.errorMessage);
+            }
+            break;
+        case 'extension_error':
+            emitPiError(state, textValue(event.error) || `PI extension failed${event.extensionPath ? `: ${event.extensionPath}` : ''}`);
+            break;
+        case 'agent_settled':
+            finishPiTurn(state, state.cancelRequested ? 'cancelled' : 'completed');
+            break;
+        case 'thinking_level_changed': {
+            const effectiveLevel = textValue(event.level || event.thinkingLevel);
+            if (THINKING_LEVELS.has(effectiveLevel)) {
+                state.thinking = effectiveLevel;
+            }
+            break;
+        }
+        // These are valid informational/state events and need no wire translation.
+        case 'agent_start':
+        case 'agent_end':
+        case 'turn_start':
+        case 'turn_end':
+        case 'message_start':
+        case 'entry_appended':
+        case 'queue_update':
+        case 'session_info_changed':
+        case 'auto_retry_start':
+        case 'auto_retry_end':
+        case 'summarization_retry_scheduled':
+        case 'summarization_retry_attempt_start':
+        case 'summarization_retry_finished':
+            break;
+        case 'extension_ui_request':
+            if (typeof event.id === 'string'
+                && ['select', 'confirm', 'input', 'editor'].includes(textValue(event.method))) {
+                writeRpcRecord(state, {
+                    type: 'extension_ui_response',
+                    id: event.id,
+                    cancelled: true,
+                });
+            }
+            break;
+        default:
+            // Extensions can add informational events. Unknown records remain isolated.
+            break;
+    }
+}
+function handlePiRecord(state, value) {
+    const record = asRecord(value);
+    if (!record || typeof record.type !== 'string') {
+        protocolFailure(state, 'record must be a JSON object with a type');
+        return;
+    }
+    if (record.type === 'response')
+        handleRpcResponse(state, record);
+    else
+        handlePiEvent(state, record);
+}
+function attachStrictJsonlReader(state, child) {
+    const decoder = new StringDecoder('utf8');
+    let pending = '';
+    child.stdout?.on('data', (chunk) => {
+        if (state.child !== child || state.protocolFailed)
+            return;
+        pending += typeof chunk === 'string' ? chunk : decoder.write(chunk);
+        let newlineIndex = pending.indexOf('\n');
+        while (newlineIndex !== -1) {
+            const line = pending.slice(0, newlineIndex);
+            pending = pending.slice(newlineIndex + 1);
+            if (line.trim()) {
+                try {
+                    handlePiRecord(state, JSON.parse(line));
+                }
+                catch (error) {
+                    protocolFailure(state, `malformed JSONL record: ${error.message}`);
+                    return;
+                }
+            }
+            newlineIndex = pending.indexOf('\n');
+        }
+    });
+    child.stdout?.on('end', () => {
+        if (state.child !== child || state.protocolFailed)
+            return;
+        pending += decoder.end();
+        if (pending.trim())
+            protocolFailure(state, 'stdout ended with an unterminated record');
+    });
+}
+function directSpawnCommand(command, prefixArgs) {
+    const direct = resolveWindowsNpmWrapper(command);
+    if (direct) {
+        return { command: direct.command, args: [...direct.prefixArgs, ...prefixArgs] };
+    }
+    if (platform() === 'win32' && command.toLowerCase().endsWith('.cmd')) {
+        return {
+            command: process.env.COMSPEC || 'C:\\Windows\\system32\\cmd.exe',
+            args: ['/d', '/s', '/c', command, ...prefixArgs],
+        };
+    }
+    return { command, args: prefixArgs };
+}
+async function launchPiProcess(state) {
+    if (state.launching)
+        return state.launching;
+    if (state.child)
+        return;
+    state.launching = (async () => {
+        const provider = getProvider(state.providerId);
+        const resolvedCommand = resolveProviderCommand(provider);
+        const launchArgs = [
+            '--mode', 'rpc',
+            '--session-dir', sessionDirForWorkDir(state.workDir, state.providerId),
+        ];
+        if (state.sessionFile)
+            launchArgs.push('--session', state.sessionFile);
+        else
+            launchArgs.push('--session-id', state.piSessionId);
+        const direct = directSpawnCommand(resolvedCommand.command, [...resolvedCommand.prefixArgs, ...launchArgs]);
+        let child;
+        try {
+            child = spawn(direct.command, direct.args, {
+                cwd: state.workDir,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: { ...getCleanEnv(), ...(provider.env || {}) },
+                ...resolvedCommand.spawnOpts,
+                windowsHide: true,
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to start PI: ${error.message}`);
+        }
+        state.child = child;
+        state.childProviderId = state.providerId;
+        state.protocolFailed = false;
+        state.stderrBuffer = '';
+        attachStrictJsonlReader(state, child);
+        child.stderr?.on('data', (chunk) => {
+            appendBoundedDiagnostics(state, String(chunk));
+        });
+        child.on('error', (error) => {
+            if (state.child !== child)
+                return;
+            state.child = null;
+            state.childProviderId = null;
+            const wrapped = new Error(`Failed to start PI: ${error.message}`);
+            rejectPendingRpc(state, wrapped);
+            if (state.turnActive)
+                failPiTurn(state, wrapped.message);
+            cleanPiAttachments(state);
+        });
+        child.on('close', (code) => {
+            if (state.child !== child)
+                return;
+            state.child = null;
+            state.childProviderId = null;
+            const diagnostic = state.stderrBuffer.trim();
+            const error = new Error(diagnostic || `PI RPC process exited${code == null ? '' : ` with code ${code}`}`);
+            rejectPendingRpc(state, error);
+            if (state.turnActive)
+                failPiTurn(state, error.message);
+            cleanPiAttachments(state);
+        });
+        const response = await sendRpcCommand(state, { type: 'get_state' });
+        const data = asRecord(response.data);
+        const actualSessionId = textValue(data?.sessionId);
+        if (!actualSessionId || actualSessionId !== state.piSessionId) {
+            throw new Error(`PI opened unexpected session "${actualSessionId || '(missing)'}"; expected "${state.piSessionId}"`);
+        }
+        const reportedSessionFile = textValue(data?.sessionFile);
+        if (reportedSessionFile && existsSync(reportedSessionFile)) {
+            state.sessionFile = reportedSessionFile;
+        }
+        state.lastPiSessionId = actualSessionId;
+        if (!state.sessionNotified) {
+            state.sessionNotified = true;
+            sendFn({
+                type: 'backend_event',
+                conversationId: state.conversationId,
+                event: { type: 'session_started', session: sessionRef(actualSessionId) },
+            });
+        }
+        void refreshAvailableModels(state);
+    })();
+    try {
+        await state.launching;
+    }
+    catch (error) {
+        terminatePiChild(state);
+        throw error;
+    }
+    finally {
+        state.launching = null;
+    }
+}
+async function refreshAvailableModels(state) {
+    try {
+        const response = await sendRpcCommand(state, { type: 'get_available_models' });
+        const data = asRecord(response.data);
+        const models = Array.isArray(data?.models) ? data.models : [];
+        state.availableModels = models
+            .map(asRecord)
+            .filter((model) => !!model)
+            .map(model => (typeof model.provider === 'string' && typeof model.id === 'string'
+            ? `${model.provider}/${model.id}`
+            : ''))
+            .filter(Boolean);
+        sendFn({
+            type: 'pi_models_list',
+            providerId: state.providerId,
+            conversationId: state.conversationId,
+            models: state.availableModels,
+        });
+    }
+    catch {
+        // Model discovery is optional and must not fail an otherwise healthy turn.
+    }
+}
+export function getPiAvailableModels(providerId = 'pi') {
+    return [...new Set([...conversations.values()]
+            .filter(state => state.providerId === providerId)
+            .flatMap(state => state.availableModels))].sort();
+}
+function normalizePiOptions(input) {
+    if (!input)
+        return { value: {} };
+    const value = {};
+    if (input.model != null && input.model !== '') {
+        const slash = input.model.indexOf('/');
+        const provider = slash > 0 ? input.model.slice(0, slash) : '';
+        const modelId = slash > 0 ? input.model.slice(slash + 1) : '';
+        if (input.model.length > 256
+            || !MODEL_PART_PATTERN.test(provider)
+            || !MODEL_PART_PATTERN.test(modelId)) {
+            return { value, error: `Invalid PI model identifier: ${input.model}` };
+        }
+        value.model = `${provider}/${modelId}`;
+    }
+    if (input.thinking != null) {
+        if (!THINKING_LEVELS.has(input.thinking)) {
+            return { value, error: `Invalid PI thinking level: ${input.thinking}` };
+        }
+        value.thinking = input.thinking;
+    }
+    return { value };
+}
+async function applyPiOptions(state, options) {
+    let modelChanged = false;
+    if (options.model && options.model !== state.model) {
+        const slash = options.model.indexOf('/');
+        await sendRpcCommand(state, {
+            type: 'set_model',
+            provider: options.model.slice(0, slash),
+            modelId: options.model.slice(slash + 1),
+        });
+        state.model = options.model;
+        modelChanged = true;
+    }
+    if (options.thinking && (modelChanged || options.thinking !== state.thinking)) {
+        await sendRpcCommand(state, { type: 'set_thinking_level', level: options.thinking });
+    }
+    if (modelChanged || options.thinking) {
+        const response = await sendRpcCommand(state, { type: 'get_state' });
+        const data = asRecord(response.data);
+        const effectiveThinking = textValue(data?.thinkingLevel);
+        state.thinking = THINKING_LEVELS.has(effectiveThinking)
+            ? effectiveThinking
+            : null;
+        const model = asRecord(data?.model);
+        if (typeof model?.provider === 'string' && typeof model.id === 'string') {
+            state.model = `${model.provider}/${model.id}`;
+        }
+    }
+}
+function decodeBase64Strict(data) {
+    if (data.length > Math.ceil(MAX_ATTACHMENT_BYTES / 3) * 4 + 4
+        || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(data)) {
+        throw new Error('Attachment data is not valid base64');
+    }
+    const buffer = Buffer.from(data, 'base64');
+    if (buffer.length > MAX_ATTACHMENT_BYTES) {
+        throw new Error(`Attachment exceeds the ${MAX_ATTACHMENT_BYTES / 1024 / 1024} MB limit`);
+    }
+    return buffer;
+}
+function validateAttachmentName(name) {
+    if (!name
+        || name.length > 255
+        || basename(name) !== name
+        || /[\\/\u0000-\u001f]/.test(name)
+        || name === '.'
+        || name === '..') {
+        throw new Error(`Unsafe attachment filename: ${name || '(empty)'}`);
+    }
+    return name;
+}
+function preparePiAttachments(state, text, files) {
+    if (!files?.length)
+        return { message: text };
+    if (files.length > MAX_ATTACHMENTS) {
+        throw new Error(`PI accepts at most ${MAX_ATTACHMENTS} attachments per message`);
+    }
+    const images = [];
+    const filePaths = [];
+    for (const file of files) {
+        const name = validateAttachmentName(file.name);
+        if (!MIME_PATTERN.test(file.mimeType)) {
+            throw new Error(`Invalid attachment MIME type: ${file.mimeType}`);
+        }
+        const buffer = decodeBase64Strict(file.data);
+        if (file.mimeType.toLowerCase().startsWith('image/')) {
+            if (!IMAGE_MIME_PATTERN.test(file.mimeType)) {
+                throw new Error(`Unsupported PI image type: ${file.mimeType}`);
+            }
+            images.push({ type: 'image', data: file.data, mimeType: file.mimeType });
+            continue;
+        }
+        mkdirSync(ATTACHMENT_DIR, { recursive: true });
+        const filePath = join(ATTACHMENT_DIR, `${randomUUID()}-${name}`);
+        writeFileSync(filePath, buffer, { flag: 'wx', mode: 0o600 });
+        state.attachmentPaths.add(filePath);
+        const turnPaths = state.turnAttachmentPaths.get(state.turnId || '');
+        if (turnPaths)
+            turnPaths.add(filePath);
+        else
+            state.turnAttachmentPaths.set(state.turnId || '', new Set([filePath]));
+        filePaths.push(resolve(filePath));
+    }
+    const attachmentNote = filePaths.length
+        ? `\n\nAttached files:\n${filePaths.map(filePath => `- ${filePath}`).join('\n')}`
+        : '';
+    return {
+        message: `${text}${attachmentNote}`,
+        ...(images.length ? { images } : {}),
+    };
+}
+export function handlePiChat(conversationId, text, workDir, options, files) {
+    const resumeId = options?.resumeSessionId;
+    if (resumeId) {
+        rebindPiConversation(resumeId, conversationId, options?.providerId || 'pi', workDir);
+    }
+    let state = conversations.get(conversationId);
+    if (!state) {
+        state = createState(conversationId, workDir, options?.providerId || 'pi');
+        conversations.set(conversationId, state);
+    }
+    if (state.turnActive) {
+        emitPiError(state, 'PI is already processing this conversation.');
+        return;
+    }
+    state.workDir = resolve(workDir);
+    const requestedProviderId = options?.providerId || state.providerId;
+    const providerChanged = state.providerId !== requestedProviderId;
+    if (providerChanged) {
+        if (state.child)
+            terminatePiChild(state);
+        state.piSessionId = null;
+        state.lastPiSessionId = null;
+        state.sessionFile = null;
+        state.sessionNotified = false;
+        state.model = null;
+        state.thinking = null;
+        state.availableModels = [];
+    }
+    else if (state.child && state.childProviderId !== requestedProviderId) {
+        terminatePiChild(state);
+    }
+    state.providerId = requestedProviderId;
+    if (resumeId) {
+        if (resumeId !== state.piSessionId) {
+            if (state.child)
+                terminatePiChild(state);
+            state.piSessionId = resumeId;
+            state.lastPiSessionId = resumeId;
+            state.sessionNotified = false;
+        }
+        if (!state.sessionFile) {
+            state.sessionFile = findPiSessionFile(state.workDir, resumeId, state.providerId);
+        }
+    }
+    else if (!state.piSessionId) {
+        state.piSessionId = randomUUID();
+        state.lastPiSessionId = state.piSessionId;
+        state.sessionFile = null;
+        state.sessionNotified = false;
+    }
+    const normalized = normalizePiOptions(options?.piOptions);
+    startPiTurn(state);
+    if (resumeId && !state.sessionFile) {
+        failPiTurn(state, `PI session ${resumeId} was not found in ${state.workDir}`);
+        return;
+    }
+    if (normalized.error) {
+        failPiTurn(state, normalized.error);
+        return;
+    }
+    const turnId = state.turnId;
+    const priorSetup = state.setupPromise;
+    void (async () => {
+        try {
+            if (priorSetup) {
+                try {
+                    await priorSetup;
+                }
+                catch { /* the prior turn reports its own setup failure */ }
+            }
+            if (!state.turnActive || state.turnId !== turnId || state.cancelRequested) {
+                return;
+            }
+            const prompt = preparePiAttachments(state, text, files);
+            const setupPromise = (async () => {
+                await launchPiProcess(state);
+                if (!state.turnActive || state.turnId !== turnId || state.cancelRequested)
+                    return;
+                await applyPiOptions(state, normalized.value);
+            })();
+            state.setupPromise = setupPromise;
+            try {
+                await setupPromise;
+            }
+            finally {
+                if (state.setupPromise === setupPromise)
+                    state.setupPromise = null;
+            }
+            if (!state.turnActive || state.turnId !== turnId) {
+                cleanPiAttachments(state, turnId);
+                return;
+            }
+            if (state.cancelRequested) {
+                finishPiTurn(state, 'cancelled');
+                return;
+            }
+            await sendRpcCommand(state, { type: 'prompt', ...prompt });
+            if (!state.turnActive || state.turnId !== turnId)
+                return;
+            const stateResponse = await sendRpcCommand(state, { type: 'get_state' });
+            const stateData = asRecord(stateResponse.data);
+            if (stateData?.isStreaming === false && state.turnActive && state.turnId === turnId) {
+                finishPiTurn(state, 'completed');
+            }
+        }
+        catch (error) {
+            cleanPiAttachments(state, turnId);
+            if (state.turnActive && state.turnId === turnId) {
+                failPiTurn(state, error.message);
+            }
+        }
+    })();
+}
+export function cancelPiExecution(conversationId) {
+    const state = conversations.get(conversationId);
+    if (!state) {
+        sendFn({ type: 'execution_cancelled', conversationId });
+        return;
+    }
+    if (!state.turnActive) {
+        sendFn({
+            type: 'execution_cancelled',
+            conversationId,
+            claudeSessionId: state.piSessionId,
+            turnId: state.turnId,
+            stateVersion: state.stateVersion,
+        });
+        return;
+    }
+    state.cancelRequested = true;
+    const cancelledTurnId = state.turnId;
+    if (!state.child) {
+        finishPiTurn(state, 'cancelled');
+        return;
+    }
+    void sendRpcCommand(state, { type: 'abort' }, ABORT_TIMEOUT_MS)
+        .then(() => {
+        const fallback = setTimeout(() => {
+            if (state.turnActive && state.turnId === cancelledTurnId) {
+                // Without agent_settled we cannot distinguish late events from a
+                // subsequent turn, so discard this RPC process before completing.
+                terminatePiChild(state);
+                finishPiTurn(state, 'cancelled');
+            }
+        }, 250);
+        fallback.unref?.();
+    })
+        .catch(() => {
+        terminatePiChild(state);
+        if (state.turnActive && state.turnId === cancelledTurnId)
+            finishPiTurn(state, 'cancelled');
+    });
+}
+function cleanupPiConversation(conversationId) {
+    const state = conversations.get(conversationId);
+    if (!state)
+        return;
+    rejectPendingRpc(state, new Error('PI conversation was closed'));
+    cleanPiAttachments(state);
+    if (state.heartbeatTimer)
+        clearInterval(state.heartbeatTimer);
+    state.heartbeatTimer = null;
+    terminatePiChild(state);
+    conversations.delete(conversationId);
+}
+export function cleanupAllPiConversations() {
+    for (const conversationId of [...conversations.keys()])
+        cleanupPiConversation(conversationId);
+}
+export function restartPiConversation(conversationId, options = {}) {
+    const old = conversations.get(conversationId);
+    const wasTurnActive = old?.turnActive || false;
+    const providerId = options.providerId || old?.providerId || 'pi';
+    const previousSessionId = old?.piSessionId || old?.lastPiSessionId || null;
+    const piSessionId = previousSessionId && old
+        && (providerId === old.providerId
+            || findPiSessionFile(old.workDir, previousSessionId, providerId))
+        ? previousSessionId
+        : null;
+    if (old)
+        cleanupPiConversation(conversationId);
+    const state = createState(conversationId, old?.workDir || process.cwd(), providerId);
+    state.piSessionId = piSessionId;
+    state.lastPiSessionId = piSessionId;
+    state.sessionFile = piSessionId
+        ? findPiSessionFile(state.workDir, piSessionId, state.providerId)
+        : null;
+    state.model = old?.model || null;
+    state.thinking = old?.thinking || null;
+    state.stateVersion = (old?.stateVersion || 0) + 1;
+    conversations.set(conversationId, state);
+    return { wasTurnActive, piSessionId };
+}
+export function evictByPiSessionId(piSessionId, providerId = 'pi', workDir) {
+    for (const [conversationId, state] of conversations) {
+        if ((state.piSessionId === piSessionId || state.lastPiSessionId === piSessionId)
+            && state.providerId === providerId
+            && (!workDir || normalizePathForCompare(state.workDir) === normalizePathForCompare(workDir))) {
+            if (state.turnActive)
+                return true;
+            cleanupPiConversation(conversationId);
+        }
+    }
+    return false;
+}
+export function _resetResolvedPiPathForTests() {
+    resetCachedExecutablePath('pi');
+}
+// ── PI session filesystem ───────────────────────────────────────────────────
+function expandPiPath(value, baseDir) {
+    if (value === '~')
+        return homedir();
+    if (value.startsWith('~/') || value.startsWith('~\\')) {
+        return resolve(homedir(), value.slice(2));
+    }
+    return isAbsolute(value) ? resolve(value) : resolve(baseDir, value);
+}
+function readPiSessionDirSetting(settingsPath) {
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        return typeof settings.sessionDir === 'string' && settings.sessionDir.trim()
+            ? settings.sessionDir.trim()
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function getPiProviderEnv(providerId = 'pi') {
+    return getProvider(providerId).env || {};
+}
+function getPiAgentDir(providerId = 'pi') {
+    const providerEnv = getPiProviderEnv(providerId);
+    return expandPiPath(providerEnv.PI_CODING_AGENT_DIR
+        || process.env.PI_CODING_AGENT_DIR
+        || join(homedir(), '.pi', 'agent'), process.cwd());
+}
+function getPiSessionLayout(workDir, providerId = 'pi') {
+    const resolvedWorkDir = resolve(workDir || process.cwd());
+    const providerEnv = getPiProviderEnv(providerId);
+    const environmentRoot = providerEnv.PI_CODING_AGENT_SESSION_DIR
+        || process.env.PI_CODING_AGENT_SESSION_DIR;
+    if (environmentRoot) {
+        return { root: expandPiPath(environmentRoot, resolvedWorkDir), custom: true };
+    }
+    const agentDir = getPiAgentDir(providerId);
+    const globalSettingsPath = join(agentDir, 'settings.json');
+    const globalSessionDir = readPiSessionDirSetting(globalSettingsPath);
+    if (globalSessionDir) {
+        return {
+            root: expandPiPath(globalSessionDir, resolvedWorkDir),
+            custom: true,
+        };
+    }
+    return { root: join(agentDir, 'sessions'), custom: false };
+}
+function getPiSessionRoot(workDir, providerId = 'pi') {
+    return getPiSessionLayout(workDir, providerId).root;
+}
+function sessionDirForWorkDir(workDir, providerId = 'pi') {
+    const layout = getPiSessionLayout(workDir, providerId);
+    if (layout.custom)
+        return layout.root;
+    const resolvedWorkDir = resolve(workDir);
+    const safePath = `--${resolvedWorkDir.replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`;
+    return join(layout.root, safePath);
+}
+function normalizePathForCompare(value) {
+    const normalized = resolve(value).replace(/\\/g, '/').replace(/\/+$/, '');
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+function isWithinRoot(filePath, root) {
+    const rel = relative(root, resolve(filePath));
+    return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+function listJsonlFiles(root, includeDirectChildDirs = false) {
+    if (!existsSync(root))
+        return [];
+    const result = [];
+    let entries;
+    try {
+        entries = readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return result;
+    }
+    for (const entry of entries) {
+        const fullPath = join(root, entry.name);
+        if (!isWithinRoot(fullPath, root))
+            continue;
+        if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+            result.push(fullPath);
+        }
+        else if (includeDirectChildDirs && entry.isDirectory()) {
+            let children;
+            try {
+                children = readdirSync(fullPath, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const child of children) {
+                const childPath = join(fullPath, child.name);
+                if (child.isFile()
+                    && child.name.endsWith('.jsonl')
+                    && isWithinRoot(childPath, root))
+                    result.push(childPath);
+            }
+        }
+    }
+    return result;
+}
+function parseTimestamp(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value !== 'string')
+        return 0;
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? 0 : parsed;
+}
+function contentText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((item) => {
+        const block = asRecord(item);
+        return block?.type === 'text' ? textValue(block.text) : '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function buildActiveBranch(entries) {
+    const treeEntries = entries.filter(entry => (entry.type !== 'session'
+        && typeof entry.id === 'string'));
+    if (!treeEntries.length)
+        return [];
+    if (treeEntries.every(entry => entry.parentId === undefined))
+        return treeEntries;
+    const byId = new Map(treeEntries.map(entry => [entry.id, entry]));
+    const branch = [];
+    const visited = new Set();
+    let current = treeEntries.at(-1);
+    while (current) {
+        const id = current.id;
+        if (visited.has(id))
+            return [];
+        visited.add(id);
+        branch.push(current);
+        if (current.parentId === null)
+            break;
+        if (typeof current.parentId !== 'string')
+            return [];
+        current = byId.get(current.parentId);
+        if (!current)
+            return [];
+    }
+    return branch.reverse();
+}
+function parsePiSession(filePath, stats, root = getPiSessionRoot()) {
+    if (!isWithinRoot(filePath, root))
+        return null;
+    let content;
+    try {
+        content = readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const entries = [];
+    for (const line of content.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            const record = asRecord(parsed);
+            if (record)
+                entries.push(record);
+        }
+        catch {
+            // PI itself tolerates malformed historical lines; the RPC stream does not.
+        }
+    }
+    const header = entries[0];
+    if (!header
+        || header.type !== 'session'
+        || typeof header.id !== 'string'
+        || !SESSION_ID_PATTERN.test(header.id)
+        || typeof header.cwd !== 'string'
+        || !isAbsolute(header.cwd))
+        return null;
+    const activeBranch = buildActiveBranch(entries);
+    let customTitle = '';
+    for (const entry of entries) {
+        if (entry.type === 'session_info')
+            customTitle = textValue(entry.name).trim();
+    }
+    let firstPrompt = '';
+    let lastText = '';
+    let lastModified = parseTimestamp(header.timestamp);
+    for (const entry of activeBranch) {
+        if (entry.type !== 'message')
+            continue;
+        const message = asRecord(entry.message);
+        if (!message)
+            continue;
+        const text = contentText(message.content).trim();
+        if ((message.role === 'user' || message.role === 'assistant') && text) {
+            if (message.role === 'user' && !firstPrompt)
+                firstPrompt = text.slice(0, 100);
+            lastText = text.slice(0, 120);
+            lastModified = Math.max(lastModified, parseTimestamp(message.timestamp) || parseTimestamp(entry.timestamp));
+        }
+    }
+    const projectPath = resolve(header.cwd);
+    const title = customTitle || firstPrompt || lastText || header.id.slice(0, 8);
+    return {
+        sessionId: header.id,
+        title,
+        ...(customTitle ? { customTitle } : {}),
+        preview: lastText || firstPrompt || title,
+        firstPrompt: firstPrompt || title,
+        lastModified: lastModified || stats?.mtimeMs || statSync(filePath).mtimeMs,
+        projectPath,
+        projectFolder: projectPath.replace(/[\\/]+$/, '').split(/[\\/]/).pop() || projectPath,
+        sourcePath: resolve(filePath),
+        entries,
+        activeBranch,
+    };
+}
+function piEntries(workDir, providerId = 'pi') {
+    const requested = workDir ? normalizePathForCompare(workDir) : '';
+    const layout = getPiSessionLayout(workDir, providerId);
+    const root = workDir && !layout.custom
+        ? sessionDirForWorkDir(workDir, providerId)
+        : layout.root;
+    const result = [];
+    for (const filePath of listJsonlFiles(root, !workDir && !layout.custom)) {
+        let stats;
+        try {
+            stats = statSync(filePath);
+        }
+        catch {
+            continue;
+        }
+        const session = parsePiSession(filePath, stats, root);
+        if (!session)
+            continue;
+        if (requested && normalizePathForCompare(session.projectPath) !== requested)
+            continue;
+        result.push({
+            session,
+            sortKey: {
+                lastModified: session.lastModified,
+                sessionId: session.sessionId,
+                tieBreaker: normalizePathForCompare(session.sourcePath),
+            },
+        });
+    }
+    result.sort((a, b) => compareCursorSortKeys(a.sortKey, b.sortKey));
+    return result;
+}
+function normalizeSessionLimit(limit) {
+    if (limit === Number.POSITIVE_INFINITY)
+        return limit;
+    if (!Number.isFinite(limit) || !limit || limit <= 0)
+        return PI_SESSION_LIST_LIMIT;
+    return Math.min(Math.floor(limit), 500);
+}
+function compareCursorSortKeys(a, b) {
+    const modified = b.lastModified - a.lastModified;
+    if (modified)
+        return modified;
+    const id = a.sessionId.localeCompare(b.sessionId);
+    return id || a.tieBreaker.localeCompare(b.tieBreaker);
+}
+function encodePiCursor(scope, key, workDir) {
+    return Buffer.from(JSON.stringify({
+        v: 1,
+        provider: 'pi',
+        scope,
+        ...(scope === 'workdir' && workDir ? { workDir: normalizePathForCompare(workDir) } : {}),
+        ...key,
+    }), 'utf8').toString('base64url');
+}
+function decodePiCursor(cursor, scope, workDir) {
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+    }
+    catch {
+        throw new Error('Invalid PI session list cursor');
+    }
+    const value = asRecord(parsed);
+    if (!value
+        || value.v !== 1
+        || value.provider !== 'pi'
+        || value.scope !== scope
+        || typeof value.lastModified !== 'number'
+        || !Number.isFinite(value.lastModified)
+        || typeof value.sessionId !== 'string'
+        || typeof value.tieBreaker !== 'string')
+        throw new Error('Invalid PI session list cursor');
+    if (scope === 'workdir' && value.workDir !== normalizePathForCompare(workDir || '')) {
+        throw new Error('PI session list cursor does not match requested workDir');
+    }
+    return {
+        lastModified: value.lastModified,
+        sessionId: value.sessionId,
+        tieBreaker: value.tieBreaker,
+    };
+}
+function pageStart(entries, cursor, scope, workDir) {
+    if (!cursor)
+        return 0;
+    const key = decodePiCursor(cursor, scope, workDir);
+    const index = entries.findIndex(entry => compareCursorSortKeys(entry.sortKey, key) > 0);
+    return index < 0 ? entries.length : index;
+}
+export function listPiSessions(workDir, providerId = 'pi') {
+    return listPiSessionsPage(workDir, { limit: Number.POSITIVE_INFINITY, providerId }).sessions;
+}
+export function listPiSessionsPage(workDir, options = {}) {
+    const providerId = options.providerId || 'pi';
+    const entries = piEntries(workDir, providerId);
+    const start = pageStart(entries, options.cursor, 'workdir', workDir);
+    const limit = normalizeSessionLimit(options.limit);
+    const page = limit === Number.POSITIVE_INFINITY
+        ? entries.slice(start)
+        : entries.slice(start, start + limit);
+    const hasMore = start + page.length < entries.length;
+    return {
+        sessions: page.map(({ session }) => ({
+            sessionId: session.sessionId,
+            title: session.title,
+            ...(session.customTitle ? { customTitle: session.customTitle } : {}),
+            preview: session.preview,
+            lastModified: session.lastModified,
+            providerId,
+            workDir: session.projectPath,
+        })),
+        hasMore,
+        ...(hasMore && page.length
+            ? { nextCursor: encodePiCursor('workdir', page.at(-1).sortKey, workDir) }
+            : {}),
+    };
+}
+export function listAllPiSessions(limit = 500, providerId = 'pi') {
+    return listAllPiSessionsPage({ limit, providerId }).sessions;
+}
+export function listAllPiSessionsPage(options = {}) {
+    const providerId = options.providerId || 'pi';
+    const entries = piEntries(undefined, providerId);
+    const start = pageStart(entries, options.cursor, 'global');
+    const limit = normalizeSessionLimit(options.limit);
+    const page = limit === Number.POSITIVE_INFINITY
+        ? entries.slice(start)
+        : entries.slice(start, start + limit);
+    const hasMore = start + page.length < entries.length;
+    return {
+        sessions: page.map(({ session }) => ({
+            sessionId: session.sessionId,
+            projectPath: session.projectPath,
+            projectFolder: session.projectFolder,
+            stableIdentity: normalizePathForCompare(session.sourcePath),
+            title: session.title,
+            firstPrompt: session.firstPrompt,
+            lastModified: session.lastModified,
+            providerId,
+            workDir: session.projectPath,
+        })),
+        hasMore,
+        ...(hasMore && page.length
+            ? { nextCursor: encodePiCursor('global', page.at(-1).sortKey) }
+            : {}),
+        indexState: 'ready',
+    };
+}
+function findPiSessionFile(workDir, sessionId, providerId = 'pi') {
+    if (!SESSION_ID_PATTERN.test(sessionId))
+        return null;
+    const requested = normalizePathForCompare(workDir);
+    const root = sessionDirForWorkDir(workDir, providerId);
+    for (const filePath of listJsonlFiles(root)) {
+        const parsed = parsePiSession(filePath, undefined, root);
+        if (parsed?.sessionId === sessionId
+            && normalizePathForCompare(parsed.projectPath) === requested)
+            return parsed.sourcePath;
+    }
+    return null;
+}
+function findPiSessionGlobally(sessionId, providerId = 'pi') {
+    if (!SESSION_ID_PATTERN.test(sessionId))
+        return null;
+    const layout = getPiSessionLayout(undefined, providerId);
+    const root = layout.root;
+    for (const filePath of listJsonlFiles(root, !layout.custom)) {
+        const parsed = parsePiSession(filePath, undefined, root);
+        if (parsed?.sessionId === sessionId)
+            return parsed;
+    }
+    return null;
+}
+export function getPiSessionWorkDir(sessionId, providerId = 'pi', workDir) {
+    if (workDir) {
+        const root = sessionDirForWorkDir(workDir, providerId);
+        const filePath = findPiSessionFile(workDir, sessionId, providerId);
+        return filePath
+            ? parsePiSession(filePath, undefined, root)?.projectPath
+            : undefined;
+    }
+    return findPiSessionGlobally(sessionId, providerId)?.projectPath;
+}
+function toIsoTimestamp(entry, message) {
+    const raw = message?.timestamp ?? entry.timestamp;
+    if (typeof raw === 'string' && Number.isFinite(Date.parse(raw)))
+        return raw;
+    if (typeof raw === 'number' && Number.isFinite(raw))
+        return new Date(raw).toISOString();
+    return undefined;
+}
+function toolOutputText(value) {
+    const record = asRecord(value);
+    if (record && Array.isArray(record.content)) {
+        const text = contentText(record.content);
+        if (text)
+            return text;
+    }
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function readPiSessionMessages(workDir, sessionId, providerId = 'pi') {
+    const root = sessionDirForWorkDir(workDir, providerId);
+    const filePath = findPiSessionFile(workDir, sessionId, providerId);
+    if (!filePath)
+        return [];
+    const parsed = parsePiSession(filePath, undefined, root);
+    if (!parsed)
+        return [];
+    const messages = [];
+    const tools = new Map();
+    for (const entry of parsed.activeBranch) {
+        if (entry.type !== 'message')
+            continue;
+        const message = asRecord(entry.message);
+        if (!message)
+            continue;
+        const timestamp = toIsoTimestamp(entry, message);
+        if (message.role === 'user') {
+            const text = contentText(message.content);
+            if (text)
+                messages.push({ role: 'user', content: text, timestamp });
+        }
+        else if (message.role === 'assistant' && Array.isArray(message.content)) {
+            for (const item of message.content) {
+                const block = asRecord(item);
+                if (!block)
+                    continue;
+                if (block.type === 'text' && typeof block.text === 'string' && block.text) {
+                    messages.push({ role: 'assistant', content: block.text, timestamp });
+                }
+                else if (block.type === 'thinking' && typeof block.thinking === 'string' && block.thinking) {
+                    messages.push({
+                        role: 'assistant',
+                        content: block.thinking,
+                        timestamp,
+                        isThinking: true,
+                    });
+                }
+                else if (block.type === 'toolCall'
+                    && typeof block.id === 'string'
+                    && typeof block.name === 'string') {
+                    const tool = {
+                        role: 'tool',
+                        content: '',
+                        toolName: block.name,
+                        toolId: block.id,
+                        toolInput: toolOutputText(block.arguments),
+                        timestamp,
+                    };
+                    tools.set(block.id, tool);
+                    messages.push(tool);
+                }
+            }
+        }
+        else if (message.role === 'toolResult') {
+            const id = textValue(message.toolCallId);
+            const output = contentText(message.content);
+            const existing = tools.get(id);
+            if (existing)
+                existing.toolOutput = output;
+            else {
+                messages.push({
+                    role: 'tool',
+                    content: '',
+                    toolName: textValue(message.toolName) || 'tool',
+                    toolId: id,
+                    toolOutput: output,
+                    timestamp,
+                });
+            }
+        }
+        else if (message.role === 'bashExecution') {
+            messages.push({
+                role: 'tool',
+                content: '',
+                toolName: 'bash',
+                toolId: textValue(message.id) || textValue(entry.id),
+                toolInput: toolOutputText({ command: message.command }),
+                toolOutput: textValue(message.output),
+                timestamp,
+            });
+        }
+    }
+    return messages;
+}
+function activePiSession(sessionId, providerId, workDir) {
+    for (const state of conversations.values()) {
+        if ((state.piSessionId === sessionId || state.lastPiSessionId === sessionId)
+            && state.providerId === providerId
+            && normalizePathForCompare(state.workDir) === normalizePathForCompare(workDir)
+            && state.turnActive)
+            return true;
+    }
+    return false;
+}
+function uniqueEntryId(entries) {
+    const ids = new Set(entries.map(entry => textValue(entry.id)).filter(Boolean));
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const id = randomUUID().slice(0, 8);
+        if (!ids.has(id))
+            return id;
+    }
+    return randomUUID();
+}
+export function renamePiSession(workDir, sessionId, newTitle, providerId = 'pi') {
+    if (activePiSession(sessionId, providerId, workDir))
+        return false;
+    const root = sessionDirForWorkDir(workDir, providerId);
+    const filePath = findPiSessionFile(workDir, sessionId, providerId);
+    if (!filePath)
+        return false;
+    const parsed = parsePiSession(filePath, undefined, root);
+    const title = newTitle.replace(/[\r\n]+/g, ' ').trim().slice(0, 200);
+    if (!parsed || !title)
+        return false;
+    const leaf = parsed.entries.filter(entry => entry.type !== 'session').at(-1);
+    const entry = {
+        type: 'session_info',
+        id: uniqueEntryId(parsed.entries),
+        parentId: typeof leaf?.id === 'string' ? leaf.id : null,
+        timestamp: new Date().toISOString(),
+        name: title,
+    };
+    try {
+        const needsNewline = !readFileSync(filePath, 'utf8').endsWith('\n');
+        appendFileSync(filePath, `${needsNewline ? '\n' : ''}${JSON.stringify(entry)}\n`, 'utf8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function deletePiSession(workDir, sessionId, providerId = 'pi') {
+    if (activePiSession(sessionId, providerId, workDir))
+        return false;
+    const root = sessionDirForWorkDir(workDir, providerId);
+    const filePath = findPiSessionFile(workDir, sessionId, providerId);
+    if (!filePath || !isWithinRoot(filePath, root))
+        return false;
+    try {
+        unlinkSync(filePath);
+        return true;
+    }
+    catch {
+        try {
+            rmSync(filePath, { force: true });
+            return !existsSync(filePath);
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function rewritePiHeaderCwd(content, cwd) {
+    const lines = content.split('\n');
+    const headerIndex = lines.findIndex(line => line.trim());
+    if (headerIndex < 0)
+        return null;
+    try {
+        const header = JSON.parse(lines[headerIndex]);
+        if (header?.type !== 'session' || typeof header.id !== 'string')
+            return null;
+        header.cwd = resolve(cwd);
+        lines[headerIndex] = JSON.stringify(header);
+        return lines.join('\n');
+    }
+    catch {
+        return null;
+    }
+}
+function writeExclusiveAndSync(filePath, content) {
+    const fd = openSync(filePath, 'wx', 0o600);
+    try {
+        writeFileSync(fd, content, 'utf8');
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function movePiSession(fromWorkDir, toWorkDir, sessionId, providerId = 'pi') {
+    if (activePiSession(sessionId, providerId, fromWorkDir))
+        return false;
+    const sourceRoot = sessionDirForWorkDir(fromWorkDir, providerId);
+    const sourcePath = findPiSessionFile(fromWorkDir, sessionId, providerId);
+    if (!sourcePath || !isWithinRoot(sourcePath, sourceRoot))
+        return false;
+    const targetDir = sessionDirForWorkDir(toWorkDir, providerId);
+    const targetRoot = getPiSessionRoot(toWorkDir, providerId);
+    if (!isWithinRoot(targetDir, targetRoot))
+        return false;
+    try {
+        mkdirSync(targetDir, { recursive: true });
+    }
+    catch {
+        return false;
+    }
+    let targetPath = join(targetDir, basename(sourcePath));
+    if (resolve(targetPath) === resolve(sourcePath)) {
+        targetPath = join(targetDir, `${new Date().toISOString().replace(/[:.]/g, '-')}_${sessionId}.jsonl`);
+    }
+    if (!isWithinRoot(targetPath, targetRoot) || existsSync(targetPath))
+        return false;
+    let content;
+    try {
+        content = readFileSync(sourcePath, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    const rewritten = rewritePiHeaderCwd(content, toWorkDir);
+    if (rewritten == null)
+        return false;
+    const temporaryPath = `${targetPath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        writeExclusiveAndSync(temporaryPath, rewritten);
+        renameSync(temporaryPath, targetPath);
+        unlinkSync(sourcePath);
+        for (const state of conversations.values()) {
+            if (state.piSessionId === sessionId || state.lastPiSessionId === sessionId) {
+                if (state.providerId !== providerId
+                    || normalizePathForCompare(state.workDir) !== normalizePathForCompare(fromWorkDir))
+                    continue;
+                rejectPendingRpc(state, new Error('PI session was moved'));
+                terminatePiChild(state);
+                state.workDir = resolve(toWorkDir);
+                state.sessionFile = targetPath;
+            }
+        }
+        return true;
+    }
+    catch {
+        try {
+            rmSync(temporaryPath, { force: true });
+        }
+        catch { /* best effort */ }
+        try {
+            rmSync(targetPath, { force: true });
+        }
+        catch { /* best effort */ }
+        return false;
+    }
+}
+export { piCapabilities };
+//# sourceMappingURL=pi.js.map