@akagilnc/pi-workflow-roles 0.1.5365 → 0.1.5368

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

@@ -10,6 +10,7 @@ import { writeFile } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
 import { buildAutoResumeContinuationPrompt, findRunDirectoryById, readRoleRunState, RESUME_TRANSPORT_ENVELOPE, } from "./run-lifecycle.js";
 import { CliUsageError } from "./cli-errors.js";
+import { projectPublicTurnAxes } from "./turn-request.js";
 import { bindAdmittedTicketNumber, buildInstructionTransportPrompt, freezeAttachmentsIntoRun, relocateAdmittedRunToTicket, } from "./invocation.js";
 import { readRecordedSubmissionRows } from "../submission-ledger.js";
 import { readDeclaredTicketNumber } from "../run-ticket-number.js";
@@ -41,7 +42,7 @@ import { homeFromRunDirectory } from "../activation-ledger-topology.js";
 import { recordRunStart } from "../host-session-record.js";
 import { attemptProducedFreshSubmission, classifyPostAdmissionFailure, controlledFailureInputFromResolution, exitCodeForTerminalOutcome, explicitInternalKnownFailureClassificationInput, formatCliDiagnostic, formatErrorCauseDetail, formatTerminalResult, inspectJudgeSession, isLawfulTypedTerminalOutcome, presentFailureTerminal, publishedFailureErrorPath, presentStructuralRejection, resolveAuditedRunnerFailureResolution, resolveControlledFailureResumeObservation, settleFailureTerminalResult, settleHostEndedNoReceipt, attachRecordedSubmissions, rewritePublishedFailureErrorPath, } from "./settlement.js";
 import {} from "./terminal.js";
-import { ensureRealArtifactsDirectory, persistReturnedRunState, runWithAutoResumeLoop, TurnDispatchedFailure, } from "./auto-resume.js";
+import { ensureRealArtifactsDirectory, persistReturnedRunState, runWithAutoResumeLoop, TurnDispatchedFailure, writeHardenedArtifactFile, } from "./auto-resume.js";
 function projectRelocatedTurnIdentity(request, result, admitted, relocation) {
     const rewrite = (value) => rewriteRunDirectoryPathValue(value, relocation.oldRunDirectory, relocation.newRunDirectory);
     const mutableRequest = request;
@@ -131,7 +132,10 @@ async function recordBestEffortPostDispatchDiagnostic(admitted, env, diagnostic,
     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 =
@@ -817,13 +821,8 @@ export function resumeTurnRequestProjectionOptions(admitted, request, env, summo
         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 }),
@@ -839,13 +838,8 @@ export function resumeTurnRequestProjectionOptions(admitted, request, env, summo
 export function roleTurnOptions(env, admitted, continuation) {
     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 }),
@@ -872,6 +866,44 @@ async function dispatchAfterWriterLease(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(input) {
+    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, attachmentPath) {
     const absolute = isAbsolute(attachmentPath)
         ? attachmentPath
@@ -1018,65 +1050,45 @@ export async function runPostAdmissionSeatResume(input) {
     try {
         if (env.stationChild === true) {
             let firstTurn;
-            const stationAdapters = withOnceSuccessfulBeforeDispatch(adapters);
             // One public call → one detour scope across in-place auto-resume dispatches.
             const invocationScopeId = mintEngineDetourInvocationScope({
                 ...(input.effectiveEngine === undefined
                     ? {}
                     : { 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: () => ({ resumeTurn: false }),
                 buildResumePayload: () => ({ 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({
@@ -1208,39 +1220,26 @@ export async function runPostAdmissionOneShot(input) {
  */
 export async function runPostAdmissionResumable(input) {
     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({
         ...(effectiveEngine === undefined ? {} : { effectiveEngine }),
     });
     const buildScopedInitial = () => withEngineDetourInvocationScope(buildInitialRequest(), invocationScopeId);
     const buildScopedResume = () => 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/dist/public-cli/role-seat-runtime.js

@@ -0,0 +1,29 @@
+/**
+ * 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.js";
+import { resolvedSeatWithModel, } from "./config.js";
+import { loadHostProvidersTable, projectHostFacingProvider, } from "./host-providers.js";
+import { composeRoleTurnHostAdapters, selectRoleTurnHost, } from "./role-turn-host-resolution.js";
+export function openRoleSeatRuntime(input) {
+    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/dist/public-cli/run-lifecycle.js

@@ -17,7 +17,7 @@ import { parseCollectorRepository } from "../collector-config.js";
 import { rewriteAdmittedRoleRunPage, rewriteRunDirectoryPathValue, } from "../role-run-relocation.js";
 import { appendEngineSessionMaterial, engineSessionMaterialFromOptions, pickEngineAxis, } from "../package-resources/engine-material.js";
 import { packagedResumeSourcePath, packagedRoleMetadata, } from "../packaged-role-registry.js";
-import { recordEffectiveInvocationModel, requireAuthorityRef, isReviewerLens, } from "./invocation.js";
+import { admittedReviewerBaseFault, recordEffectiveInvocationModel, requireAuthorityRef, isReviewerLens, } from "./invocation.js";
 /** 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.
  */
@@ -1263,11 +1263,11 @@ 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("-")) {
-                throw new CliUsageError(`role run admitted reviewer base revision is damaged: ${runId}`);
+            const baseFault = admittedReviewerBaseFault(rawBase);
+            if (baseFault !== undefined || rawBase === undefined) {
+                throw new CliUsageError(baseFault === "damaged"
+                    ? `role run admitted reviewer base revision is damaged: ${runId}`
+                    : `role run admitted reviewer base revision is missing: ${runId}`);
             }
             const lens = fields.lens;
             if (!isReviewerLens(lens)) {

package/dist/public-cli/turn-request.js

@@ -2,6 +2,20 @@ import { pickEngineAxis } from "../package-resources/engine-material.js";
 import { packagedRoleActivationFlags, packagedRoleMetadata, } from "../packaged-role-registry.js";
 import { installedMethodSkillPath } from "./machine-method-skills.js";
 import { parentRunPathFromGatePointerInstruction } from "./run-lifecycle.js";
+/**
+ * Env axes shared by every public turn projection.
+ * Callers add correlation, continuation, host, and station-only fields.
+ */
+export function projectPublicTurnAxes(env) {
+    return {
+        packageRoot: env.packageRoot,
+        home: env.home,
+        agentDir: env.agentDir,
+        ...(env.model === undefined ? {} : { model: env.model }),
+        ...pickEngineAxis(env),
+        ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
+    };
+}
 export function projectRoleTurnRequest(admitted, roleDetails, options) {
     const cwd = admitted.projectRoot ?? admitted.repoRoot ?? admitted.cwd;
     if (cwd === undefined)

package/dist/public-role-summons.js

@@ -3,7 +3,6 @@ import { existsSync } from "node:fs";
 import { realpath } from "node:fs/promises";
 import { join } from "node:path";
 import { promisify } from "node:util";
-import { pickEngineAxis } from "./package-resources/engine-material.js";
 const AK_ROLE_PACKAGE_ROOT_ENV = "AK_ROLE_PACKAGE_ROOT";
 const execFileAsync = promisify(execFile);
 function createCapturingIo() {
@@ -69,12 +68,6 @@ async function resolveSummonHome(options) {
   if (fromCwd !== void 0 && fromCwd.length > 0) return fromCwd;
   return packageMachineHome();
 }
-function projectSeatEngine(seat) {
-  return pickEngineAxis(seat);
-}
-function projectSeatHost(seat) {
-  return seat.host === void 0 ? {} : { host: seat.host };
-}
 function hostSelectionFailureFromUnknown(error) {
   if (typeof error !== "object" || error === null) return void 0;
   if (error.name !== "HostSelectionError") return void 0;
@@ -85,44 +78,36 @@ async function createSummonEnv(options, afterHost) {
   const [
     { piDurablePrincipalAuthority },
     { appendPiSessionCustomEntry },
-    { resolveRoleTurnHost },
-    { missingResolvedSeatModelMessage, resolvedSeatWithModel }
+    { openRoleSeatRuntime },
+    { missingResolvedSeatModelMessage }
   ] = await Promise.all([
     import("./pi/durable-principal.js"),
     import("./pi/role-turn-host.js"),
-    import("./public-cli/role-turn-host-resolution.js"),
+    import("./public-cli/role-seat-runtime.js"),
     import("./public-cli/config.js")
   ]);
   const principalAuthority = options.principalAuthority ?? piDurablePrincipalAuthority;
-  const roleTurnHost = resolveRoleTurnHost(
-    {
+  const opened = openRoleSeatRuntime({
+    resolution: {
       packageRoot: options.packageRoot,
       ...options.roleTurnHost === void 0 ? {} : { roleTurnHost: options.roleTurnHost },
       ...options.hostAdapters === void 0 ? {} : { hostAdapters: options.hostAdapters },
       ...options.extraPiArgs === void 0 || options.extraPiArgs.length === 0 ? {} : { extraPiArgs: options.extraPiArgs },
       ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
     },
-    { role: options.role, seat: options.seat, principalAuthority }
-  );
-  afterHost?.();
-  const seatWithModel = resolvedSeatWithModel(options.seat);
-  if (seatWithModel === void 0) {
+    principalAuthority,
+    role: options.role,
+    seat: options.seat,
+    home: options.home,
+    ...afterHost === void 0 ? {} : { afterHost },
+    ...options.hostFacingModel === void 0 ? {} : { hostFacingModel: options.hostFacingModel }
+  });
+  if (!opened.ok) {
     return {
       ok: false,
       missingModelMessage: missingResolvedSeatModelMessage(options.role)
     };
   }
-  const hostName = seatWithModel.host ?? "pi";
-  let hostFacingSelection = options.hostFacingModel;
-  if (hostFacingSelection === void 0) {
-    const { loadHostProvidersTable, projectHostFacingProvider } = await import("./public-cli/host-providers.js");
-    hostFacingSelection = projectHostFacingProvider(
-      seatWithModel.selection,
-      hostName,
-      loadHostProvidersTable(options.home),
-      options.home
-    );
-  }
   return {
     ok: true,
     env: {
@@ -131,12 +116,13 @@ async function createSummonEnv(options, afterHost) {
       agentDir: options.agentDir,
       sessionAppender: appendPiSessionCustomEntry,
       packageRoot: options.packageRoot,
-      roleTurnHost,
+      roleTurnHost: opened.roleTurnHost,
       cwd: options.cwd,
       credentials: options.credentials,
-      ...hostFacingSelection === void 0 ? {} : { model: hostFacingSelection },
-      ...projectSeatEngine(seatWithModel),
-      ...projectSeatHost(seatWithModel),
+      ...opened.model === void 0 ? {} : { model: opened.model },
+      ...opened.engine === void 0 ? {} : { engine: opened.engine },
+      ...opened.engineModel === void 0 ? {} : { engineModel: opened.engineModel },
+      host: opened.host,
       ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
     }
   };
@@ -144,13 +130,14 @@ async function createSummonEnv(options, afterHost) {
 async function summonPublicRole(options) {
   const packageRoot = resolveSummonsPackageRoot(options.packageRoot);
   const home = await resolveSummonHome(options);
-  const agentDir = options.agentDir ?? process.env.PI_CODING_AGENT_DIR ?? join(home, ".pi", "agent");
   const {
     loadCredentialProviders,
     loadPublicCliConfig,
     resolveEffectiveSeat,
+    resolvePublicAgentDir,
     validatePublicCliConfigAxes
   } = await import("./public-cli/config.js");
+  const agentDir = resolvePublicAgentDir(options.agentDir, home);
   const credentials = options.credentials ?? await loadCredentialProviders(agentDir);
   const config = await loadPublicCliConfig(home);
   validatePublicCliConfigAxes(config, packageRoot);

package/dist/role-run-placement.js

@@ -64,6 +64,9 @@ function roleRunPlacement(ledgerHome, input) {
 function roleRunArtifactsDirectory(runDirectory) {
   return join(runDirectory, "artifacts");
 }
+function isUnboundRunDirectory(runDirectory) {
+  return runDirectory.replaceAll("\\", "/").includes("/unbound/runs/");
+}
 function ensureRoleRunDirectory(ledgerHome, directory) {
   return ensureRealDirectoryTree(ledgerHome, directory);
 }
@@ -78,6 +81,7 @@ function ensureRoleRunPlacement(ledgerHome, placement) {
 export {
   ensureRoleRunDirectory,
   ensureRoleRunPlacement,
+  isUnboundRunDirectory,
   listBookRunDirectories,
   roleRunArtifactsDirectory,
   roleRunPlacement

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akagilnc/pi-workflow-roles",
-  "version": "0.1.5365",
+  "version": "0.1.5368",
   "description": "Soul-bound workflow roles for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/book-topology-migration-placement.ts

@@ -10,7 +10,9 @@ import { readdir, readFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 
 import { pathContainedIn } from "./activation-ledger-topology.ts";
-import { roleRunPlacement } from "./role-run-placement.ts";
+import { isUnboundRunDirectory, roleRunPlacement } from "./role-run-placement.ts";
+
+export { isUnboundRunDirectory };
 import {
   MIGRATION_TICKET_DERIVATION_PAGE,
   readBoardTicketNumber,
@@ -167,10 +169,6 @@ export async function resolveMigratingRunTicket(runDirectory: string): Promise<{
   };
 }
 
-export function isUnboundRunDirectory(runDirectory: string): boolean {
-  return runDirectory.replaceAll("\\", "/").includes("/unbound/runs/");
-}
-
 export function bookHistoricalRoots(
   booksDirectory: string,
   backupBooksDirectory: string,

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

@@ -210,7 +210,7 @@ function jsonSafeReplacer(): (key: string, value: unknown) => unknown {
  * + O_NOFOLLOW where the platform provides it (a planted symlink is never
  * followed) — mirrors settlement.ts's own hardened artifact writers.
  */
-async function writeHardenedArtifactFile(
+export async function writeHardenedArtifactFile(
   artifactsDir: string,
   namePrefix: string,
   payload: Record<string, unknown>,