@hcflabs/pi-subagent 28.2.1 → 28.2.2

package/dist/direct-herdr.js

@@ -86,6 +86,9 @@ export function exactDirectTerminalTurn(jsonl, prompt) {
     return reason === "stop" || reason === "error" || reason === "aborted";
 }
 const turnSuffix = (turn) => `\n\nTurn identity: ${turn}`;
+/** How long to wait for Pi to retry a turn that ended with a provider error, and how many times. */
+const PROVIDER_RETRY_GRACE_MS = 65_000;
+const PROVIDER_RETRY_WAITS = 5;
 /** Refuse continuation unless the saved session's exact recorded turn is terminal and no later user turn exists. */
 export async function assertSettledDirectSession(sessionFile, turn) {
     const info = await stat(sessionFile).catch((error) => {
@@ -481,36 +484,65 @@ export function createDirectHerdr(pi, cwd, idleMs) {
                                 deadline = Date.now() + idleMs;
                             }
                         };
-                        while (current === "working" || current === "idle") {
-                            // A turn may finish before observation begins (or between waits).
-                            if (current === "idle") {
-                                const answer = await maybeAnswer();
-                                if (answer !== undefined)
-                                    return answer;
-                            }
-                            await observeProgress();
-                            const remaining = deadline - Date.now();
-                            if (remaining <= 0)
-                                throw new Error(`Herdr agent in tab ${tabId} made no progress for ${idleMs}ms; inspect ${sessionFile} before retrying.`);
-                            const args = ["agent", "wait", name,
-                                ...(current === "idle" ? ["--until", "working"] : ["--until", "idle"]),
-                                "--until", "done", "--until", "blocked", "--until", "unknown",
-                                "--timeout", String(Math.max(1, Math.min(current === "idle" ? 1000 : OPERATION_MS - 1000, remaining)))];
+                        let retryWaits = 0;
+                        // A provider error, such as HTTP 429, ends a turn with stopReason "error", and Pi can then retry it.
+                        // Wait a bounded time for the retry before the error counts as the final answer.
+                        const retryPending = async () => {
+                            if (retryWaits >= PROVIDER_RETRY_WAITS)
+                                return false;
+                            const info = await stat(sessionFile).catch(() => undefined);
+                            if (!info || info.size > SESSION_LIMIT)
+                                return false;
+                            if (exactFinalTurn(await readFile(sessionFile, "utf8"), prompt)?.stopReason !== "error")
+                                return false;
+                            retryWaits += 1;
+                            const args = ["agent", "wait", name, "--until", "working", "--timeout", String(PROVIDER_RETRY_GRACE_MS)];
                             const waited = await herdr.exec(args, options(signal));
                             if (waited.code !== 0 || waited.killed) {
-                                if (!waited.killed && hasHerdrErrorCode(waited, "timeout")) {
-                                    continue;
-                                }
+                                if (!waited.killed && hasHerdrErrorCode(waited, "timeout"))
+                                    return false;
                                 throw new Error(herdrCommandFailure(args, waited));
                             }
-                            const next = inspect(JSON.parse(waited.stdout), "agent_info", name, paneId, tabId);
-                            if (next !== current)
-                                deadline = Date.now() + idleMs;
-                            current = next;
+                            current = inspect(JSON.parse(waited.stdout), "agent_info", name, paneId, tabId);
+                            deadline = Date.now() + idleMs;
+                            return current === "working";
+                        };
+                        for (;;) {
+                            while (current === "working" || current === "idle") {
+                                // A turn may finish before observation begins (or between waits).
+                                if (current === "idle") {
+                                    const answer = await maybeAnswer();
+                                    if (answer !== undefined)
+                                        return answer;
+                                }
+                                await observeProgress();
+                                const remaining = deadline - Date.now();
+                                if (remaining <= 0)
+                                    throw new Error(`Herdr agent in tab ${tabId} made no progress for ${idleMs}ms; inspect ${sessionFile} before retrying.`);
+                                const args = ["agent", "wait", name,
+                                    ...(current === "idle" ? ["--until", "working"] : ["--until", "idle"]),
+                                    "--until", "done", "--until", "blocked", "--until", "unknown",
+                                    "--timeout", String(Math.max(1, Math.min(current === "idle" ? 1000 : OPERATION_MS - 1000, remaining)))];
+                                const waited = await herdr.exec(args, options(signal));
+                                if (waited.code !== 0 || waited.killed) {
+                                    if (!waited.killed && hasHerdrErrorCode(waited, "timeout")) {
+                                        continue;
+                                    }
+                                    throw new Error(herdrCommandFailure(args, waited));
+                                }
+                                const next = inspect(JSON.parse(waited.stdout), "agent_info", name, paneId, tabId);
+                                if (next !== current)
+                                    deadline = Date.now() + idleMs;
+                                current = next;
+                            }
+                            if (current !== "done")
+                                throw new Error(`Herdr agent in tab ${tabId} became ${current}; inspect it before retrying.`);
+                            const answer = await maybeAnswer();
+                            if (answer !== undefined)
+                                return answer;
+                            if (!await retryPending())
+                                return readAnswer();
                         }
-                        if (current !== "done")
-                            throw new Error(`Herdr agent in tab ${tabId} became ${current}; inspect it before retrying.`);
-                        return readAnswer();
                     },
                     async focus() {
                         // A reused pane ID must not receive focus: the agent identity must match the launch first.

package/docs/orchestration.md

@@ -143,6 +143,8 @@ If the extension cannot prove termination of the stopped worker, the workflow ke
 
 The extension retrieves each final answer from its exact Pi session file, not its possibly truncated screen. Idle, blocked, unknown, or malformed answers fail with recoverable tab and session identities. No whole-run deadline applies.
 
+A provider error, such as HTTP 429, can end a worker turn before Pi retries it automatically. When the final turn has `stopReason: "error"`, the extension waits up to 65 seconds for the worker to work again, at most 5 times for one task. The task fails only when Pi does not retry in that time.
+
 The tasks in a request share a 40 KiB inline answer budget. Each worker prompt states its share. A longer exact answer is still a success. The result shows a UTF-8-safe prefix and a truncation marker. The marker gives the path of a private `answer-<turn>.md` file beside the session file, which holds the full answer. For a write task, the budget applies to the `answer` field of the completion object. A chain step receives the full answer of the previous step in `{previous}`; the budget applies only to the result for Main. The result details keep `answerFile` for each full-answer file. Recovery text includes these paths outside the output limit, even when checkout notes remove the inline link.
 
 Herdr accepts prompt text as one command argument. To stay below the operating system's argument limit, a task packet above 64 KiB uses a private, exclusively created `task-<turn>.md` file beside the session file. This packet includes the full chain context. The worker prompt requires the Role's `read` tool to read all parts with line offsets before work starts. Pi's native `read` can return a line of exactly 50 KiB (51,200 bytes), but not a longer line. If any packet line is longer, or `read` is absent, the worker uses the Role's `bash` tool. If a line is too long and `bash` is absent, the task fails before tab creation with the read limit and a request for `bash` or shorter lines. A Role with neither tool also fails before tab creation; the extension adds no tool. The task file stays available for recovery.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hcflabs/pi-subagent",
-  "version": "28.2.1",
+  "version": "28.2.2",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",