cli-jaw 2.17.38 → 2.17.39

package/dist/src/agent/pi-runtime.js

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import { join } from 'node:path';
+import { isAbsolute, join } from 'node:path';
 import { detectCliBinary } from '../core/cli-detect.js';
 import { resolveWindowsLaunchSpec, launchArgv } from '../core/windows-launch-spec.js';
 import { decideShellFallback } from '../core/windows-shell-fallback.js';
@@ -11,6 +11,139 @@ import { probeOpenCodexEndpointModels } from '../cli/opencodex-models.js';
 import { launchSpec } from '../core/exec-name.js';
 import { mergeEnvWindowsSafe } from './spawn-env.js';
 import { createTextStreamReader } from './stream-text.js';
+import { PiTurnAccumulator, PiRuntimeError, piSupportsSettled } from './runtime/pi-turn.js';
+const PI_VERSION_TIMEOUT_MS = 15_000;
+const PI_VERSION_OUTPUT_BYTES = 64 * 1024;
+const PI_CLEANUP_TIMEOUT_MS = 2_000;
+const PI_KILL_GRACE_MS = 1_000;
+const PI_EXECUTION_CANCEL = Symbol('Pi execution cancellation');
+/** A recognized child stays handled even after closure; never fall back to stale PID signalling. */
+export function cancelPiExecution(child) {
+    const cancel = Reflect.get(child, PI_EXECUTION_CANCEL);
+    if (typeof cancel !== 'function')
+        return false;
+    cancel();
+    return true;
+}
+/** Per execution, never a PID registry. A receipt is evidence, not cwd ownership. */
+function createPiExecutionCleanup() {
+    const handles = {};
+    let started = false, sealed = false, decided = false;
+    let receipt;
+    let deadline;
+    let escalation;
+    let gentle;
+    let resolve;
+    const cleanup = new Promise(yes => { resolve = yes; });
+    const signal = (entry, name) => {
+        if (!entry || entry.retired || entry.child.exitCode !== null || entry.child.signalCode !== null)
+            return false;
+        if (entry.sent.has(name) || entry.sent.has('SIGKILL'))
+            return entry.child.killed;
+        entry.sent.add(name);
+        try {
+            const sent = entry.kill(name);
+            if (!sent)
+                entry.retired = true;
+            return sent;
+        }
+        catch {
+            entry.retired = true;
+            return false;
+        }
+    };
+    const groupGone = (entry) => {
+        if (!entry?.ownGroup || !entry.child.pid)
+            return true;
+        try {
+            process.kill(-entry.child.pid, 0);
+            return false;
+        }
+        catch (error) {
+            return error.code === 'ESRCH';
+        }
+    };
+    const decide = (expired = false) => {
+        if (!started || !sealed || decided)
+            return;
+        if (!expired && Object.values(handles).some(entry => !entry.closed))
+            return;
+        decided = true;
+        clearTimeout(deadline);
+        clearTimeout(escalation);
+        clearTimeout(gentle);
+        const state = (kind) => !handles[kind] ? 'not-started'
+            : handles[kind].closed ? 'closed' : 'unconfirmed';
+        const rpc = state('rpc'), version = state('version');
+        const descendantsGone = !handles.version?.closed || groupGone(handles.version);
+        const safe = rpc !== 'unconfirmed' && version !== 'unconfirmed' && descendantsGone;
+        // Snapshot BEFORE detaching held pipes; induced close cannot upgrade it.
+        receipt = Object.freeze({ rpc, version, cwdDisposition: safe ? 'removable' : 'retain',
+            reason: safe ? null : !descendantsGone ? 'descendants-unconfirmed' : 'owned-close-unconfirmed' });
+        resolve(receipt);
+        if (!safe)
+            for (const entry of Object.values(handles)) {
+                if (!entry.closed) {
+                    entry.child.stdout?.destroy();
+                    entry.child.stderr?.destroy();
+                    entry.child.unref();
+                }
+            }
+    };
+    return {
+        cleanup,
+        get receipt() { return receipt; },
+        killRpc: (name) => signal(handles.rpc, name),
+        track(kind, child, ownGroup = false) {
+            const entry = { child, retired: false, closed: false, ownGroup,
+                kill: child.kill.bind(child), sent: new Set() };
+            handles[kind] = entry;
+            child.once('exit', () => { entry.retired = true; });
+            child.once('error', () => { entry.retired = true; });
+            child.once('close', () => { entry.retired = true; entry.closed = true; decide(); });
+        },
+        versionGroupGone: () => groupGone(handles.version),
+        seal() { sealed = true; decide(); },
+        teardown(force = false) {
+            if (!started) {
+                started = true;
+                deadline = setTimeout(() => decide(true), PI_CLEANUP_TIMEOUT_MS);
+                escalation = setTimeout(() => {
+                    for (const entry of Object.values(handles))
+                        signal(entry, 'SIGKILL');
+                }, PI_KILL_GRACE_MS);
+                try {
+                    handles.rpc?.child.stdin?.end();
+                }
+                catch { /* retained handle remains owned */ }
+                gentle = setTimeout(() => signal(handles.rpc, 'SIGTERM'), 750);
+            }
+            if (!decided) {
+                signal(handles.version, 'SIGTERM');
+                if (force)
+                    signal(handles.rpc, 'SIGTERM');
+                decide();
+            }
+            return cleanup;
+        },
+    };
+}
+function notifyPiRawRecord(observer, record) {
+    try {
+        observer?.(record);
+    }
+    catch {
+        console.warn('[jaw:pi] raw activity observer failed');
+    }
+}
+function notifyPiEvent(observer, event) {
+    try {
+        observer?.(event);
+    }
+    catch {
+        console.warn('[jaw:pi] semantic observer failed');
+    }
+}
 const PI_PACKAGE = '@earendil-works/pi-coding-agent';
 const LOCAL_HOST_RE = /^(localhost|127\.0\.0\.1|\[?::1\]?)$/i;
 const PI_RPC_CAPABILITY_SCHEMA = 1;
@@ -211,17 +344,11 @@ export function resolvePiCommand(env = process.env) {
         source: 'npm-exec',
     };
 }
-function resolvePiCommandIdentity(command, env = process.env) {
-    const spec = launchSpec(command.command, [...command.baseArgs, '--version'], process.platform, env);
-    const result = spawnSync(spec.file, spec.args, {
-        encoding: 'utf8',
-        env,
-        timeout: 15_000,
-    });
+function resolvePiCommandIdentity(command, result) {
     const version = `${result.stdout || ''}\n${result.stderr || ''}`.trim() || `exit:${String(result.status)}`;
     return JSON.stringify({ source: command.source, command: command.command, baseArgs: command.baseArgs, version });
 }
-function loadPiAbortEffective(profileId, command) {
+function loadPiAbortEffective(profileId, commandId) {
     try {
         const raw = JSON.parse(fs.readFileSync(join(JAW_HOME, 'pi', 'rpc-capabilities.json'), 'utf8'));
         if (!raw || typeof raw !== 'object' || Array.isArray(raw))
@@ -230,7 +357,7 @@ function loadPiAbortEffective(profileId, command) {
         if (capability['schemaVersion'] !== PI_RPC_CAPABILITY_SCHEMA
             || capability['abortEffective'] !== true
             || capability['profileId'] !== profileId
-            || capability['commandId'] !== resolvePiCommandIdentity(command))
+            || capability['commandId'] !== commandId)
             return false;
         const probedAt = Date.parse(typeof capability['probedAt'] === 'string' ? capability['probedAt'] : '');
         return Number.isFinite(probedAt)
@@ -288,6 +415,93 @@ function resolvePiSpawn(command, args) {
     }
     return { command, args, useShell: wantsShell, envDelta: {} };
 }
+function capturePiLaunchIdentity(command, launch) {
+    const files = [...new Set([command.command, launch.command].filter(isAbsolute))];
+    const snapshot = (file) => {
+        try {
+            const stat = fs.statSync(file, { bigint: true });
+            return [fs.realpathSync(file), stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].map(String).join('\0');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+    };
+    const before = files.map(snapshot);
+    return () => files.every((file, index) => snapshot(file) === before[index]);
+}
+function startPiVersionProbe(launch, cwd, env, owner, identityCurrent) {
+    let settled = false, timer;
+    let resolve, reject;
+    const done = new Promise((yes, no) => { resolve = yes; reject = no; });
+    const fail = (reason) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        reject(new Error(reason));
+    };
+    try {
+        const child = spawn(launch.command, launch.args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'],
+            detached: process.platform !== 'win32', ...(launch.useShell ? { shell: true } : {}) });
+        owner.track('version', child, process.platform !== 'win32');
+        const outDecoder = new StringDecoder('utf8'), errDecoder = new StringDecoder('utf8');
+        let stdout = '', stderr = '', outBytes = 0, errBytes = 0;
+        timer = setTimeout(() => fail('pi capability probe timed out'), PI_VERSION_TIMEOUT_MS);
+        child.once('error', () => fail('pi capability probe spawn failed'));
+        child.stdout?.once('error', () => fail('pi capability stdout failed'));
+        child.stderr?.once('error', () => fail('pi capability stderr failed'));
+        child.stdout?.on('data', (chunk) => {
+            if (settled)
+                return;
+            outBytes += chunk.length;
+            if (outBytes > PI_VERSION_OUTPUT_BYTES) {
+                fail('pi capability stdout exceeded limit');
+                return;
+            }
+            stdout += outDecoder.write(chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            if (settled)
+                return;
+            errBytes += chunk.length;
+            if (errBytes > PI_VERSION_OUTPUT_BYTES) {
+                fail('pi capability stderr exceeded limit');
+                return;
+            }
+            stderr += errDecoder.write(chunk);
+        });
+        child.once('close', (status, signal) => {
+            if (settled)
+                return;
+            try {
+                if (status === null || signal !== null || !owner.versionGroupGone()) {
+                    fail('pi capability probe close unconfirmed');
+                    return;
+                }
+                if (!identityCurrent()) {
+                    fail('pi capability command changed during preparation');
+                    return;
+                }
+                stdout += outDecoder.end();
+                stderr += errDecoder.end();
+                settled = true;
+                clearTimeout(timer);
+                resolve({ stdout, stderr, status });
+            }
+            catch {
+                fail('pi capability command identity unavailable');
+            }
+        });
+    }
+    catch {
+        fail('pi capability probe setup failed');
+    }
+    // A factory can be closed before a caller submits its first prompt.
+    void done.catch(() => { });
+    return { done, cancel: () => fail('pi capability probe cancelled') };
+}
 export function listPiModels(piInput, profileId, options = {}) {
     const dir = ensurePiRuntimeConfig(piInput, profileId, options.effort || '', options.root);
     const cmd = resolvePiCommand();
@@ -433,7 +647,8 @@ function extractPiSessionId(obj) {
 const PI_PERSISTENT_STDERR_MAX_CHARS = 4000;
 export function spawnPersistentPiRpc(profile, pi, options) {
     const dir = ensurePiRuntimeConfig(pi, profile.id, options.effort || '', options.root);
-    const cmd = resolvePiCommand();
+    const inherited = { ...process.env }, cwd = options.cwd, profileId = profile.id, initialEffort = options.effort;
+    const cmd = resolvePiCommand(inherited);
     const args = [
         ...cmd.baseArgs,
         '--mode', 'rpc',
@@ -445,12 +660,18 @@ export function spawnPersistentPiRpc(profile, pi, options) {
         ...(options.sessionId ? ['--session-id', options.sessionId] : []),
     ];
     const launch = resolvePiSpawn(cmd.command, args);
+    const versionLaunch = resolvePiSpawn(cmd.command, [...cmd.baseArgs, '--version']);
+    const identityCurrent = capturePiLaunchIdentity(cmd, launch);
+    const rpcEnv = mergeEnvWindowsSafe({ ...inherited, PI_CODING_AGENT_DIR: dir }, launch.envDelta);
+    const versionEnv = mergeEnvWindowsSafe({ ...inherited, PI_CODING_AGENT_DIR: dir }, versionLaunch.envDelta);
+    const owner = createPiExecutionCleanup();
     const child = spawn(launch.command, launch.args, {
-        cwd: options.cwd,
-        env: mergeEnvWindowsSafe({ ...process.env, PI_CODING_AGENT_DIR: dir }, launch.envDelta),
+        cwd,
+        env: rpcEnv,
         stdio: ['pipe', 'pipe', 'pipe'],
         ...(launch.useShell ? { shell: true } : {}),
     });
+    owner.track('rpc', child);
     const decoder = new StringDecoder('utf8');
     let buffer = '';
     let stderr = '';
@@ -458,7 +679,12 @@ export function spawnPersistentPiRpc(profile, pi, options) {
     const stderrReader = createTextStreamReader();
     let activePrompt = null;
     let abortWait = null;
-    let closed = false;
+    let closed = false, closing = false, poisoned = false, stopRequested = false, rpcExited = false;
+    let settledProtocol = false, capabilityReady = false, abortEffective = false;
+    let version;
+    let prepared;
+    let closePromise;
+    let failureClaim;
     const write = (type, fields = {}) => {
         if (!session.alive || !child.stdin.writable)
             throw new Error('pi rpc session is not writable');
@@ -475,17 +701,26 @@ export function spawnPersistentPiRpc(profile, pi, options) {
         wait.resolve();
     };
     const dispatchLine = (line) => {
+        if (closing || poisoned || owner.receipt?.rpc === 'unconfirmed')
+            return;
         let raw;
         try {
             raw = JSON.parse(line);
         }
         catch {
-            console.warn(`[jaw:pi] JSON parse failed: ${line.slice(0, 200)}`);
+            console.warn(`[jaw:pi] JSON parse failed (${line.length} chars; payload omitted)`);
             return;
         }
         if (!raw || typeof raw !== 'object' || Array.isArray(raw))
             return;
         const record = raw;
+        const isAbortResponse = abortWait && record['id'] === abortWait.id
+            && record['type'] === 'response' && record['command'] === 'abort';
+        // The old prompt may have ended and a newer one may already be active.
+        // Its abort acknowledgement still belongs to the captured abort owner.
+        // A newer prompt with no observer deliberately owns (and drops) its raw records.
+        notifyPiRawRecord(isAbortResponse ? abortWait?.onRawRecord
+            : activePrompt ? activePrompt.turn ? activePrompt.onRawRecord : undefined : abortWait?.onRawRecord, raw);
         if (abortWait && record['id'] === abortWait.id && record['type'] === 'response' && record['command'] === 'abort') {
             if (record['success'] === true)
                 abortWait.accepted = true;
@@ -509,32 +744,47 @@ export function spawnPersistentPiRpc(profile, pi, options) {
             || (stateName !== '' && !['running', 'active', 'generating'].includes(stateName)));
         if (event.sessionId) {
             session.sessionId = event.sessionId;
-            activePrompt?.onEvent?.({ kind: 'session', sessionId: event.sessionId });
+            notifyPiEvent(activePrompt?.onEvent, { kind: 'session', sessionId: event.sessionId });
         }
-        if (event.tool)
-            activePrompt?.onEvent?.({ kind: 'tool', ...event.tool });
-        if (event.thinking)
-            activePrompt?.onEvent?.({ kind: 'thinking', text: event.thinking });
-        if (event.text && activePrompt && !(event.done && activePrompt.text)) {
-            activePrompt.text += event.text;
-            activePrompt.onEvent?.({ kind: 'text', text: event.text });
+        if (event.tool && activePrompt?.turn)
+            notifyPiEvent(activePrompt.onEvent, { kind: 'tool', ...event.tool });
+        if (event.thinking && activePrompt?.turn)
+            notifyPiEvent(activePrompt.onEvent, { kind: 'thinking', text: event.thinking });
+        if (activePrompt?.turn && record['type'] === 'response' && record['command'] === 'prompt'
+            && record['id'] === activePrompt.requestId && record['success'] === false) {
+            const message = typeof record['error'] === 'string' ? record['error']
+                : trimString(record['error']?.['message']);
+            rejectOutstanding(new Error(message || 'pi rpc prompt rejected'));
+            return;
         }
-        if (event.done || (abortWait && nonRunning)) {
-            if (activePrompt) {
+        const accepted = activePrompt?.turn?.observe(record);
+        if (accepted?.text)
+            notifyPiEvent(activePrompt?.onEvent, { kind: 'text', text: accepted.text });
+        const abortNonRunning = Boolean(isAbortResponse) && nonRunning && !abortWait?.terminal;
+        const terminal = accepted?.done || (capabilityReady && !activePrompt && record['type'] === (settledProtocol ? 'agent_settled' : 'agent_end'));
+        if (terminal || abortNonRunning) {
+            if (activePrompt?.turn) {
+                const turn = activePrompt.turn;
                 const prompt = activePrompt;
                 activePrompt = null;
-                prompt.resolve({ text: prompt.text, stderr: stderr.slice(prompt.stderrStart) });
+                const runtimeOutcome = turn.snapshot(abortNonRunning ? 'stopped' : undefined);
+                const result = { text: runtimeOutcome.partialText, stderr: stderr.slice(prompt.stderrStart), runtimeOutcome };
+                if (rpcExited)
+                    void owner.cleanup.then(() => prompt.resolve(result));
+                else
+                    prompt.resolve(result);
             }
             if (abortWait)
                 abortWait.terminal = true;
         }
         settleAbort();
     };
-    const rejectOutstanding = (error) => {
+    const rejectOutstanding = (error, status = child.killed ? 'stopped' : 'error') => {
         if (activePrompt) {
             const prompt = activePrompt;
             activePrompt = null;
-            prompt.reject(error);
+            prompt.reject(new PiRuntimeError(error, prompt.turn?.snapshot(status)
+                ?? { status, finalText: null, partialText: '' }));
         }
         if (abortWait) {
             const wait = abortWait;
@@ -543,10 +793,49 @@ export function spawnPersistentPiRpc(profile, pi, options) {
             wait.reject(error);
         }
     };
+    const claimOutstanding = (status) => {
+        const prompt = activePrompt, abort = abortWait;
+        activePrompt = null;
+        abortWait = null;
+        if (abort)
+            clearTimeout(abort.timer);
+        const outcome = prompt?.turn?.snapshot(status) ?? { status, finalText: null, partialText: '' };
+        return (error) => {
+            prompt?.reject(new PiRuntimeError(error, outcome));
+            abort?.reject(error);
+        };
+    };
+    const failSession = (error, stopped = stopRequested || child.killed) => {
+        if (failureClaim)
+            return;
+        failureClaim = { error, stopped };
+        poisoned = true;
+        closing = true;
+        abortEffective = false;
+        const publish = claimOutstanding(stopped ? 'stopped' : 'error');
+        version?.cancel();
+        void owner.teardown(true).then(() => publish(error));
+    };
+    const closeSession = (force) => {
+        stopRequested = true;
+        closing = true;
+        abortEffective = false;
+        const publish = closePromise ? null : claimOutstanding('stopped');
+        version?.cancel();
+        const cleanup = owner.teardown(force);
+        closePromise ??= cleanup.then(receipt => {
+            publish?.(new Error(receipt.rpc === 'closed'
+                ? `pi rpc session exited with code ${String(child.exitCode)}` : 'pi rpc session cleanup unconfirmed'));
+            if (receipt.cwdDisposition === 'retain')
+                throw new Error('pi execution cleanup unconfirmed');
+        });
+        void closePromise.catch(() => { console.warn('[jaw:pi] execution cleanup unconfirmed'); });
+        return closePromise;
+    };
     const session = {
         child,
-        get alive() { return !closed && child.exitCode == null && !child.killed; },
-        abortEffective: loadPiAbortEffective(profile.id, cmd),
+        get alive() { return !closed && !closing && !poisoned && child.exitCode == null && !child.killed; },
+        get abortEffective() { return capabilityReady && !closing && !poisoned && abortEffective; },
         sessionId: options.sessionId || null,
         sendPrompt(message, opts = {}) {
             if (activePrompt)
@@ -560,21 +849,34 @@ export function spawnPersistentPiRpc(profile, pi, options) {
                 // A head-only cap without this reset would freeze stderr.length
                 // and make every later slice() return ''.
                 stderr = '';
-                activePrompt = { text: '', stderrStart: stderr.length, onEvent: opts.onEvent, resolve, reject };
-                try {
-                    if (opts.effort)
-                        write('set_thinking_level', { level: opts.effort });
-                    write('prompt', { message });
-                }
-                catch (error) {
-                    activePrompt = null;
-                    reject(error);
-                }
+                const effort = opts.effort;
+                const pending = { turn: null, requestId: 0, stderrStart: stderr.length,
+                    onEvent: opts.onEvent, onRawRecord: opts.onRawRecord, resolve, reject };
+                activePrompt = pending;
+                void prepared.then(() => {
+                    if (activePrompt !== pending || !session.alive)
+                        return;
+                    pending.turn = new PiTurnAccumulator(settledProtocol);
+                    try {
+                        if (effort)
+                            write('set_thinking_level', { level: effort });
+                        pending.requestId = write('prompt', { message });
+                    }
+                    catch (error) {
+                        failSession(error);
+                    }
+                }, () => { });
             });
         },
         abort() {
             if (!activePrompt)
                 return Promise.resolve();
+            if (!activePrompt.turn) {
+                const pending = activePrompt;
+                activePrompt = null;
+                pending.resolve({ text: '', stderr: '', runtimeOutcome: { status: 'stopped', finalText: null, partialText: '' } });
+                return Promise.resolve();
+            }
             if (abortWait)
                 return Promise.reject(new Error('pi rpc abort already active'));
             return new Promise((resolve, reject) => {
@@ -592,25 +894,11 @@ export function spawnPersistentPiRpc(profile, pi, options) {
                     abortWait = null;
                     reject(new Error('pi rpc abort timed out'));
                 }, PI_RPC_ABORT_TIMEOUT_MS);
-                abortWait = { id, accepted: false, terminal: false, resolve, reject, timer };
+                abortWait = { id, onRawRecord: activePrompt?.onRawRecord, accepted: false, terminal: false, resolve, reject, timer };
             });
         },
-        close() {
-            if (closed)
-                return;
-            try {
-                child.stdin.end();
-            }
-            catch { /* already closed */ }
-            setTimeout(() => {
-                if (child.exitCode == null && !child.killed)
-                    child.kill('SIGTERM');
-            }, 750).unref();
-        },
-        kill() {
-            if (child.exitCode == null && !child.killed)
-                child.kill('SIGTERM');
-        },
+        close: () => closeSession(false),
+        kill() { void closeSession(true).catch(() => { }); },
     };
     child.stdout?.on('data', (chunk) => {
         buffer += decoder.write(chunk);
@@ -633,22 +921,47 @@ export function spawnPersistentPiRpc(profile, pi, options) {
         if (stderr.length < PI_PERSISTENT_STDERR_MAX_CHARS)
             stderr += stderrReader.write(chunk);
     });
-    child.on('error', (error) => rejectOutstanding(error));
+    child.on('error', (error) => failSession(error));
+    child.stdin?.on('error', error => failSession(error));
+    child.stdout?.on('error', error => failSession(error));
+    child.stderr?.on('error', error => failSession(error));
+    child.once('exit', (code, signal) => {
+        rpcExited = true;
+        abortEffective = false;
+        version?.cancel();
+        void owner.teardown().then(() => {
+            failSession(new Error(`pi rpc session exited with code ${String(code)}`), Boolean(signal) || child.killed);
+        });
+    });
     child.on('close', (code) => {
         closed = true;
         buffer += decoder.end();
-        if (buffer.trim())
+        if (buffer.trim() && owner.receipt?.rpc !== 'unconfirmed')
             dispatchLine(buffer.trim());
-        rejectOutstanding(new Error(`pi rpc session exited with code ${String(code)}`));
+        failSession(new Error(`pi rpc session exited with code ${String(code)}`));
     });
-    write('get_state');
-    if (options.effort)
-        write('set_thinking_level', { level: options.effort });
+    version = startPiVersionProbe(versionLaunch, cwd, versionEnv, owner, identityCurrent);
+    prepared = version.done.then(observation => {
+        if (!session.alive)
+            throw new Error('pi rpc session closed during preparation');
+        settledProtocol = observation.status === 0 && piSupportsSettled(observation.stdout);
+        abortEffective = observation.status === 0 && loadPiAbortEffective(profileId, resolvePiCommandIdentity(cmd, observation));
+        capabilityReady = true;
+        write('get_state');
+        if (initialEffort)
+            write('set_thinking_level', { level: initialEffort });
+    }).catch(error => { failSession(error); throw error; });
+    void prepared.catch(() => { });
+    owner.seal();
     return session;
 }
 export function spawnPiRpc(profile, pi, options) {
     const dir = ensurePiRuntimeConfig(pi, profile.id, options.effort || '', options.root);
-    const cmd = resolvePiCommand();
+    const inherited = { ...process.env }, cwd = options.cwd, effort = options.effort;
+    const onEvent = options.onEvent, onRawRecord = options.onRawRecord;
+    const fullPrompt = options.sysPrompt ? `${options.sysPrompt}\n\n${options.prompt}` : options.prompt;
+    const hasHistory = fullPrompt.includes('[Recent Context]');
+    const cmd = resolvePiCommand(inherited);
     const args = [
         ...cmd.baseArgs,
         '--mode', 'rpc',
@@ -660,64 +973,90 @@ export function spawnPiRpc(profile, pi, options) {
         ...(options.sessionId ? ['--session-id', options.sessionId] : []),
     ];
     const launch = resolvePiSpawn(cmd.command, args);
+    const versionLaunch = resolvePiSpawn(cmd.command, [...cmd.baseArgs, '--version']);
+    const identityCurrent = capturePiLaunchIdentity(cmd, launch);
+    const rpcEnv = mergeEnvWindowsSafe({ ...inherited, PI_CODING_AGENT_DIR: dir }, launch.envDelta);
+    const versionEnv = mergeEnvWindowsSafe({ ...inherited, PI_CODING_AGENT_DIR: dir }, versionLaunch.envDelta);
+    const owner = createPiExecutionCleanup();
     const child = spawn(launch.command, launch.args, {
-        cwd: options.cwd,
-        env: mergeEnvWindowsSafe({ ...process.env, PI_CODING_AGENT_DIR: dir }, launch.envDelta),
+        cwd,
+        env: rpcEnv,
         stdio: ['pipe', 'pipe', 'pipe'],
         ...(launch.useShell ? { shell: true } : {}),
     });
+    owner.track('rpc', child);
     const decoder = new StringDecoder('utf8');
     let buffer = '';
     let stderr = '';
-    let text = '';
     const stderrReader = createTextStreamReader();
     let sessionId = null;
-    let doneSettled = false;
+    let doneSettled = false, promptDispatched = false;
+    let turn = null;
+    let version;
     let seq = 1;
+    let promptId = 0;
+    let finish;
     const done = new Promise((resolve, reject) => {
-        const finish = (code = 0) => {
+        finish = (code = 0, status, error) => {
             if (doneSettled)
                 return;
             doneSettled = true;
-            try {
-                child.stdin.end();
-            }
-            catch { /* already closed */ }
-            setTimeout(() => {
-                if (!child.killed && child.exitCode == null)
-                    child.kill('SIGTERM');
-            }, 750);
-            resolve({ text, code, sessionId, stderr });
+            const runtimeOutcome = turn?.snapshot(status) ?? { status: status ?? 'error', finalText: null, partialText: '' };
+            const selected = { text: runtimeOutcome.partialText, code, sessionId, stderr, runtimeOutcome };
+            version?.cancel();
+            void owner.teardown(status === 'error' || status === 'stopped').then(() => {
+                if (error)
+                    reject(new PiRuntimeError(error, runtimeOutcome));
+                else
+                    resolve(selected);
+            });
         };
         let parseFailures = 0;
         const dispatchLine = (line) => {
+            if (doneSettled || owner.receipt?.rpc === 'unconfirmed')
+                return;
             let parsed;
             try {
                 parsed = JSON.parse(line);
             }
             catch {
                 parseFailures++;
-                console.warn(`[jaw:pi] JSON parse failed (${parseFailures}): ${line.slice(0, 200)}`);
+                console.warn(`[jaw:pi] JSON parse failed (${parseFailures}; ${line.length} chars; payload omitted)`);
+                return;
+            }
+            if (!promptDispatched || !turn)
+                return;
+            notifyPiRawRecord(onRawRecord, parsed);
+            const record = parsed && typeof parsed === 'object' ? parsed : {};
+            if (record['type'] === 'response' && record['command'] === 'prompt'
+                && record['id'] === promptId && record['success'] === false) {
+                finish(1, 'error');
                 return;
             }
             const event = parsePiRpcRecord(parsed);
             if (event.sessionId) {
                 sessionId = event.sessionId;
-                options.onEvent?.({ kind: 'session', sessionId });
+                notifyPiEvent(onEvent, { kind: 'session', sessionId });
             }
             if (event.tool)
-                options.onEvent?.({ kind: 'tool', ...event.tool });
+                notifyPiEvent(onEvent, { kind: 'tool', ...event.tool });
             if (event.thinking)
-                options.onEvent?.({ kind: 'thinking', text: event.thinking });
-            if (event.text && !(event.done && text)) {
-                text += event.text;
-                options.onEvent?.({ kind: 'text', text: event.text });
-            }
-            if (event.done)
+                notifyPiEvent(onEvent, { kind: 'thinking', text: event.thinking });
+            const accepted = turn.observe(parsed);
+            if (accepted.text)
+                notifyPiEvent(onEvent, { kind: 'text', text: accepted.text });
+            if (accepted.done)
                 finish(0);
         };
-        child.on('error', reject);
-        child.stdout.on('data', (chunk) => {
+        child.on('error', error => finish(1, 'error', error));
+        child.stdin?.on('error', error => finish(1, child.killed ? 'stopped' : 'error', error));
+        child.stdout?.on('error', error => finish(1, 'error', error));
+        child.stderr?.on('error', error => finish(1, 'error', error));
+        child.once('exit', (code, signal) => {
+            version?.cancel();
+            void owner.teardown().then(() => finish(code ?? 1, signal || child.killed ? 'stopped' : 'error'));
+        });
+        child.stdout?.on('data', (chunk) => {
             buffer += decoder.write(chunk);
             const lines = buffer.split('\n');
             buffer = lines.pop() ?? '';
@@ -730,24 +1069,52 @@ export function spawnPiRpc(profile, pi, options) {
                 if (line.trim())
                     dispatchLine(line.trim());
         });
-        child.stderr.on('data', (chunk) => { if (stderr.length < 4000)
+        child.stderr?.on('data', (chunk) => { if (stderr.length < 4000)
             stderr += stderrReader.write(chunk); });
-        child.on('close', (code) => {
+        child.on('close', (code, signal) => {
             if (buffer.trim())
                 dispatchLine(buffer.trim());
-            finish(code ?? 0);
+            finish(code ?? 1, signal || child.killed ? 'stopped' : 'error');
         });
     });
     const write = (type, fields = {}) => {
-        child.stdin.write(JSON.stringify({ id: seq++, type, ...fields }) + '\n');
+        if (doneSettled || child.exitCode !== null || child.signalCode !== null || child.killed || !child.stdin?.writable)
+            throw new Error('pi rpc execution is not writable');
+        const id = seq++;
+        child.stdin.write(JSON.stringify({ id, type, ...fields }) + '\n');
+        return id;
     };
-    write('get_state');
-    if (options.effort)
-        write('set_thinking_level', { level: options.effort });
-    const fullPrompt = options.sysPrompt ? `${options.sysPrompt}\n\n${options.prompt}` : options.prompt;
-    const hasHistory = fullPrompt.includes('[Recent Context]');
-    console.log(`[jaw:pi] prompt len=${fullPrompt.length}, hasHistory=${hasHistory}, effort=${options.effort || 'none'}, sessionId=${options.sessionId || 'new'}`);
-    write('prompt', { message: fullPrompt });
-    return { child, done };
+    const originalKill = child.kill.bind(child);
+    child.kill = (signal) => {
+        const stopSignal = signal === undefined || signal === 15 ? 'SIGTERM'
+            : signal === 9 ? 'SIGKILL' : signal === 2 ? 'SIGINT' : signal;
+        if (stopSignal !== 'SIGTERM' && stopSignal !== 'SIGKILL' && stopSignal !== 'SIGINT')
+            return originalKill(signal);
+        const sent = owner.killRpc(stopSignal);
+        if (!doneSettled)
+            finish(1, 'stopped');
+        else
+            owner.teardown(true);
+        return sent;
+    };
+    Object.defineProperty(child, PI_EXECUTION_CANCEL, { value: () => { child.kill('SIGTERM'); } });
+    version = startPiVersionProbe(versionLaunch, cwd, versionEnv, owner, identityCurrent);
+    void version.done.then(observation => {
+        if (doneSettled)
+            return;
+        if (child.killed || child.exitCode !== null || child.signalCode !== null) {
+            finish(1, child.killed ? 'stopped' : 'error');
+            return;
+        }
+        turn = new PiTurnAccumulator(observation.status === 0 && piSupportsSettled(observation.stdout));
+        write('get_state');
+        if (effort)
+            write('set_thinking_level', { level: effort });
+        console.log(`[jaw:pi] prompt len=${fullPrompt.length}, hasHistory=${hasHistory}, effort=${effort || 'none'}, sessionId=${options.sessionId || 'new'}`);
+        promptId = write('prompt', { message: fullPrompt });
+        promptDispatched = true;
+    }).catch(error => finish(1, child.killed ? 'stopped' : 'error', error));
+    owner.seal();
+    return { child, done, cleanup: owner.cleanup };
 }
 //# sourceMappingURL=pi-runtime.js.map