@akagilnc/pi-workflow-roles 0.1.5504 → 0.1.5575

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

@@ -13,10 +13,11 @@ 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";
+import { parseTicketNumber, readDeclaredTicketNumber } from "../run-ticket-number.js";
 import { pathContainedIn } from "../activation-ledger-topology.js";
 import { pickEngineAxis } from "../package-resources/engine-material.js";
 import { readStoredHostSessionId } from "../session-identity.js";
+import { reportRunRecord } from "../sitian-facade.js";
 import { createReceiptDeliveryPolicy, deliveryLimitFromConfig, } from "../receipt-delivery-policy.js";
 import { rewriteRunDirectoryPathValue } from "../role-run-relocation.js";
 import { isOfficerReviewSeat } from "../packaged-role-registry.js";
@@ -40,10 +41,9 @@ import { mintEngineDetourInvocationScope, withEngineDetourInvocationScope, } fro
 import { clearCurrentCourt, describeErrorIdentity, markRunRunning, readCurrentCourt, recordCurrentCourt, } from "./run-lifecycle.js";
 import { processCancelDiagnostic, processCancelSignalName, } from "./process-cancel.js";
 import { DEFAULT_ROLE_TURN_HOST } from "../host-descriptions.js";
-import { recordRunStart } from "../host-session-record.js";
 import { classifyPostAdmissionFailure, exitCodeForTerminalOutcome, explicitInternalKnownFailureClassificationInput, formatCliDiagnostic, formatErrorCauseDetail, ledgerReadScope, isLawfulTypedTerminalOutcome, presentStructuralRejection, settleFailureTerminalResult, settleHostEndedNoReceipt, noteSettlementFault, attachRecordedSubmissions, retainPackageFault, } from "./settlement.js";
 import {} from "./terminal.js";
-import { ensureRealArtifactsDirectory, persistReturnedRunState, presentTerminal, runWithAutoResumeLoop, TurnDispatchedFailure, } from "./auto-resume.js";
+import { persistReturnedRunState, presentTerminal, runWithAutoResumeLoop, TurnDispatchedFailure, } 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);
@@ -87,7 +87,7 @@ async function settleProcessCancelAfterTurn(input) {
             ? { knownDiagnostic: processCancelDiagnostic(input.cancelName) }
             : { knownFailure: input.result.knownFailure }),
         cancelName: input.cancelName,
-    }, input.invocationScopeId), input.adapters, input.env.principalAuthority, input.io, input.persistRunState, input.notePackageFault);
+    }, input.invocationScopeId), input.adapters, input.env.principalAuthority, input.io, input.persistRunState, input.notePackageFault, input.courtAttemptId);
     return {
         ...failed,
         turnDispatched: true,
@@ -170,7 +170,9 @@ export async function resolveResumeMethodMaterialAdapters(input) {
         return { kind: "terminal", ...terminal };
     }
 }
-export async function presentControlledFailure(admitted, failureInput, adapters, authority, io, persistRunState = true, notePackageFault) {
+export async function presentControlledFailure(admitted, failureInput, adapters, authority, io, persistRunState = true, notePackageFault, 
+/** Open-court identity already on the turn request / currentCourt (#1161). */
+courtAttemptId) {
     const hasThrown = Object.hasOwn(failureInput, "thrown");
     const knownFailure = failureInput.knownFailure;
     // knownFailure channel owns details when present; otherwise caller knownDetails.
@@ -231,6 +233,9 @@ export async function presentControlledFailure(admitted, failureInput, adapters,
         const settled = await settleFailureTerminalResult(admitted, failure, authority, {
             recordAttemptHistory: true,
             ...(notePackageFault === undefined ? {} : { notePackageFault }),
+            ...(courtAttemptId === undefined || courtAttemptId.length === 0
+                ? {}
+                : { courtAttemptId }),
             ...(failureInput.invocationScopeId === undefined ||
                 failureInput.invocationScopeId.length === 0
                 ? {}
@@ -263,9 +268,9 @@ export async function presentControlledFailure(admitted, failureInput, adapters,
  * the true cause through its own existing dispatch-exception machinery once
  * the retry budget is exhausted.
  */
-async function settleAfterTurnStarted(admitted, failureInput, adapters, authority, io, persistRunState, notePackageFault) {
+async function settleAfterTurnStarted(admitted, failureInput, adapters, authority, io, persistRunState, notePackageFault, courtAttemptId) {
     try {
-        return (await presentControlledFailure(admitted, failureInput, adapters, authority, io, persistRunState, notePackageFault));
+        return (await presentControlledFailure(admitted, failureInput, adapters, authority, io, persistRunState, notePackageFault, courtAttemptId));
     }
     catch (error) {
         throw new TurnDispatchedFailure(error);
@@ -321,9 +326,9 @@ function settlementScopeForTurn(request) {
  *
  * The caller owns the live delivery policy; the request projects its next send.
  */
-async function buildReceiptDeliveryRequest(input) {
-    const { admitted, env, request, receiptDelivery } = input;
-    const hostSessionId = await readStoredHostSessionId(env.host, env.principalAuthority, admitted.principal);
+/** Bare in-call催交 resume: hostSessionId absent; adapter is the sole load authority. */
+function buildReceiptDeliveryRequest(input) {
+    const { request, receiptDelivery } = input;
     return {
         ...request,
         continuation: {
@@ -332,7 +337,6 @@ async function buildReceiptDeliveryRequest(input) {
                 ...receiptDelivery.deliveryState(),
                 deliveryTurns: receiptDelivery.issuedDeliveryRequests() + 1,
             }),
-            ...(hostSessionId === undefined ? {} : { hostSessionId }),
         },
         deliveryRequestLimit: receiptDelivery.limit,
     };
@@ -378,19 +382,19 @@ async function settleCompletedHostTurn(input) {
     // machinery once the retry budget is exhausted.
     let stderrLogWriteFailure;
     try {
-        await writeFile(join(admitted.runDirectory, "stderr.log"), result.stderr, "utf8");
+        reportRunRecord(admitted.runDirectory, "stderr", { text: result.stderr }, "post-admission");
     }
     catch (error) {
         stderrLogWriteFailure = error;
-        // Best-effort: stderr.log is secondary to the host terminal. A write
+        // Best-effort: the stderr log line is secondary to the host terminal. A write
         // failure leaves a durable note and, on a host failure, rides in
         // packageFact. It does not become the cause.
-        await recordBestEffortPostDispatchDiagnostic(admitted, env, `stderr.log write failed (best-effort continue): ${describeErrorIdentity(error)}`, io);
+        await recordBestEffortPostDispatchDiagnostic(admitted, env, `stderr log write failed (best-effort continue): ${describeErrorIdentity(error)}`, io);
     }
     // Host facts are resolved before trySettle. A host failure skips trySettle
     // so a later read cannot replace that report. A clean host whose settlement
     // read throws is noted above and is not turned into a failure terminal.
-    // stderr.log and run-state writes are notes beside the host terminal.
+    // the stderr log line and run-state writes are notes beside the host terminal.
     let settled;
     let settledOutcome;
     // The host CLI's own report: timeout, declared failure, cancel, or exit.
@@ -440,6 +444,9 @@ async function settleCompletedHostTurn(input) {
                     deferredPersist,
                     invocationScopeId: request.invocationScopeId,
                     notePackageFault: courtScope.notePackageFault,
+                    ...(courtScope.courtAttemptId === undefined
+                        ? {}
+                        : { courtAttemptId: courtScope.courtAttemptId }),
                 })) };
         }
         if (persistRunState) {
@@ -476,11 +483,62 @@ async function settleCompletedHostTurn(input) {
             // Secondary fact only — never the cause, and never merged into the
             // host's own details.
             ...(stderrLogWriteFact === undefined ? {} : { packageFact: stderrLogWriteFact }),
-        }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault);
+        }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault, courtScope.courtAttemptId);
         return { kind: "settled", outcome: await finishAfterTurn(withProcessCancelSkipAutoResume({ ...failed, turnDispatched: true, ...deferredPersist }, env.signal)) };
     }
     return { kind: "still-missing" };
 }
+/**
+ * #858 / #1071: the first identifiable ticketNumber field declaration among the
+ * run's sealed rows files an unbound run (integer, digit string, or leading #N
+ * token). Terminal rows match settlement (#881): accepted and audit-escalation —
+ * an escalated submission still carries the original role params. Later
+ * receipts remain untouched; prose note/report is never consulted; this seam
+ * does not adjudicate a ticket change. Runs in the public call's own process
+ * (no role leg writes the run's current.json).
+ */
+export async function bindSealedTicketNumber(admitted) {
+    if (admitted.ticketNumber !== undefined)
+        return;
+    const rows = await readRecordedSubmissionRows(admitted.projectRoot, admitted.runId, ledgerReadScope(admitted));
+    let ticketNumber;
+    for (const row of rows) {
+        if (row.role !== admitted.role
+            || (row.kind !== "accepted" && row.kind !== "audit-escalation")) {
+            continue;
+        }
+        const payload = row.accepted;
+        if (!isRecord(payload))
+            continue;
+        ticketNumber = readDeclaredTicketNumber(payload.ticketNumber);
+        if (ticketNumber !== undefined)
+            break;
+    }
+    if (ticketNumber !== undefined)
+        await bindAdmittedTicketNumber(admitted, ticketNumber);
+}
+/**
+ * The ticket a diarist asserted on a completed submission, whether or not the
+ * rest of that submission was later accepted (a bounds reask does not unsay the
+ * ticket). Before this ran in the leg's accept hook; the leg now only appends its
+ * ledger rows and the public call's own process binds the ticket from them.
+ */
+export async function bindDiaristAssertedTicketNumber(admitted) {
+    if (admitted.ticketNumber !== undefined)
+        return;
+    const rows = await readRecordedSubmissionRows(admitted.projectRoot, admitted.runId, ledgerReadScope(admitted));
+    for (const row of rows) {
+        if (row.role !== admitted.role || !isRecord(row.accepted))
+            continue;
+        if (row.accepted.status !== "completed" || !("ticketNumber" in row.accepted))
+            continue;
+        const ticketNumber = parseTicketNumber(row.accepted.ticketNumber);
+        if (ticketNumber !== undefined) {
+            await bindAdmittedTicketNumber(admitted, ticketNumber);
+            return;
+        }
+    }
+}
 export async function dispatchPostAdmissionTurn(input) {
     const { admitted, env, io, request, lease, adapters, effectiveEngine } = input;
     const persistRunState = input.persistRunState !== false;
@@ -533,7 +591,7 @@ export async function dispatchPostAdmissionTurn(input) {
                     knownDiagnostic: processCancelDiagnostic(cancelBeforeFinish),
                     cancelName: cancelBeforeFinish,
                     skipRunStateWrite: true,
-                }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault)),
+                }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault, courtScope.courtAttemptId)),
                 turnDispatched: true,
                 skipAutoResume: true,
                 ...deferredPersist,
@@ -575,24 +633,7 @@ export async function dispatchPostAdmissionTurn(input) {
             // an escalated submission still carries the original role params.
             // Later receipts remain untouched; prose note/report is never consulted;
             // this seam does not adjudicate a ticket change.
-            if (admitted.ticketNumber === undefined) {
-                const rows = await readRecordedSubmissionRows(admitted.projectRoot, admitted.runId, ledgerReadScope(admitted));
-                let ticketNumber;
-                for (const row of rows) {
-                    if (row.role !== admitted.role
-                        || (row.kind !== "accepted" && row.kind !== "audit-escalation")) {
-                        continue;
-                    }
-                    const payload = row.accepted;
-                    if (!isRecord(payload))
-                        continue;
-                    ticketNumber = readDeclaredTicketNumber(payload.ticketNumber);
-                    if (ticketNumber !== undefined)
-                        break;
-                }
-                if (ticketNumber !== undefined)
-                    await bindAdmittedTicketNumber(admitted, ticketNumber);
-            }
+            await bindSealedTicketNumber(admitted);
             // #863: shared post-admission bind must relocate unbound→ticket in-home
             // before lease release (work-seat self-report and any prior board bind).
             const relocation = await relocateAdmittedRunToTicket(admitted, env.principalAuthority, lease);
@@ -618,7 +659,7 @@ export async function dispatchPostAdmissionTurn(input) {
                     code: null,
                     stderr: "",
                     thrown: error,
-                }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault)),
+                }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault, courtScope.courtAttemptId)),
                 ...(result.turnDispatched === true ? { turnDispatched: true } : {}),
                 ...(result.skipAutoResume === true ? { skipAutoResume: true } : {}),
                 ...deferredPersist,
@@ -649,7 +690,7 @@ export async function dispatchPostAdmissionTurn(input) {
                     code: null,
                     stderr: "",
                     thrown: error,
-                }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault));
+                }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault, courtScope.courtAttemptId));
                 return { ...settled, ...deferredPersist };
             }
         }
@@ -668,7 +709,7 @@ export async function dispatchPostAdmissionTurn(input) {
             turnRequest = { ...turnRequest, stationChild: env.stationChild };
         }
         // Selected host axis rides the shared Host envelope for in-turn tools
-        // (detour usage ledger) — never a pre-spawn invocation.json reread.
+        // (detour usage ledger) — never a pre-spawn current.json reread.
         if (typeof env.host === "string" && env.host.trim() !== "") {
             turnRequest = { ...turnRequest, host: env.host.trim() };
         }
@@ -685,7 +726,6 @@ export async function dispatchPostAdmissionTurn(input) {
             // host CLI's native resume. Nothing here may gate, redirect or reshape
             // that dispatch on prior conclusions, row counts or report presence;
             // the authoritative post-turn settlement reads whatever really happened.
-            recordRunStart(admitted.runDirectory);
             turnDispatched = true;
             result = await env.roleTurnHost.executeTurn(turnRequest);
         }
@@ -699,7 +739,7 @@ export async function dispatchPostAdmissionTurn(input) {
                 // call is a second fact; it must not become a new Error in its place.
                 ...(processCancelName === undefined ? {} : { cancelName: processCancelName }),
                 thrown: error,
-            }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault);
+            }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault, courtScope.courtAttemptId);
             return await finishAfterTurn(withProcessCancelSkipAutoResume({ ...settled, turnDispatched: true, ...deferredPersist }, env.signal));
         }
         // #1132: settle this turn through the ONE post-turn settlement authority,
@@ -734,11 +774,9 @@ export async function dispatchPostAdmissionTurn(input) {
             let deliveryResult;
             let deliveryTurnRequest;
             try {
-                const deliveryRequest = await buildReceiptDeliveryRequest({
-                    admitted,
-                    env,
-                    // Host and the other axes already selected on this turn ride the
-                    // shared projection. The pre-projection request does not have them.
+                // Host and the other axes already selected on this turn ride the
+                // shared projection. The pre-projection request does not have them.
+                const deliveryRequest = buildReceiptDeliveryRequest({
                     request: turnRequest,
                     receiptDelivery,
                 });
@@ -758,7 +796,7 @@ export async function dispatchPostAdmissionTurn(input) {
                 // its true cause, through the one settlement authority (ADR 0080).
                 // The turn started, so the caller's loop resumes instead of replaying
                 // the initial payload. The issued count survives that re-entry.
-                const settled = await settleAfterTurnStarted(admitted, withEngineDetourInvocationScope({ timedOut: false, code: null, stderr: "", thrown: error }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState);
+                const settled = await settleAfterTurnStarted(admitted, withEngineDetourInvocationScope({ timedOut: false, code: null, stderr: "", thrown: error }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState, courtScope.notePackageFault, courtScope.courtAttemptId);
                 return await finishAfterTurn(withProcessCancelSkipAutoResume({
                     ...settled,
                     turnDispatched: true,
@@ -818,6 +856,9 @@ export async function dispatchPostAdmissionTurn(input) {
                 deferredPersist,
                 invocationScopeId: request.invocationScopeId,
                 notePackageFault: courtScope.notePackageFault,
+                ...(courtScope.courtAttemptId === undefined
+                    ? {}
+                    : { courtAttemptId: courtScope.courtAttemptId }),
             }));
         }
         if (persistRunState) {
@@ -1111,6 +1152,9 @@ export async function runPostAdmissionSeatResume(input) {
                 };
             }
         }
+        // Public explicit resume: attach the stored native id when the caller
+        // left it unset (399c3c8c). In-call auto-resume / 催交 / gate retry omit
+        // the field; those load inside the host adapter (host-contracts).
         let turnRequest = await input.buildTurnRequest(admittedForBuild, request);
         if (turnRequest.continuation.kind === "resume"
             && turnRequest.continuation.hostSessionId === undefined) {
@@ -1211,7 +1255,7 @@ export async function runPostAdmissionSeatResume(input) {
     catch (error) {
         if (error instanceof TurnDispatchedFailure)
             throw error;
-        await presentResumeFailurePointer(input.io, error, (failure) => writeResumeDiagnosticFile(loaded.admitted.runDirectory, loaded.admitted.runId, failure, loaded.admitted.role));
+        await presentResumeFailurePointer(input.io, error, (failure) => writeResumeDiagnostic(loaded.admitted.runDirectory, loaded.admitted.runId, failure, loaded.admitted.role));
         return { exitCode: error instanceof CliUsageError ? 2 : 1 };
     }
 }
@@ -1231,12 +1275,12 @@ async function pointExistingRunFailure(home, runId, authority, io, thrown) {
         record = await readRoleRunState(runDirectory, authority);
     }
     catch {
-        await presentResumeFailurePointer(io, thrown, (failure) => writeResumeDiagnosticFile(runDirectory, runId, failure));
+        await presentResumeFailurePointer(io, thrown, (failure) => writeResumeDiagnostic(runDirectory, runId, failure));
         return true;
     }
     if (record === undefined)
         return false;
-    await presentResumeFailurePointer(io, thrown, (failure) => writeResumeDiagnosticFile(runDirectory, runId, failure, record.role));
+    await presentResumeFailurePointer(io, thrown, (failure) => writeResumeDiagnostic(runDirectory, runId, failure, record.role));
     return true;
 }
 export async function presentLocatedResumeFailure(home, runId, authority, io, thrown) {
@@ -1275,18 +1319,15 @@ async function presentResumeFailurePointer(io, thrown, publish) {
         }, io);
     }
 }
-async function writeResumeDiagnosticFile(runDirectory, runId, failure, role) {
-    const dir = await ensureRealArtifactsDirectory(runDirectory);
-    const path = join(dir, `resume-diagnostic-${randomUUID()}.json`);
-    await writeFile(path, `${JSON.stringify({
+async function writeResumeDiagnostic(runDirectory, runId, failure, role) {
+    return reportRunRecord(runDirectory, "resume-diagnostic", {
         runId,
         ...(role === undefined ? {} : { role }),
         diagnostic: failure.diagnostic,
         ...(failure.cause === undefined ? {} : { cause: failure.cause }),
         ...(failure.identity === undefined ? {} : { identity: failure.identity }),
         ...(failure.details === undefined ? {} : { details: failure.details }),
-    }, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
-    return path;
+    }, "post-admission").recordFile;
 }
 /**
  * Shared post-admission one-shot path: folds into runPostAdmissionResumable (#840 / #416).

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

@@ -16,6 +16,7 @@ import { retainedRunPathsMatch, rewriteAdmittedRoleRunPage, rewriteRunDirectoryP
 import { appendEngineSessionMaterial, engineSessionMaterialFromOptions, pickEngineAxis, } from "../package-resources/engine-material.js";
 import { packagedResumeSourcePath, packagedRoleMetadata, } from "../packaged-role-registry.js";
 import { admittedReviewerBaseFault, recordEffectiveInvocationModel, requireAuthorityRef, isReviewerLens, } from "./invocation.js";
+import { readPageSync, writeSectionSync } from "../run-dossier.js";
 import { isRecord, errorText, isEnoent } from "../unknown-value.js";
 /** Default for the #422 configurable single-call auto-resume ceiling
  * (public-cli.json top-level `autoResumeLimit`). No longer the runtime truth
@@ -41,11 +42,10 @@ export function buildAutoResumeContinuationPrompt(options) {
         ...pickEngineAxis(options),
     })).join("\n");
 }
-const RUN_STATE_FILE = "run-state.json";
 const WRITER_LOCK_FILE = "writer.lock";
 export async function writeRoleRunState(runDirectory, record) {
     const payload = { ...record, runDirectory };
-    await writeFile(join(runDirectory, RUN_STATE_FILE), `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    writeSectionSync(runDirectory, "runState", { ...payload });
 }
 function parseSameTicketSummonsMaterials(raw) {
     if (!isRecord(raw))
@@ -106,43 +106,34 @@ function parseCurrentCourtState(raw) {
     };
 }
 async function readRoleRunStateRaw(runDirectory) {
-    let raw;
-    try {
-        raw = JSON.parse(await readFile(join(runDirectory, RUN_STATE_FILE), "utf8"));
-    }
-    catch (error) {
-        // Only true absence (ENOENT) is a lawful "no run state yet". A real read
-        // failure (EISDIR, EACCES, ...) or a JSON.parse SyntaxError on a present
-        // file is genuine infrastructure/data damage and must keep its own
-        // identity — callers route it through the controlled-failure seam
-        // (markRunRunning/markRunTerminal/recordCurrentCourt)
-        // instead of it being relabeled "run state missing" (#836).
-        if (errorCodeOf(error) === "ENOENT")
-            return undefined;
-        throw error;
-    }
-    return raw;
+    // Only true absence (no state.jsonl run-state row) is a lawful "no run state
+    // yet". A real read failure (EISDIR, EACCES, ...) or an illegal latest payload
+    // is genuine infrastructure/data damage and must keep its own identity —
+    // callers route it through the controlled-failure seam
+    // (markRunRunning/markRunTerminal/recordCurrentCourt) instead of it being
+    // relabeled "run state missing" (#836). readPageSync throws those.
+    return readPageSync(runDirectory, "runState");
 }
 function parseRoleRunIdentity(raw, runDirectory) {
     if (!isRecord(raw)) {
-        throw new TypeError("Invalid run-state.json");
+        throw new TypeError("Invalid state.jsonl run-state");
     }
     const record = raw;
     if (typeof record.runId !== "string" || record.runId.trim() === "") {
-        throw new TypeError("Invalid run-state.json");
+        throw new TypeError("Invalid state.jsonl run-state");
     }
     const role = typeof record.role === "string" ? packagedRoleMetadata(record.role)?.role : undefined;
     if (role === undefined) {
-        throw new TypeError("Invalid run-state.json");
+        throw new TypeError("Invalid state.jsonl run-state");
     }
     if (record.state !== "admitted" &&
         record.state !== "running" &&
         record.state !== "resumable" &&
         record.state !== "terminal") {
-        throw new TypeError("Invalid run-state.json");
+        throw new TypeError("Invalid state.jsonl run-state");
     }
     if (typeof record.bookKey !== "string")
-        throw new TypeError("Invalid run-state.json");
+        throw new TypeError("Invalid state.jsonl run-state");
     return {
         runId: record.runId,
         role,
@@ -158,11 +149,9 @@ async function readRoleRunStateDisk(runDirectory) {
     const identity = parseRoleRunIdentity(raw, runDirectory);
     const record = raw;
     if (typeof record.projectRoot !== "string")
-        throw new TypeError("Invalid run-state.json");
+        throw new TypeError("Invalid state.jsonl run-state");
     if (typeof record.sessionDirectory !== "string")
-        throw new TypeError("Invalid run-state.json");
-    if (typeof record.admittedRequestPath !== "string")
-        throw new TypeError("Invalid run-state.json");
+        throw new TypeError("Invalid state.jsonl run-state");
     const storedRunDirectory = typeof record.runDirectory === "string" && record.runDirectory.trim() !== ""
         ? record.runDirectory
         : runDirectory;
@@ -185,7 +174,6 @@ async function readRoleRunStateDisk(runDirectory) {
         bookKey: identity.bookKey,
         projectRoot: record.projectRoot,
         runDirectory: runDir,
-        admittedRequestPath: rewriteRunDirectoryPathValue(record.admittedRequestPath, storedRunDirectory, runDirectory),
         principalWire,
         ...(phase === undefined ? {} : { phase }),
         ...(currentCourt === undefined ? {} : { currentCourt }),
@@ -203,11 +191,10 @@ async function writeRoleRunStateDisk(runDirectory, disk) {
         ...(disk.principalWire.sessionFile === undefined
             ? {}
             : { sessionFile: disk.principalWire.sessionFile }),
-        admittedRequestPath: disk.admittedRequestPath,
         ...(disk.phase === undefined ? {} : { phase: disk.phase }),
         ...(disk.currentCourt === undefined ? {} : { currentCourt: disk.currentCourt }),
     };
-    await writeFile(join(runDirectory, RUN_STATE_FILE), `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    writeSectionSync(runDirectory, "runState", payload);
 }
 /** One authority.decode of the uninterpreted wire → record + opaque principal (frozen wire itself). */
 function materializeRoleRunFromDisk(disk, authority) {
@@ -224,7 +211,6 @@ function materializeRoleRunFromDisk(disk, authority) {
                 sessionDirectory: coordinates.sessionDirectory,
                 sessionFile: coordinates.sessionFile,
                 runDirectory: disk.runDirectory,
-                admittedRequestPath: disk.admittedRequestPath,
                 ...(disk.phase === undefined ? {} : { phase: disk.phase }),
             },
         };
@@ -265,14 +251,13 @@ export async function markRunAdmitted(admitted, authority) {
         projectRoot: admitted.projectRoot,
         sessionDirectory,
         sessionFile,
-        admittedRequestPath: admitted.admittedRequestPath,
         ...(workerPhase === undefined ? {} : { phase: workerPhase }),
     });
 }
 /**
  * Shared dispatch execution seam: transition to running, then record the
  * effective launch model (initial or resume override) and the authoritative
- * seat engine/host onto invocation.json.
+ * seat engine/host onto the invocation section.
  * Role runners must not coordinate lifecycle ledger writes themselves.
  * Engine axis is authoritative here (#617): present string is written; omit/undefined
  * clears any prior engine key so unset-engine + resume does not keep a stale value.
@@ -664,19 +649,9 @@ export function parentRunPathFromGatePointerInstruction(instruction) {
  * Missing page → undefined; damage / non-ENOENT IO propagates.
  */
 export async function readRunParentPath(runDirectory) {
-    let raw;
-    try {
-        raw = JSON.parse(await readFile(join(runDirectory, "admitted-request.json"), "utf8"));
-    }
-    catch (error) {
-        if (errorCodeOf(error) === "ENOENT")
-            return undefined;
-        throw error;
-    }
-    if (!isRecord(raw)) {
+    const record = readPageSync(runDirectory, "admitted");
+    if (record === undefined)
         return undefined;
-    }
-    const record = raw;
     if (typeof record.sourceRunPath === "string" && record.sourceRunPath.trim() !== "") {
         return record.sourceRunPath;
     }
@@ -789,7 +764,7 @@ async function loadResumableRunRecord(home, runId, authority) {
         throw new CliUsageError(`unknown role run id: ${runId}`);
     }
     const { run, principal } = materialized;
-    // Reconstruct admitted identity from durable run record + admitted-request.json.
+    // Reconstruct admitted identity from durable run record + the admitted section.
     let instruction = "";
     let instructionEmpty = true;
     let attachments = [];
@@ -817,9 +792,10 @@ async function loadResumableRunRecord(home, runId, authority) {
     let sourceRunPath;
     let sourceRun;
     try {
-        const raw = JSON.parse(await readFile(run.admittedRequestPath, "utf8"));
-        if (isRecord(raw)) {
-            const record = raw;
+        const record = readPageSync(run.runDirectory, "admitted");
+        if (record === undefined)
+            throw new Error("state.jsonl has no admitted-request row");
+        {
             const storedRunDirectory = typeof record.runDirectory === "string" && record.runDirectory.trim() !== ""
                 ? record.runDirectory
                 : run.runDirectory;
@@ -954,9 +930,8 @@ async function loadResumableRunRecord(home, runId, authority) {
     }
     let model;
     try {
-        const invocationRaw = JSON.parse(await readFile(join(run.runDirectory, "invocation.json"), "utf8"));
-        if (isRecord(invocationRaw)) {
-            const rec = invocationRaw;
+        const rec = readPageSync(run.runDirectory, "invocation");
+        if (rec !== undefined) {
             if (typeof rec.provider === "string" && typeof rec.model === "string") {
                 model = {
                     provider: rec.provider,
@@ -1043,7 +1018,6 @@ function resumedBaseAdmitted(loaded) {
         attachments: loaded.admittedFields.attachments,
         runDirectory: loaded.run.runDirectory,
         principal: loaded.principal,
-        admittedRequestPath: loaded.run.admittedRequestPath,
         ...(loaded.admittedFields.model === undefined ? {} : { model: loaded.admittedFields.model }),
         ...restoredTicketFields(loaded.admittedFields),
     };