@tea-agent/loop-agent 0.39.0-next.8 → 0.39.0

package/dist/executors/pi-playwright-cli-tool.js

@@ -4,7 +4,8 @@ import { appendFile, lstat, mkdir, readFile, realpath, stat, } from "node:fs/pro
 import path from "node:path";
 import { processTreeSpawnOptions, terminateProcessTree, } from "./process-tree.js";
 import { resolvePlaywrightCliLauncher } from "./playwright-cli-launcher.js";
-import { PLAYWRIGHT_CLI_ALLOWED_COMMANDS, isPlaywrightCliCommand, } from "../shared/playwright-cli-command-policy.js";
+import { PLAYWRIGHT_CLI_ALLOWED_COMMANDS, isPlaywrightCliCommand, parsePlaywrightCliFindMatchCount, } from "../shared/playwright-cli-command-policy.js";
+import { defaultFrontendTestLayout, escapeRegexLiteral, } from "../workflows/dag/frontend-test-layout.js";
 export { PLAYWRIGHT_CLI_ALLOWED_COMMANDS, isPlaywrightCliCommand, };
 /** Logical capability name only; execution always uses the verified JS launcher. */
 export const PLAYWRIGHT_CLI_EXECUTABLE = "playwright-cli";
@@ -111,6 +112,13 @@ export async function readPlaywrightCliReceipts(runDir, nodeId) {
     }
 }
 export function summarizePlaywrightCliReceipts(receipts) {
+    // Sequence numbers are assigned at dispatch time, which is the controller's
+    // causal order. Receipt lines are appended when each command COMPLETES, so
+    // concurrent commands (e.g. parallel find calls issued in one turn) persist
+    // out of sequence order. Judge chain contiguity on the dispatch order by
+    // sorting on `sequence` first; a genuinely missing receipt (gap) or a
+    // duplicated sequence still fails the contiguity check below.
+    const orderedReceipts = [...receipts].sort((a, b) => a.sequence - b.sequence);
     let hasSuccessfulOpen = false;
     let hasInteractionOrAssertion = false;
     let hasMeaningfulAssertion = false;
@@ -122,7 +130,7 @@ export function summarizePlaywrightCliReceipts(receipts) {
     let hasContiguousControllerSequence = true;
     let previousSequence = 0;
     const caseIds = new Set();
-    for (const receipt of receipts) {
+    for (const receipt of orderedReceipts) {
         caseIds.add(receipt.caseId);
         const succeeded = receipt.exitCode === 0 && !receipt.timedOut;
         const ordered = receipt.sequence === previousSequence + 1;
@@ -137,8 +145,10 @@ export function summarizePlaywrightCliReceipts(receipts) {
         if (PLAYWRIGHT_CLI_INTERACTION_COMMANDS.has(receipt.command) && succeeded) {
             hasInteractionOrAssertion = true;
         }
-        // A successful find is the only model-visible semantic assertion in v1.
-        if (receipt.command === "find" && succeeded) {
+        // A successful find (or find-unique, its semantic wrapper) is the only
+        // model-visible semantic assertion in v1.
+        if ((receipt.command === "find" || receipt.command === "find-unique") &&
+            succeeded) {
             hasMeaningfulAssertion = true;
             if (ordered && sawOpen)
                 sawMeaningfulAssertionAfterOpen = true;
@@ -258,7 +268,8 @@ function validateOpenArgs(args, baseUrl) {
 }
 function resolveEvidenceRelative(rawPath, ctx) {
     const evidenceDir = normalizePosix(ctx.evidenceDir).replace(/\/$/, "");
-    const evidencePrefix = `testcase/frontend/evidence/${ctx.caseId}`;
+    const layout = ctx.layout ?? defaultFrontendTestLayout();
+    const evidencePrefix = `${layout.evidenceDir}/${ctx.caseId}`;
     if (!(evidenceDir === evidencePrefix ||
         evidenceDir.startsWith(`${evidencePrefix}/`))) {
         throw new PlaywrightCliPolicyError("evidence-dir-invalid", `evidenceDir must be under ${evidencePrefix}`);
@@ -282,7 +293,7 @@ function resolveEvidenceRelative(rawPath, ctx) {
     if (candidate.startsWith(`${evidenceDir}/`) || candidate === evidenceDir) {
         return candidate;
     }
-    if (candidate.startsWith("testcase/frontend/evidence/") &&
+    if (candidate.startsWith(`${layout.evidenceDir}/`) &&
         !candidate.startsWith(`${evidencePrefix}/`)) {
         throw new PlaywrightCliPolicyError("path-cross-case", "output path escapes current case evidenceDir");
     }
@@ -463,11 +474,12 @@ function assertInputPathAllowed(rawPath, ctx) {
     if (!isSafeRelativePosix(candidate)) {
         throw new PlaywrightCliPolicyError("input-path-unsafe", `unsafe input path: ${rawPath}`);
     }
+    const layout = ctx.layout ?? defaultFrontendTestLayout();
     const allowedPrefixes = [
-        `testcase/frontend/evidence/${ctx.caseId}/`,
-        "testcase/frontend/cases/",
-        "testcase/frontend/rag/",
-        "testcase/frontend/fixtures/",
+        `${layout.evidenceDir}/${ctx.caseId}/`,
+        `${layout.casesDir}/`,
+        `${layout.ragDir}/`,
+        `${layout.fixturesDir}/`,
     ];
     if (!allowedPrefixes.some((prefix) => candidate === prefix.slice(0, -1) || candidate.startsWith(prefix)) &&
         !candidate.startsWith(normalizePosix(ctx.evidenceDir) + "/")) {
@@ -523,6 +535,17 @@ export function preparePlaywrightCliArgv(input, ctx) {
     else if (command === "pdf" || command === "snapshot") {
         args = normalizePdfOrSnapshotArgs(command, rawArgs, ctx);
     }
+    else if (command === "find-unique") {
+        // find-unique is a controller-side semantic wrapper: the underlying CLI
+        // only knows `find`; uniqueness (matchCount === 1) is judged by the
+        // executor after parsing the find output. Require exactly one text
+        // literal — a unique-control assertion is meaningless with multiple.
+        const literals = rawArgs.filter((arg) => !arg.startsWith("-"));
+        if (rawArgs.length !== 1 || literals.length !== 1) {
+            throw new PlaywrightCliPolicyError("find-unique-args", "find-unique requires exactly one text literal and no flags");
+        }
+        args = literals;
+    }
     else {
         args = rewriteArgsForPaths(command, rawArgs, ctx);
     }
@@ -609,8 +632,8 @@ async function validatePlaywrightCliOutputPath(command, args, ctx) {
     if (!outputFilename)
         return;
     const repoRoot = path.resolve(ctx.repoRoot);
-    const caseEvidenceRoot = path.resolve(repoRoot, "testcase", "frontend", "evidence", ctx.caseId);
-    const evidenceDir = path.resolve(repoRoot, ctx.evidenceDir);
+    const caseEvidenceRoot = path.resolve(repoRoot, ctx.evidenceDir);
+    const evidenceDir = caseEvidenceRoot;
     const target = path.resolve(repoRoot, outputFilename);
     if (!pathIsContained(repoRoot, caseEvidenceRoot) ||
         !pathIsContained(caseEvidenceRoot, evidenceDir) ||
@@ -818,7 +841,10 @@ export async function executePlaywrightCliCommand(input, ctx, signal) {
         };
     }
     let executable = PLAYWRIGHT_CLI_EXECUTABLE;
-    let argv = [command, ...args];
+    // find-unique executes as the underlying CLI `find` command; uniqueness is
+    // a controller-side judgment on the parsed match count.
+    const cliCommand = command === "find-unique" ? "find" : command;
+    let argv = [cliCommand, ...args];
     try {
         await validatePlaywrightCliOutputPath(command, args, ctx);
         await validatePlaywrightCliInputFiles(command, args, ctx);
@@ -827,7 +853,7 @@ export async function executePlaywrightCliCommand(input, ctx, signal) {
         if (!ctx.runCommand) {
             const launcher = resolvePlaywrightCliLauncher(ctx.repoRoot);
             executable = launcher.executable;
-            argv = [...launcher.argvPrefix, command, ...args];
+            argv = [...launcher.argvPrefix, cliCommand, ...args];
         }
     }
     catch (error) {
@@ -887,6 +913,19 @@ export async function executePlaywrightCliCommand(input, ctx, signal) {
     }
     const finishedAt = new Date();
     const combined = `${runResult.stdout}\n${runResult.stderr}`;
+    // find-family commands report their match count in stdout with exit code
+    // 0 even on zero matches — parse the count so receipts carry the real
+    // assertion signal for finalize-side audits.
+    const matchCount = command === "find" || command === "find-unique"
+        ? parsePlaywrightCliFindMatchCount(runResult.stdout || "")
+        : undefined;
+    // find-unique fails closed unless exactly one match was found (including
+    // zero and unparseable outputs).
+    const findUniqueFailed = command === "find-unique" && matchCount !== 1 && !runResult.timedOut;
+    const effectiveExitCode = findUniqueFailed && runResult.exitCode === 0 ? 1 : runResult.exitCode;
+    const effectiveStderr = findUniqueFailed
+        ? `${runResult.stderr}${runResult.stderr ? "\n" : ""}find-unique: expected exactly 1 match, got ${matchCount === undefined ? "unparseable output" : `${matchCount}`}`
+        : runResult.stderr;
     const receipt = {
         schemaVersion: 1,
         caseId: ctx.caseId,
@@ -895,25 +934,28 @@ export async function executePlaywrightCliCommand(input, ctx, signal) {
         argsRedacted: redactPlaywrightCliArgs(command, args),
         startedAt: startedAt.toISOString(),
         finishedAt: finishedAt.toISOString(),
-        exitCode: runResult.exitCode,
+        exitCode: effectiveExitCode,
         durationMs: finishedAt.getTime() - startedAt.getTime(),
         outputSha256: createHash("sha256").update(combined).digest("hex"),
         toolVersion: ctx.toolVersion ?? "unknown",
         timedOut: runResult.timedOut || undefined,
+        ...(matchCount !== undefined ? { matchCount } : {}),
         errorClass: runResult.timedOut
             ? "timeout"
             : runResult.signal === "abort"
                 ? "abort"
-                : runResult.exitCode === 0
+                : effectiveExitCode === 0
                     ? undefined
-                    : "nonzero-exit",
+                    : findUniqueFailed
+                        ? "find-unique-count-mismatch"
+                        : "nonzero-exit",
     };
     await appendReceipt(ctx, receipt);
     return {
-        ok: runResult.exitCode === 0 && !runResult.timedOut,
-        exitCode: runResult.exitCode,
+        ok: effectiveExitCode === 0 && !runResult.timedOut,
+        exitCode: effectiveExitCode,
         stdout: runResult.stdout,
-        stderr: runResult.stderr,
+        stderr: effectiveStderr,
         timedOut: runResult.timedOut,
         receipt,
         errorClass: receipt.errorClass,
@@ -985,22 +1027,26 @@ export async function createPlaywrightCliTool(ctx) {
 export const PI_COMMAND_CAPABILITY_REGISTRY = {
     "playwright-cli": createPlaywrightCliTool,
 };
-export function resolveCaseIdFromWriteSet(writeSet) {
+export function resolveCaseIdFromWriteSet(writeSet, layout = defaultFrontendTestLayout()) {
+    const prefix = layout.evidenceDir.replace(/\/$/, "");
+    const escaped = escapeRegexLiteral(prefix);
+    const exact = new RegExp(`^${escaped}/([^/]+)(?:/\\*\\*)?$`);
+    const nested = new RegExp(`^${escaped}/([^/]+)/`);
     for (const entry of writeSet ?? []) {
         const normalized = normalizePosix(entry);
-        const match = normalized.match(/^testcase\/frontend\/evidence\/([^/]+)(?:\/\*\*)?$/);
+        const match = normalized.match(exact);
         if (match?.[1] && match[1] !== "**" && match[1] !== "*") {
             return match[1];
         }
-        const nested = normalized.match(/^testcase\/frontend\/evidence\/([^/]+)\//);
-        if (nested?.[1])
-            return nested[1];
+        const nestedMatch = normalized.match(nested);
+        if (nestedMatch?.[1])
+            return nestedMatch[1];
     }
     return undefined;
 }
-export function resolveEvidenceDirFromWriteSet(writeSet) {
-    const caseId = resolveCaseIdFromWriteSet(writeSet);
+export function resolveEvidenceDirFromWriteSet(writeSet, layout = defaultFrontendTestLayout()) {
+    const caseId = resolveCaseIdFromWriteSet(writeSet, layout);
     if (!caseId)
         return undefined;
-    return `testcase/frontend/evidence/${caseId}`;
+    return `${layout.evidenceDir}/${caseId}`;
 }

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) {