@ai-sdk/harness-pi 1.0.73 → 1.0.75

package/dist/index.js

@@ -116,13 +116,16 @@ import { mkdir as mkdir3, rm as rm2 } from "fs/promises";
 import { tmpdir } from "os";
 import path7 from "path";
 import { Type as Type2 } from "typebox";
+import {
+  HarnessCapabilityUnsupportedError as HarnessCapabilityUnsupportedError2
+} from "@ai-sdk/harness";
 import { resolveSandboxHomeDir } from "@ai-sdk/harness/utils";
 
 // src/pi-auth.ts
 import { getAiGatewayAuthFromEnv } from "@ai-sdk/harness/utils";
 
 // src/version.ts
-var VERSION = true ? "1.0.73" : "0.0.0-test";
+var VERSION = true ? "1.0.75" : "0.0.0-test";
 
 // src/pi-auth.ts
 var DEFAULT_GATEWAY_BASE_URL = "https://ai-gateway.vercel.sh";
@@ -1557,34 +1560,113 @@ function normalizeRelativePath(inputPath) {
 }
 async function readCommandOutput(sandbox, command) {
   const result = await sandbox.run({ command });
-  const output = result.stdout || result.stderr;
   if (result.exitCode != null && result.exitCode !== 0) {
     throw new Error(
-      output || `Sandbox command failed with exit code ${result.exitCode}`
+      result.stderr || result.stdout || `Sandbox command failed with exit code ${result.exitCode}`
     );
   }
-  return output;
+  return result.stdout || result.stderr;
 }
 async function listRemoteWorkspaceEntries(sandbox, sandboxWorkDir) {
-  const contextPredicate = PI_CONTEXT_FILENAMES.map(
-    (name) => `-name ${shellQuote2(name)}`
-  ).join(" -o ");
-  const configFinds = PI_CONFIG_DIRS.map(
-    (dir) => `  if [ -d ./${dir} ]; then find -L ./${dir} \\( -type d -o -type f \\) -print0; fi;`
-  );
+  const scopedPaths = [
+    ...PI_CONFIG_DIRS.map((dir) => `./${dir}`),
+    ...PI_CONTEXT_FILENAMES.map((name) => `./${name}`)
+  ];
   const listCommand = [
-    "{",
-    ...configFinds,
-    `  find . -maxdepth 1 -type f \\( ${contextPredicate} \\) -print0;`,
-    "} |",
-    "while IFS= read -r -d '' entry; do",
-    "  rel=${entry#./}",
-    '  if [ -d "$entry" ]; then',
-    `    printf 'd\\t%s\\n' "$rel"`,
-    '  elif [ -f "$entry" ]; then',
-    `    printf 'f\\t%s\\n' "$rel"`,
+    `pi_config_sources=(${scopedPaths.map(
+      (scopedPath) => shellQuote2(path6.posix.join(sandboxWorkDir, scopedPath.slice(2)))
+    ).join(" ")})`,
+    `pi_config_relatives=(${scopedPaths.map((scopedPath) => shellQuote2(scopedPath.slice(2))).join(" ")})`,
+    `pi_config_ancestors=(${scopedPaths.map(() => "''").join(" ")})`,
+    `pi_config_resolve_ancestors=(${scopedPaths.map(() => "1").join(" ")})`,
+    "pi_config_index=0",
+    'while [ "$pi_config_index" -lt "${#pi_config_sources[@]}" ]; do',
+    "  source=${pi_config_sources[$pi_config_index]}",
+    "  relative=${pi_config_relatives[$pi_config_index]}",
+    "  ancestors=${pi_config_ancestors[$pi_config_index]}",
+    "  resolve_ancestors=${pi_config_resolve_ancestors[$pi_config_index]}",
+    "  pi_config_index=$((pi_config_index + 1))",
+    '  if [ "$resolve_ancestors" = 1 ] || [ -L "$source" ]; then',
+    "    pending=$source",
+    "    resolved=",
+    "    seen_links=",
+    '    case "$pending" in',
+    "      /*) ;;",
+    "      *) pending=$PWD/$pending ;;",
+    "    esac",
+    '    while [ -n "$pending" ]; do',
+    "      pending=${pending#/}",
+    '      [ -n "$pending" ] || break',
+    "      component=${pending%%/*}",
+    '      if [ "$pending" = "$component" ]; then',
+    "        pending=",
+    "      else",
+    "        pending=${pending#*/}",
+    "      fi",
+    '      case "$component" in',
+    '        ""|.) continue ;;',
+    "        ..)",
+    "          resolved=${resolved%/*}",
+    "          continue",
+    "          ;;",
+    "      esac",
+    "      candidate=$resolved/$component",
+    '      if [ -L "$candidate" ]; then',
+    '        case "$seen_links" in',
+    '          *"',
+    '"$candidate"',
+    '"*)',
+    `            printf 'Pi config traversal encountered a symlink cycle at %s\\n' "$candidate" >&2`,
+    "            exit 1",
+    "            ;;",
+    "        esac",
+    '        seen_links=$seen_links"',
+    '"$candidate"',
+    '"',
+    '        target=$(readlink "$candidate") || exit $?',
+    '        case "$target" in',
+    "          /*) pending=$target${pending:+/$pending} ;;",
+    "          *) pending=${candidate%/*}/$target${pending:+/$pending} ;;",
+    "        esac",
+    "        resolved=",
+    "      else",
+    "        resolved=$candidate",
+    "      fi",
+    "    done",
+    '    if [ -z "$resolved" ]; then',
+    `      printf 'Pi config traversal resolved %s to the filesystem root; skipping\\n' "$relative" >&2`,
+    "      continue",
+    "    fi",
+    "    source=$resolved",
     "  fi",
-    "done | LC_ALL=C sort"
+    '  if [ -d "$source" ]; then',
+    '    case "$ancestors" in',
+    '      *"',
+    '"$source"',
+    '"*)',
+    `        printf 'Pi config traversal encountered a symlink cycle at %s\\n' "$relative" >&2`,
+    "        exit 1",
+    "        ;;",
+    "    esac",
+    '    ancestors=$ancestors"',
+    '"$source"',
+    '"',
+    `    printf 'd\\t%s\\n' "$relative"`,
+    '    for child in "$source"/* "$source"/.[!.]* "$source"/..?*; do',
+    '      if [ -L "$child" ] || [ -d "$child" ] || [ -f "$child" ]; then',
+    "        child_name=${child##*/}",
+    '        pi_config_sources+=("$child")',
+    '        pi_config_relatives+=("$relative/$child_name")',
+    '        pi_config_ancestors+=("$ancestors")',
+    "        pi_config_resolve_ancestors+=(0)",
+    "      fi",
+    "    done",
+    '  elif [ -f "$source" ]; then',
+    `    printf 'f\\t%s\\t%s\\n' "$relative" "$source"`,
+    "  fi",
+    "  true",
+    "done",
+    "true"
   ].join("\n");
   const output = await readCommandOutput(
     sandbox,
@@ -1593,11 +1675,13 @@ async function listRemoteWorkspaceEntries(sandbox, sandboxWorkDir) {
   const directories = [];
   const files = [];
   for (const line of output.split("\n").filter(Boolean)) {
-    const [kind, rawPath] = line.split("	", 2);
+    const [kind, rawPath, sandboxPath] = line.split("	", 3);
     if (!rawPath) continue;
     const relativePath = normalizeRelativePath(rawPath);
     if (kind === "d") directories.push(relativePath);
-    else if (kind === "f") files.push(relativePath);
+    else if (kind === "f" && sandboxPath) {
+      files.push({ relativePath, sandboxPath });
+    }
   }
   return { directories, files };
 }
@@ -1648,7 +1732,7 @@ function buildRequiredDirectories(remoteDirectories, remoteFiles) {
     directories.add(normalizeRelativePath(directory));
   }
   for (const file of remoteFiles) {
-    let current = path6.dirname(normalizeRelativePath(file));
+    let current = path6.dirname(normalizeRelativePath(file.relativePath));
     while (current !== "." && current !== path6.sep && current.length > 0) {
       directories.add(current);
       current = path6.dirname(current);
@@ -1663,7 +1747,9 @@ async function syncHostWorkspaceFromSandbox(args) {
     sandboxWorkDir
   );
   const hostEntries = await collectHostScopedEntries(hostWorkDir);
-  const remoteFiles = new Set(remoteEntries.files);
+  const remoteFiles = new Set(
+    remoteEntries.files.map((file) => file.relativePath)
+  );
   const requiredDirectories = buildRequiredDirectories(
     remoteEntries.directories,
     remoteEntries.files
@@ -1685,15 +1771,11 @@ async function syncHostWorkspaceFromSandbox(args) {
   )) {
     await mkdir2(path6.join(hostWorkDir, relativePath), { recursive: true });
   }
-  for (const relativePath of remoteEntries.files) {
-    const remotePath = path6.posix.join(
-      sandboxWorkDir,
-      relativePath.split(path6.sep).join("/")
-    );
-    const bytes = await sandbox.readBinaryFile({ path: remotePath });
+  for (const { relativePath, sandboxPath } of remoteEntries.files) {
+    const bytes = await sandbox.readBinaryFile({ path: sandboxPath });
     if (!bytes) {
       throw new Error(
-        `Sandbox workspace file disappeared during mirror sync: ${remotePath}`
+        `Sandbox workspace file disappeared during mirror sync: ${sandboxPath}`
       );
     }
     const content = Buffer.from(bytes);
@@ -1973,6 +2055,9 @@ async function createPiSession(input) {
   let suspending = false;
   const pendingToolResults = /* @__PURE__ */ new Map();
   const pendingToolApprovals = /* @__PURE__ */ new Map();
+  const deliveredDanglingResults = /* @__PURE__ */ new Map();
+  let restoredSessionManager;
+  let deferredRerun;
   let currentEmit;
   let translatorState;
   let activeTurn;
@@ -2011,15 +2096,161 @@ async function createPiSession(input) {
       sessionFileName
     });
   }
-  function createPromptControl(input2) {
-    const abortHandler = () => {
-      piSession?.abort().catch(() => {
+  function getRestoredSessionManager() {
+    if (resumeSessionFilePath == null) return void 0;
+    restoredSessionManager ??= SessionManager.open(
+      resumeSessionFilePath,
+      hostSessionDir,
+      sessionWorkDir
+    );
+    return restoredSessionManager;
+  }
+  function findDanglingHostToolCalls(userTools) {
+    if (piSession != null || resumeSessionFilePath == null) return [];
+    const hostToolNames = new Set(userTools.map((tool2) => tool2.name));
+    if (hostToolNames.size === 0) return [];
+    const journal = getRestoredSessionManager();
+    if (journal == null) return [];
+    const messages = journal.buildSessionContext().messages;
+    const resolvedToolCallIds = new Set(
+      deliveredDanglingResults.keys()
+    );
+    for (const message of messages) {
+      if (message.role === "toolResult") {
+        resolvedToolCallIds.add(message.toolCallId);
+      }
+    }
+    const dangling = [];
+    for (const message of messages) {
+      if (message.role !== "assistant") continue;
+      if (message.stopReason === "error" || message.stopReason === "aborted") {
+        continue;
+      }
+      for (const block of message.content) {
+        if (block.type === "toolCall" && hostToolNames.has(block.name) && !resolvedToolCallIds.has(block.id)) {
+          dangling.push({ toolCallId: block.id, toolName: block.name });
+        }
+      }
+    }
+    return dangling;
+  }
+  function acceptDanglingHostToolResult(args) {
+    const barrier = deferredRerun;
+    const toolName = barrier?.awaiting.get(args.toolCallId);
+    if (barrier == null || toolName == null) return;
+    barrier.awaiting.delete(args.toolCallId);
+    deliveredDanglingResults.set(args.toolCallId, {
+      toolName,
+      output: args.output,
+      isError: args.isError ?? false
+    });
+    if (barrier.awaiting.size === 0) {
+      barrier.startRerun();
+    }
+  }
+  function appendDeliveredHostToolResults() {
+    if (deliveredDanglingResults.size === 0 || resumeSessionFilePath == null) {
+      return false;
+    }
+    const journal = getRestoredSessionManager();
+    if (journal == null) return false;
+    for (const [toolCallId, delivered] of deliveredDanglingResults) {
+      journal.appendMessage({
+        role: "toolResult",
+        toolCallId,
+        toolName: delivered.toolName,
+        content: [
+          { type: "text", text: serializeToolOutput(delivered.output) }
+        ],
+        isError: delivered.isError,
+        timestamp: Date.now()
       });
+    }
+    deliveredDanglingResults.clear();
+    if (!sessionFileName) {
+      sessionFileName = safePiSessionFileName(
+        path7.basename(resumeSessionFilePath)
+      );
+    }
+    return true;
+  }
+  function deferRerunUntilHostToolResults(danglingCalls, continueOpts) {
+    deferredRerun?.cancel();
+    let resolveDone;
+    let rejectDone;
+    const done = new Promise((resolve, reject) => {
+      resolveDone = resolve;
+      rejectDone = reject;
+    });
+    let settled = false;
+    const startRerun = () => {
+      if (settled) return;
+      settled = true;
+      deferredRerun = void 0;
+      void (async () => {
+        try {
+          const control = await runTurn({
+            text: "",
+            tools: continueOpts.tools ?? [],
+            instructions: continueOpts.instructions,
+            emit: continueOpts.emit,
+            abortSignal: continueOpts.abortSignal
+          });
+          await control.done;
+          resolveDone();
+        } catch (error) {
+          rejectDone(error);
+        }
+      })();
     };
-    if (input2.abortSignal) {
-      input2.abortSignal.addEventListener("abort", abortHandler, {
+    const cancel = (reason) => {
+      if (settled) return;
+      settled = true;
+      deferredRerun = void 0;
+      if (reason == null) {
+        resolveDone();
+      } else {
+        rejectDone(reason);
+      }
+    };
+    deferredRerun = {
+      awaiting: new Map(
+        danglingCalls.map((call) => [call.toolCallId, call.toolName])
+      ),
+      startRerun,
+      cancel
+    };
+    const abortBarrier = () => {
+      cancel(
+        continueOpts.abortSignal?.reason ?? new Error(
+          "Pi turn was aborted before its host tool results were delivered."
+        )
+      );
+    };
+    if (continueOpts.abortSignal?.aborted) {
+      abortBarrier();
+    } else {
+      continueOpts.abortSignal?.addEventListener("abort", abortBarrier, {
         once: true
       });
+    }
+    return createPromptControl({
+      done,
+      abortSignal: continueOpts.abortSignal
+    });
+  }
+  function createPromptControl(input2) {
+    const abortHandler = () => {
+      void input2.abort?.(input2.abortSignal?.reason);
+    };
+    if (input2.abortSignal) {
+      if (input2.abortSignal.aborted) {
+        abortHandler();
+      } else {
+        input2.abortSignal.addEventListener("abort", abortHandler, {
+          once: true
+        });
+      }
       void input2.done.then(
         () => {
           input2.abortSignal?.removeEventListener("abort", abortHandler);
@@ -2032,7 +2263,10 @@ async function createPiSession(input) {
     return {
       async submitToolResult(args) {
         const pending = pendingToolResults.get(args.toolCallId);
-        if (!pending) return;
+        if (!pending) {
+          acceptDanglingHostToolResult(args);
+          return;
+        }
         pendingToolResults.delete(args.toolCallId);
         translatorState?.hostToolResults.set(args.toolCallId, args.output);
         pending.resolve(args.output);
@@ -2121,11 +2355,7 @@ async function createPiSession(input) {
     }
     const { customTools, builtinNames } = buildToolDefinitions(userTools);
     const toolNames = customTools.map((t) => t.name);
-    const sessionManager = isFirstBuild && resumeSessionFilePath ? SessionManager.open(
-      resumeSessionFilePath,
-      hostSessionDir,
-      sessionWorkDir
-    ) : SessionManager.create(sessionWorkDir, hostSessionDir);
+    const sessionManager = isFirstBuild && resumeSessionFilePath ? getRestoredSessionManager() : SessionManager.create(sessionWorkDir, hostSessionDir);
     const { session } = await createAgentSession({
       cwd: sessionWorkDir,
       agentDir: hostAgentDir,
@@ -2170,90 +2400,137 @@ async function createPiSession(input) {
       throw new Error("Pi session has been stopped.");
     }
     const userTools = turnOpts.tools;
-    const signature = JSON.stringify(userTools.map((t) => t.name).sort());
-    const needsRebuild = piSession == null || signature !== lastToolsSignature;
-    let resourcesReloaded = false;
-    if (needsRebuild) {
-      resourcesReloaded = await rebuildPiSession(userTools, piSession == null);
-      lastToolsSignature = signature;
-    }
-    if (!resourcesReloaded) {
-      await reloadResourcesOnly();
-    }
-    await syncHostWorkspaceFromSandbox({
-      sandbox,
-      sandboxWorkDir: input.sessionWorkDir,
-      hostWorkDir
-    });
     currentEmit = turnOpts.emit;
-    translatorState = createPiTranslatorState({
-      builtinToolNames: [...PI_NATIVE_BUILTIN_NAMES],
-      hostToolNames: userTools.map((tool2) => tool2.name),
-      nativeToCommon: NATIVE_TO_COMMON
-    });
-    turnOpts.emit({ type: "stream-start" });
-    const turnPromise = (async () => {
-      let terminalError;
-      const session = piSession;
-      const unsubErr = session.subscribe((raw) => {
-        const ev = parseNativeEvent(raw);
-        if (!ev) return;
-        const err = getPiTerminalError(ev);
-        if (err && !terminalError) {
-          terminalError = err;
-        }
+    const turnAbortController = new AbortController();
+    const abort = async (reason) => {
+      if (turnAbortController.signal.aborted) return;
+      if (reason === void 0) {
+        turnAbortController.abort();
+      } else {
+        turnAbortController.abort(reason);
+      }
+      await Promise.resolve(piSession?.abort()).catch(() => {
       });
+    };
+    const turnPromise = (async () => {
       try {
-        await session.prompt(turnOpts.text);
-        if (terminalError) {
-          if (suspending && isAbortError(terminalError)) return;
-          currentEmit?.({ type: "error", error: new Error(terminalError) });
-          return;
+        await applySessionInstructions(turnOpts.instructions);
+        turnAbortController.signal.throwIfAborted();
+        const didAppendDeliveredHostToolResults = appendDeliveredHostToolResults();
+        const signature = JSON.stringify(userTools.map((t) => t.name).sort());
+        const needsRebuild = piSession == null || signature !== lastToolsSignature;
+        let resourcesReloaded = false;
+        if (needsRebuild) {
+          resourcesReloaded = await rebuildPiSession(
+            userTools,
+            piSession == null
+          );
+          turnAbortController.signal.throwIfAborted();
+          lastToolsSignature = signature;
         }
-        const stats = session.getSessionStats();
-        const finishReason = {
-          unified: "stop",
-          raw: void 0
-        };
-        const usage = {
-          inputTokens: {
-            total: stats.tokens.input,
-            noCache: void 0,
-            cacheRead: stats.tokens.cacheRead,
-            cacheWrite: stats.tokens.cacheWrite
-          },
-          outputTokens: {
-            total: stats.tokens.output,
-            text: void 0,
-            reasoning: void 0
+        if (!resourcesReloaded) {
+          await reloadResourcesOnly();
+          turnAbortController.signal.throwIfAborted();
+        }
+        await syncHostWorkspaceFromSandbox({
+          sandbox,
+          sandboxWorkDir: input.sessionWorkDir,
+          hostWorkDir
+        });
+        turnAbortController.signal.throwIfAborted();
+        translatorState = createPiTranslatorState({
+          builtinToolNames: [...PI_NATIVE_BUILTIN_NAMES],
+          hostToolNames: userTools.map((tool2) => tool2.name),
+          nativeToCommon: NATIVE_TO_COMMON
+        });
+        currentEmit?.({ type: "stream-start" });
+        if (didAppendDeliveredHostToolResults) {
+          currentEmit?.({
+            type: "finish-step",
+            finishReason: { unified: "tool-calls", raw: void 0 },
+            usage: {
+              inputTokens: {
+                total: 0,
+                noCache: 0,
+                cacheRead: 0,
+                cacheWrite: 0
+              },
+              outputTokens: {
+                total: 0,
+                text: 0,
+                reasoning: 0
+              }
+            },
+            harnessMetadata: { pi: { inferredStep: true } }
+          });
+        }
+        let terminalError;
+        const session = piSession;
+        const unsubErr = session.subscribe((raw) => {
+          const ev = parseNativeEvent(raw);
+          if (!ev) return;
+          const err = getPiTerminalError(ev);
+          if (err && !terminalError) {
+            terminalError = err;
           }
-        };
-        currentEmit?.({
-          type: "finish",
-          finishReason,
-          totalUsage: usage
         });
+        try {
+          await session.prompt(turnOpts.text);
+          if (terminalError) {
+            if (suspending && isAbortError(terminalError)) return;
+            currentEmit?.({ type: "error", error: new Error(terminalError) });
+            return;
+          }
+          const stats = session.getSessionStats();
+          const finishReason = {
+            unified: "stop",
+            raw: void 0
+          };
+          const usage = {
+            inputTokens: {
+              total: stats.tokens.input,
+              noCache: void 0,
+              cacheRead: stats.tokens.cacheRead,
+              cacheWrite: stats.tokens.cacheWrite
+            },
+            outputTokens: {
+              total: stats.tokens.output,
+              text: void 0,
+              reasoning: void 0
+            }
+          };
+          currentEmit?.({
+            type: "finish",
+            finishReason,
+            totalUsage: usage
+          });
+        } catch (err) {
+          if (suspending && isAbortError(err)) return;
+          currentEmit?.({ type: "error", error: err });
+        } finally {
+          unsubErr();
+        }
       } catch (err) {
         if (suspending && isAbortError(err)) return;
-        currentEmit?.({ type: "error", error: err });
-      } finally {
-        unsubErr();
+        throw err;
       }
     })();
     const activeTurnToken = {};
     const done = turnPromise.finally(() => {
       if (activeTurn?.token === activeTurnToken) {
         activeTurn = void 0;
+        currentEmit = void 0;
       }
-      currentEmit = void 0;
     });
     activeTurn = {
       token: activeTurnToken,
-      done
+      done,
+      abort
     };
     return createPromptControl({
       done,
-      abortSignal: turnOpts.abortSignal
+      abortSignal: turnOpts.abortSignal,
+      abort
     });
   }
   const doStop = async () => {
@@ -2262,8 +2539,18 @@ async function createPiSession(input) {
     }
     stopped = true;
     parkedPiSessions.delete(input.sessionId);
+    deferredRerun?.cancel();
+    const turnToStop = activeTurn;
+    const abortingTurn = turnToStop?.abort();
     settlePendingToolResults("Pi session stopped");
     settlePendingToolApprovals("Pi session stopped");
+    await abortingTurn;
+    await turnToStop?.done.catch(() => {
+    });
+    try {
+      appendDeliveredHostToolResults();
+    } catch {
+    }
     if (sessionFileName) {
       try {
         await persistSessionFile();
@@ -2290,26 +2577,51 @@ async function createPiSession(input) {
     // only resume path is restoring the session file on a fresh/snapshotted
     // sandbox, i.e. `rerun`.
     doPromptTurn: async (promptOpts) => {
-      await applySessionInstructions(promptOpts.instructions);
+      if (promptOpts.responseFormat?.type === "json") {
+        throw new HarnessCapabilityUnsupportedError2({
+          message: "Harness 'pi' does not support structured output.",
+          harnessId: HARNESS_ID2
+        });
+      }
       return runTurn({
         text: extractUserText(promptOpts.prompt),
         tools: promptOpts.tools ?? [],
+        instructions: promptOpts.instructions,
         emit: promptOpts.emit,
         abortSignal: promptOpts.abortSignal
       });
     },
     doContinueTurn: async (continueOpts) => {
+      if (continueOpts.responseFormat?.type === "json") {
+        throw new HarnessCapabilityUnsupportedError2({
+          message: "Harness 'pi' does not support structured output.",
+          harnessId: HARNESS_ID2
+        });
+      }
       if (activeTurn != null) {
         currentEmit = continueOpts.emit;
         return createPromptControl({
           done: activeTurn.done,
-          abortSignal: continueOpts.abortSignal
+          abortSignal: continueOpts.abortSignal,
+          abort: activeTurn.abort
         });
       }
-      await applySessionInstructions(continueOpts.instructions);
+      if (stopped) {
+        throw new Error("Pi session has been stopped.");
+      }
+      const danglingHostToolCalls = findDanglingHostToolCalls(
+        continueOpts.tools ?? []
+      );
+      if (danglingHostToolCalls.length > 0) {
+        return deferRerunUntilHostToolResults(
+          danglingHostToolCalls,
+          continueOpts
+        );
+      }
       return runTurn({
         text: "",
         tools: continueOpts.tools ?? [],
+        instructions: continueOpts.instructions,
         emit: continueOpts.emit,
         abortSignal: continueOpts.abortSignal
       });
@@ -2324,8 +2636,14 @@ async function createPiSession(input) {
       if (stopped) return;
       stopped = true;
       parkedPiSessions.delete(input.sessionId);
+      deferredRerun?.cancel();
+      const turnToDestroy = activeTurn;
+      const abortingTurn = turnToDestroy?.abort();
       settlePendingToolResults("Pi session stopped");
       settlePendingToolApprovals("Pi session stopped");
+      await abortingTurn;
+      await turnToDestroy?.done.catch(() => {
+      });
       await disposePiSession();
       workspaceVfs.unmount();
       await rm2(hostRoot, { recursive: true, force: true });
@@ -2369,8 +2687,15 @@ async function createPiSession(input) {
         };
       }
       suspending = true;
-      await Promise.resolve(piSession?.abort()).catch(() => {
+      const turnToSuspend = activeTurn;
+      await turnToSuspend?.abort();
+      deferredRerun?.cancel();
+      await turnToSuspend?.done.catch(() => {
       });
+      try {
+        appendDeliveredHostToolResults();
+      } catch {
+      }
       if (sessionFileName) {
         try {
           await persistSessionFile();