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

package/src/public-cli/settlement.ts

@@ -11,12 +11,15 @@ import {
   readAnalystGateCyclesFromAuditorRoles,
   type AnalystGateCycleRound,
 } from "../analyst-gate-cycles-read.ts";
+import { readSitianRecords, resolveSitianRecordPath, sitianReport } from "../sitian-facade.ts";
 
 import { isAuditEscalationResult } from "../audit-escalation.ts";
 import { AUDITOR_SOUL_ROLES } from "../auditor-soul.ts";
 import { DOCTOR_AUDIT_TOOL_NAME } from "../doctor-auditor.ts";
 import { JUDGE_AUDIT_TOOL_NAME } from "../judge-auditor.ts";
-import { knownFailureFromProviderStop, type ExplicitInternalKnownFailure, readReviewerDispatchRejection } from "./explicit-internal.ts";
+import type { RoleTurnKnownFailure } from "../host-contracts.ts";
+import { knownFailureFromProviderStop } from "../pi/known-failure.ts";
+import { readReviewerDispatchRejection } from "./reviewer-dispatch-rejection.ts";
 import {
   RESUME_TRANSPORT_ENVELOPE,
   isV1ResumableProvider,
@@ -32,6 +35,8 @@ import {
   readComplianceCandidate,
   type ComplianceDecision,
 } from "../compliance-transport.ts";
+// COMPLIANCE_RESPONSE_ENTRY_TYPE remains for boundRetainedAuditResponse (call/result
+// interval binding on historical session bytes). Provider-stop retain authority is Sitian.
 import {
   COLLECTOR_OBSERVE_TOOL,
   COLLECTOR_REQUEST_TOOL,
@@ -93,6 +98,12 @@ import {
 } from "../navigator-invocation-identity.ts";
 import type { NavigatorPhase } from "../navigator-attendance.ts";
 import { NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, parseNoReceiptLifecycleFacts, type NoReceiptLifecycleFacts } from "../receipt-delivery-policy.ts";
+import type {
+  DurablePrincipal,
+  DurablePrincipalAuthority,
+  DurablePrincipalCoordinates,
+} from "../host-contracts.ts";
+import { decodePiDurablePrincipal } from "../pi/durable-principal.ts";
 import {
   ensureRunArtifactsDir,
   type AdmittedCoderInvocation,
@@ -105,6 +116,14 @@ import {
   type AdmittedReviewerInvocation,
   type AdmittedRoleInvocation,
 } from "./invocation.ts";
+
+/** Settlement path reads go through the host decode accessor only. */
+function coordinatesFromAdmitted(
+  authority: DurablePrincipalAuthority,
+  admitted: { readonly principal: DurablePrincipal },
+): DurablePrincipalCoordinates {
+  return decodePiDurablePrincipal(authority, admitted.principal);
+}
 import {
   exitCodeForTerminalOutcome,
   formatTerminalResult,
@@ -445,7 +464,7 @@ export function classifyPostAdmissionFailure(input: {
 
 /** One projection owner for the four audited public runners. */
 export function explicitInternalKnownFailureClassificationInput(
-  failure: ExplicitInternalKnownFailure | undefined,
+  failure: RoleTurnKnownFailure | undefined,
 ) {
   if (failure === undefined) return {};
   return {
@@ -634,8 +653,9 @@ export function extractSessionProviderStop(
   entries: readonly SessionEntry[],
 ): SessionProviderStop | undefined {
   // A resumed dispatch appends a typed top-level user turn to the same session.
-  // Retained audit state from an older attempt must not replace the newer attempt's
-  // native provider stop. Sessions without a user turn are the initial attempt.
+  // Older attempt native stops must not replace the newer attempt's stop.
+  // Sessions without a user turn are the initial attempt.
+  // Auditor retained responses live in Sitian (kind=auditor); see readSessionProviderStop.
   let attemptStart = 0;
   for (let i = entries.length - 1; i >= 0; i -= 1) {
     const entry = entries[i];
@@ -645,17 +665,6 @@ export function extractSessionProviderStop(
     }
   }
 
-  // The shared auditor is a nested model turn. Within the current attempt its
-  // retained typed response is authoritative when failInfrastructure subsequently
-  // aborts the parent turn.
-  for (let i = entries.length - 1; i >= attemptStart; i -= 1) {
-    const entry = entries[i];
-    if (entry?.type !== "custom" || entry.customType !== COMPLIANCE_RESPONSE_ENTRY_TYPE) continue;
-    const response = isRecord(entry.data) && isRecord(entry.data.response) ? entry.data.response : undefined;
-    const stop = sessionProviderStopFromAssistant(response);
-    if (stop !== undefined) return stop;
-    break;
-  }
   for (let i = entries.length - 1; i >= attemptStart; i -= 1) {
     const entry = entries[i];
     if (entry?.type !== "message") continue;
@@ -667,10 +676,46 @@ export function extractSessionProviderStop(
   return undefined;
 }
 
-/** Read the bound session principal and extract a typed provider-stop, if any. */
+/**
+ * Latest Sitian-retained auditor response stop for this parent session principal.
+ * Writer: retainComplianceResponse → sitianReport(kind=auditor, payload={version,response}).
+ * Payload stopReason is preserved as retained — aborted stays aborted; no 500/error wash here.
+ */
+async function readSitianRetainedAuditorProviderStop(
+  sessionFile: string,
+): Promise<SessionProviderStop | undefined> {
+  try {
+    const { recordFile } = resolveSitianRecordPath({
+      level: "event",
+      kind: "auditor",
+      sessionParent: sessionFile,
+      // Path is driven by sessionParent when under ledger home; cwd is a fallback only.
+      cwd: dirname(sessionFile),
+    });
+    const { records } = await readSitianRecords(recordFile);
+    for (let i = records.length - 1; i >= 0; i -= 1) {
+      const payload = records[i]?.payload;
+      if (!isRecord(payload) || !isRecord(payload.response)) continue;
+      // Lifecycle events carry `type` (binding / compliance_failure); retain does not.
+      if (typeof payload.type === "string") continue;
+      const stop = sessionProviderStopFromAssistant(payload.response as SessionMessage);
+      if (stop !== undefined) return stop;
+      // Latest retain exists but is not a provider-stop — do not scan older retains
+      // (mirrors former session COMPLIANCE_RESPONSE preference break).
+      break;
+    }
+  } catch {
+    // Missing volume or unreadable path is absence, not a settlement failure.
+  }
+  return undefined;
+}
+
+/** Read retained auditor stop (Sitian) then native session assistant stop, if any. */
 export async function readSessionProviderStop(
   sessionFile: string,
 ): Promise<SessionProviderStop | undefined> {
+  const retained = await readSitianRetainedAuditorProviderStop(sessionFile);
+  if (retained !== undefined) return retained;
   try {
     const entries = await readBoundSessionEntries(sessionFile);
     return extractSessionProviderStop(entries);
@@ -686,7 +731,7 @@ export async function readSessionProviderStop(
  */
 export async function readBoundEvidenceChildKnownFailure(
   sessionFile: string,
-): Promise<ExplicitInternalKnownFailure | undefined> {
+): Promise<RoleTurnKnownFailure | undefined> {
   const childDirectory = join(dirname(sessionFile), "evidence-children");
   let names: string[];
   try {
@@ -796,7 +841,7 @@ async function loadBoundAuditorVolumes(
 
 function complianceFailureFromAuditorVolumes(
   volumes: readonly BoundAuditorVolume[],
-): ExplicitInternalKnownFailure | undefined {
+): RoleTurnKnownFailure | undefined {
   for (const { entries, attemptEntryId, parentId, sessionFile } of volumes) {
     const stop = extractSessionProviderStop(entries);
     if (stop === undefined) continue;
@@ -823,7 +868,7 @@ function complianceFailureFromAuditorVolumes(
 
 function providerStopFallbackFromAuditorVolumes(
   volumes: readonly BoundAuditorVolume[],
-): ExplicitInternalKnownFailure | undefined {
+): RoleTurnKnownFailure | undefined {
   for (const { entries } of volumes) {
     const stop = extractSessionProviderStop(entries);
     if (stop === undefined) continue;
@@ -842,7 +887,7 @@ function providerStopFallbackFromAuditorVolumes(
 /** Recover a provider stop from the auditor child bound to the current parent attempt. */
 export async function readBoundAuditorKnownFailure(
   sessionFile: string,
-): Promise<ExplicitInternalKnownFailure | undefined> {
+): Promise<RoleTurnKnownFailure | undefined> {
   const volumes = await loadBoundAuditorVolumes(sessionFile);
   if (volumes === undefined) return undefined;
   return complianceFailureFromAuditorVolumes(volumes)
@@ -852,7 +897,7 @@ export async function readBoundAuditorKnownFailure(
 /** Strong auditor tier only — retained compliance-failure entries, no provider-stop fallback. */
 async function readBoundAuditorComplianceFailure(
   sessionFile: string,
-): Promise<ExplicitInternalKnownFailure | undefined> {
+): Promise<RoleTurnKnownFailure | undefined> {
   const volumes = await loadBoundAuditorVolumes(sessionFile);
   if (volumes === undefined) return undefined;
   return complianceFailureFromAuditorVolumes(volumes);
@@ -861,7 +906,7 @@ async function readBoundAuditorComplianceFailure(
 /** Weaker auditor tier: provider stop without a retained compliance-failure entry. */
 async function readBoundAuditorProviderStopFallback(
   sessionFile: string,
-): Promise<ExplicitInternalKnownFailure | undefined> {
+): Promise<RoleTurnKnownFailure | undefined> {
   const volumes = await loadBoundAuditorVolumes(sessionFile);
   if (volumes === undefined) return undefined;
   return providerStopFallbackFromAuditorVolumes(volumes);
@@ -869,7 +914,7 @@ async function readBoundAuditorProviderStopFallback(
 
 function typedFailedTerminatingToolKnownFailure(
   entries: readonly SessionEntry[],
-): ExplicitInternalKnownFailure | undefined {
+): RoleTurnKnownFailure | undefined {
   let attemptStart = 0;
   for (let i = entries.length - 1; i >= 0; i -= 1) {
     if (entries[i]?.type === "message" && entries[i]?.message?.role === "user") {
@@ -908,7 +953,7 @@ function typedFailedTerminatingToolKnownFailure(
  * never re-read the sidecar in presentControlledFailure.
  */
 export type AuditedRunnerFailureResolution = {
-  readonly knownFailure?: ExplicitInternalKnownFailure;
+  readonly knownFailure?: RoleTurnKnownFailure;
   /** Successful sidecar read (not absence). */
   readonly typedHttpObservation?: TypedProviderHttpObservation;
   /**
@@ -920,7 +965,7 @@ export type AuditedRunnerFailureResolution = {
 };
 
 function resolutionOf(
-  knownFailure: ExplicitInternalKnownFailure | undefined,
+  knownFailure: RoleTurnKnownFailure | undefined,
   typedHttp: {
     readonly settled: boolean;
     readonly observation?: TypedProviderHttpObservation;
@@ -935,9 +980,9 @@ function resolutionOf(
 
 /** Sole evidence-priority owner for public runners with Soul auditors. */
 export async function resolveAuditedRunnerFailureResolution(input: {
-  runner: ExplicitInternalKnownFailure | undefined;
+  runner: RoleTurnKnownFailure | undefined;
   sessionFile: string;
-  credential: ExplicitInternalKnownFailure | undefined;
+  credential: RoleTurnKnownFailure | undefined;
   /** Reviewer only: recover child-written rejection page into knownFailure.details. */
   runDirectory?: string;
 }): Promise<AuditedRunnerFailureResolution> {
@@ -1063,12 +1108,12 @@ export async function resolveAuditedRunnerFailureResolution(input: {
 
 /** Sole evidence-priority owner for public runners with Soul auditors. */
 export async function resolveAuditedRunnerKnownFailure(input: {
-  runner: ExplicitInternalKnownFailure | undefined;
+  runner: RoleTurnKnownFailure | undefined;
   sessionFile: string;
-  credential: ExplicitInternalKnownFailure | undefined;
+  credential: RoleTurnKnownFailure | undefined;
   /** Reviewer only: recover child-written rejection page into knownFailure.details. */
   runDirectory?: string;
-}): Promise<ExplicitInternalKnownFailure | undefined> {
+}): Promise<RoleTurnKnownFailure | undefined> {
   return (await resolveAuditedRunnerFailureResolution(input)).knownFailure;
 }
 
@@ -1084,7 +1129,7 @@ export async function resolveControlledFailureResumeObservation(input: {
   readonly typedHttpObservation?: TypedProviderHttpObservation;
 }): Promise<{
   readonly typedHttp429?: TypedHttp429Observation;
-  readonly observationReadFailure?: ExplicitInternalKnownFailure;
+  readonly observationReadFailure?: RoleTurnKnownFailure;
 }> {
   if (input.typedHttpObservationSettled === true) {
     const observation = input.typedHttpObservation;
@@ -1118,7 +1163,7 @@ export async function resolveControlledFailureResumeObservation(input: {
 export function controlledFailureInputFromResolution(
   resolution: AuditedRunnerFailureResolution,
 ): {
-  knownFailure?: ExplicitInternalKnownFailure;
+  knownFailure?: RoleTurnKnownFailure;
   typedHttpObservationSettled?: true;
   typedHttpObservation?: TypedProviderHttpObservation;
 } {
@@ -1815,10 +1860,10 @@ type AttemptHistorySource = {
  * the history entry backing the overwrite did not land (fail closed).
  */
 export async function appendRunAttemptHistory(
-  admitted: AttemptHistorySource,
+  source: AttemptHistorySource,
   outcome: AttemptHistoryOutcome,
 ): Promise<void> {
-  const entries = await readBoundSessionEntries(admitted.sessionFile);
+  const entries = await readBoundSessionEntries(source.sessionFile);
   let parentId: string | null = null;
   let priorEntries = 0;
   for (const entry of entries) {
@@ -1831,22 +1876,35 @@ export async function appendRunAttemptHistory(
     }
   }
   const timestamp = new Date().toISOString();
-  // Shape mirrors pi SessionManager.appendCustomEntry.
+  const attemptData = {
+    sequence: priorEntries + 1,
+    role: source.role,
+    runId: source.runId,
+    recordedAt: timestamp,
+    outcome,
+  };
   const line = `${JSON.stringify({
     type: "custom",
     customType: ATTEMPT_HISTORY_ENTRY_TYPE,
-    data: {
-      sequence: priorEntries + 1,
-      role: admitted.role,
-      runId: admitted.runId,
-      recordedAt: timestamp,
-      outcome,
-    },
+    data: attemptData,
     id: randomUUID(),
     parentId,
     timestamp,
   })}\n`;
-  await appendFile(admitted.sessionFile, line, "utf8");
+  await appendFile(source.sessionFile, line, "utf8");
+  try {
+    sitianReport({
+      level: "event",
+      kind: "attempt-history",
+      subject: { runId: source.runId },
+      sessionParent: source.sessionFile,
+      payload: {
+        type: ATTEMPT_HISTORY_ENTRY_TYPE,
+        ...attemptData,
+      },
+      source: "settlement",
+    });
+  } catch {}
 }
 
 /** Lawful Judge outcomes extracted from session (never a fabricated failure Receipt). */
@@ -2157,10 +2215,10 @@ export function extractNavigatorFact(
  * so the controlled-failure Terminal itself still settles.
  */
 async function extractNavigatorFactFromAdmittedSession(
-  admitted: AdmittedRoleInvocation,
+  sessionFile: string,
 ): Promise<TerminalNavigatorFact> {
   try {
-    const entries = await readBoundSessionEntries(admitted.sessionFile);
+    const entries = await readBoundSessionEntries(sessionFile);
     return extractNavigatorFact(entries);
   } catch (error) {
     if (isMissingPathError(error)) {
@@ -2181,11 +2239,11 @@ async function extractNavigatorFactFromAdmittedSession(
 export async function publishJudgeArtifacts(
   admitted: AdmittedJudgeInvocation,
   roleOutcome: TerminalRoleOutcome,
-  sessionDirectory: string,
+  coordinates: DurablePrincipalCoordinates,
 ): Promise<TerminalArtifactRef[]> {
   // #419: history first — report/evidence stay last-write-wins views only
   // because every attempt's complete result has already been appended.
-  await appendRunAttemptHistory(admitted, roleOutcome);
+  await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -2207,8 +2265,8 @@ export async function publishJudgeArtifacts(
     `${JSON.stringify(
       {
         runId: admitted.runId,
-        sessionDirectory,
-        sessionFile: admitted.sessionFile,
+        sessionDirectory: coordinates.sessionDirectory,
+        sessionFile: coordinates.sessionFile,
         admittedRequestPath: admitted.admittedRequestPath,
         attachments: admitted.attachments.map((a) => ({
           provenancePath: a.provenancePath,
@@ -2235,13 +2293,13 @@ export async function publishJudgeArtifacts(
 export async function publishCoderArtifacts(
   admitted: AdmittedCoderInvocation,
   roleOutcome: TerminalRoleOutcome,
-  sessionDirectory: string,
+  coordinates: DurablePrincipalCoordinates,
   options: {
     readonly methodProvenance?: PackagedMethodSkillProvenance;
     readonly coderOutput?: CoderOutput;
   } = {},
 ): Promise<TerminalArtifactRef[]> {
-  await appendRunAttemptHistory(admitted, roleOutcome);
+  await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -2269,8 +2327,8 @@ export async function publishCoderArtifacts(
         runId: admitted.runId,
         role: "coder",
         phase: admitted.phase,
-        sessionDirectory,
-        sessionFile: admitted.sessionFile,
+        sessionDirectory: coordinates.sessionDirectory,
+        sessionFile: coordinates.sessionFile,
         admittedRequestPath: admitted.admittedRequestPath,
         taskPath: admitted.taskPath,
         attachments: admitted.attachments.map((a) => ({
@@ -2335,10 +2393,10 @@ export function extractCoderRoleOutcome(
  * Malformed JSONL / other read failures throw with knownCause=session.
  */
 async function readLawfulSettlementEntries(
-  admitted: AdmittedRoleInvocation,
+  sessionFile: string,
 ): Promise<SessionEntry[] | undefined> {
   try {
-    return await readBoundSessionEntries(admitted.sessionFile);
+    return await readBoundSessionEntries(sessionFile);
   } catch (error) {
     // Missing path is absence of a lawful outcome; callers classify via session inspect.
     if (isMissingPathError(error)) return undefined;
@@ -2357,8 +2415,10 @@ async function readLawfulSettlementEntries(
  */
 export async function readLawfulJudgeRoleOutcome(
   admitted: AdmittedJudgeInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<LawfulJudgeRoleOutcome | undefined> {
-  const entries = await readLawfulSettlementEntries(admitted);
+  const { sessionFile } = coordinatesFromAdmitted(authority, admitted);
+  const entries = await readLawfulSettlementEntries(sessionFile);
   if (entries === undefined) return undefined;
   return extractJudgeRoleOutcome(entries);
 }
@@ -2370,9 +2430,10 @@ export async function readLawfulJudgeRoleOutcome(
  */
 export async function hasLawfulJudgeTerminalResult(
   admitted: AdmittedJudgeInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<boolean> {
   try {
-    const outcome = await readLawfulJudgeRoleOutcome(admitted);
+    const outcome = await readLawfulJudgeRoleOutcome(admitted, authority);
     return outcome !== undefined && isLawfulTypedTerminalOutcome(outcome);
   } catch {
     return false;
@@ -2392,8 +2453,10 @@ export async function hasLawfulJudgeTerminalResult(
  */
 async function settleLawfulJudgeTerminalResult(
   admitted: AdmittedJudgeInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalResult | undefined> {
-  const entries = await readLawfulSettlementEntries(admitted);
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const entries = await readLawfulSettlementEntries(coordinates.sessionFile);
   if (entries === undefined) return undefined;
   const roleOutcome = extractJudgeRoleOutcome(entries);
   if (roleOutcome === undefined) {
@@ -2404,7 +2467,7 @@ async function settleLawfulJudgeTerminalResult(
   const artifacts = await publishJudgeArtifacts(
     admitted,
     roleOutcome,
-    admitted.sessionDirectory,
+    coordinates,
   );
   return withOptionalGateProjection(
     {
@@ -2413,7 +2476,7 @@ async function settleLawfulJudgeTerminalResult(
       artifacts,
       runId: admitted.runId,
     },
-    admitted.sessionDirectory,
+    coordinates.sessionDirectory,
   );
 }
 
@@ -2424,8 +2487,9 @@ async function settleLawfulJudgeTerminalResult(
  */
 export async function settleJudgeTerminalResult(
   admitted: AdmittedJudgeInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalResult> {
-  const settled = await settleLawfulJudgeTerminalResult(admitted);
+  const settled = await settleLawfulJudgeTerminalResult(admitted, authority);
   if (settled === undefined) {
     throw new Error(
       "Judge Role run completed without a lawful typed terminal result",
@@ -2441,17 +2505,20 @@ export async function settleJudgeTerminalResult(
  */
 export async function trySettleJudgeTerminalResult(
   admitted: AdmittedJudgeInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulJudgeTerminalResult(admitted);
+  return settleLawfulJudgeTerminalResult(admitted, authority);
 }
 
 async function settleLawfulCoderTerminalResult(
   admitted: AdmittedCoderInvocation,
+  authority: DurablePrincipalAuthority,
   options: {
     readonly methodProvenance?: PackagedMethodSkillProvenance;
   } = {},
 ): Promise<TerminalResult | undefined> {
-  const entries = await readLawfulSettlementEntries(admitted);
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const entries = await readLawfulSettlementEntries(coordinates.sessionFile);
   if (entries === undefined) return undefined;
   const extracted = extractCoderRoleOutcome(entries);
   if (extracted === undefined) return undefined;
@@ -2459,7 +2526,7 @@ async function settleLawfulCoderTerminalResult(
   const artifacts = await publishCoderArtifacts(
     admitted,
     extracted.outcome,
-    admitted.sessionDirectory,
+    coordinates,
     {
       coderOutput: extracted.output,
       ...(options.methodProvenance === undefined
@@ -2474,18 +2541,19 @@ async function settleLawfulCoderTerminalResult(
       artifacts,
       runId: admitted.runId,
     },
-    admitted.sessionDirectory,
+    coordinates.sessionDirectory,
   );
 }
 
 /** Settle a lawful Coder Terminal from the admitted session (shared #106 success interface). */
 export async function settleCoderTerminalResult(
   admitted: AdmittedCoderInvocation,
+  authority: DurablePrincipalAuthority,
   options: {
     readonly methodProvenance?: PackagedMethodSkillProvenance;
   } = {},
 ): Promise<TerminalResult> {
-  const settled = await settleLawfulCoderTerminalResult(admitted, options);
+  const settled = await settleLawfulCoderTerminalResult(admitted, authority, options);
   if (settled === undefined) {
     throw new Error(
       "Coder Role run completed without a lawful typed terminal result",
@@ -2546,14 +2614,14 @@ export function extractFixerMethodInvocations(
 export async function publishFixerArtifacts(
   admitted: AdmittedFixerInvocation,
   roleOutcome: TerminalRoleOutcome,
-  sessionDirectory: string,
+  coordinates: DurablePrincipalCoordinates,
   options: {
     readonly methodProvenance: PackagedMethodSkillProvenance;
     readonly methodInvocations?: readonly ObservedPackagedMethodSkillInvocation[];
     readonly fixerOutput?: FixerOutput;
   },
 ): Promise<TerminalArtifactRef[]> {
-  await appendRunAttemptHistory(admitted, roleOutcome);
+  await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -2581,8 +2649,8 @@ export async function publishFixerArtifacts(
         runId: admitted.runId,
         role: "fixer",
         phase: admitted.phase,
-        sessionDirectory,
-        sessionFile: admitted.sessionFile,
+        sessionDirectory: coordinates.sessionDirectory,
+        sessionFile: coordinates.sessionFile,
         admittedRequestPath: admitted.admittedRequestPath,
         packetPath: admitted.packetPath,
         ...(admitted.prerequisitesPath === undefined
@@ -2652,13 +2720,16 @@ export function extractFixerRoleOutcome(
 
 async function settleLawfulFixerTerminalResult(
   admitted: AdmittedFixerInvocation,
+  authority: DurablePrincipalAuthority,
   options: {
     readonly methodProvenance: PackagedMethodSkillProvenance;
     readonly methodSkillPath: string;
     readonly methodSkillConfiguredPath: string;
   },
 ): Promise<TerminalResult | undefined> {
-  const entries = await readLawfulSettlementEntries(admitted);
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const { sessionDirectory, sessionFile } = coordinates;
+  const entries = await readLawfulSettlementEntries(sessionFile);
   if (entries === undefined) return undefined;
   const extracted = extractFixerRoleOutcome(entries);
   if (extracted === undefined) return undefined;
@@ -2672,7 +2743,7 @@ async function settleLawfulFixerTerminalResult(
   const artifacts = await publishFixerArtifacts(
     admitted,
     extracted.outcome,
-    admitted.sessionDirectory,
+    coordinates,
     {
       ...(extracted.output === undefined ? {} : { fixerOutput: extracted.output }),
       methodProvenance: options.methodProvenance,
@@ -2686,20 +2757,21 @@ async function settleLawfulFixerTerminalResult(
       artifacts,
       runId: admitted.runId,
     },
-    admitted.sessionDirectory,
+    sessionDirectory,
   );
 }
 
 /** Settle a lawful Fixer Terminal from the admitted session (shared #106 success interface). */
 export async function settleFixerTerminalResult(
   admitted: AdmittedFixerInvocation,
+  authority: DurablePrincipalAuthority,
   options: {
     readonly methodProvenance: PackagedMethodSkillProvenance;
     readonly methodSkillPath: string;
     readonly methodSkillConfiguredPath: string;
   },
 ): Promise<TerminalResult> {
-  const settled = await settleLawfulFixerTerminalResult(admitted, options);
+  const settled = await settleLawfulFixerTerminalResult(admitted, authority, options);
   if (settled === undefined) {
     throw new Error(
       "Fixer Role run completed without a lawful typed terminal result",
@@ -2711,12 +2783,12 @@ export async function settleFixerTerminalResult(
 export async function publishCollectorArtifacts(
   admitted: AdmittedCollectorInvocation,
   roleOutcome: TerminalRoleOutcome,
-  sessionDirectory: string,
+  coordinates: DurablePrincipalCoordinates,
   options: {
     readonly collectorReceipt?: CollectorReceipt;
   } = {},
 ): Promise<TerminalArtifactRef[]> {
-  await appendRunAttemptHistory(admitted, roleOutcome);
+  await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -2745,8 +2817,8 @@ export async function publishCollectorArtifacts(
         prNumber: admitted.prNumber,
         repository: admitted.repository.canonical,
         manifestDigest: admitted.manifestDigest,
-        sessionDirectory,
-        sessionFile: admitted.sessionFile,
+        sessionDirectory: coordinates.sessionDirectory,
+        sessionFile: coordinates.sessionFile,
         admittedRequestPath: admitted.admittedRequestPath,
         attachments: admitted.attachments.map((a) => ({
           provenancePath: a.provenancePath,
@@ -2804,8 +2876,11 @@ export function extractCollectorRoleOutcome(
 
 async function settleLawfulCollectorTerminalResult(
   admitted: AdmittedCollectorInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalResult | undefined> {
-  const entries = await readLawfulSettlementEntries(admitted);
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const { sessionDirectory, sessionFile } = coordinates;
+  const entries = await readLawfulSettlementEntries(sessionFile);
   if (entries === undefined) return undefined;
   const extracted = extractCollectorRoleOutcome(entries);
   if (extracted === undefined) {
@@ -2837,7 +2912,7 @@ async function settleLawfulCollectorTerminalResult(
   const artifacts = await publishCollectorArtifacts(
     admitted,
     extracted.outcome,
-    admitted.sessionDirectory,
+    coordinates,
     { collectorReceipt: extracted.receipt },
   );
   return withOptionalGateProjection(
@@ -2847,15 +2922,16 @@ async function settleLawfulCollectorTerminalResult(
       artifacts,
       runId: admitted.runId,
     },
-    admitted.sessionDirectory,
+    sessionDirectory,
   );
 }
 
 /** Settle a lawful Collector Terminal from the admitted session. */
 export async function settleCollectorTerminalResult(
   admitted: AdmittedCollectorInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalResult> {
-  const settled = await settleLawfulCollectorTerminalResult(admitted);
+  const settled = await settleLawfulCollectorTerminalResult(admitted, authority);
   if (settled === undefined) {
     throw new Error(
       "Collector Role run completed without a lawful typed terminal result",
@@ -2867,19 +2943,20 @@ export async function settleCollectorTerminalResult(
 /** Try to settle a lawful Collector Terminal; undefined only for genuine absence. */
 export async function trySettleCollectorTerminalResult(
   admitted: AdmittedCollectorInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulCollectorTerminalResult(admitted);
+  return settleLawfulCollectorTerminalResult(admitted, authority);
 }
 
 export async function publishDoctorArtifacts(
   admitted: AdmittedDoctorInvocation,
   roleOutcome: TerminalRoleOutcome,
-  sessionDirectory: string,
+  coordinates: DurablePrincipalCoordinates,
   options: {
     readonly doctorOutput?: DoctorOutput;
   } = {},
 ): Promise<TerminalArtifactRef[]> {
-  await appendRunAttemptHistory(admitted, roleOutcome);
+  await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -2908,8 +2985,8 @@ export async function publishDoctorArtifacts(
         issueNumber: admitted.issueNumber,
         caseRunsPath: admitted.caseRunsPath,
         caseIdentity: admitted.caseIdentity,
-        sessionDirectory,
-        sessionFile: admitted.sessionFile,
+        sessionDirectory: coordinates.sessionDirectory,
+        sessionFile: coordinates.sessionFile,
         admittedRequestPath: admitted.admittedRequestPath,
         attachments: admitted.attachments.map((a) => ({
           provenancePath: a.provenancePath,
@@ -2992,8 +3069,11 @@ export function extractDoctorRoleOutcome(
 
 async function settleLawfulDoctorTerminalResult(
   admitted: AdmittedDoctorInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalResult | undefined> {
-  const entries = await readLawfulSettlementEntries(admitted);
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const { sessionDirectory, sessionFile } = coordinates;
+  const entries = await readLawfulSettlementEntries(sessionFile);
   if (entries === undefined) return undefined;
   const extracted = extractDoctorRoleOutcome(entries);
   if (extracted === undefined) return undefined;
@@ -3023,7 +3103,7 @@ async function settleLawfulDoctorTerminalResult(
   const artifacts = await publishDoctorArtifacts(
     admitted,
     extracted.outcome,
-    admitted.sessionDirectory,
+    coordinates,
     extracted.output === undefined ? {} : { doctorOutput: extracted.output },
   );
   return withOptionalGateProjection(
@@ -3033,15 +3113,16 @@ async function settleLawfulDoctorTerminalResult(
       artifacts,
       runId: admitted.runId,
     },
-    admitted.sessionDirectory,
+    sessionDirectory,
   );
 }
 
 /** Settle a lawful Doctor Terminal from the admitted session. */
 export async function settleDoctorTerminalResult(
   admitted: AdmittedDoctorInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalResult> {
-  const settled = await settleLawfulDoctorTerminalResult(admitted);
+  const settled = await settleLawfulDoctorTerminalResult(admitted, authority);
   if (settled === undefined) {
     throw new Error(
       "Doctor Role run completed without a lawful typed terminal result",
@@ -3053,8 +3134,9 @@ export async function settleDoctorTerminalResult(
 /** Try to settle a lawful Doctor Terminal; undefined only for genuine absence. */
 export async function trySettleDoctorTerminalResult(
   admitted: AdmittedDoctorInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulDoctorTerminalResult(admitted);
+  return settleLawfulDoctorTerminalResult(admitted, authority);
 }
 
 /** Lawful Notary accepted outcome (pass/bounce). */
@@ -3094,8 +3176,11 @@ export function extractNotaryRoleOutcome(
 
 async function settleLawfulNotaryTerminalResult(
   admitted: AdmittedNotaryInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalResult | undefined> {
-  const entries = await readLawfulSettlementEntries(admitted);
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const { sessionDirectory, sessionFile } = coordinates;
+  const entries = await readLawfulSettlementEntries(sessionFile);
   if (entries === undefined) return undefined;
   const extracted = extractNotaryRoleOutcome(entries);
   if (extracted === undefined) {
@@ -3116,7 +3201,7 @@ async function settleLawfulNotaryTerminalResult(
           cause: "output",
           diagnostic: residual.diagnostic,
           details: { candidate: residual.candidate, acceptedReceipt: false },
-        });
+        }, authority);
       }
       if (
         acceptedNonUsable === undefined &&
@@ -3136,7 +3221,7 @@ async function settleLawfulNotaryTerminalResult(
         cause: "output",
         diagnostic: "符宝郎回执无显式 pass/bounce",
         details: { candidate: acceptedNonUsable, acceptedReceipt: false },
-      });
+      }, authority);
     }
     return undefined;
   }
@@ -3148,15 +3233,16 @@ async function settleLawfulNotaryTerminalResult(
       artifacts: [],
       runId: admitted.runId,
     },
-    admitted.sessionDirectory,
+    sessionDirectory,
   );
 }
 
 /** Settle a lawful Notary Terminal from the admitted session. */
 export async function settleNotaryTerminalResult(
   admitted: AdmittedNotaryInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalResult> {
-  const settled = await settleLawfulNotaryTerminalResult(admitted);
+  const settled = await settleLawfulNotaryTerminalResult(admitted, authority);
   if (settled === undefined) {
     throw new Error(
       "Notary Role run completed without a lawful typed terminal result",
@@ -3168,25 +3254,30 @@ export async function settleNotaryTerminalResult(
 /** Try to settle a lawful Notary Terminal; undefined only for genuine absence. */
 export async function trySettleNotaryTerminalResult(
   admitted: AdmittedNotaryInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulNotaryTerminalResult(admitted);
+  return settleLawfulNotaryTerminalResult(admitted, authority);
 }
 
 /** Try to settle a lawful Coder Terminal; undefined only for genuine absence. */
 export async function trySettleCoderTerminalResult(
   admitted: AdmittedCoderInvocation,
+  authority: DurablePrincipalAuthority,
   options: {
     readonly methodProvenance?: PackagedMethodSkillProvenance;
   } = {},
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulCoderTerminalResult(admitted, options);
+  return settleLawfulCoderTerminalResult(admitted, authority, options);
 }
 
 export async function hasLawfulCoderTerminalResult(
   admitted: AdmittedCoderInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<boolean> {
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const { sessionDirectory, sessionFile } = coordinates;
   try {
-    const entries = await readLawfulSettlementEntries(admitted);
+    const entries = await readLawfulSettlementEntries(sessionFile);
     if (entries === undefined) return false;
     const extracted = extractCoderRoleOutcome(entries);
     return extracted !== undefined && isLawfulTypedTerminalOutcome(extracted.outcome);
@@ -3198,20 +3289,24 @@ export async function hasLawfulCoderTerminalResult(
 /** Try to settle a lawful Fixer Terminal; undefined only for genuine absence. */
 export async function trySettleFixerTerminalResult(
   admitted: AdmittedFixerInvocation,
+  authority: DurablePrincipalAuthority,
   options: {
     readonly methodProvenance: PackagedMethodSkillProvenance;
     readonly methodSkillPath: string;
     readonly methodSkillConfiguredPath: string;
   },
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulFixerTerminalResult(admitted, options);
+  return settleLawfulFixerTerminalResult(admitted, authority, options);
 }
 
 export async function hasLawfulFixerTerminalResult(
   admitted: AdmittedFixerInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<boolean> {
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const { sessionDirectory, sessionFile } = coordinates;
   try {
-    const entries = await readLawfulSettlementEntries(admitted);
+    const entries = await readLawfulSettlementEntries(sessionFile);
     if (entries === undefined) return false;
     const extracted = extractFixerRoleOutcome(entries);
     return extracted !== undefined && isLawfulTypedTerminalOutcome(extracted.outcome);
@@ -3254,14 +3349,14 @@ export function extractReviewerMethodInvocations(
 export async function publishReviewerArtifacts(
   admitted: AdmittedReviewerInvocation,
   roleOutcome: TerminalRoleOutcome,
-  sessionDirectory: string,
+  coordinates: DurablePrincipalCoordinates,
   options: {
     readonly methodProvenance: PackagedMethodSkillProvenance;
     readonly methodInvocations?: readonly ObservedPackagedMethodSkillInvocation[];
     readonly reviewerReceipt?: RuntimeReviewerReceiptV2;
   },
 ): Promise<TerminalArtifactRef[]> {
-  await appendRunAttemptHistory(admitted, roleOutcome);
+  await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -3287,8 +3382,8 @@ export async function publishReviewerArtifacts(
       {
         runId: admitted.runId,
         role: "reviewer",
-        sessionDirectory,
-        sessionFile: admitted.sessionFile,
+        sessionDirectory: coordinates.sessionDirectory,
+        sessionFile: coordinates.sessionFile,
         admittedRequestPath: admitted.admittedRequestPath,
         baseRevision: admitted.baseRevision,
         authorityRefs: [...admitted.authorityRefs],
@@ -3361,13 +3456,16 @@ export function extractReviewerRoleOutcome(
 
 async function settleLawfulReviewerTerminalResult(
   admitted: AdmittedReviewerInvocation,
+  authority: DurablePrincipalAuthority,
   options: {
     readonly methodProvenance: PackagedMethodSkillProvenance;
     readonly methodSkillPath: string;
     readonly methodSkillConfiguredPath: string;
   },
 ): Promise<TerminalResult | undefined> {
-  const entries = await readLawfulSettlementEntries(admitted);
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const { sessionDirectory, sessionFile } = coordinates;
+  const entries = await readLawfulSettlementEntries(sessionFile);
   if (entries === undefined) return undefined;
   const extracted = extractReviewerRoleOutcome(entries);
   if (extracted === undefined) return undefined;
@@ -3381,7 +3479,7 @@ async function settleLawfulReviewerTerminalResult(
   const artifacts = await publishReviewerArtifacts(
     admitted,
     extracted.outcome,
-    admitted.sessionDirectory,
+    coordinates,
     {
       ...(extracted.receipt === undefined ? {} : { reviewerReceipt: extracted.receipt }),
       methodProvenance: options.methodProvenance,
@@ -3395,20 +3493,21 @@ async function settleLawfulReviewerTerminalResult(
       artifacts,
       runId: admitted.runId,
     },
-    admitted.sessionDirectory,
+    sessionDirectory,
   );
 }
 
 /** Settle a lawful Reviewer Terminal from the admitted session (shared #106 success interface). */
 export async function settleReviewerTerminalResult(
   admitted: AdmittedReviewerInvocation,
+  authority: DurablePrincipalAuthority,
   options: {
     readonly methodProvenance: PackagedMethodSkillProvenance;
     readonly methodSkillPath: string;
     readonly methodSkillConfiguredPath: string;
   },
 ): Promise<TerminalResult> {
-  const settled = await settleLawfulReviewerTerminalResult(admitted, options);
+  const settled = await settleLawfulReviewerTerminalResult(admitted, authority, options);
   if (settled === undefined) {
     throw new Error(
       "Reviewer Role run completed without a lawful typed terminal result",
@@ -3420,20 +3519,24 @@ export async function settleReviewerTerminalResult(
 /** Try to settle a lawful Reviewer Terminal; undefined only for genuine absence. */
 export async function trySettleReviewerTerminalResult(
   admitted: AdmittedReviewerInvocation,
+  authority: DurablePrincipalAuthority,
   options: {
     readonly methodProvenance: PackagedMethodSkillProvenance;
     readonly methodSkillPath: string;
     readonly methodSkillConfiguredPath: string;
   },
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulReviewerTerminalResult(admitted, options);
+  return settleLawfulReviewerTerminalResult(admitted, authority, options);
 }
 
 export async function hasLawfulReviewerTerminalResult(
   admitted: AdmittedReviewerInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<boolean> {
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const { sessionDirectory, sessionFile } = coordinates;
   try {
-    const entries = await readLawfulSettlementEntries(admitted);
+    const entries = await readLawfulSettlementEntries(sessionFile);
     if (entries === undefined) return false;
     const extracted = extractReviewerRoleOutcome(entries);
     return extracted !== undefined && isLawfulTypedTerminalOutcome(extracted.outcome);
@@ -3493,14 +3596,14 @@ export function extractMergerMethodInvocations(
 export async function publishMergerArtifacts(
   admitted: AdmittedMergerInvocation,
   roleOutcome: TerminalRoleOutcome,
-  sessionDirectory: string,
+  coordinates: DurablePrincipalCoordinates,
   options: {
     readonly methodProvenance: PackagedMethodSkillProvenance;
     readonly methodInvocations?: readonly ObservedPackagedMethodSkillInvocation[];
     readonly mergerOutput?: MergerOutput;
   },
 ): Promise<TerminalArtifactRef[]> {
-  await appendRunAttemptHistory(admitted, roleOutcome);
+  await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
   const reportPath = join(artifactsDir, "report.json");
   const evidencePath = join(artifactsDir, "evidence.json");
@@ -3526,8 +3629,8 @@ export async function publishMergerArtifacts(
       {
         runId: admitted.runId,
         role: "merger",
-        sessionDirectory,
-        sessionFile: admitted.sessionFile,
+        sessionDirectory: coordinates.sessionDirectory,
+        sessionFile: coordinates.sessionFile,
         admittedRequestPath: admitted.admittedRequestPath,
         mergerInputPath: admitted.mergerInputPath,
         derived: admitted.derived,
@@ -3589,13 +3692,16 @@ export function extractMergerRoleOutcome(
 
 async function settleLawfulMergerTerminalResult(
   admitted: AdmittedMergerInvocation,
+  authority: DurablePrincipalAuthority,
   options: {
     readonly methodProvenance: PackagedMethodSkillProvenance;
     readonly methodSkillPath: string;
     readonly methodSkillConfiguredPath: string;
   },
 ): Promise<TerminalResult | undefined> {
-  const entries = await readLawfulSettlementEntries(admitted);
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const { sessionDirectory, sessionFile } = coordinates;
+  const entries = await readLawfulSettlementEntries(sessionFile);
   if (entries === undefined) return undefined;
   const extracted = extractMergerRoleOutcome(entries);
   if (extracted === undefined) {
@@ -3650,7 +3756,7 @@ async function settleLawfulMergerTerminalResult(
   const artifacts = await publishMergerArtifacts(
     admitted,
     extracted.outcome,
-    admitted.sessionDirectory,
+    coordinates,
     {
       mergerOutput: extracted.output,
       methodProvenance: options.methodProvenance,
@@ -3664,20 +3770,21 @@ async function settleLawfulMergerTerminalResult(
       artifacts,
       runId: admitted.runId,
     },
-    admitted.sessionDirectory,
+    sessionDirectory,
   );
 }
 
 /** Settle a lawful Merger Terminal from the admitted session (shared #106 success interface). */
 export async function settleMergerTerminalResult(
   admitted: AdmittedMergerInvocation,
+  authority: DurablePrincipalAuthority,
   options: {
     readonly methodProvenance: PackagedMethodSkillProvenance;
     readonly methodSkillPath: string;
     readonly methodSkillConfiguredPath: string;
   },
 ): Promise<TerminalResult> {
-  const settled = await settleLawfulMergerTerminalResult(admitted, options);
+  const settled = await settleLawfulMergerTerminalResult(admitted, authority, options);
   if (settled === undefined) {
     throw new Error(
       "Merger Role run completed without a lawful typed terminal result",
@@ -3689,20 +3796,24 @@ export async function settleMergerTerminalResult(
 /** Try to settle a lawful Merger Terminal; undefined only for genuine absence. */
 export async function trySettleMergerTerminalResult(
   admitted: AdmittedMergerInvocation,
+  authority: DurablePrincipalAuthority,
   options: {
     readonly methodProvenance: PackagedMethodSkillProvenance;
     readonly methodSkillPath: string;
     readonly methodSkillConfiguredPath: string;
   },
 ): Promise<TerminalResult | undefined> {
-  return settleLawfulMergerTerminalResult(admitted, options);
+  return settleLawfulMergerTerminalResult(admitted, authority, options);
 }
 
 export async function hasLawfulMergerTerminalResult(
   admitted: AdmittedMergerInvocation,
+  authority: DurablePrincipalAuthority,
 ): Promise<boolean> {
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const { sessionDirectory, sessionFile } = coordinates;
   try {
-    const entries = await readLawfulSettlementEntries(admitted);
+    const entries = await readLawfulSettlementEntries(sessionFile);
     if (entries === undefined) return false;
     const extracted = extractMergerRoleOutcome(entries);
     return extracted !== undefined && isLawfulTypedTerminalOutcome(extracted.outcome);
@@ -3832,7 +3943,9 @@ async function writeFailureJsonRetainingCause(
 export async function publishFailureArtifacts(
   admitted: AdmittedRoleInvocation,
   failure: ControlledFailure,
+  authority: DurablePrincipalAuthority,
 ): Promise<TerminalArtifactRef[]> {
+  const { sessionDirectory, sessionFile } = coordinatesFromAdmitted(authority, admitted);
   const { baseDir, attempt: baseAttempt } = await resolveFailureArtifactsBase(
     admitted.runDirectory,
   );
@@ -3843,13 +3956,13 @@ export async function publishFailureArtifacts(
   // strand the original controlled failure outside settlement — it rides
   // publicationIssues instead of aborting durability.
   try {
-    await appendRunAttemptHistory(admitted, {
+    await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile }, {
       kind: "failure",
       role: admitted.role,
       ...failure,
     });
   } catch (error) {
-    priorIssues.push(publicationAttemptFromError(admitted.sessionFile, error));
+    priorIssues.push(publicationAttemptFromError(sessionFile, error));
   }
 
   // Prefer conventional names; unique fallback dirs keep colliding fixed paths
@@ -3901,8 +4014,8 @@ export async function publishFailureArtifacts(
 
   const evidencePayload: Record<string, unknown> = {
     runId: admitted.runId,
-    sessionDirectory: admitted.sessionDirectory,
-    sessionFile: admitted.sessionFile,
+    sessionDirectory: sessionDirectory,
+    sessionFile: sessionFile,
     admittedRequestPath: admitted.admittedRequestPath,
     attachments: admitted.attachments.map((a) => ({
       provenancePath: a.provenancePath,
@@ -3995,13 +4108,16 @@ function redactNavigatorFactForPublicTerminal(
 export async function settleFailureTerminalResult(
   admitted: AdmittedRoleInvocation,
   failure: ControlledFailure,
+  authority: DurablePrincipalAuthority,
   options: { readonly resume?: TerminalResume } = {},
 ): Promise<TerminalResult> {
+  const coordinates = coordinatesFromAdmitted(authority, admitted);
+  const { sessionDirectory, sessionFile } = coordinates;
   // #288 is lawful only when the lifecycle owner persisted an exhausted,
   // current-attempt fact. Transcript reconstruction must not turn arbitrary output
   // failures (or bytes retained from a prior resume attempt) into exit zero.
   if (failure.cause === "output") {
-    const entries = await readBoundSessionEntries(admitted.sessionFile).catch(() => undefined);
+    const entries = await readBoundSessionEntries(sessionFile).catch(() => undefined);
     if (entries !== undefined) {
       let attemptStart = 0;
       for (let index = entries.length - 1; index >= 0; index -= 1) {
@@ -4019,11 +4135,11 @@ export async function settleFailureTerminalResult(
             return withOptionalGateProjection(
               {
                 roleOutcome: { kind: "no_receipt", role: admitted.role, status: "no-accepted-receipt", ...facts, decisiveFacts },
-                navigator: await extractNavigatorFactFromAdmittedSession(admitted),
+                navigator: await extractNavigatorFactFromAdmittedSession(sessionFile),
                 artifacts: [],
                 runId: admitted.runId,
               },
-              admitted.sessionDirectory,
+              sessionDirectory,
             );
           }
         } catch { /* malformed lifecycle bytes remain the existing nonzero output failure */ }
@@ -4031,9 +4147,9 @@ export async function settleFailureTerminalResult(
     }
   }
   // Exact-session attendance only — never infer no-advice from caller omission.
-  const navigator = await extractNavigatorFactFromAdmittedSession(admitted);
+  const navigator = await extractNavigatorFactFromAdmittedSession(sessionFile);
   // Private durable artifacts retain the original diagnostic identity (including run ID).
-  const artifacts = await publishFailureArtifacts(admitted, failure);
+  const artifacts = await publishFailureArtifacts(admitted, failure, authority);
   const decisiveFacts: Record<string, unknown> = {
     cause: failure.cause,
     diagnostic: failure.diagnostic,
@@ -4072,7 +4188,7 @@ export async function settleFailureTerminalResult(
         artifacts: [],
         resume: options.resume,
       },
-      admitted.sessionDirectory,
+      sessionDirectory,
     );
   }
   const roleOutcome: TerminalRoleOutcome = {
@@ -4090,7 +4206,7 @@ export async function settleFailureTerminalResult(
       artifacts,
       runId: admitted.runId,
     },
-    admitted.sessionDirectory,
+    sessionDirectory,
   );
 }
 
@@ -4098,9 +4214,10 @@ export async function settleFailureTerminalResult(
 export async function settleJudgeFailureTerminalResult(
   admitted: AdmittedJudgeInvocation,
   failure: ControlledFailure,
+  authority: DurablePrincipalAuthority,
   options: { readonly resume?: TerminalResume } = {},
 ): Promise<TerminalResult> {
-  return settleFailureTerminalResult(admitted, failure, options);
+  return settleFailureTerminalResult(admitted, failure, authority, options);
 }
 
 /**