@akagilnc/pi-workflow-roles 0.1.5252 → 0.1.5270

package/dist/public-cli/main.js

@@ -538,7 +538,6 @@ __export(durable_principal_exports, {
   issuePiDurablePrincipalCoordinates: () => issuePiDurablePrincipalCoordinates,
   piDurablePrincipalAuthority: () => piDurablePrincipalAuthority
 });
-import { lstat } from "node:fs/promises";
 import { join as join5 } from "node:path";
 function encode(coordinates) {
   return coordinates;
@@ -591,15 +590,6 @@ var init_durable_principal = __esm({
           sessionDirectory: record4.sessionDirectory,
           sessionFile: typeof record4.sessionFile === "string" && record4.sessionFile.trim() !== "" ? record4.sessionFile : join5(record4.sessionDirectory, "session.jsonl")
         };
-      },
-      async isAvailable(principal) {
-        const { sessionFile } = this.decode(principal);
-        try {
-          const stat2 = await lstat(sessionFile);
-          return stat2.isFile() && !stat2.isSymbolicLink();
-        } catch {
-          return false;
-        }
       }
     };
   }
@@ -15828,7 +15818,6 @@ var init_host_descriptions = __esm({
           modelFlag: "--model"
         }),
         modelPassing: "argv",
-        boundResume: "session/load",
         sessionBindingFile: "grok-acp-session.json"
       }),
       /**
@@ -15846,7 +15835,6 @@ var init_host_descriptions = __esm({
           thinkingFlag: "--reasoning"
         }),
         modelPassing: "set_model",
-        boundResume: "session/load",
         sessionBindingFile: "hermes-acp-session.json",
         seatProfileSoul: Object.freeze({
           flag: "-p",
@@ -16618,7 +16606,7 @@ var init_cli_errors = __esm({
 
 // src/public-cli/machine-method-skills.ts
 import { accessSync, constants, statSync as statSync2 } from "node:fs";
-import { lstat as lstat2, mkdir as mkdir2, symlink } from "node:fs/promises";
+import { lstat, mkdir as mkdir2, symlink } from "node:fs/promises";
 import { join as join9 } from "node:path";
 import { spawnSync } from "node:child_process";
 function skillRoot(home) {
@@ -16648,7 +16636,7 @@ function linkedSkillRoot(home, host) {
 }
 async function occupied(path) {
   try {
-    await lstat2(path);
+    await lstat(path);
     return true;
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
@@ -17371,8 +17359,8 @@ function formatTerminalResult(result) {
       `diagnostic	${encodeTerminalField(result.roleOutcome.diagnostic)}`
     );
   }
-  if (result.roleOutcome.kind === "failure" || result.roleOutcome.kind === "no_receipt" || result.roleOutcome.kind === "audit_escalation") {
-    const facts = result.roleOutcome.decisiveFacts ?? {};
+  if (result.roleOutcome.kind === "failure" || result.roleOutcome.kind === "no_receipt" || result.roleOutcome.kind === "audit_escalation" || result.roleOutcome.decisiveFacts?.failedAttempts !== void 0) {
+    const facts = result.roleOutcome.kind === "accepted" ? { failedAttempts: result.roleOutcome.decisiveFacts?.failedAttempts } : result.roleOutcome.decisiveFacts ?? {};
     for (const [key, value] of Object.entries(facts)) {
       if (value === void 0) continue;
       const rendered = typeof value === "string" ? value : JSON.stringify(value);
@@ -18798,7 +18786,7 @@ var init_uuidv7 = __esm({
 
 // src/notary-source-run.ts
 import { dirname as dirname11, isAbsolute as isAbsolute5, join as join17, resolve as resolve8, basename as basename5 } from "node:path";
-import { lstat as lstat3, realpath as realpath3 } from "node:fs/promises";
+import { lstat as lstat2, realpath as realpath3 } from "node:fs/promises";
 async function readRetainedIdentity(runDirectory) {
   try {
     return await readRoleRunIdentity(runDirectory);
@@ -18826,7 +18814,7 @@ async function requireRunDirectory(candidate, display) {
   }
   let stat2;
   try {
-    stat2 = await lstat3(real);
+    stat2 = await lstat2(real);
   } catch (error) {
     throw new NotarySourceRunError(
       `notary --source-run is not a readable run directory: ${display}`,
@@ -19965,7 +19953,7 @@ var init_option_definitions = __esm({
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
 import {
-  lstat as lstat4,
+  lstat as lstat3,
   mkdtemp,
   readFile as readFile12,
   realpath as realpath4,
@@ -20527,7 +20515,7 @@ async function readRegularFileAttachment(sourcePath) {
   const absolute = isAbsolute6(sourcePath) ? sourcePath : resolve9(sourcePath);
   let st;
   try {
-    st = await lstat4(absolute);
+    st = await lstat3(absolute);
   } catch (error) {
     throw new CliUsageError(
       `attachment is not a readable regular file: ${sourcePath}`,
@@ -26033,7 +26021,7 @@ 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) : void 0;
   } catch (error) {
     if (!(error instanceof CliUsageError)) throw error;
@@ -26076,7 +26064,7 @@ async function queueConclusionFromChild(child, env, io) {
   }
 }
 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);
   }
@@ -26271,7 +26259,7 @@ async function auditSubmittedRole(turn, env, io, passedOfficer, passedReceipt, p
       const escalation = chain.passes.at(-1);
       const escalatedRunId = escalation?.runId ?? (escalation?.runDirectory === void 0 ? void 0 : runIdFromRunDirectory(escalation.runDirectory));
       if (escalatedRunId === void 0) 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 terminal2 = await trySettlePublicSeat(officer.admitted, env.principalAuthority, void 0);
       if (terminal2 === void 0) throw new Error("escalated audit has no terminal result");
       io.stdout(formatTerminalResult(terminal2));
@@ -27138,7 +27126,6 @@ __export(run_lifecycle_exports, {
   describeErrorIdentity: () => describeErrorIdentity,
   findLatestRunIdForSeatTicket: () => findLatestRunIdForSeatTicket,
   findRunDirectoryById: () => findRunDirectoryById,
-  isDurablePrincipalAvailable: () => isDurablePrincipalAvailable,
   isV1ResumableProvider: () => isV1ResumableProvider,
   loadResumablePublicRole: () => loadResumablePublicRole,
   markRunAdmitted: () => markRunAdmitted,
@@ -27158,7 +27145,7 @@ __export(run_lifecycle_exports, {
   renderResumeCommand: () => renderResumeCommand,
   writeRoleRunState: () => writeRoleRunState
 });
-import { chmod, lstat as lstat6, open, readdir as readdir6, readFile as readFile16, unlink as unlink4, writeFile as writeFile5 } from "node:fs/promises";
+import { chmod, lstat as lstat5, open, readdir as readdir6, readFile as readFile16, unlink as unlink4, writeFile as writeFile5 } from "node:fs/promises";
 import { basename as basename8, join as join30 } from "node:path";
 function buildAutoResumeContinuationPrompt(options) {
   return appendEngineSessionMaterial(
@@ -27472,9 +27459,6 @@ async function clearCurrentCourt(runDirectory, expectedCourtAttemptId) {
     ...current.resumable === void 0 ? {} : { resumable: current.resumable }
   });
 }
-async function isDurablePrincipalAvailable(principal, authority) {
-  return authority.isAvailable(principal);
-}
 function describeErrorIdentity(error) {
   const candidate = error;
   const name = typeof candidate?.name === "string" && candidate.name !== "" ? candidate.name : typeof error;
@@ -27716,7 +27700,7 @@ async function runHasFormedSessionPrincipal(runDirectory) {
   if (disk === void 0) return false;
   const sessionFile = typeof disk.principalWire.sessionFile === "string" && disk.principalWire.sessionFile.trim() !== "" ? disk.principalWire.sessionFile : join30(disk.principalWire.sessionDirectory, "session.jsonl");
   try {
-    const stat2 = await lstat6(sessionFile);
+    const stat2 = await lstat5(sessionFile);
     return stat2.isFile() && !stat2.isSymbolicLink();
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return false;
@@ -27808,7 +27792,7 @@ function restoredTicketFields(fields) {
     ...fields.courtTicketNumbers === void 0 ? {} : { courtTicketNumbers: fields.courtTicketNumbers }
   };
 }
-async function loadResumableRunRecord(home, runId, authority, allowUnformedAdmitted = false) {
+async function loadResumableRunRecord(home, runId, authority) {
   const runDirectory = await findRunDirectoryById(home, runId);
   if (runDirectory === void 0) {
     throw new CliUsageError(`unknown role run id: ${runId}`);
@@ -27822,11 +27806,6 @@ async function loadResumableRunRecord(home, runId, authority, allowUnformedAdmit
     throw new CliUsageError(`unknown role run id: ${runId}`);
   }
   const { run, principal } = materialized;
-  if (!(allowUnformedAdmitted && run.state === "admitted") && !await isDurablePrincipalAvailable(principal, authority)) {
-    throw new CliUsageError(
-      `role run Pi session principal is unavailable: ${runId}`
-    );
-  }
   let instruction = "";
   let instructionEmpty = true;
   let attachments = [];
@@ -28103,8 +28082,8 @@ async function peekRoleRunRole(home, runId) {
   const run = await readRoleRunIdentity(runDirectory);
   return run?.role;
 }
-async function loadResumablePublicRole(home, runId, authority, allowUnformedAdmitted = false) {
-  const loaded = await loadResumableRunRecord(home, runId, authority, allowUnformedAdmitted);
+async function loadResumablePublicRole(home, runId, authority) {
+  const loaded = await loadResumableRunRecord(home, runId, authority);
   return seatLoadedResult(loaded, admitResumedRole(loaded));
 }
 function admitResumedRole(loaded) {
@@ -28396,12 +28375,6 @@ function createSessionIdentityAuthority(authority, sessionBindingFile) {
     }
   };
 }
-function resolveHostAwareSessionAvailability(host, principalAuthority) {
-  if (host === void 0 || host === DEFAULT_ROLE_TURN_HOST) {
-    return (principal) => principalAuthority.isAvailable(principal);
-  }
-  return async (principal) => await readStoredHostSessionId(host, principalAuthority, principal) !== void 0;
-}
 async function readStoredHostSessionId(host, authority, principal) {
   if (host === void 0 || host === DEFAULT_ROLE_TURN_HOST) return void 0;
   const description = lookupHostDescription(host) ?? lookupHeadlessHostDescription(host);
@@ -28509,9 +28482,9 @@ var init_host_session_record = __esm({
 // src/public-cli/auto-resume.ts
 import { constants as fsConstants2 } from "node:fs";
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { lstat as lstat7, mkdir as mkdir4, open as open2 } from "node:fs/promises";
+import { lstat as lstat6, mkdir as mkdir4, open as open2 } from "node:fs/promises";
 import { join as join33 } from "node:path";
-async function persistReturnedRunState(admitted, authority, options) {
+async function persistReturnedRunState(admitted, options) {
   if (options?.lawful === true) {
     await markRunTerminal(admitted.runDirectory);
     return;
@@ -28521,10 +28494,8 @@ async function persistReturnedRunState(admitted, authority, options) {
   });
   const typedHttp429 = resumeObservation.typedHttp429;
   if (admitted.principal !== void 0 && typedHttp429 !== void 0) {
-    if (await authority.isAvailable(admitted.principal)) {
-      await markRunResumable(admitted.runDirectory, typedHttp429);
-      return;
-    }
+    await markRunResumable(admitted.runDirectory, typedHttp429);
+    return;
   }
   await markRunTerminal(admitted.runDirectory);
 }
@@ -28546,20 +28517,20 @@ async function finalizeExceptionRunBestEffort(runDirectory, io) {
   }
 }
 async function ensureRealArtifactsDirectory(runDirectory) {
-  const runStat = await lstat7(runDirectory);
+  const runStat = await lstat6(runDirectory);
   if (runStat.isSymbolicLink() || !runStat.isDirectory()) {
     throw new Error("run artifact retention: run directory is not a real directory");
   }
   const artifactsDir = roleRunArtifactsDirectory(runDirectory);
   try {
-    const existing = await lstat7(artifactsDir);
+    const existing = await lstat6(artifactsDir);
     if (existing.isSymbolicLink() || !existing.isDirectory()) {
       throw new Error("run artifact retention: artifacts path is not a real directory");
     }
   } catch (error) {
     if (!isMissingPathError5(error)) throw error;
     await mkdir4(artifactsDir, { recursive: true });
-    const created = await lstat7(artifactsDir);
+    const created = await lstat6(artifactsDir);
     if (created.isSymbolicLink() || !created.isDirectory()) {
       throw new Error("run artifact retention: artifacts directory is not a real directory");
     }
@@ -28690,7 +28661,6 @@ function dispatchExceptionFailureTerminal(input) {
 async function runWithAutoResumeLoop(options) {
   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();
@@ -28698,6 +28668,9 @@ async function runWithAutoResumeLoop(options) {
   let lastThrownError;
   let everyAttemptThrew = true;
   const retainedErrorFiles = [];
+  const failedAttempts = [];
+  let stoppedResult;
+  let endReason;
   while (true) {
     let result;
     let turnStartedBeforeThrow = false;
@@ -28706,6 +28679,11 @@ async function runWithAutoResumeLoop(options) {
       result = await options.dispatch(currentPayload, lease, isFirst, dummyIo);
     } catch (error) {
       lastThrownError = error;
+      const failedAttempt = {
+        attempt: dispatchOrdinal,
+        diagnostic: describeErrorIdentity(unwrapTurnDispatchedFailure(error))
+      };
+      failedAttempts.push(failedAttempt);
       turnStartedBeforeThrow = error instanceof TurnDispatchedFailure;
       const attempt = dispatchOrdinal;
       try {
@@ -28717,6 +28695,7 @@ async function runWithAutoResumeLoop(options) {
           error
         );
         retainedErrorFiles.push(file);
+        failedAttempt.errorFile = file;
         options.io.stderr(
           `dispatch attempt ${attempt} threw (${describeErrorIdentity(error)}); full error retained at ${file}
 `
@@ -28737,100 +28716,30 @@ async function runWithAutoResumeLoop(options) {
     dispatchOrdinal += 1;
     if (result !== void 0) {
       everyAttemptThrew = false;
-      const terminal = result.terminal;
-      if (terminal !== void 0) {
-        terminal.autoResumeCount = autoResumeAttempts;
-      }
-      const lawful = terminal !== void 0 && isLawfulTypedTerminalOutcome(terminal.roleOutcome);
-      if (lawful) {
-        if (terminal !== void 0) {
-          options.io.stdout(formatTerminalResult(terminal));
+      const terminal2 = result.terminal;
+      if (terminal2 !== void 0) {
+        terminal2.autoResumeCount = autoResumeAttempts;
+        if (terminal2.roleOutcome.kind === "failure") {
+          failedAttempts.push({
+            attempt: dispatchOrdinal - 1,
+            diagnostic: terminal2.roleOutcome.diagnostic,
+            decisiveFacts: terminal2.roleOutcome.decisiveFacts
+          });
         }
-        return result;
-      }
-      if (result.skipAutoResume === true) {
-        if (terminal !== void 0) presentTerminal(terminal, options.io);
-        return result;
-      }
-      if (processCancelSignalName(options.signal) !== void 0) {
-        if (terminal !== void 0) presentTerminal(terminal, options.io);
-        return result;
-      }
-    }
-    if (result !== void 0) {
-      const terminal = result.terminal;
-      if (autoResumeAttempts >= limit) {
-        if (terminal !== void 0) presentTerminal(terminal, options.io);
-        return result;
       }
-      if (result.turnDispatched === true && !await isPrincipalAvailable(options.admitted.principal)) {
-        if (terminal !== void 0) presentTerminal(terminal, options.io);
-        return result;
+      if (terminal2 !== void 0 && isLawfulTypedTerminalOutcome(terminal2.roleOutcome) || result.skipAutoResume === true || autoResumeAttempts >= limit || processCancelSignalName(options.signal) !== void 0) {
+        stoppedResult = result;
+        break;
       }
     } else {
       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;
       }
       const cancelName = processCancelSignalName(options.signal);
       if (cancelName !== void 0) {
-        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++;
@@ -28839,6 +28748,34 @@ async function runWithAutoResumeLoop(options) {
       isFirst = false;
     }
   }
+  const terminal = stoppedResult === void 0 ? await attachDispatchExceptionTerminal(
+    options.admitted,
+    dispatchExceptionFailureTerminal({
+      role: options.admitted.role,
+      runId: options.admitted.runId,
+      causeError: lastThrownError,
+      errorFiles: retainedErrorFiles,
+      autoResumeAttempts,
+      endReason,
+      everyAttemptThrew
+    }),
+    options.io
+  ) : stoppedResult.terminal;
+  if (stoppedResult === void 0) {
+    await finalizeExceptionRunBestEffort(options.admitted.runDirectory, options.io);
+  }
+  const complete = terminal !== void 0 && failedAttempts.length > 0 ? { ...terminal, roleOutcome: {
+    ...terminal.roleOutcome,
+    decisiveFacts: { ...terminal.roleOutcome.decisiveFacts, failedAttempts }
+  } } : terminal;
+  if (complete !== void 0) {
+    if (isLawfulTypedTerminalOutcome(complete.roleOutcome)) {
+      options.io.stdout(formatTerminalResult(complete));
+    } else {
+      presentTerminal(complete, options.io);
+    }
+  }
+  return stoppedResult === void 0 ? { exitCode: 1, terminal: complete } : { ...stoppedResult, ...complete === void 0 ? {} : { terminal: complete } };
 }
 var dummyIo, TurnDispatchedFailure, DISPATCH_ERROR_RETENTION_ENTRY_TYPE;
 var init_auto_resume = __esm({
@@ -29007,14 +28944,9 @@ async function presentControlledFailure2(admitted, failureInput, adapters, autho
     ...failureInput.knownDiagnostic === void 0 ? {} : { knownDiagnostic: failureInput.knownDiagnostic },
     ...session === void 0 ? {} : { session }
   });
-  let resumable = false;
-  const typedHttp429 = resumeObservation.typedHttp429;
-  if (admitted.principal !== void 0) {
-    const sessionPrincipalAvailable = await authority.isAvailable(admitted.principal);
-    resumable = sessionPrincipalAvailable && typedHttp429 !== void 0;
-  }
+  const resumable = admitted.principal !== void 0 && resumeObservation.typedHttp429 !== void 0;
   if (persistRunState && !failureInput.skipRunStateWrite) {
-    await persistReturnedRunState(admitted, authority);
+    await persistReturnedRunState(admitted);
   }
   let publishedErrorPath;
   let terminal;
@@ -29059,7 +28991,7 @@ async function settleDeferredPersist(admitted, authority, adapters, io, result)
   const { needsPersist: _needsPersist, ...settledResult } = result;
   const lawful = isLawfulTypedTerminalOutcome(result.terminal.roleOutcome);
   try {
-    await persistReturnedRunState(admitted, authority, lawful ? { lawful: true } : void 0);
+    await persistReturnedRunState(admitted, lawful ? { lawful: true } : void 0);
     return settledResult;
   } catch (error) {
     const failed = await settleAfterTurnStarted(
@@ -29337,7 +29269,7 @@ async function dispatchPostAdmissionTurn(input) {
       }
       if (persistRunState) {
         try {
-          await persistReturnedRunState(admitted, env.principalAuthority, { lawful: true });
+          await persistReturnedRunState(admitted, { lawful: true });
         } catch (error) {
           await recordBestEffortPostDispatchDiagnostic(
             admitted,
@@ -29422,7 +29354,7 @@ async function dispatchPostAdmissionTurn(input) {
     }
     if (persistRunState) {
       try {
-        await persistReturnedRunState(admitted, env.principalAuthority, { lawful: true });
+        await persistReturnedRunState(admitted, { lawful: true });
       } catch (error) {
         await recordBestEffortPostDispatchDiagnostic(
           admitted,
@@ -29639,10 +29571,6 @@ async function runPostAdmissionSeatResume(input) {
       return await runWithAutoResumeLoop({
         admitted: loaded.admitted,
         principalAuthority: env.principalAuthority,
-        isPrincipalAvailable: resolveHostAwareSessionAvailability(
-          env.host,
-          env.principalAuthority
-        ),
         io: input.io,
         sessionAppender: env.sessionAppender,
         autoResumeLimit: env.autoResumeLimit,
@@ -29830,7 +29758,6 @@ async function runPostAdmissionResumable(input) {
   return runWithAutoResumeLoop({
     admitted,
     principalAuthority: env.principalAuthority,
-    isPrincipalAvailable: resolveHostAwareSessionAvailability(env.host, env.principalAuthority),
     io,
     sessionAppender: env.sessionAppender,
     autoResumeLimit: env.autoResumeLimit,

package/dist/public-cli/post-admission.js

@@ -15,7 +15,7 @@ import { readRecordedSubmissionRows } from "../submission-ledger.js";
 import { readDeclaredTicketNumber } from "../run-ticket-number.js";
 import { pathContainedIn } from "../activation-ledger-topology.js";
 import { pickEngineAxis } from "../package-resources/engine-material.js";
-import { readStoredHostSessionId, resolveHostAwareSessionAvailability, } from "../session-identity.js";
+import { readStoredHostSessionId } from "../session-identity.js";
 import { rewriteRunDirectoryPathValue } from "../role-run-relocation.js";
 import { isOfficerReviewSeat } from "../packaged-role-registry.js";
 /** Original error bytes, never relabeled — a secondary fact riding beside a classified cause. */
@@ -223,16 +223,10 @@ export async function presentControlledFailure(admitted, failureInput, adapters,
             : { knownDiagnostic: failureInput.knownDiagnostic }),
         ...(session === undefined ? {} : { session }),
     });
-    // #665 / #416: resume hint is seat-uniform — principal available && typed 429 → show.
-    // Do not fork the public terminal face on per-seat hasLawful / isResumableRole (ADR 0040).
-    let resumable = false;
-    const typedHttp429 = resumeObservation.typedHttp429;
-    if (admitted.principal !== undefined) {
-        const sessionPrincipalAvailable = await authority.isAvailable(admitted.principal);
-        resumable = sessionPrincipalAvailable && typedHttp429 !== undefined;
-    }
+    // #665 / #416: typed 429 with a run principal offers resume; the host decides availability.
+    const resumable = admitted.principal !== undefined && resumeObservation.typedHttp429 !== undefined;
     if (persistRunState && !failureInput.skipRunStateWrite) {
-        await persistReturnedRunState(admitted, authority);
+        await persistReturnedRunState(admitted);
     }
     let publishedErrorPath;
     let terminal;
@@ -302,7 +296,7 @@ async function settleDeferredPersist(admitted, authority, adapters, io, result)
     const { needsPersist: _needsPersist, ...settledResult } = result;
     const lawful = isLawfulTypedTerminalOutcome(result.terminal.roleOutcome);
     try {
-        await persistReturnedRunState(admitted, authority, lawful ? { lawful: true } : undefined);
+        await persistReturnedRunState(admitted, lawful ? { lawful: true } : undefined);
         return settledResult;
     }
     catch (error) {
@@ -675,7 +669,7 @@ export async function dispatchPostAdmissionTurn(input) {
             }
             if (persistRunState) {
                 try {
-                    await persistReturnedRunState(admitted, env.principalAuthority, { lawful: true });
+                    await persistReturnedRunState(admitted, { lawful: true });
                 }
                 catch (error) {
                     await recordBestEffortPostDispatchDiagnostic(admitted, env, `run-state persistence failed beside host terminal (best-effort continue): ${describeErrorIdentity(error)}`, io);
@@ -747,7 +741,7 @@ export async function dispatchPostAdmissionTurn(input) {
         }
         if (persistRunState) {
             try {
-                await persistReturnedRunState(admitted, env.principalAuthority, { lawful: true });
+                await persistReturnedRunState(admitted, { lawful: true });
             }
             catch (error) {
                 await recordBestEffortPostDispatchDiagnostic(admitted, env, `run-state persistence failed beside host terminal (best-effort continue): ${describeErrorIdentity(error)}`, io);
@@ -1046,7 +1040,6 @@ export async function runPostAdmissionSeatResume(input) {
             return await runWithAutoResumeLoop({
                 admitted: loaded.admitted,
                 principalAuthority: env.principalAuthority,
-                isPrincipalAvailable: resolveHostAwareSessionAvailability(env.host, env.principalAuthority),
                 io: input.io,
                 sessionAppender: env.sessionAppender,
                 autoResumeLimit: env.autoResumeLimit,
@@ -1237,7 +1230,6 @@ export async function runPostAdmissionResumable(input) {
     return runWithAutoResumeLoop({
         admitted,
         principalAuthority: env.principalAuthority,
-        isPrincipalAvailable: resolveHostAwareSessionAvailability(env.host, env.principalAuthority),
         io,
         sessionAppender: env.sessionAppender,
         autoResumeLimit: env.autoResumeLimit,

package/dist/public-cli/run-lifecycle.js

@@ -429,13 +429,6 @@ export async function clearCurrentCourt(runDirectory, expectedCourtAttemptId) {
         ...(current.resumable === undefined ? {} : { resumable: current.resumable }),
     });
 }
-/**
- * True when the host authority reports the durable principal available.
- * Resume must reopen this exact principal; directory-latest is not identity.
- */
-export async function isDurablePrincipalAvailable(principal, authority) {
-    return authority.isAvailable(principal);
-}
 export class RunWriterLeaseHeldError extends Error {
     code = "AK_RUN_WRITER_LEASE_HELD";
     constructor(message = "role run writer lease is already held") {
@@ -932,7 +925,7 @@ function restoredTicketFields(fields) {
             : { courtTicketNumbers: fields.courtTicketNumbers }),
     };
 }
-async function loadResumableRunRecord(home, runId, authority, allowUnformedAdmitted = false) {
+async function loadResumableRunRecord(home, runId, authority) {
     const runDirectory = await findRunDirectoryById(home, runId);
     if (runDirectory === undefined) {
         throw new CliUsageError(`unknown role run id: ${runId}`);
@@ -941,17 +934,14 @@ async function loadResumableRunRecord(home, runId, authority, allowUnformedAdmit
     if (disk === undefined) {
         throw new CliUsageError(`unknown role run id: ${runId}`);
     }
-    // #416: removed terminal/resumable gates per owner decision "根本不要有限制" (2026-08-22).
-    // Only the exact Pi session principal check remains as honest failure.
+    // #416 / #1091: removed terminal/resumable and local session-file gates.
+    // The load seam locates the run and recovers identity; host CLI answers continuation.
     // One authority.decode of the uninterpreted wire yields both principal and record.
     const materialized = materializeRoleRunFromDisk(disk, authority);
     if (materialized === undefined) {
         throw new CliUsageError(`unknown role run id: ${runId}`);
     }
     const { run, principal } = materialized;
-    if (!(allowUnformedAdmitted && run.state === "admitted") && !(await isDurablePrincipalAvailable(principal, authority))) {
-        throw new CliUsageError(`role run Pi session principal is unavailable: ${runId}`);
-    }
     // Reconstruct admitted identity from durable run record + admitted-request.json.
     let instruction = "";
     let instructionEmpty = true;
@@ -1268,8 +1258,8 @@ export async function peekRoleRunRole(home, runId) {
  * selects the existing restore checks. The stored native host session id is
  * read on the public explicit resume seam, not from this load.
  */
-export async function loadResumablePublicRole(home, runId, authority, allowUnformedAdmitted = false) {
-    const loaded = await loadResumableRunRecord(home, runId, authority, allowUnformedAdmitted);
+export async function loadResumablePublicRole(home, runId, authority) {
+    const loaded = await loadResumableRunRecord(home, runId, authority);
     return seatLoadedResult(loaded, admitResumedRole(loaded));
 }
 /**

package/dist/public-cli/terminal.js

@@ -69,8 +69,10 @@ export function formatTerminalResult(result) {
     if (result.roleOutcome.kind === "failure") {
         lines.push(`diagnostic\t${encodeTerminalField(result.roleOutcome.diagnostic)}`);
     }
-    if (result.roleOutcome.kind === "failure" || result.roleOutcome.kind === "no_receipt" || result.roleOutcome.kind === "audit_escalation") {
-        const facts = result.roleOutcome.decisiveFacts ?? {};
+    if (result.roleOutcome.kind === "failure" || result.roleOutcome.kind === "no_receipt" || result.roleOutcome.kind === "audit_escalation" || result.roleOutcome.decisiveFacts?.failedAttempts !== undefined) {
+        const facts = result.roleOutcome.kind === "accepted"
+            ? { failedAttempts: result.roleOutcome.decisiveFacts?.failedAttempts }
+            : result.roleOutcome.decisiveFacts ?? {};
         for (const [key, value] of Object.entries(facts)) {
             if (value === undefined)
                 continue;

package/dist/session-identity.js

@@ -31,24 +31,6 @@ export function createSessionIdentityAuthority(authority, sessionBindingFile) {
         },
     };
 }
-/**
- * Host-aware resumable-session probe (#840 P1). The shared auto-resume loop
- * (public-cli/auto-resume.ts) asks one question — "can this principal's turn
- * still be resumed" — without itself knowing which concrete host executed it.
- * Pi's own session.jsonl transcript (DurablePrincipalAuthority#isAvailable)
- * answers that only for the pi host; ACP and headless hosts persist their
- * resumable native session id under their own session-identity binding file
- * instead (#729 / #731 / #645) and never write session.jsonl, so the plain
- * pi check always reports them unavailable after one attempt. One lookup per
- * registered host family — no per-host-name branch, no per-seat whitelist.
- */
-export function resolveHostAwareSessionAvailability(host, principalAuthority) {
-    if (host === undefined || host === DEFAULT_ROLE_TURN_HOST) {
-        return (principal) => principalAuthority.isAvailable(principal);
-    }
-    // Unregistered names have no binding file: absence, not a guess at pi.
-    return async (principal) => (await readStoredHostSessionId(host, principalAuthority, principal)) !== undefined;
-}
 /**
  * Native session/thread id already stored for this principal on `host`.
  * Public explicit resume reads it once and hands it to the host adapter.