@akagilnc/pi-workflow-roles 0.1.5252 → 0.1.5270

package/dist/host-descriptions.js

@@ -9,7 +9,6 @@ export const HOST_DESCRIPTIONS = Object.freeze({
             modelFlag: "--model",
         }),
         modelPassing: "argv",
-        boundResume: "session/load",
         sessionBindingFile: "grok-acp-session.json",
     }),
     /**
@@ -27,7 +26,6 @@ export const HOST_DESCRIPTIONS = Object.freeze({
             thinkingFlag: "--reasoning",
         }),
         modelPassing: "set_model",
-        boundResume: "session/load",
         sessionBindingFile: "hermes-acp-session.json",
         seatProfileSoul: Object.freeze({
             flag: "-p",

package/dist/navigator-public-session.js

@@ -136,9 +136,14 @@ function createNativeNavigatorSessionFactory(deps) {
           }
           if (outcome.kind === "failure") {
             providerFailure = navigatorProviderFailureFromPublicTerminal(outcome);
+            const failedAttempts = outcome.decisiveFacts.failedAttempts;
+            const attemptReasons = Array.isArray(failedAttempts) ? failedAttempts.map((entry, index) => {
+              const fact = entry !== null && typeof entry === "object" ? entry : void 0;
+              return `${typeof fact?.attempt === "number" ? fact.attempt + 1 : index + 1}: ${typeof fact?.diagnostic === "string" ? fact.diagnostic : outcome.diagnostic}`;
+            }) : [];
             throw navigatorUnavailableError(
               providerFailure.source,
-              new Error(outcome.diagnostic),
+              new Error(attemptReasons.length > 0 ? attemptReasons.join("\n") : outcome.diagnostic),
               providerFailure.cause
             );
           }

package/dist/pi/durable-principal.js

@@ -1,4 +1,3 @@
-import { lstat } from "node:fs/promises";
 import { join } from "node:path";
 import { resolveBookKeyFromGit } from "../activation-ledger-git.js";
 import { resolveActivationLedgerHome } from "../activation-ledger-topology.js";
@@ -21,7 +20,7 @@ export function issuePiDurablePrincipalCoordinates(request) {
         ...placement,
     };
 }
-/** Pi's durable-principal codec and availability authority. */
+/** Pi's durable-principal codec. */
 export const piDurablePrincipalAuthority = {
     issue(request) {
         const coordinates = issuePiDurablePrincipalCoordinates(request);
@@ -51,14 +50,4 @@ export const piDurablePrincipalAuthority = {
                 : join(record.sessionDirectory, "session.jsonl"),
         };
     },
-    async isAvailable(principal) {
-        const { sessionFile } = this.decode(principal);
-        try {
-            const stat = await lstat(sessionFile);
-            return stat.isFile() && !stat.isSymbolicLink();
-        }
-        catch {
-            return false;
-        }
-    },
 };

package/dist/public-cli/auto-resume.js

@@ -30,7 +30,7 @@ const dummyIo = { stdout: () => { }, stderr: () => { } };
  * Write failure must escape the retried dispatch try instead of becoming a
  * synthetic host-turn terminal.
  */
-export async function persistReturnedRunState(admitted, authority, options) {
+export async function persistReturnedRunState(admitted, options) {
     if (options?.lawful === true) {
         await markRunTerminal(admitted.runDirectory);
         return;
@@ -40,10 +40,8 @@ export async function persistReturnedRunState(admitted, authority, options) {
     });
     const typedHttp429 = resumeObservation.typedHttp429;
     if (admitted.principal !== undefined && typedHttp429 !== undefined) {
-        if (await authority.isAvailable(admitted.principal)) {
-            await markRunResumable(admitted.runDirectory, typedHttp429);
-            return;
-        }
+        await markRunResumable(admitted.runDirectory, typedHttp429);
+        return;
     }
     await markRunTerminal(admitted.runDirectory);
 }
@@ -286,8 +284,6 @@ export async function runWithAutoResumeLoop(options) {
     // `attempts >= limit` comparison (always false) — reject here, before any dispatch.
     const limit = options.autoResumeLimit ?? AUTO_RESUME_LIMIT;
     parseAutoResumeLimit(limit);
-    const isPrincipalAvailable = options.isPrincipalAvailable ??
-        ((principal) => options.principalAuthority.isAvailable(principal));
     let autoResumeAttempts = 0;
     let isFirst = true;
     let currentPayload = options.buildInitialPayload();
@@ -295,6 +291,9 @@ export async function runWithAutoResumeLoop(options) {
     let lastThrownError;
     let everyAttemptThrew = true;
     const retainedErrorFiles = [];
+    const failedAttempts = [];
+    let stoppedResult;
+    let endReason;
     while (true) {
         let result;
         // Set only when the caught throw is a TurnDispatchedFailure (#840 r9 判词
@@ -317,6 +316,11 @@ export async function runWithAutoResumeLoop(options) {
             // diagnostic-sink-isolation precedent). When a lease is held inside
             // dispatch, that path owns release in its own finally.
             lastThrownError = error;
+            const failedAttempt = {
+                attempt: dispatchOrdinal,
+                diagnostic: describeErrorIdentity(unwrapTurnDispatchedFailure(error)),
+            };
+            failedAttempts.push(failedAttempt);
             turnStartedBeforeThrow = error instanceof TurnDispatchedFailure;
             const attempt = dispatchOrdinal;
             try {
@@ -325,6 +329,7 @@ export async function runWithAutoResumeLoop(options) {
                 // never orphan the retained file (#426 fix_now #5).
                 const { file, pointerError } = await retainDispatchError(options.admitted, options.principalAuthority, options.sessionAppender, attempt, error);
                 retainedErrorFiles.push(file);
+                failedAttempt.errorFile = file;
                 options.io.stderr(`dispatch attempt ${attempt} threw (${describeErrorIdentity(error)}); full error retained at ${file}\n`);
                 if (pointerError !== undefined) {
                     options.io.stderr(`dispatch error retention failed (best-effort continue): ${describeErrorIdentity(pointerError)}\n`);
@@ -348,95 +353,31 @@ export async function runWithAutoResumeLoop(options) {
             const terminal = result.terminal;
             if (terminal !== undefined) {
                 terminal.autoResumeCount = autoResumeAttempts;
-            }
-            const lawful = terminal !== undefined && isLawfulTypedTerminalOutcome(terminal.roleOutcome);
-            if (lawful) {
-                if (terminal !== undefined) {
-                    // Present lawful terminal once to real io (dummy was used inside dispatch)
-                    options.io.stdout(formatTerminalResult(terminal));
+                if (terminal.roleOutcome.kind === "failure") {
+                    failedAttempts.push({
+                        attempt: dispatchOrdinal - 1,
+                        diagnostic: terminal.roleOutcome.diagnostic,
+                        decisiveFacts: terminal.roleOutcome.decisiveFacts,
+                    });
                 }
-                return result;
-            }
-            if (result.skipAutoResume === true) {
-                if (terminal !== undefined)
-                    presentTerminal(terminal, options.io);
-                return result;
-            }
-            // #855: process cancel — stop even if dispatch forgot skipAutoResume.
-            if (processCancelSignalName(options.signal) !== undefined) {
-                if (terminal !== undefined)
-                    presentTerminal(terminal, options.io);
-                return result;
-            }
-        }
-        if (result !== undefined) {
-            const terminal = result.terminal;
-            if (autoResumeAttempts >= limit) {
-                if (terminal !== undefined)
-                    presentTerminal(terminal, options.io);
-                return result;
             }
-            if (result.turnDispatched === true
-                && !(await isPrincipalAvailable(options.admitted.principal))) {
-                if (terminal !== undefined)
-                    presentTerminal(terminal, options.io);
-                return result;
+            if (terminal !== undefined && isLawfulTypedTerminalOutcome(terminal.roleOutcome)
+                || result.skipAutoResume === true
+                || autoResumeAttempts >= limit
+                || processCancelSignalName(options.signal) !== undefined) {
+                stoppedResult = result;
+                break;
             }
         }
         else {
-            // Exception path: continue through the identical budget/session gates.
             if (autoResumeAttempts >= limit) {
-                const terminal = await attachDispatchExceptionTerminal(options.admitted, dispatchExceptionFailureTerminal({
-                    role: options.admitted.role,
-                    runId: options.admitted.runId,
-                    causeError: lastThrownError,
-                    errorFiles: retainedErrorFiles,
-                    autoResumeAttempts,
-                    endReason: "auto-resume budget exhausted",
-                    everyAttemptThrew,
-                }), options.io);
-                await finalizeExceptionRunBestEffort(options.admitted.runDirectory, options.io);
-                presentTerminal(terminal, options.io);
-                return {
-                    exitCode: 1,
-                    terminal,
-                };
+                endReason = "auto-resume budget exhausted";
+                break;
             }
-            // #855: process cancel on the throw path — do not re-dispatch; name the signal.
             const cancelName = processCancelSignalName(options.signal);
             if (cancelName !== undefined) {
-                const terminal = await attachDispatchExceptionTerminal(options.admitted, dispatchExceptionFailureTerminal({
-                    role: options.admitted.role,
-                    runId: options.admitted.runId,
-                    causeError: lastThrownError,
-                    errorFiles: retainedErrorFiles,
-                    autoResumeAttempts,
-                    endReason: `ak-role terminated by ${cancelName}`,
-                    everyAttemptThrew,
-                }), options.io);
-                await finalizeExceptionRunBestEffort(options.admitted.runDirectory, options.io);
-                presentTerminal(terminal, options.io);
-                return {
-                    exitCode: 1,
-                    terminal,
-                };
-            }
-            if (!(await isPrincipalAvailable(options.admitted.principal))) {
-                const terminal = await attachDispatchExceptionTerminal(options.admitted, dispatchExceptionFailureTerminal({
-                    role: options.admitted.role,
-                    runId: options.admitted.runId,
-                    causeError: lastThrownError,
-                    errorFiles: retainedErrorFiles,
-                    autoResumeAttempts,
-                    endReason: "session principal unavailable before further resume",
-                    everyAttemptThrew,
-                }), options.io);
-                await finalizeExceptionRunBestEffort(options.admitted.runDirectory, options.io);
-                presentTerminal(terminal, options.io);
-                return {
-                    exitCode: 1,
-                    terminal,
-                };
+                endReason = `ak-role terminated by ${cancelName}`;
+                break;
             }
         }
         autoResumeAttempts++;
@@ -449,4 +390,35 @@ export async function runWithAutoResumeLoop(options) {
             isFirst = false;
         }
     }
+    const terminal = stoppedResult === undefined
+        ? await attachDispatchExceptionTerminal(options.admitted, dispatchExceptionFailureTerminal({
+            role: options.admitted.role,
+            runId: options.admitted.runId,
+            causeError: lastThrownError,
+            errorFiles: retainedErrorFiles,
+            autoResumeAttempts,
+            endReason: endReason,
+            everyAttemptThrew,
+        }), options.io)
+        : stoppedResult.terminal;
+    if (stoppedResult === undefined) {
+        await finalizeExceptionRunBestEffort(options.admitted.runDirectory, options.io);
+    }
+    const complete = terminal !== undefined && failedAttempts.length > 0
+        ? { ...terminal, roleOutcome: {
+                ...terminal.roleOutcome,
+                decisiveFacts: { ...terminal.roleOutcome.decisiveFacts, failedAttempts },
+            } }
+        : terminal;
+    if (complete !== undefined) {
+        if (isLawfulTypedTerminalOutcome(complete.roleOutcome)) {
+            options.io.stdout(formatTerminalResult(complete));
+        }
+        else {
+            presentTerminal(complete, options.io);
+        }
+    }
+    return stoppedResult === undefined
+        ? { exitCode: 1, terminal: complete }
+        : { ...stoppedResult, ...(complete === undefined ? {} : { terminal: complete }) };
 }

package/dist/public-cli/instruction-seat-run.js

@@ -753,7 +753,7 @@ export async function runPublicInstructionSeatResume(request, env, io) {
     };
     let binding;
     try {
-        const loaded = await loadResumablePublicRole(env.home, request.runId, env.principalAuthority, true);
+        const loaded = await loadResumablePublicRole(env.home, request.runId, env.principalAuthority);
         binding = loaded.admitted.role === "auditor"
             ? await readAuditorResumeBinding(loaded.admitted.runDirectory)
             : undefined;
@@ -805,7 +805,7 @@ async function queueConclusionFromChild(child, env, io) {
 }
 /** Continue the parent once a child has submitted. The child words ride the existing resume. */
 export async function continueParentAfterChild(parentRunId, child, env, io) {
-    const loaded = await loadResumablePublicRole(env.home, parentRunId, env.principalAuthority, true);
+    const loaded = await loadResumablePublicRole(env.home, parentRunId, env.principalAuthority);
     if (loaded.run.state !== "admitted" && !AUDITED_ROLES.has(loaded.admitted.role)) {
         return runPublicInstructionSeatResume({ runId: parentRunId }, env, io);
     }
@@ -1005,7 +1005,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
                     ? undefined : runIdFromRunDirectory(escalation.runDirectory));
             if (escalatedRunId === undefined)
                 throw new Error("escalated audit has no resumable run identity");
-            const officer = await loadResumablePublicRole(env.home, escalatedRunId, env.principalAuthority, true);
+            const officer = await loadResumablePublicRole(env.home, escalatedRunId, env.principalAuthority);
             const terminal = await trySettlePublicSeat(officer.admitted, env.principalAuthority, undefined);
             if (terminal === undefined)
                 throw new Error("escalated audit has no terminal result");