@akagilnc/pi-workflow-roles 0.1.5365 → 0.1.5375

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,14 +42,15 @@ 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";
+import { isRecord, errorText } from "../unknown-value.js";
 function projectRelocatedTurnIdentity(request, result, admitted, relocation) {
     const rewrite = (value) => rewriteRunDirectoryPathValue(value, relocation.oldRunDirectory, relocation.newRunDirectory);
     const mutableRequest = request;
     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"]) {
             const record = activation;
             if (field in record)
@@ -131,7 +133,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 =
@@ -348,7 +353,7 @@ export async function dispatchPostAdmissionTurn(input) {
                         continue;
                     }
                     const payload = row.accepted;
-                    if (payload === null || typeof payload !== "object" || Array.isArray(payload))
+                    if (!isRecord(payload))
                         continue;
                     ticketNumber = readDeclaredTicketNumber(payload.ticketNumber);
                     if (ticketNumber !== undefined)
@@ -817,13 +822,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 +839,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 +867,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 +1051,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({
@@ -1155,7 +1168,7 @@ async function presentResumeFailurePointer(io, thrown, publish) {
             cause.thrownCause = formatErrorCauseDetail(thrown.cause);
         }
         presentStructuralRejection({
-            message: thrown instanceof Error ? thrown.message : String(thrown),
+            message: errorText(thrown),
             cause,
         }, io);
     }
@@ -1208,39 +1221,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,8 @@ 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";
+import { isRecord, errorText, isEnoent } from "../unknown-value.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.
  */
@@ -72,7 +73,7 @@ export async function writeRoleRunState(runDirectory, record) {
     await writeFile(join(runDirectory, RUN_STATE_FILE), `${JSON.stringify(payload, null, 2)}\n`, "utf8");
 }
 function parseSameTicketSummonsMaterials(raw) {
-    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+    if (!isRecord(raw))
         return undefined;
     const record = raw;
     const instruction = typeof record.instruction === "string" ? record.instruction : undefined;
@@ -84,9 +85,7 @@ function parseSameTicketSummonsMaterials(raw) {
         ? record.sourceRunPath
         : undefined;
     let sourceRun;
-    if (record.sourceRun !== null &&
-        typeof record.sourceRun === "object" &&
-        !Array.isArray(record.sourceRun)) {
+    if (isRecord(record.sourceRun)) {
         const sr = record.sourceRun;
         if (typeof sr.runId === "string" &&
             sr.runId.trim() !== "" &&
@@ -119,7 +118,7 @@ function parseSameTicketSummonsMaterials(raw) {
     };
 }
 function parseCurrentCourtState(raw) {
-    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+    if (!isRecord(raw))
         return undefined;
     const record = raw;
     if (typeof record.courtAttemptId !== "string" || record.courtAttemptId.length === 0) {
@@ -150,7 +149,7 @@ async function readRoleRunStateRaw(runDirectory) {
     return raw;
 }
 function parseRoleRunIdentity(raw, runDirectory) {
-    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    if (!isRecord(raw)) {
         throw new TypeError("Invalid run-state.json");
     }
     const record = raw;
@@ -202,8 +201,7 @@ async function readRoleRunStateDisk(runDirectory) {
     };
     let resumable;
     if (record.resumable !== undefined && record.resumable !== null) {
-        if (typeof record.resumable === "object" &&
-            !Array.isArray(record.resumable)) {
+        if (isRecord(record.resumable)) {
             const r = record.resumable;
             if (r.httpStatus === 429 &&
                 typeof r.provider === "string" &&
@@ -767,7 +765,7 @@ export async function readRunParentPath(runDirectory) {
             return undefined;
         throw error;
     }
-    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    if (!isRecord(raw)) {
         return undefined;
     }
     const record = raw;
@@ -916,7 +914,7 @@ async function loadResumableRunRecord(home, runId, authority) {
     let sourceRun;
     try {
         const raw = JSON.parse(await readFile(run.admittedRequestPath, "utf8"));
-        if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
+        if (isRecord(raw)) {
             const record = raw;
             const storedRunDirectory = typeof record.runDirectory === "string" && record.runDirectory.trim() !== ""
                 ? record.runDirectory
@@ -983,9 +981,7 @@ async function loadResumableRunRecord(home, runId, authority) {
             if (typeof record.caseRunsPath === "string" && record.caseRunsPath.trim() !== "") {
                 caseRunsPath = record.caseRunsPath;
             }
-            if (record.caseIdentity !== null &&
-                typeof record.caseIdentity === "object" &&
-                !Array.isArray(record.caseIdentity)) {
+            if (isRecord(record.caseIdentity)) {
                 const ci = record.caseIdentity;
                 if (typeof ci.issueNumber === "number" &&
                     Number.isSafeInteger(ci.issueNumber) &&
@@ -999,9 +995,7 @@ async function loadResumableRunRecord(home, runId, authority) {
             if (typeof record.sourceRunPath === "string" && record.sourceRunPath.trim() !== "") {
                 sourceRunPath = record.sourceRunPath;
             }
-            if (record.sourceRun !== null &&
-                typeof record.sourceRun === "object" &&
-                !Array.isArray(record.sourceRun)) {
+            if (isRecord(record.sourceRun)) {
                 const sr = record.sourceRun;
                 if (typeof sr.runId === "string" &&
                     sr.runId.trim() !== "" &&
@@ -1029,9 +1023,7 @@ async function loadResumableRunRecord(home, runId, authority) {
                 record.mergerInputPath.trim() !== "") {
                 mergerInputPath = record.mergerInputPath;
             }
-            if (record.derived !== null &&
-                typeof record.derived === "object" &&
-                !Array.isArray(record.derived)) {
+            if (isRecord(record.derived)) {
                 const d = record.derived;
                 if (typeof d.targetObjectId === "string" &&
                     typeof d.sourceObjectId === "string" &&
@@ -1061,9 +1053,7 @@ async function loadResumableRunRecord(home, runId, authority) {
     let model;
     try {
         const invocationRaw = JSON.parse(await readFile(join(run.runDirectory, "invocation.json"), "utf8"));
-        if (invocationRaw !== null &&
-            typeof invocationRaw === "object" &&
-            !Array.isArray(invocationRaw)) {
+        if (isRecord(invocationRaw)) {
             const rec = invocationRaw;
             if (typeof rec.provider === "string" && typeof rec.model === "string") {
                 model = {
@@ -1087,9 +1077,7 @@ async function loadResumableRunRecord(home, runId, authority) {
         if (error instanceof CliUsageError) {
             throw error;
         }
-        if (!(error instanceof Error &&
-            "code" in error &&
-            error.code === "ENOENT")) {
+        if (!isEnoent(error)) {
             throw new CliUsageError(`role run invocation identity is unreadable: ${runId}`, { cause: error });
         }
     }
@@ -1263,11 +1251,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)) {
@@ -1331,7 +1319,7 @@ function admitResumedRole(loaded) {
                 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) {

package/dist/public-cli/settlement.js

@@ -167,6 +167,7 @@ function coordinatesFromAdmitted(authority, admitted) {
     return authority.decode(admitted.principal);
 }
 import { coalesceSubmissionRows, exitCodeForTerminalOutcome, formatTerminalResult, isLawfulTypedTerminalOutcome, adviceNavigatorFact, } from "./terminal.js";
+import { isEnoent, isMissingPathError, isRecord } from "../unknown-value.js";
 export { exitCodeForTerminalOutcome, formatTerminalResult, isLawfulTypedTerminalOutcome, };
 // A resumable public Terminal omits artifact paths (#108); its actual error
 // publication remains available only to the CLI's resume presentation seam.
@@ -239,7 +240,7 @@ export async function inspectJudgeSession(sessionFile) {
         return { state: "present" };
     }
     catch (error) {
-        if (isMissingPathError(error))
+        if (isEnoent(error))
             return { state: "missing" };
         return {
             state: "unreadable",
@@ -493,18 +494,6 @@ export function explicitInternalKnownFailureClassificationInput(failure) {
  * the budget to start a cold full host turn (owner 2026-09-17 #959).
  */
 export const NAVIGATOR_POST_ROLE_GRACE_MS = 10_000;
-function isMissingPathError(error) {
-    return (error instanceof Error &&
-        "code" in error &&
-        error.code === "ENOENT");
-}
-/** Face clear only: path not enterable as a face (ENOENT or file mid-path). */
-function isAbsentFacePathError(error) {
-    return (error instanceof Error &&
-        "code" in error &&
-        (error.code === "ENOENT" ||
-            error.code === "ENOTDIR"));
-}
 /**
  * Preserve session-read failure identity as a typed session cause.
  * SyntaxError keeps its name so durable settlement does not wash malformed JSONL
@@ -665,7 +654,7 @@ async function loadBoundAuditorVolumes(sessionFile) {
         parentEntries = await readBoundSessionEntries(sessionFile);
     }
     catch (error) {
-        if (isMissingPathError(error))
+        if (isEnoent(error))
             return undefined;
         throw sessionReadFailure(error, "failed to read parent session for auditor binding");
     }
@@ -682,7 +671,7 @@ async function loadBoundAuditorVolumes(sessionFile) {
             sawAnyDirectory = true;
         }
         catch (error) {
-            if (isMissingPathError(error))
+            if (isEnoent(error))
                 continue;
             throw sessionReadFailure(error, "failed to read bound auditor session directory");
         }
@@ -887,7 +876,7 @@ export async function resolveAuditedRunnerFailureResolution(input) {
             return resolutionOf(terminatingFailure);
     }
     catch (error) {
-        if (!isMissingPathError(error)) {
+        if (!isEnoent(error)) {
             const failure = sessionReadFailure(error, "failed to recover typed terminating-tool failure");
             return resolutionOf({
                 cause: "session",
@@ -1005,9 +994,6 @@ export function controlledFailureInputFromResolution(resolution) {
             : {}),
     };
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function safelyRead(object, key) {
     try {
         return { readable: true, value: object[key] };
@@ -1024,9 +1010,7 @@ function toolResultText(message) {
         return "";
     return content
         .map((part) => {
-        if (typeof part === "object" &&
-            part !== null &&
-            !Array.isArray(part) &&
+        if (isRecord(part) &&
             typeof part.text === "string") {
             return part.text;
         }
@@ -1611,7 +1595,7 @@ async function extractNavigatorFactFromAdmittedSession(sessionFile) {
         return extractNavigatorFact(entries);
     }
     catch (error) {
-        if (isMissingPathError(error)) {
+        if (isEnoent(error)) {
             return {
                 disposition: "unavailable",
                 source: "unknown",
@@ -1638,7 +1622,7 @@ async function removeFaceIfPresent(path) {
         // force:true already ignores ENOENT; ENOTDIR = face path not enterable
         // (artifacts-as-file mid-path) — same absent-face semantics as the reader.
         // Other errno stay loud (失败诚实).
-        if (isAbsentFacePathError(error))
+        if (isMissingPathError(error))
             return;
         throw error;
     }
@@ -1722,7 +1706,7 @@ async function readLawfulSettlementEntries(sessionFile) {
     }
     catch (error) {
         // Missing path is absence of a lawful outcome; callers classify via session inspect.
-        if (isMissingPathError(error))
+        if (isEnoent(error))
             return undefined;
         // Malformed JSONL and other read failures keep typed session identity.
         throw error instanceof Error &&
@@ -2028,7 +2012,7 @@ function countersignTerminalFromEntries(entries) {
             continue;
         if (entry.customType !== SECRETARIAT_GATE_OFFICER_ENTRY_TYPE)
             continue;
-        const data = entry.data !== null && typeof entry.data === "object" && !Array.isArray(entry.data)
+        const data = isRecord(entry.data)
             ? entry.data
             : undefined;
         if (data === undefined || !packagedDurableOfficerEntry(data.officer))

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)