@akagilnc/pi-workflow-roles 0.1.2521 → 0.1.2653-next.71811ca

package/src/pi/role-turn-host.ts

@@ -0,0 +1,459 @@
+/**
+ * Pi adapter for the host-neutral main-session execution seam (#526 / S1b-2).
+ * Owns argv construction, spawn/SIGTERM/close, and session codec helpers.
+ * public-cli runners project RoleTurnRequest; this module is the sole argv owner.
+ */
+import { execFile, spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, realpath } from "node:fs/promises";
+import { delimiter, isAbsolute, join, resolve } from "node:path";
+import { platform } from "node:process";
+import { promisify } from "node:util";
+import { randomUUID } from "node:crypto";
+import { appendFile, readFile } from "node:fs/promises";
+
+import type {
+  DurablePrincipal,
+  DurablePrincipalAuthority,
+  MethodBinding,
+  RoleTurnActivation,
+  RoleTurnHost,
+  RoleTurnKnownFailure,
+  RoleTurnModelConfig,
+  RoleTurnRequest,
+  RoleTurnResult,
+} from "../host-contracts.ts";
+import { ExplicitInternalActivationError } from "../host-contracts.ts";
+import { applyEngineChildEnv } from "../engine-detour.ts";
+import { decodePiDurablePrincipal } from "./durable-principal.ts";
+
+/** Package-relative Internal role entrypoint (ADR 0052; same path as public-cli registry). */
+const INTERNAL_ROLE_ENTRYPOINT_RELATIVE = "extensions/role-runtime.ts";
+
+export function resolveInternalRoleEntrypoint(packageRoot: string): string {
+  return join(packageRoot, INTERNAL_ROLE_ENTRYPOINT_RELATIVE);
+}
+
+/** Non-dispatch args: load Internal once and exit via Pi help (no model turn). */
+export const EXPLICIT_INTERNAL_LOAD_PROBE_ARGS = [
+  "--no-skills",
+  "--no-prompt-templates",
+  "--no-themes",
+  "--no-context-files",
+  "--no-session",
+  "--help",
+] as const;
+
+export function buildExplicitInternalActivationArgs(
+  selectedRoleEntry: string,
+  extraArgs: readonly string[] = [],
+): string[] {
+  return ["--no-extensions", "-e", selectedRoleEntry, ...extraArgs];
+}
+
+function buildSeatModelCliArgs(model: RoleTurnModelConfig | undefined): string[] {
+  if (model === undefined) return [];
+  return [
+    "--provider",
+    model.provider,
+    "--model",
+    model.model,
+    ...(model.thinking === undefined ? [] : ["--thinking", model.thinking]),
+  ];
+}
+
+function buildActivationFlagArgs(activation: RoleTurnActivation): string[] {
+  switch (activation.role) {
+    case "judge":
+      return ["--ak-role", "judge"];
+    case "coder":
+      return [
+        "--ak-role",
+        "coder",
+        "--ak-coder-phase",
+        activation.phase,
+        "--ak-coder-task",
+        activation.taskPath,
+      ];
+    case "fixer":
+      return [
+        "--ak-role",
+        "fixer",
+        "--ak-fixer-phase",
+        activation.phase,
+        "--ak-fix-packet",
+        activation.packetPath,
+        ...(activation.prerequisitesPath === undefined
+          ? []
+          : ["--ak-fixer-prerequisites", activation.prerequisitesPath]),
+      ];
+    case "reviewer":
+      return [
+        "--ak-role",
+        "reviewer",
+        "--ak-review-base",
+        activation.baseRevision,
+        ...(activation.authorityRefs.length === 0
+          ? []
+          : ["--ak-review-authority-refs", JSON.stringify([...activation.authorityRefs])]),
+        ...(activation.ticketNumber === undefined
+          ? []
+          : ["--ak-review-ticket-number", String(activation.ticketNumber)]),
+      ];
+    case "merger":
+      return ["--ak-role", "merger", "--ak-merger-input", activation.inputPath];
+    case "collector":
+      return [
+        "--ak-role",
+        "collector",
+        "--ak-collector-repo",
+        activation.repo,
+        "--ak-collector-pr",
+        activation.pr,
+        ...(activation.requestManifestPath === undefined
+          ? []
+          : ["--ak-collector-request-manifest", activation.requestManifestPath]),
+      ];
+    case "doctor":
+      return ["--ak-role", "doctor", "--ak-doctor-case", activation.casePath];
+    case "notary":
+      return ["--ak-role", "notary", "--ak-notary-source-run", activation.sourceRun];
+    default: {
+      const _exhaustive: never = activation;
+      return _exhaustive;
+    }
+  }
+}
+
+function buildMethodArgs(methods: readonly MethodBinding[]): string[] {
+  const skillArgs: string[] = [];
+  for (const method of methods) {
+    if (method.kind === "skill") {
+      skillArgs.push("--skill", method.path);
+    }
+  }
+  return skillArgs;
+}
+
+/**
+ * Translate a closed RoleTurnRequest into Pi argv after `--no-extensions -e entry`.
+ * Controlled session constants and session coordinates are adapter-internal.
+ */
+export function buildPiTurnExtraArgs(
+  request: RoleTurnRequest,
+  authority: DurablePrincipalAuthority,
+  extraPiArgs: readonly string[] = [],
+): string[] {
+  const { sessionFile, sessionDirectory } = decodePiDurablePrincipal(
+    authority,
+    request.principal,
+  );
+  const prompt =
+    request.continuation.kind === "initial" || request.continuation.kind === "resume"
+      ? request.continuation.prompt
+      : (() => {
+          const _exhaustive: never = request.continuation;
+          return _exhaustive;
+        })();
+  return [
+    "--no-skills",
+    ...buildMethodArgs(request.methods),
+    "--no-prompt-templates",
+    "--no-themes",
+    "--no-context-files",
+    "--session",
+    sessionFile,
+    "--session-dir",
+    sessionDirectory,
+    ...extraPiArgs,
+    ...buildActivationFlagArgs(request.activation),
+    "--mode",
+    "json",
+    ...buildSeatModelCliArgs(request.model),
+    prompt,
+  ];
+}
+
+export type PiSpawnRunner = (
+  args: readonly string[],
+  options: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+  },
+) => Promise<{
+  code: number | null;
+  stderr: string;
+  timedOut: boolean;
+  knownFailure?: RoleTurnKnownFailure;
+}>;
+
+export type LaunchedPiIdentity = {
+  readonly executable: string;
+  readonly version: string;
+};
+
+export type LaunchedRolePackageIdentity = {
+  readonly roleEntry: string;
+  readonly rolePackageRoot: string;
+  readonly rolePackageVersion: string;
+  readonly entryMode: "public-cli";
+};
+
+export type PiRoleTurnHostConfig = {
+  readonly packageRoot: string;
+  readonly principalAuthority: DurablePrincipalAuthority;
+  /** Test / seat-specific extra Pi args (faux provider etc.). */
+  readonly extraPiArgs?: readonly string[];
+  readonly timeoutMs?: number;
+  /** Low-level spawn seam (tests inject faux children). */
+  readonly spawnRunner?: PiSpawnRunner;
+  readonly recordLaunchedPiIdentity?: (
+    runDirectory: string,
+    identity: LaunchedPiIdentity,
+  ) => Promise<void>;
+  readonly recordLaunchedRolePackageIdentity?: (
+    runDirectory: string,
+    identity: LaunchedRolePackageIdentity,
+  ) => Promise<void>;
+  readonly observeLaunchedRolePackageIdentity?: (
+    packageRoot: string,
+    roleEntrypoint: string,
+  ) => Promise<LaunchedRolePackageIdentity>;
+};
+
+const execFileAsync = promisify(execFile);
+
+async function resolveSelectedPi(
+  command: string,
+  cwd: string,
+  env: NodeJS.ProcessEnv,
+): Promise<string> {
+  const searchPath =
+    env.PATH ?? (platform === "win32" ? (process.env.PATH ?? "") : "/usr/bin:/bin");
+  const candidates =
+    isAbsolute(command) || command.includes("/")
+      ? [resolve(cwd, command)]
+      : searchPath.split(delimiter).map((dir) => resolve(cwd, dir, command));
+  for (const candidate of candidates) {
+    try {
+      await access(candidate, constants.X_OK);
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code === "ENOENT" || code === "ENOTDIR" || code === "EACCES") continue;
+      throw new ExplicitInternalActivationError(
+        `Pi executable resolution failed: ${String((error as Error).message)}`,
+        { knownCause: "activation", cause: error },
+      );
+    }
+    return await realpath(candidate);
+  }
+  throw new ExplicitInternalActivationError(`Pi executable not found: ${command}`, {
+    knownCause: "activation",
+  });
+}
+
+async function selectedPiIdentity(
+  command: string,
+  cwd: string,
+  env: NodeJS.ProcessEnv,
+): Promise<LaunchedPiIdentity> {
+  const executable = await resolveSelectedPi(command, cwd, env);
+  const { stdout } = await execFileAsync(executable, ["--version"], {
+    cwd,
+    env,
+    encoding: "utf8",
+  });
+  const version = stdout.trim();
+  if (version === "") throw new Error(`Pi executable returned an empty version: ${executable}`);
+  return { executable, version };
+}
+
+/**
+ * Default child runner: canonically select `pi` on PATH (or PI_BINARY) and launch
+ * that exact file. Close settles exactly once for natural return / error / SIGTERM.
+ */
+type SpawnedPiChild = ReturnType<typeof spawn> & {
+  stderr: NonNullable<ReturnType<typeof spawn>["stderr"]>;
+};
+
+export function createDefaultPiSpawnRunner(options: {
+  recordLaunchedPiIdentity?: (
+    runDirectory: string,
+    identity: LaunchedPiIdentity,
+  ) => Promise<void>;
+}): PiSpawnRunner {
+  return async (args, spawnOptions) => {
+    const command = spawnOptions.env.PI_BINARY ?? "pi";
+    const piIdentity = await selectedPiIdentity(command, spawnOptions.cwd, spawnOptions.env);
+    return await new Promise((resolveResult, reject) => {
+      // Child stdout is discarded at the stdio seam (CLAUDE.md Role invocation
+      // evidence). Do not pipe or accumulate it. stderr stays piped for diagnostics.
+      const child: SpawnedPiChild = spawn(piIdentity.executable, [...args], {
+        cwd: spawnOptions.cwd,
+        env: spawnOptions.env,
+        stdio: ["ignore", "ignore", "pipe"],
+      });
+      let stderr = "";
+      let timedOut = false;
+      // No default wall clock. Only an explicit caller budget arms a timer (ADR 0010).
+      // SIGKILL is unconditionally forbidden — graceful SIGTERM only.
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      let settled = false;
+      // `error` fires for pre-spawn failures (ENOENT after identity check is a
+      // true activation failure) or kill/dispatch errors. Retain it so `close`
+      // remains the SOLE settlement point (spec-B: child close once). Only
+      // fall back to rejecting on `error` if `close` never fires (e.g. spawn
+      // never succeeded so no `close` event will arrive).
+      let hasSpawned = false;
+      let executionError: Error | undefined;
+      const armTimeoutAfterChildReady = (): void => {
+        if (spawnOptions.timeoutMs === undefined) return;
+        timer = setTimeout(() => {
+          timedOut = true;
+          child.kill("SIGTERM");
+        }, spawnOptions.timeoutMs);
+      };
+      let identityRecorded: Promise<void> = Promise.resolve();
+      child.once("spawn", () => {
+        hasSpawned = true;
+        armTimeoutAfterChildReady();
+        const runDirectory = spawnOptions.env.AK_ROLE_RUN_DIR;
+        if (
+          typeof runDirectory === "string" &&
+          runDirectory !== "" &&
+          options.recordLaunchedPiIdentity !== undefined
+        ) {
+          identityRecorded = options.recordLaunchedPiIdentity(runDirectory, piIdentity);
+        }
+      });
+      child.stderr.setEncoding("utf8").on("data", (chunk) => {
+        stderr += chunk;
+      });
+      child.on("error", (error) => {
+        // A pre-spawn error has no child lifecycle to close. After spawn,
+        // retain the execution error and let the mandatory close event own
+        // cleanup and the single settlement.
+        if (settled || hasSpawned) {
+          executionError = error;
+          return;
+        }
+        if (timer !== undefined) clearTimeout(timer);
+        settled = true;
+        reject(error);
+      });
+      child.on("close", (code) => {
+        if (timer !== undefined) clearTimeout(timer);
+        void identityRecorded.then(
+          () => {
+            if (settled) return;
+            settled = true;
+            if (executionError !== undefined) {
+              reject(executionError);
+              return;
+            }
+            resolveResult({
+              code,
+              stderr,
+              timedOut,
+            });
+          },
+          (error) => {
+            if (settled) return;
+            settled = true;
+            reject(error);
+          },
+        );
+      });
+    });
+  };
+}
+
+/** Create the production Pi RoleTurnHost (composition-root assembly). */
+export function createPiRoleTurnHost(config: PiRoleTurnHostConfig): RoleTurnHost {
+  const spawnRunner =
+    config.spawnRunner ??
+    createDefaultPiSpawnRunner({
+      ...(config.recordLaunchedPiIdentity === undefined
+        ? {}
+        : { recordLaunchedPiIdentity: config.recordLaunchedPiIdentity }),
+    });
+
+  return {
+    async executeTurn(request: RoleTurnRequest): Promise<RoleTurnResult> {
+      const roleEntry = await realpath(resolveInternalRoleEntrypoint(config.packageRoot));
+      const extraArgs = buildPiTurnExtraArgs(
+        request,
+        config.principalAuthority,
+        config.extraPiArgs ?? [],
+      );
+      const args = buildExplicitInternalActivationArgs(roleEntry, extraArgs);
+      const env: NodeJS.ProcessEnv = {
+        ...process.env,
+        HOME: request.home,
+        PI_CODING_AGENT_DIR: request.agentDir,
+        AK_ROLE_RUN_DIR: request.runDirectory,
+      };
+      applyEngineChildEnv(env, request.engine);
+      if (request.correlationId !== undefined && request.correlationId.trim() !== "") {
+        env.AK_CORRELATION_ID = request.correlationId;
+      }
+      // Package provenance is known before Pi starts.
+      if (
+        config.recordLaunchedRolePackageIdentity !== undefined &&
+        config.observeLaunchedRolePackageIdentity !== undefined
+      ) {
+        await config.recordLaunchedRolePackageIdentity(
+          request.runDirectory,
+          await config.observeLaunchedRolePackageIdentity(config.packageRoot, roleEntry),
+        );
+      }
+      const timeoutMs = request.timeoutMs ?? config.timeoutMs;
+      return await spawnRunner(args, {
+        cwd: request.cwd,
+        env,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+      });
+    },
+  };
+}
+
+import { sitianReport } from "../sitian-facade.ts";
+
+/**
+ * Append one custom JSONL entry to the durable principal's session file.
+ * Pi session codec only — AK artifact O_EXCL retention stays in public-cli.
+ */
+export async function appendPiSessionCustomEntry(
+  authority: DurablePrincipalAuthority,
+  principal: DurablePrincipal,
+  customType: string,
+  data: unknown,
+): Promise<void> {
+  const { sessionFile } = decodePiDurablePrincipal(authority, principal);
+  const text = await readFile(sessionFile, "utf8");
+  let parentId: string | null = null;
+  for (const line of text.trim().split("\n").filter(Boolean)) {
+    const entry = JSON.parse(line) as { id?: unknown; type?: unknown };
+    if (typeof entry.id === "string" && entry.type !== "session") parentId = entry.id;
+  }
+  const timestamp = new Date().toISOString();
+  const pointerLine = `${JSON.stringify({
+    type: "custom",
+    customType,
+    data,
+    id: randomUUID(),
+    parentId,
+    timestamp,
+  })}\n`;
+  await appendFile(sessionFile, pointerLine, "utf8");
+  try {
+    sitianReport({
+      level: "event",
+      kind: "dispatch-error",
+      sessionParent: sessionFile,
+      payload: { customType, data },
+      source: "pi-role-turn-host",
+    });
+  } catch {}
+}

package/src/public-cli/auto-resume.ts

@@ -13,13 +13,17 @@
  */
 import { constants as fsConstants } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { appendFile, lstat, mkdir, open, readFile } from "node:fs/promises";
+import { lstat, mkdir, open } from "node:fs/promises";
 import { join } from "node:path";
 
+import type {
+  DurablePrincipal,
+  DurablePrincipalAuthority,
+  SessionCustomEntryAppender,
+} from "../host-contracts.ts";
 import {
   AUTO_RESUME_LIMIT,
   describeErrorIdentity,
-  isSessionPrincipalAvailable,
   acquireRunWriterLease,
   markRunTerminal,
   RunWriterLeaseHeldError,
@@ -192,7 +196,9 @@ function jsonSafeReplacer(): (key: string, value: unknown) => unknown {
  * attempt can never overwrite an earlier attempt's file.
  */
 async function retainDispatchError(
-  admitted: { sessionFile: string; runDirectory: string },
+  admitted: { runDirectory: string; principal: DurablePrincipal },
+  principalAuthority: DurablePrincipalAuthority,
+  sessionAppender: SessionCustomEntryAppender,
   attempt: number,
   error: unknown,
 ): Promise<{ file: string; pointerError?: unknown }> {
@@ -216,6 +222,7 @@ async function retainDispatchError(
   // construction; a colliding name fails loudly instead of overwriting.
   // O_NOFOLLOW when the platform provides it keeps a planted symlink from
   // being followed; on platforms without it, exclusivity still holds.
+  // AK artifact owner stays here; only the session JSONL pointer uses Pi codec.
   const noFollowFlag =
     typeof fsConstants.O_NOFOLLOW === "number" ? fsConstants.O_NOFOLLOW : 0;
   const handle = await open(
@@ -228,13 +235,8 @@ async function retainDispatchError(
   } finally {
     await handle.close();
   }
-  // Addressable pointer in the dossier (卷宗): reuses the session principal's
-  // appended custom-entry shape (mirrors pi SessionManager.appendCustomEntry,
-  // same mechanism as #419 attempt history — no second ledger introduced).
-  // The one-writer lease is held for the append (#426 review: production
-  // dispatchers release the lease in their finally before the rejection reaches
-  // this point); if a concurrent writer already holds it, the append is skipped
-  // gracefully — the error file itself is already durably retained.
+  // Addressable pointer in the dossier (卷宗): Pi session custom-entry codec
+  // (appendPiSessionCustomEntry). Lease still owned here with run-writer.
   let pointerLease: RunWriterLease;
   try {
     pointerLease = await acquireRunWriterLease(admitted.runDirectory);
@@ -243,32 +245,17 @@ async function retainDispatchError(
     throw error;
   }
   // Pointer-stage failure (#426 fix_now #5) is separated from the file write:
-  // once the error file is durably on disk, a failed readFile/JSON.parse/
-  // appendFile must not reject through here and orphan it — the file path is
-  // still handed back to the caller (retainedErrorFiles → terminal
-  // dispatchErrorFiles/artifacts), and the pointer failure is reported
-  // separately by the caller.
+  // once the error file is durably on disk, a failed session append must not
+  // reject through here and orphan it — the file path is still handed back.
   let pointerError: unknown;
   try {
-    const text = await readFile(admitted.sessionFile, "utf8");
-    // Session headers are not branch entries (#419 precedent in
-    // appendRunAttemptHistory excludes type === "session"); leave parentId null
-    // until a non-header entry exists so the pointer stays addressable.
-    let parentId: string | null = null;
-    for (const line of text.trim().split("\n").filter(Boolean)) {
-      const entry = JSON.parse(line) as { id?: unknown; type?: unknown };
-      if (typeof entry.id === "string" && entry.type !== "session") parentId = entry.id;
-    }
     const timestamp = new Date().toISOString();
-    const pointerLine = `${JSON.stringify({
-      type: "custom",
-      customType: DISPATCH_ERROR_RETENTION_ENTRY_TYPE,
-      data: { version: 1, attempt, file: filePath, recordedAt: timestamp },
-      id: randomUUID(),
-      parentId,
-      timestamp,
-    })}\n`;
-    await appendFile(admitted.sessionFile, pointerLine, "utf8");
+    await sessionAppender(
+      principalAuthority,
+      admitted.principal,
+      DISPATCH_ERROR_RETENTION_ENTRY_TYPE,
+      { version: 1, attempt, file: filePath, recordedAt: timestamp },
+    );
   } catch (error) {
     pointerError = error;
   } finally {
@@ -331,15 +318,20 @@ function dispatchExceptionFailureTerminal(input: {
   };
 }
 
-export async function runWithAutoResumeLoop<T extends AutoResumeDispatchResult>(options: {
+export async function runWithAutoResumeLoop<
+  T extends AutoResumeDispatchResult,
+  TPayload = unknown,
+>(options: {
   admitted: {
-    sessionFile: string;
     runDirectory: string;
     /** Identity for the loop-owned typed failure terminal (dispatch-exception exhaustion). */
     role: TerminalRoleName;
     runId: string;
+    principal: DurablePrincipal;
   };
+  principalAuthority: DurablePrincipalAuthority;
   io: CliIo;
+  sessionAppender: SessionCustomEntryAppender;
   /**
    * Effective ceiling (#422), resolved by the caller before the loop; never re-read
    * per round. undefined = package default (AUTO_RESUME_LIMIT). Domain-validated at
@@ -347,9 +339,9 @@ export async function runWithAutoResumeLoop<T extends AutoResumeDispatchResult>(
    * before the first dispatch instead of silently bypassing the ceiling comparison.
    */
   autoResumeLimit?: number | undefined;
-  buildInitialArgs: () => string[];
-  buildResumeArgs: () => string[];
-  dispatch: (extraArgs: string[], lease: RunWriterLease, isFirst: boolean, attemptIo: CliIo) => Promise<T>;
+  buildInitialPayload: () => TPayload;
+  buildResumePayload: () => TPayload;
+  dispatch: (payload: TPayload, lease: RunWriterLease, isFirst: boolean, attemptIo: CliIo) => Promise<T>;
 }): Promise<T> {
   // #422 single-point resolution + domain validation. NaN would bypass every
   // `attempts >= limit` comparison (always false) — reject here, before any dispatch.
@@ -357,7 +349,7 @@ export async function runWithAutoResumeLoop<T extends AutoResumeDispatchResult>(
   parseAutoResumeLimit(limit);
   let autoResumeAttempts = 0;
   let isFirst = true;
-  let currentExtraArgs = options.buildInitialArgs();
+  let currentPayload = options.buildInitialPayload();
   let dispatchOrdinal = 0;
   let lastThrownError: unknown;
   let everyAttemptThrew = true;
@@ -379,7 +371,7 @@ export async function runWithAutoResumeLoop<T extends AutoResumeDispatchResult>(
 
     let result: T | undefined;
     try {
-      result = await options.dispatch(currentExtraArgs, lease, isFirst, dummyIo);
+      result = await options.dispatch(currentPayload, lease, isFirst, dummyIo);
     } catch (error) {
       // Owner 2026-08-23: 「出了异常，就原地记录错误信息，然后重试。」
       // Retain the whole exception in place (per-attempt full file + dossier
@@ -392,7 +384,13 @@ export async function runWithAutoResumeLoop<T extends AutoResumeDispatchResult>(
         // Track the file as soon as it is durably written (#426 review):
         // a pointer-stage failure comes back separately (pointerError) and must
         // never orphan the retained file (#426 fix_now #5).
-        const { file, pointerError } = await retainDispatchError(options.admitted, attempt, error);
+        const { file, pointerError } = await retainDispatchError(
+          options.admitted,
+          options.principalAuthority,
+          options.sessionAppender,
+          attempt,
+          error,
+        );
         retainedErrorFiles.push(file);
         options.io.stderr(
           `dispatch attempt ${attempt} threw (${describeErrorIdentity(error)}); full error retained at ${file}\n`,
@@ -430,7 +428,7 @@ export async function runWithAutoResumeLoop<T extends AutoResumeDispatchResult>(
         if (terminal !== undefined) presentTerminal(terminal, options.io);
         return result;
       }
-      if (!(await isSessionPrincipalAvailable(options.admitted.sessionFile))) {
+      if (!(await options.principalAuthority.isAvailable(options.admitted.principal))) {
         if (terminal !== undefined) presentTerminal(terminal, options.io);
         return result;
       }
@@ -453,7 +451,7 @@ export async function runWithAutoResumeLoop<T extends AutoResumeDispatchResult>(
           terminal,
         } as T;
       }
-      if (!(await isSessionPrincipalAvailable(options.admitted.sessionFile))) {
+      if (!(await options.principalAuthority.isAvailable(options.admitted.principal))) {
         const terminal = dispatchExceptionFailureTerminal({
           role: options.admitted.role,
           runId: options.admitted.runId,
@@ -473,7 +471,7 @@ export async function runWithAutoResumeLoop<T extends AutoResumeDispatchResult>(
     }
 
     autoResumeAttempts++;
-    currentExtraArgs = options.buildResumeArgs();
+    currentPayload = options.buildResumePayload();
     isFirst = false;
   }
 }