@akagilnc/pi-workflow-roles 0.1.5365 → 0.1.5375

package/src/public-cli/post-admission.ts

@@ -18,7 +18,7 @@ import {
   type SameTicketSummonsMaterials,
 } from "./run-lifecycle.ts";
 import { CliUsageError } from "./cli-errors.ts";
-import type { RoleTurnRequestProjectionOptions } from "./turn-request.ts";
+import { projectPublicTurnAxes, type RoleTurnRequestProjectionOptions } from "./turn-request.ts";
 import {
   bindAdmittedTicketNumber,
   buildInstructionTransportPrompt,
@@ -119,8 +119,11 @@ import {
   persistReturnedRunState,
   runWithAutoResumeLoop,
   TurnDispatchedFailure,
+  writeHardenedArtifactFile,
 } from "./auto-resume.ts";
 
+import { isRecord, errorText } from "../unknown-value.ts";
+
 function projectRelocatedTurnIdentity(
   request: RoleTurnRequest,
   result: { readonly terminal?: TerminalResult },
@@ -136,7 +139,7 @@ function projectRelocatedTurnIdentity(
   mutableRequest.runDirectory = admitted.runDirectory;
   mutableRequest.principal = admitted.principal;
   const activation = mutableRequest.activation;
-  if (activation !== null && typeof activation === "object" && !Array.isArray(activation)) {
+  if (isRecord(activation)) {
     for (const field of ["taskPath", "packetPath", "prerequisitesPath", "inputPath", "requestManifestPath"] as const) {
       const record = activation as Record<string, unknown>;
       if (field in record) record[field] = rewrite(record[field]);
@@ -268,11 +271,10 @@ async function recordBestEffortPostDispatchDiagnostic<A extends AdmittedRoleInvo
   } catch (appendError) {
     try {
       const artifactsDir = await ensureRealArtifactsDirectory(admitted.runDirectory);
-      await writeFile(
-        join(artifactsDir, `post-admission-diagnostic-${randomUUID()}.json`),
-        `${JSON.stringify({ version: 1, ...payload }, null, 2)}\n`,
-        { encoding: "utf8", flag: "wx" },
-      );
+      await writeHardenedArtifactFile(artifactsDir, "post-admission-diagnostic", {
+        version: 1,
+        ...payload,
+      });
     } catch (artifactError) {
       retentionFailure =
         `post-dispatch diagnostic durable retention failed on both channels (best-effort continue): dossier=${describeErrorIdentity(appendError)}; artifact=${describeErrorIdentity(artifactError)}`;
@@ -733,7 +735,7 @@ export async function dispatchPostAdmissionTurn<
             continue;
           }
           const payload = row.accepted;
-          if (payload === null || typeof payload !== "object" || Array.isArray(payload)) continue;
+          if (!isRecord(payload)) continue;
           ticketNumber = readDeclaredTicketNumber(
             (payload as { ticketNumber?: unknown }).ticketNumber,
           );
@@ -1318,13 +1320,8 @@ export function resumeTurnRequestProjectionOptions(
     prompt = "";
   }
   return {
-    packageRoot: env.packageRoot,
-    home: env.home,
+    ...projectPublicTurnAxes(env),
     ...(env.host === undefined ? {} : { host: env.host }),
-    agentDir: env.agentDir,
-    ...(env.model === undefined ? {} : { model: env.model }),
-    ...pickEngineAxis(env),
-    ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
     ...(env.correlationId === undefined && admitted.correlationId === undefined
       ? {}
       : { correlationId: env.correlationId ?? admitted.correlationId }),
@@ -1345,13 +1342,8 @@ export function roleTurnOptions(
 ): RoleTurnRequestProjectionOptions {
   const correlationId = env.correlationId ?? admitted.correlationId;
   return {
-    packageRoot: env.packageRoot,
-    home: env.home,
+    ...projectPublicTurnAxes(env),
     ...(env.host === undefined ? {} : { host: env.host }),
-    agentDir: env.agentDir,
-    ...(env.model === undefined ? {} : { model: env.model }),
-    ...pickEngineAxis(env),
-    ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
     ...(correlationId === undefined || correlationId.trim() === ""
       ? {}
       : { correlationId }),
@@ -1383,6 +1375,66 @@ async function dispatchAfterWriterLease<T>(input: {
   }
 }
 
+/**
+ * One auto-resume dispatch: deferred run-state persist settles on the same
+ * path for station-child and ordinary in-call retries. The caller owns how
+ * the turn request is built and which correlation id the env carries.
+ */
+async function runSettledAutoResumeLoop<
+  A extends AdmittedRoleInvocation,
+  T extends TerminalResult,
+  P,
+>(input: {
+  admitted: A;
+  env: PostAdmissionEnv;
+  io: CliIo;
+  adapters: PostAdmissionAdapters<A, T>;
+  effectiveEngine?: string;
+  dispatchEnv?: PostAdmissionEnv;
+  buildInitialPayload: () => P;
+  buildResumePayload: () => P;
+  toRequest: (payload: P) => Promise<RoleTurnRequest>;
+}): Promise<{ exitCode: number; admitted?: A; terminal?: T }> {
+  const adapters = withOnceSuccessfulBeforeDispatch(input.adapters);
+  const dispatchEnv = input.dispatchEnv ?? input.env;
+  return runWithAutoResumeLoop({
+    admitted: input.admitted,
+    principalAuthority: input.env.principalAuthority,
+    io: input.io,
+    sessionAppender: input.env.sessionAppender,
+    autoResumeLimit: input.env.autoResumeLimit,
+    ...(input.env.signal === undefined ? {} : { signal: input.env.signal }),
+    buildInitialPayload: input.buildInitialPayload,
+    buildResumePayload: input.buildResumePayload,
+    dispatch: async (payload, lease, _isFirst, attemptIo) =>
+      dispatchAfterWriterLease({
+        ...(lease === undefined ? {} : { lease }),
+        build: () => input.toRequest(payload),
+        dispatch: async (request) => {
+          const result = await dispatchPostAdmissionTurn({
+            admitted: input.admitted,
+            env: dispatchEnv,
+            io: attemptIo,
+            request,
+            ...(lease === undefined ? {} : { lease }),
+            adapters,
+            persistRunState: false,
+            ...(input.effectiveEngine === undefined
+              ? {}
+              : { effectiveEngine: input.effectiveEngine }),
+          });
+          return settleDeferredPersist(
+            input.admitted,
+            input.env.principalAuthority,
+            adapters,
+            attemptIo,
+            result,
+          );
+        },
+      }),
+  });
+}
+
 function isAlreadyFrozenSummonsAttachment(
   runDirectory: string,
   attachmentPath: string,
@@ -1601,7 +1653,6 @@ export async function runPostAdmissionSeatResume<
   try {
     if (env.stationChild === true) {
       let firstTurn: RoleTurnRequest | undefined;
-      const stationAdapters = withOnceSuccessfulBeforeDispatch(adapters);
       type StationChildAttempt = { readonly resumeTurn: boolean };
       // One public call → one detour scope across in-place auto-resume dispatches.
       const invocationScopeId = mintEngineDetourInvocationScope({
@@ -1609,68 +1660,42 @@ export async function runPostAdmissionSeatResume<
           ? {}
           : { effectiveEngine: input.effectiveEngine }),
       });
-      return await runWithAutoResumeLoop({
+      return await runSettledAutoResumeLoop({
         admitted: loaded.admitted,
-        principalAuthority: env.principalAuthority,
+        env,
         io: input.io,
-        sessionAppender: env.sessionAppender,
-        autoResumeLimit: env.autoResumeLimit,
-        ...(env.signal === undefined ? {} : { signal: env.signal }),
+        adapters,
+        ...(input.effectiveEngine === undefined
+          ? {}
+          : { effectiveEngine: input.effectiveEngine }),
         buildInitialPayload: (): StationChildAttempt => ({ resumeTurn: false }),
         buildResumePayload: (): StationChildAttempt => ({ resumeTurn: true }),
-        // Same as public manual resume: prior-court sealed acceptance is not a
-        // redispatch brake (#833). New-court station-child turns still auto-resume.
-        dispatch: async (payload, lease, _isFirst, attemptIo) =>
-          dispatchAfterWriterLease({
-            ...(lease === undefined ? {} : { lease }),
-            build: async () => {
-              // #840 r8 判词 class 2: this call-local retry must keep this
-              // court's frozen summons / 交卷 body / attachments verbatim
-              // (same object as firstTurn) and project only the minimal
-              // host-needed resume trigger — never engine handbook material,
-              // which would replace a 审核循环 same-ticket continuation with a bare outsourcing
-              // 「重新读」 envelope (#755 contract, resumeTurnRequestProjectionOptions
-              // above). RESUME_TRANSPORT_ENVELOPE is the same package-owned,
-              // non-semantic trigger that projection already uses for a
-              // same-ticket summons carrying no instruction/attachments.
-              if (payload.resumeTurn && firstTurn !== undefined) {
-                return {
-                  ...firstTurn,
-                  continuation: {
-                    kind: "resume",
-                    prompt: RESUME_TRANSPORT_ENVELOPE,
-                  },
-                };
-              }
-              const turnRequest = withEngineDetourInvocationScope(
-                await buildRequestAfterLease(),
-                invocationScopeId,
-              );
-              firstTurn = turnRequest;
-              return turnRequest;
-            },
-            dispatch: async (turnRequest) => {
-              const result = await dispatchPostAdmissionTurn({
-                admitted: loaded.admitted,
-                env,
-                io: attemptIo,
-                request: turnRequest,
-                ...(lease === undefined ? {} : { lease }),
-                adapters: stationAdapters,
-                persistRunState: false,
-                ...(input.effectiveEngine === undefined
-                  ? {}
-                  : { effectiveEngine: input.effectiveEngine }),
-              });
-              return settleDeferredPersist(
-                loaded.admitted,
-                env.principalAuthority,
-                stationAdapters,
-                attemptIo,
-                result,
-              );
-            },
-          }),
+        toRequest: async (payload) => {
+          // #840 r8 判词 class 2: this call-local retry must keep this
+          // court's frozen summons / 交卷 body / attachments verbatim
+          // (same object as firstTurn) and project only the minimal
+          // host-needed resume trigger — never engine handbook material,
+          // which would replace a 审核循环 same-ticket continuation with a bare outsourcing
+          // 「重新读」 envelope (#755 contract, resumeTurnRequestProjectionOptions
+          // above). RESUME_TRANSPORT_ENVELOPE is the same package-owned,
+          // non-semantic trigger that projection already uses for a
+          // same-ticket summons carrying no instruction/attachments.
+          if (payload.resumeTurn && firstTurn !== undefined) {
+            return {
+              ...firstTurn,
+              continuation: {
+                kind: "resume",
+                prompt: RESUME_TRANSPORT_ENVELOPE,
+              },
+            };
+          }
+          const turnRequest = withEngineDetourInvocationScope(
+            await buildRequestAfterLease(),
+            invocationScopeId,
+          );
+          firstTurn = turnRequest;
+          return turnRequest;
+        },
       });
     }
     const resumed = await runPostAdmissionManualResume({
@@ -1779,7 +1804,7 @@ async function presentResumeFailurePointer(
       cause.thrownCause = formatErrorCauseDetail(thrown.cause);
     }
     presentStructuralRejection({
-      message: thrown instanceof Error ? thrown.message : String(thrown),
+      message: errorText(thrown),
       cause,
     }, io);
   }
@@ -1873,7 +1898,6 @@ export async function runPostAdmissionResumable<
   terminal?: T;
 }> {
   const { admitted, env, io, buildInitialRequest, buildResumeRequest, effectiveEngine } = input;
-  const adapters = withOnceSuccessfulBeforeDispatch(input.adapters);
 
   // One public call → one detour scope across in-place auto-resume dispatches.
   const invocationScopeId = mintEngineDetourInvocationScope({
@@ -1884,32 +1908,20 @@ export async function runPostAdmissionResumable<
   const buildScopedResume = (): RoleTurnRequest =>
     withEngineDetourInvocationScope(buildResumeRequest(), invocationScopeId);
 
-  return runWithAutoResumeLoop({
+  return runSettledAutoResumeLoop({
     admitted,
-    principalAuthority: env.principalAuthority,
+    env,
     io,
-    sessionAppender: env.sessionAppender,
-    autoResumeLimit: env.autoResumeLimit,
-    ...(env.signal === undefined ? {} : { signal: env.signal }),
+    adapters: input.adapters,
+    ...(effectiveEngine === undefined ? {} : { effectiveEngine }),
+    // Ordinary in-call retry keeps the admitted correlation when one was stored.
+    dispatchEnv: {
+      ...env,
+      ...(admitted.correlationId === undefined ? {} : { correlationId: admitted.correlationId }),
+    },
     buildInitialPayload: buildScopedInitial,
     buildResumePayload: buildScopedResume,
-    dispatch: async (request, lease, _isFirst, attemptIo) => {
-      const result = await dispatchPostAdmissionTurn({
-        admitted,
-        env: {
-          ...env,
-          ...(admitted.correlationId === undefined ? {} : { correlationId: admitted.correlationId }),
-        },
-        io: attemptIo,
-        request,
-        ...(lease === undefined ? {} : { lease }),
-        adapters,
-        persistRunState: false,
-        // #600: every attempt (initial + auto-resume) writes seat engine when present.
-        ...(effectiveEngine === undefined ? {} : { effectiveEngine }),
-      });
-      return settleDeferredPersist(admitted, env.principalAuthority, adapters, attemptIo, result);
-    },
+    toRequest: async (request) => request,
   });
 }
 

package/src/public-cli/role-seat-runtime.ts

@@ -0,0 +1,72 @@
+/**
+ * One seat-runtime assembly for the public CLI and nested summons.
+ * Order is host selection, the caller's argv parse, the missing-model fact,
+ * then host-facing provider projection. Callers own how a missing model is shown.
+ */
+import { pickEngineAxis } from "../package-resources/engine-material.ts";
+import type { DurablePrincipalAuthority, RoleTurnHost } from "../host-contracts.ts";
+import {
+  resolvedSeatWithModel,
+  type EffectiveSeat,
+  type SeatModelConfig,
+} from "./config.ts";
+import {
+  loadHostProvidersTable,
+  projectHostFacingProvider,
+} from "./host-providers.ts";
+import {
+  composeRoleTurnHostAdapters,
+  selectRoleTurnHost,
+  type NamedRoleTurnHostAdapter,
+  type RoleTurnHostResolutionInput,
+} from "./role-turn-host-resolution.ts";
+import type { PublicCallableRole } from "./registry.ts";
+
+export type OpenedRoleSeatRuntime =
+  | { readonly ok: false }
+  | {
+      readonly ok: true;
+      readonly roleTurnHost: RoleTurnHost;
+      readonly hostAdapters: readonly NamedRoleTurnHostAdapter[];
+      readonly model?: SeatModelConfig;
+      readonly engine?: string;
+      readonly engineModel?: string;
+      readonly host: string;
+    };
+
+export function openRoleSeatRuntime(input: {
+  readonly resolution: RoleTurnHostResolutionInput;
+  readonly principalAuthority: DurablePrincipalAuthority;
+  readonly role: PublicCallableRole;
+  readonly seat: EffectiveSeat;
+  readonly home: string;
+  readonly afterHost?: () => void;
+  /** Already host-facing. A second projection would rename the provider again. */
+  readonly hostFacingModel?: SeatModelConfig;
+}): OpenedRoleSeatRuntime {
+  const hostAdapters = composeRoleTurnHostAdapters(
+    input.resolution,
+    input.principalAuthority,
+  );
+  const roleTurnHost = selectRoleTurnHost(hostAdapters, {
+    role: input.role,
+    seat: input.seat,
+  });
+  input.afterHost?.();
+  const seatWithModel = resolvedSeatWithModel(input.seat);
+  if (seatWithModel === undefined) return { ok: false };
+  const projected = input.hostFacingModel ?? projectHostFacingProvider(
+    seatWithModel.selection,
+    seatWithModel.host,
+    loadHostProvidersTable(input.home),
+    input.home,
+  );
+  return {
+    ok: true,
+    roleTurnHost,
+    hostAdapters,
+    ...(projected === undefined ? {} : { model: projected }),
+    ...pickEngineAxis(seatWithModel),
+    host: seatWithModel.host,
+  };
+}

package/src/public-cli/run-lifecycle.ts

@@ -49,6 +49,7 @@ import {
   type PackagedRole,
 } from "../packaged-role-registry.ts";
 import {
+  admittedReviewerBaseFault,
   recordEffectiveInvocationModel,
   requireAuthorityRef,
   isReviewerLens,
@@ -70,6 +71,8 @@ import {
   type ReviewerLens,
 } from "./invocation.ts";
 
+import { isRecord, errorText, isEnoent } from "../unknown-value.ts";
+
 /** Providers eligible for v1 typed-429 resume (Codex / xAI only).
  * @deprecated v1 429-only gate removed by #416 (owner 2026-08-22: "根本不要有限制"). Kept for compatibility; do not use for new branching.
  */
@@ -240,8 +243,8 @@ type RoleRunStateDisk = {
 function parseSameTicketSummonsMaterials(
   raw: unknown,
 ): SameTicketSummonsMaterials | undefined {
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return undefined;
-  const record = raw as Record<string, unknown>;
+  if (!isRecord(raw)) return undefined;
+  const record = raw;
   const instruction =
     typeof record.instruction === "string" ? record.instruction : undefined;
   const instructionEmpty =
@@ -255,9 +258,7 @@ function parseSameTicketSummonsMaterials(
       : undefined;
   let sourceRun: NotarySourceRunLocator | undefined;
   if (
-    record.sourceRun !== null &&
-    typeof record.sourceRun === "object" &&
-    !Array.isArray(record.sourceRun)
+    isRecord(record.sourceRun)
   ) {
     const sr = record.sourceRun as Record<string, unknown>;
     if (
@@ -296,8 +297,8 @@ function parseSameTicketSummonsMaterials(
 }
 
 function parseCurrentCourtState(raw: unknown): CurrentCourtState | undefined {
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return undefined;
-  const record = raw as Record<string, unknown>;
+  if (!isRecord(raw)) return undefined;
+  const record = raw;
   if (typeof record.courtAttemptId !== "string" || record.courtAttemptId.length === 0) {
     return undefined;
   }
@@ -332,10 +333,10 @@ function parseRoleRunIdentity(raw: unknown, runDirectory: string): {
   readonly runDirectory: string;
   readonly state: RoleRunState;
 } {
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+  if (!isRecord(raw)) {
     throw new TypeError("Invalid run-state.json");
   }
-  const record = raw as Record<string, unknown>;
+  const record = raw;
   if (typeof record.runId !== "string" || record.runId.trim() === "") {
     throw new TypeError("Invalid run-state.json");
   }
@@ -389,11 +390,8 @@ async function readRoleRunStateDisk(
   };
   let resumable: TypedHttp429Observation | undefined;
   if (record.resumable !== undefined && record.resumable !== null) {
-    if (
-      typeof record.resumable === "object" &&
-      !Array.isArray(record.resumable)
-    ) {
-      const r = record.resumable as Record<string, unknown>;
+    if (isRecord(record.resumable)) {
+      const r = record.resumable;
       if (
         r.httpStatus === 429 &&
         typeof r.provider === "string" &&
@@ -701,7 +699,6 @@ export type RunWriterLease = {
 /** Kind of a writer-lease diagnostic sent on the existing sink. */
 export type WriterLeaseDiagnosticKind = "stale-reclaimed";
 
-
 /**
  * True error identity for diagnostics — name/code/message as-is, never a
  * guessed label (failure-honesty constitution).
@@ -740,7 +737,6 @@ function isProcessAlive(pid: number): boolean {
   }
 }
 
-
 export type WriterLockAutopsy =
   | { verdict: "absent" }
   | { verdict: "unknown"; reason: "unparseable"; content: string }
@@ -1071,10 +1067,10 @@ export async function readRunParentPath(
     if (errorCodeOf(error) === "ENOENT") return undefined;
     throw error;
   }
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+  if (!isRecord(raw)) {
     return undefined;
   }
-  const record = raw as Record<string, unknown>;
+  const record = raw;
   if (typeof record.sourceRunPath === "string" && record.sourceRunPath.trim() !== "") {
     return record.sourceRunPath;
   }
@@ -1279,7 +1275,7 @@ async function loadResumableRunRecord(
     const raw: unknown = JSON.parse(
       await readFile(run.admittedRequestPath, "utf8"),
     );
-    if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
+    if (isRecord(raw)) {
       const record = raw as Record<string, unknown>;
       const storedRunDirectory =
         typeof record.runDirectory === "string" && record.runDirectory.trim() !== ""
@@ -1352,9 +1348,7 @@ async function loadResumableRunRecord(
         caseRunsPath = record.caseRunsPath;
       }
       if (
-        record.caseIdentity !== null &&
-        typeof record.caseIdentity === "object" &&
-        !Array.isArray(record.caseIdentity)
+        isRecord(record.caseIdentity)
       ) {
         const ci = record.caseIdentity as Record<string, unknown>;
         if (
@@ -1372,9 +1366,7 @@ async function loadResumableRunRecord(
         sourceRunPath = record.sourceRunPath;
       }
       if (
-        record.sourceRun !== null &&
-        typeof record.sourceRun === "object" &&
-        !Array.isArray(record.sourceRun)
+        isRecord(record.sourceRun)
       ) {
         const sr = record.sourceRun as Record<string, unknown>;
         if (
@@ -1412,9 +1404,7 @@ async function loadResumableRunRecord(
         mergerInputPath = record.mergerInputPath;
       }
       if (
-        record.derived !== null &&
-        typeof record.derived === "object" &&
-        !Array.isArray(record.derived)
+        isRecord(record.derived)
       ) {
         const d = record.derived as Record<string, unknown>;
         if (
@@ -1451,9 +1441,7 @@ async function loadResumableRunRecord(
       await readFile(join(run.runDirectory, "invocation.json"), "utf8"),
     );
     if (
-      invocationRaw !== null &&
-      typeof invocationRaw === "object" &&
-      !Array.isArray(invocationRaw)
+      isRecord(invocationRaw)
     ) {
       const rec = invocationRaw as Record<string, unknown>;
       if (typeof rec.provider === "string" && typeof rec.model === "string") {
@@ -1477,13 +1465,7 @@ async function loadResumableRunRecord(
     ) {
       throw error;
     }
-    if (
-      !(
-        error instanceof Error &&
-        "code" in error &&
-        (error as { code?: unknown }).code === "ENOENT"
-      )
-    ) {
+    if (!isEnoent(error)) {
       throw new CliUsageError(
         `role run invocation identity is unreadable: ${runId}`,
         { cause: error },
@@ -1582,36 +1564,16 @@ function seatLoadedResult<R extends AdmittedRoleInvocation>(
   };
 }
 
-
 export async function peekRoleRunRole(
   home: string,
   runId: string,
-): Promise<
-  | "judge"
-  | "coder"
-  | "fixer"
-  | "collector"
-  | "doctor"
-  | "reviewer"
-  | "merger"
-  | "notary"
-  | "countersign"
-  | "gleaner-left"
-  | "inspector"
-  | "gatekeeper"
-  | "navigator"
-  | "auditor"
-  | "diarist"
-  | "secretariat"
-  | undefined
-> {
+): Promise<PackagedRole | undefined> {
   const runDirectory = await findRunDirectoryById(home, runId);
   if (runDirectory === undefined) return undefined;
   const run = await readRoleRunIdentity(runDirectory);
   return run?.role;
 }
 
-
 export type LoadedResumablePublicRole = {
   readonly admitted: AdmittedRoleInvocation;
   readonly run: RoleRunRecord;
@@ -1725,14 +1687,12 @@ function admitResumedRole(loaded: {
     }
     case "review-basis": {
       const rawBase = fields.baseRevision;
-      if (rawBase === undefined || rawBase.trim() === "") {
-        throw new CliUsageError(
-          `role run admitted reviewer base revision is missing: ${runId}`,
-        );
-      }
-      if (/\s/.test(rawBase) || rawBase.startsWith("-")) {
+      const baseFault = admittedReviewerBaseFault(rawBase);
+      if (baseFault !== undefined || rawBase === undefined) {
         throw new CliUsageError(
-          `role run admitted reviewer base revision is damaged: ${runId}`,
+          baseFault === "damaged"
+            ? `role run admitted reviewer base revision is damaged: ${runId}`
+            : `role run admitted reviewer base revision is missing: ${runId}`,
         );
       }
       const lens = fields.lens;
@@ -1812,7 +1772,7 @@ function admitResumedRole(loaded: {
       try {
         parsedRepository = parseCollectorRepository(repositoryDisplay);
       } catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
+        const detail = errorText(error);
         throw new CliUsageError(detail, { cause: error });
       }
       if (parsedRepository.canonical !== repository) {