@tea-agent/loop-agent 0.38.1 → 0.38.3

package/dist/executors/pi-executor.js

@@ -408,6 +408,50 @@ export class BoundedTextPreview {
         ].join("\n");
     }
 }
+/**
+ * Normalize provider-specific completion-limit labels to the DAG's canonical
+ * `length` signal. Other terminal reasons remain observable without being
+ * treated as truncation.
+ */
+export function normalizeProviderStopReason(value) {
+    if (typeof value !== "string" || value.trim().length === 0)
+        return undefined;
+    const trimmed = value.trim();
+    const compact = trimmed.toLowerCase().replace(/[\s_-]/g, "");
+    if ([
+        "length",
+        "maxtokens",
+        "maxoutputtokens",
+        "outputlimit",
+        "tokenlimit",
+        "tokenlimitreached",
+    ].includes(compact)) {
+        return "length";
+    }
+    return trimmed;
+}
+/**
+ * Extract a terminal stop reason from the provider event shapes used by Pi
+ * SDK/CLI bridges. Providers disagree on `stop*` versus `finish*`; keep this
+ * boundary centralized so downstream DAG recovery sees one canonical signal.
+ */
+export function extractPiEventStopReason(event) {
+    const nested = [event.message, event.response, event.completion].filter(isRecord);
+    const containers = [...nested, event];
+    for (const container of containers) {
+        for (const key of [
+            "stopReason",
+            "stop_reason",
+            "finishReason",
+            "finish_reason",
+        ]) {
+            const normalized = normalizeProviderStopReason(container[key]);
+            if (normalized)
+                return normalized;
+        }
+    }
+    return undefined;
+}
 export class PiJsonlStreamCollector {
     lineBuffer = "";
     discardUntilNewline = false;
@@ -415,6 +459,7 @@ export class PiJsonlStreamCollector {
     parsedEvents = 0;
     tokensUsed = 0;
     outputTooLarge = false;
+    stopReason;
     subagentTotalCalls = 0;
     subagentFailedCalls = 0;
     subagentModes = new Set();
@@ -454,6 +499,7 @@ export class PiJsonlStreamCollector {
             assistantText: this.assistantText.trim(),
             outputTooLarge: this.outputTooLarge,
             parsedEvents: this.parsedEvents,
+            stopReason: this.stopReason,
             subagentStats: this.formatSubagentStats(),
             tokensUsed: this.tokensUsed,
         };
@@ -472,6 +518,10 @@ export class PiJsonlStreamCollector {
         }
     }
     consumeEvent(event) {
+        const stopReason = extractPiEventStopReason(event);
+        if (stopReason === "length" || !this.stopReason) {
+            this.stopReason = stopReason ?? this.stopReason;
+        }
         const candidate = extractAssistantTextFromEvent(event);
         if (candidate !== undefined) {
             if (candidate.length > MAX_ASSISTANT_TEXT_CHARS) {
@@ -865,6 +915,7 @@ async function executeSingleCliAttempt(options, modelConfig, promptFilePath) {
                 stdoutTruncated: stdoutPreview.truncated,
                 stderrTruncated: stderrPreview.truncated,
                 outputTooLarge: collected.outputTooLarge,
+                stopReason: collected.stopReason,
                 timedOut,
                 tokensUsed: collected.tokensUsed,
                 subagentStats: collected.subagentStats,

package/dist/executors/pi-extension-resolver.js

@@ -0,0 +1,233 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Pi extension allowlist for backend implementation DAGs (plan D2/D3).
+ * DAG specs carry these frozen short ids; the executor resolves them against
+ * the Pi agent settings package inventory at run time.
+ */
+export const DAG_PI_EXTENSION_IDS = ["pi-codegraph", "pi-lens"];
+/**
+ * Alias table: one DAG short id may resolve to multiple published package
+ * names. The first settings spec whose de-`npm:`-prefixed package name is in
+ * the alias set wins (project settings override user settings).
+ */
+export const DAG_PI_EXTENSION_PACKAGE_ALIASES = {
+    "pi-codegraph": [
+        "@estebanforge/pi-codegraph-enhanced",
+        "@vndv/pi-codegraph",
+        "pi-codegraph",
+    ],
+    "pi-lens": ["pi-lens"],
+};
+/**
+ * Extension tools that must never be activated as extras on any node (D5):
+ * they mutate files without the writer path policy. Writer nodes keep only
+ * policy-wrapped edit/write; read nodes keep only navigation tools.
+ */
+export const DAG_PI_EXTENSION_WRITE_TOOL_DENY = new Set([
+    "ast_grep_replace",
+]);
+/** Builtin tool names extensions must never replace (D5). */
+export const DAG_PI_EXTENSION_PROTECTED_BUILTIN_TOOLS = new Set(["read", "edit", "write", "bash", "grep", "find", "ls"]);
+/** Deny surface extensions must never activate (D5). */
+export const DAG_PI_EXTENSION_DENIED_TOOL_IDS = new Set([
+    "apply_patch",
+    "apply-patch",
+    "full-tools",
+    "full_tools",
+    "coding-chat",
+    "coding_chat",
+    "shell",
+]);
+export function isDagPiExtensionId(value) {
+    return DAG_PI_EXTENSION_IDS.includes(value);
+}
+function getPiAgentDir() {
+    const envDir = process.env.PI_CODING_AGENT_DIR;
+    if (envDir)
+        return envDir;
+    return path.join(os.homedir(), ".pi", "agent");
+}
+function readSettingsPackages(settingsPath) {
+    try {
+        if (!existsSync(settingsPath))
+            return undefined;
+        const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
+        if (!Array.isArray(parsed.packages))
+            return undefined;
+        return parsed.packages.filter((spec) => typeof spec === "string");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Strip an `npm:` prefix from a settings package spec, e.g. `npm:pi-lens`. */
+export function packageNameFromSpec(spec) {
+    return spec.startsWith("npm:") ? spec.slice(4) : spec;
+}
+function loadPackageInventories(repoRoot) {
+    const agentDir = getPiAgentDir();
+    const userSpecs = readSettingsPackages(path.join(agentDir, "settings.json"));
+    const projectSpecs = readSettingsPackages(path.join(repoRoot, ".pi", "settings.json"));
+    const inventories = [];
+    if (userSpecs) {
+        inventories.push({
+            specs: userSpecs,
+            nodeModulesRoot: path.join(agentDir, "npm", "node_modules"),
+        });
+    }
+    if (projectSpecs) {
+        inventories.push({
+            specs: projectSpecs,
+            nodeModulesRoot: path.join(repoRoot, "node_modules"),
+        });
+    }
+    return inventories;
+}
+const EXTENSION_FILE_RE = /\.(?:ts|js|mjs|cjs)$/;
+/**
+ * Resolve a package's `pi.extensions` entries to absolute entry paths.
+ * - A file entry maps to itself.
+ * - A directory entry expands to every extension file directly inside it
+ *   (e.g. `@estebanforge/pi-codegraph-enhanced` ships `./extensions` holding
+ *   `codegraph.ts`).
+ * No `pi.extensions` declaration, or a declaration whose paths do not exist,
+ * yields no entries (caller records `no-entry`) — no heuristic scanning
+ * outside declared paths.
+ */
+export function resolvePackageEntryPaths(packageDir) {
+    let manifest;
+    try {
+        manifest = JSON.parse(readFileSync(path.join(packageDir, "package.json"), "utf8"));
+    }
+    catch {
+        return { entryPaths: [], reason: "no-entry" };
+    }
+    const declared = manifest.pi?.extensions;
+    if (!Array.isArray(declared)) {
+        return { entryPaths: [], reason: "no-entry" };
+    }
+    const entryPaths = [];
+    for (const entry of declared) {
+        if (typeof entry !== "string" || entry.length === 0)
+            continue;
+        const resolved = path.resolve(packageDir, entry);
+        if (!existsSync(resolved))
+            continue;
+        let isDirectory = false;
+        try {
+            isDirectory = statSync(resolved).isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (!isDirectory) {
+            entryPaths.push(resolved);
+            continue;
+        }
+        let names;
+        try {
+            names = readdirSync(resolved);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names.sort()) {
+            if (!EXTENSION_FILE_RE.test(name))
+                continue;
+            entryPaths.push(path.join(resolved, name));
+        }
+    }
+    if (entryPaths.length === 0) {
+        return { entryPaths: [], reason: "no-entry" };
+    }
+    return { entryPaths };
+}
+/**
+ * Resolve frozen DAG short ids against the Pi settings package inventory
+ * (user `~/.pi/agent/settings.json`, then project `.pi/settings.json` — a
+ * later match on the same alias wins). Pure synchronous read; never throws.
+ */
+export function resolveDagPiExtensions(input) {
+    const inventories = loadPackageInventories(input.repoRoot);
+    const resolved = [];
+    const missing = [];
+    for (const id of input.ids) {
+        if (!isDagPiExtensionId(id)) {
+            missing.push({
+                id,
+                reason: "package-unreadable",
+                detail: `unknown pi extension id: ${id}`,
+            });
+            continue;
+        }
+        const aliases = DAG_PI_EXTENSION_PACKAGE_ALIASES[id];
+        let matched;
+        // Later inventories (project) override earlier (user).
+        for (const inventory of inventories) {
+            for (const spec of inventory.specs) {
+                const packageName = packageNameFromSpec(spec);
+                if (!aliases.includes(packageName))
+                    continue;
+                const packageDir = path.join(inventory.nodeModulesRoot, ...packageName.split("/"));
+                if (!existsSync(packageDir))
+                    continue;
+                try {
+                    const manifest = JSON.parse(readFileSync(path.join(packageDir, "package.json"), "utf8"));
+                    if (typeof manifest.version !== "string")
+                        continue;
+                    matched = { packageDir, packageName, version: manifest.version };
+                }
+                catch {
+                    // unreadable manifest: skip this candidate
+                }
+            }
+        }
+        if (!matched) {
+            missing.push({ id, reason: "not-installed" });
+            continue;
+        }
+        const entries = resolvePackageEntryPaths(matched.packageDir);
+        if (entries.entryPaths.length === 0) {
+            missing.push({
+                id,
+                reason: entries.reason === "no-entry" ? "no-entry" : "package-unreadable",
+            });
+            continue;
+        }
+        resolved.push({
+            id,
+            packageName: matched.packageName,
+            version: matched.version,
+            entryPaths: entries.entryPaths,
+        });
+    }
+    return { resolved, missing };
+}
+/**
+ * Compute extension tool names that may join a node's active tool allowlist
+ * after session creation (D5): new tool names registered by the loaded
+ * extensions, minus protected builtins, the deny surface, and write-capable
+ * extension tools (both buckets — writer writes stay policy-wrapped only).
+ */
+export function computeExtensionToolAllowlistExtras(sessionTools, baseline) {
+    const baselineLower = new Set(baseline.map((name) => name.toLowerCase()));
+    const extras = [];
+    for (const tool of sessionTools) {
+        const name = tool && typeof tool.name === "string" ? tool.name : undefined;
+        if (!name)
+            continue;
+        const lower = name.toLowerCase();
+        if (baselineLower.has(lower))
+            continue;
+        if (DAG_PI_EXTENSION_PROTECTED_BUILTIN_TOOLS.has(lower))
+            continue;
+        if (DAG_PI_EXTENSION_DENIED_TOOL_IDS.has(lower))
+            continue;
+        if (DAG_PI_EXTENSION_WRITE_TOOL_DENY.has(lower))
+            continue;
+        extras.push(name);
+    }
+    return extras;
+}

package/dist/executors/pi-sdk-executor.js

@@ -1,8 +1,16 @@
 import { appendFile, mkdir } from "node:fs/promises";
 import path from "node:path";
-import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_ABORT_GRACE_MS, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, } from "./pi-executor.js";
+import { computeExtensionToolAllowlistExtras } from "./pi-extension-resolver.js";
+import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_ABORT_GRACE_MS, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, extractPiEventStopReason, extractAssistantTextFromPiJson, } from "./pi-executor.js";
 import { serializeSessionEvent } from "./pi-event-serializer.js";
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
+/** Same-session recovery after a transport stall. Exactly one continue per SDK attempt. */
+export const PI_SDK_STALL_CONTINUE_MAX = 1;
+/**
+ * Fixed follow-up sent after aborting a stalled prompt.
+ * Kept short so the model can resume without repeating the original task payload.
+ */
+export const PI_SDK_STALL_CONTINUE_PROMPT = "继续。上一轮因长时间无 provider 活动已被中止；请从中断处接着完成，不要重复已完成的步骤。若此前没有有效输出，请重新执行原任务。";
 let sdkSessionFactoryOverride;
 let sdkImportOverrideForTests;
 let sdkModuleOverrideForTests;
@@ -44,15 +52,15 @@ export async function resetPiSdkReuseScopeForTests() {
 export function setPiSdkSessionFactoryForTests(factory) {
     sdkSessionFactoryOverride = factory;
 }
-/** Test hook: simulate SDK import success/failure without relying on optionalDependency install state. */
+/** Test hook: simulate SDK import success/failure without relying on installed SDK state. */
 export function setPiSdkImportOverrideForTests(fn) {
     sdkImportOverrideForTests = fn;
 }
-/** Test hook: inject a mock Pi SDK module to exercise resolveSdkSessionFactory without optionalDependency. */
+/** Test hook: inject a mock Pi SDK module to exercise resolveSdkSessionFactory without loading the real SDK. */
 export function setPiSdkModuleOverrideForTests(fn) {
     sdkModuleOverrideForTests = fn;
 }
-/** Check whether the Pi SDK optional dependency satisfies the 0.80.10 runtime contract. */
+/** Check whether the Pi SDK runtime dependency satisfies the 0.83.0 runtime contract. */
 export async function checkPiSdkAvailability(_repoRoot) {
     if (sdkSessionFactoryOverride) {
         return { ok: true, detail: "pi SDK session factory override active" };
@@ -68,10 +76,10 @@ export async function checkPiSdkAvailability(_repoRoot) {
             typeof ModelRuntime?.create !== "function") {
             return {
                 ok: false,
-                detail: "pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.80.10 contract)",
+                detail: "pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.83.0 contract)",
             };
         }
-        return { ok: true, detail: "pi SDK 0.80.10 contract available" };
+        return { ok: true, detail: "pi SDK 0.83.0 contract available" };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -222,6 +230,9 @@ async function createSdkSession(sdk, input, shared) {
         noContextFiles: true,
         noSkills: true,
         noExtensions: true,
+        ...(input.additionalExtensionPaths && input.additionalExtensionPaths.length > 0
+            ? { additionalExtensionPaths: input.additionalExtensionPaths }
+            : {}),
         ...(settingsManager ? { settingsManager } : {}),
         appendSystemPromptOverride: (base) => [
             ...base,
@@ -229,6 +240,19 @@ async function createSdkSession(sdk, input, shared) {
         ],
     });
     await loader.reload();
+    // Discover extension-registered tool names BEFORE session creation (plan
+    // 2026-08-21 D5): verified against the real SDK — passing extension tool
+    // names in createAgentSession `tools` activates them, while a post-create
+    // setActiveToolsByName pin leaves the active set unchanged. Merge filtered
+    // extras into the create-time allowlist; protected builtins, the deny
+    // surface, and write-capable extension tools never join.
+    const extensionToolExtras = [];
+    if (input.additionalExtensionPaths &&
+        input.additionalExtensionPaths.length > 0) {
+        const registered = collectLoaderExtensionToolNames(loader);
+        extensionToolExtras.push(...computeExtensionToolAllowlistExtras(registered.map((name) => ({ name })), input.toolNames));
+    }
+    const sessionToolNames = [...input.toolNames, ...extensionToolExtras];
     if (input.requireWriterCustomTools) {
         if (!Array.isArray(input.customTools) || input.customTools.length === 0) {
             throw new Error("pi writer tool policy missing customTools; refusing to create uncontrolled writer session");
@@ -238,7 +262,7 @@ async function createSdkSession(sdk, input, shared) {
         cwd: input.cwd,
         sessionManager: SessionManager.inMemory(input.cwd),
         resourceLoader: loader,
-        tools: input.toolNames,
+        tools: sessionToolNames,
         modelRuntime,
         ...(settingsManager ? { settingsManager } : {}),
         ...(model ? { model } : {}),
@@ -247,6 +271,22 @@ async function createSdkSession(sdk, input, shared) {
             ? { customTools: input.customTools }
             : {}),
     });
+    if (extensionToolExtras.length > 0) {
+        // Fail closed when merged extension tools did not activate: a silent
+        // pin failure must never let the node run without its declared tools.
+        const activeTools = created.session.agent?.state?.tools;
+        if (!Array.isArray(activeTools)) {
+            throw new Error("pi SDK session does not expose agent.state.tools; refusing unverifiable extension-tool activation");
+        }
+        const activeNames = new Set(activeTools
+            .map((tool) => typeof tool?.name === "string" ? tool.name : undefined)
+            .filter((name) => Boolean(name)));
+        for (const extensionToolName of extensionToolExtras) {
+            if (!activeNames.has(extensionToolName)) {
+                throw new Error(`pi SDK extension-tool activation mismatch for ${extensionToolName}: tool did not activate at session creation`);
+            }
+        }
+    }
     const customToolNames = (input.customTools ?? [])
         .map((tool) => isRecord(tool) && typeof tool.name === "string" ? tool.name : undefined)
         .filter((name) => Boolean(name));
@@ -259,7 +299,7 @@ async function createSdkSession(sdk, input, shared) {
             .map((tool) => typeof tool?.name === "string" ? tool.name : undefined)
             .filter((name) => Boolean(name)));
         for (const customToolName of customToolNames) {
-            const expectedActive = input.toolNames.includes(customToolName);
+            const expectedActive = sessionToolNames.includes(customToolName);
             if (activeNames.has(customToolName) !== expectedActive) {
                 throw new Error(`pi SDK custom-tool activation mismatch for ${customToolName}: expectedActive=${expectedActive}`);
             }
@@ -267,6 +307,47 @@ async function createSdkSession(sdk, input, shared) {
     }
     return created.session;
 }
+/**
+ * Collect tool names registered by loader-resolved extensions. The SDK exposes
+ * each extension's `tools` as a Record (name → definition) or Map; both shapes
+ * are handled. Missing getExtensions (older SDK) yields no extras — the node
+ * then runs with the baseline allowlist only.
+ */
+function collectLoaderExtensionToolNames(loader) {
+    const getExtensions = loader?.getExtensions;
+    if (typeof getExtensions !== "function")
+        return [];
+    let parsed;
+    try {
+        parsed = getExtensions.call(loader);
+    }
+    catch {
+        return [];
+    }
+    if (!parsed || typeof parsed !== "object")
+        return [];
+    const extensions = parsed.extensions;
+    if (!Array.isArray(extensions))
+        return [];
+    const names = [];
+    for (const extension of extensions) {
+        if (!extension || typeof extension !== "object")
+            continue;
+        const tools = extension.tools;
+        if (tools instanceof Map) {
+            for (const key of tools.keys()) {
+                if (typeof key === "string")
+                    names.push(key);
+            }
+        }
+        else if (tools && typeof tools === "object") {
+            for (const key of Object.keys(tools)) {
+                names.push(key);
+            }
+        }
+    }
+    return names;
+}
 /**
  * Throttle high-noise Pi SDK events from session-events.jsonl.
  * Always keeps tool lifecycle, turn/agent end, assistant messages, and errors.
@@ -404,25 +485,6 @@ function extractSdkUsageSample(event) {
     const responseKey = responseKeyCandidates.find((value) => typeof value === "string" && value.length > 0);
     return responseKey ? { responseKey, tokens } : { tokens };
 }
-/** Extract a non-empty stop reason from a terminal SDK event.
- * Probes multiple field shapes across SDK versions so a missing field fails
- * open (undefined) rather than misclassifying an attempt. */
-function readStopReason(event) {
-    const message = isRecord(event.message) ? event.message : undefined;
-    const candidates = [
-        message?.stop_reason,
-        message?.stopReason,
-        event.stopReason,
-        event.stop_reason,
-    ];
-    for (const candidate of candidates) {
-        if (typeof candidate === "string" &&
-            candidate.trim().length > 0) {
-            return candidate.trim();
-        }
-    }
-    return undefined;
-}
 function aggregateSdkTokenUsage(samples) {
     const identified = new Map();
     let anonymousMaximum = 0;
@@ -444,6 +506,8 @@ function aggregateSdkTokenUsage(samples) {
  * When reuseScope is active, only shared auth/model resources are reused; each attempt still
  * creates and disposes its own session and resource loader. Session reuse across steps is
  * deferred until a proven reset/isolation strategy exists.
+ * A transport stall may abort the current prompt and send one continue on the
+ * same session; that is in-attempt recovery, not cross-step session reuse.
  */
 export async function executeSingleSdkAttempt(options) {
     const modelConfig = options.modelConfig;
@@ -494,7 +558,7 @@ export async function executeSingleSdkAttempt(options) {
             type === "message_end" ||
             type === "agent_end" ||
             type === "agent_settled") {
-            const candidate = readStopReason(event);
+            const candidate = extractPiEventStopReason(event);
             if (candidate)
                 stopReason = candidate;
         }
@@ -555,20 +619,37 @@ export async function executeSingleSdkAttempt(options) {
                 ? { customTools: writerCustomTools }
                 : {}),
             ...(requireWriterCustomTools ? { requireWriterCustomTools: true } : {}),
+            ...(options.piExtensionPaths && options.piExtensionPaths.length > 0
+                ? { additionalExtensionPaths: options.piExtensionPaths }
+                : {}),
         });
         let resolveStall;
         let resolveSettlement;
         let settled = false;
-        const settlementPromise = new Promise((resolve) => {
-            resolveSettlement = resolve;
-        });
-        const stallPromise = stallTimeoutMs > 0
-            ? new Promise((resolve) => {
+        let abortConfirmed = true;
+        const persistRuntimeNote = (event) => {
+            const line = serializeSessionEvent(event);
+            stdoutPreview.append(`${line}\n`);
+            stdoutCollector.append(`${line}\n`);
+            sessionEventAppender?.append(line, event);
+        };
+        const resetSettlement = () => {
+            settled = false;
+            return new Promise((resolve) => {
+                resolveSettlement = resolve;
+            });
+        };
+        const resetStallPromise = () => {
+            if (stallTimeoutMs <= 0) {
+                resolveStall = undefined;
+                return null;
+            }
+            return new Promise((resolve) => {
                 resolveStall = resolve;
-            })
-            : null;
+            });
+        };
         const armStallWatchdog = () => {
-            if (!stallPromise || !resolveStall)
+            if (stallTimeoutMs <= 0 || !resolveStall)
                 return;
             if (stallHandle)
                 clearTimeout(stallHandle);
@@ -609,17 +690,6 @@ export async function executeSingleSdkAttempt(options) {
             stdoutCollector.append(`${line}\n`);
             sessionEventAppender?.append(line, event);
         });
-        const filePrefix = options.attachedFiles
-            .map((file) => `@${file}`)
-            .join(" ");
-        const promptMessage = filePrefix
-            ? `${filePrefix}\n${options.userMessage}`
-            : options.userMessage;
-        const promptPromise = session.prompt(promptMessage);
-        // A settlement event is permitted to win the race while prompt() remains
-        // pending. Observe a later rejection so it never becomes unhandled.
-        void promptPromise.catch(() => { });
-        armStallWatchdog();
         const timeoutPromise = timeoutMs > 0
             ? new Promise((resolve) => {
                 timeoutHandle = setTimeout(() => {
@@ -627,21 +697,79 @@ export async function executeSingleSdkAttempt(options) {
                 }, timeoutMs);
             })
             : null;
-        const raced = await Promise.race([
-            promptPromise.then(() => "done"),
-            settlementPromise,
-            ...(timeoutPromise ? [timeoutPromise] : []),
-            ...(stallPromise ? [stallPromise] : []),
-        ]);
-        if (raced !== "done" && raced !== "settled") {
-            timedOut = true;
-            appendStderr(raced === "stall"
-                ? `pi SDK step stalled after ${stallTimeoutMs}ms with no provider activity`
-                : `pi SDK step timed out after ${timeoutMs}ms`);
-            const abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+        const runTurn = async (userMessage) => {
+            const settlementPromise = resetSettlement();
+            const stallPromise = resetStallPromise();
+            const promptPromise = session.prompt(userMessage);
+            // A settlement event is permitted to win the race while prompt() remains
+            // pending. Observe a later rejection so it never becomes unhandled.
+            void promptPromise.catch(() => { });
+            armStallWatchdog();
+            return Promise.race([
+                promptPromise.then(() => "done"),
+                settlementPromise,
+                ...(timeoutPromise ? [timeoutPromise] : []),
+                ...(stallPromise ? [stallPromise] : []),
+            ]);
+        };
+        const disposeSession = async () => {
             disposeAttempted = true;
             const disposeConfirmed = await runSessionActionWithGrace("dispose", () => session.dispose());
             terminationConfirmed = abortConfirmed && disposeConfirmed;
+        };
+        const failClosedAfterWait = async (reason, extraStderr, abortFirst = true) => {
+            timedOut = true;
+            appendStderr(reason === "stall"
+                ? `pi SDK step stalled after ${stallTimeoutMs}ms with no provider activity`
+                : `pi SDK step timed out after ${timeoutMs}ms`);
+            if (extraStderr)
+                appendStderr(extraStderr);
+            if (abortFirst) {
+                abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+            }
+            await disposeSession();
+        };
+        const filePrefix = options.attachedFiles
+            .map((file) => `@${file}`)
+            .join(" ");
+        const promptMessage = filePrefix
+            ? `${filePrefix}\n${options.userMessage}`
+            : options.userMessage;
+        let continuesSent = 0;
+        let raced = await runTurn(promptMessage);
+        if (raced === "stall") {
+            abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+            const withinAbsoluteTimeout = timeoutMs <= 0 || Date.now() - startedAt < timeoutMs;
+            const canContinue = abortConfirmed &&
+                writeToolCallCount === 0 &&
+                withinAbsoluteTimeout &&
+                continuesSent < PI_SDK_STALL_CONTINUE_MAX;
+            if (canContinue) {
+                // The aborted turn's stopReason must not leak onto a recovered continue.
+                stopReason = undefined;
+                continuesSent += 1;
+                persistRuntimeNote({
+                    type: "loop-agent-stall-continue",
+                    prompt: PI_SDK_STALL_CONTINUE_PROMPT,
+                    maxContinues: PI_SDK_STALL_CONTINUE_MAX,
+                });
+                raced = await runTurn(PI_SDK_STALL_CONTINUE_PROMPT);
+                if (raced !== "done" && raced !== "settled") {
+                    await failClosedAfterWait(raced === "stall" ? "stall" : "absolute-timeout", raced === "stall"
+                        ? "pi SDK stall continue did not recover; treating as timeout"
+                        : "pi SDK stall continue hit the absolute timeout", true);
+                }
+            }
+            else {
+                await failClosedAfterWait("stall", !abortConfirmed
+                    ? undefined
+                    : writeToolCallCount > 0
+                        ? "pi SDK stall continue skipped because write tools already ran"
+                        : "pi SDK stall continue skipped because absolute timeout elapsed", false);
+            }
+        }
+        else if (raced === "absolute-timeout") {
+            await failClosedAfterWait("absolute-timeout");
         }
     }
     catch (error) {