@akagilnc/pi-workflow-roles 0.1.5478 → 0.1.5504

package/src/public-cli/settlement.ts

@@ -7,11 +7,9 @@ import { randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
 import { lstat, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 
+import { sessionFileOf } from "../role-run-placement.ts";
+
 import { writeHardenedArtifactFile } from "./auto-resume.ts";
-import {
-  readAnalystGateCyclesFromAuditorRoles,
-  type AnalystGateCycleRound,
-} from "../analyst-gate-cycles-read.ts";
 import { sitianReport } from "../sitian-facade.ts";
 
 import {
@@ -26,6 +24,7 @@ import {
   processCancelDiagnostic,
   type CatchableProcessSignal,
 } from "./process-cancel.ts";
+import { readStrictPiSessionJsonl } from "../ledger-session-read.ts";
 import { serializeThrownValue } from "../serialize-thrown-value.ts";
 import { describeErrorIdentity } from "./run-lifecycle.ts";
 import {
@@ -55,7 +54,6 @@ import {
   packagedDurableOfficerEntry,
   packagedRoleAcceptedOutputTool,
   packagedRoleMetadata,
-  packagedSkipsGateOnInfrastructureStage,
   type PackagedArtifactFace,
   type PackagedArtifactLeaf,
 } from "../packaged-role-registry.ts";
@@ -217,7 +215,7 @@ export function ledgerReadScope(
 ): { home: string; sessionParent: string; attemptId?: string } {
   return {
     home: sealedLedgerHome(admitted),
-    sessionParent: join(admitted.runDirectory, "session", "session.jsonl"),
+    sessionParent: sessionFileOf(admitted.runDirectory),
     ...(scope?.courtAttemptId === undefined || scope.courtAttemptId.length === 0
       ? {}
       : { attemptId: scope.courtAttemptId }),
@@ -469,7 +467,7 @@ async function settleNoReceiptTerminal(
     );
   }
   if (scope?.previewOnly !== true) await clearOppositeTerminalArtifactFace(admitted.runDirectory);
-  return withOptionalGateProjection({
+  return attachEngineDetourToolUsage({
     roleOutcome,
     navigator: await extractNavigatorFactFromAdmittedSession(
       coordinates.sessionFile,
@@ -478,7 +476,7 @@ async function settleNoReceiptTerminal(
     ),
     artifacts: [],
     runId: admitted.runId,
-  }, coordinates.sessionDirectory, detourGateContext(admitted, scope));
+  }, coordinates.sessionDirectory, detourUsageContext(admitted, scope));
 }
 
 /** Transitional host-session reads remain only for non-sealed failure and audit evidence. */
@@ -495,8 +493,6 @@ import {
   adviceNavigatorFact,
   type ControlledFailureCause,
   type TerminalArtifactRef,
-  type TerminalGateFact,
-  type TerminalGateSeat,
   type TerminalNavigatorFact,
   type TerminalResult,
   type TerminalRoleName,
@@ -1034,12 +1030,7 @@ type SessionEntry = {
 export async function readBoundSessionEntries(
   sessionFile: string,
 ): Promise<SessionEntry[]> {
-  const text = await readFile(sessionFile, "utf8");
-  const entries: SessionEntry[] = [];
-  for (const line of text.trim().split("\n").filter(Boolean)) {
-    entries.push(JSON.parse(line) as SessionEntry);
-  }
-  return entries;
+  return await readStrictPiSessionJsonl(sessionFile) as SessionEntry[];
 }
 
 /**
@@ -1151,73 +1142,6 @@ function parseNavigatorAttendanceDetails(
   };
 }
 
-/**
- * Project direct and historical paired gate rounds onto the public Terminal.
- * actualSeats derive only from accepted receipts, never expected/missing seats.
- */
-export function projectTerminalGateFact(
-  rounds: readonly AnalystGateCycleRound[],
-): TerminalGateFact | undefined {
-  if (rounds.length === 0) return undefined;
-  const seen = new Set<TerminalGateSeat>();
-  for (const round of rounds) {
-    if (round.origin.kind === "historical_dispatch") seen.add("gatekeeper");
-    seen.add(round.officer);
-  }
-  const actualSeats = (["gatekeeper", "inspector", "notary"] as const).filter(
-    (seat) => seen.has(seat),
-  );
-  return {
-    actualSeats,
-    rounds: rounds.map((round) => ({
-      roundIndex: round.roundIndex,
-      dispatch:
-        round.origin.kind === "direct"
-          ? { kind: "direct" as const, officer: round.officer }
-          : {
-              kind: "historical_dispatch" as const,
-              officer: round.officer,
-              ...(round.origin.reason === undefined
-                ? {}
-                : { reason: round.origin.reason }),
-            },
-      officer: {
-        seat: round.officer,
-        status: round.status,
-        findings: round.findings,
-      },
-    })),
-  };
-}
-
-/**
- * Read gate facts from the run's session/auditor-roles nest (#446/#478).
- * Missing directories → undefined (no-gate zero change).
- * Damaged discovered volumes propagate — never wash to "no gate".
- */
-export async function extractGateFactFromSessionDirectory(
-  sessionDirectory: string,
-  options: {
-    readonly runDirectory?: string;
-    readonly parentSessionFile?: string;
-  } = {},
-): Promise<TerminalGateFact | undefined> {
-  const directories = [join(sessionDirectory, "auditor-roles")];
-  const parentSessionFile =
-    options.parentSessionFile ?? join(sessionDirectory, "session.jsonl");
-  const rounds = await readAnalystGateCyclesFromAuditorRoles(directories, {
-    parentSessionFile,
-  });
-  return projectTerminalGateFact(rounds);
-}
-
-/**
- * Attach optional gate projection onto a settled Terminal base.
- * Shared by every settle path so auditor-roles is scanned once here only.
- * `runId` is optional only for a batch projection that has no parent run.
- * Gate read damage is a package note beside the host terminal. It does not
- * replace that terminal and it does not omit the gate without a trace.
- */
 /**
  * #537: project this-invocation ak_engine_detour usage onto decisiveFacts.
  * Absent when engine is not mounted; callCount 0 when mounted with zero calls.
@@ -1231,16 +1155,15 @@ async function attachEngineDetourToolUsage<
 >(
   base: T,
   sessionDirectory: string,
-  gateContext: {
+  detourContext: {
     readonly runDirectory?: string;
-    readonly courtAttemptId?: string;
     readonly invocationScopeId?: string;
     readonly notePackageFault?: SettlementCourtScope["notePackageFault"];
   } = {},
 ): Promise<T> {
   const runDirectory =
-    typeof gateContext.runDirectory === "string" && gateContext.runDirectory.length > 0
-      ? gateContext.runDirectory
+    typeof detourContext.runDirectory === "string" && detourContext.runDirectory.length > 0
+      ? detourContext.runDirectory
       : runDirectoryFromSessionDirectory(sessionDirectory);
   let engineMounted = false;
   try {
@@ -1248,9 +1171,9 @@ async function attachEngineDetourToolUsage<
   } catch (error) {
     await noteSettlementFault(
       runDirectory,
-      gateContext.notePackageFault === undefined
+      detourContext.notePackageFault === undefined
         ? undefined
-        : { notePackageFault: gateContext.notePackageFault },
+        : { notePackageFault: detourContext.notePackageFault },
       `engine mount read failed beside host terminal: ${describeErrorIdentity(error)}`,
     );
     return base;
@@ -1260,9 +1183,9 @@ async function attachEngineDetourToolUsage<
   // Public-invocation scope from the shared Host envelope (settlement scope), never
   // courtAttemptId and never a detour sidecar file.
   const invocationScopeId =
-    typeof gateContext.invocationScopeId === "string" &&
-    gateContext.invocationScopeId.length > 0
-      ? gateContext.invocationScopeId
+    typeof detourContext.invocationScopeId === "string" &&
+    detourContext.invocationScopeId.length > 0
+      ? detourContext.invocationScopeId
       : undefined;
 
   const sessionFile = sessionFileFromSessionDirectory(sessionDirectory);
@@ -1277,9 +1200,9 @@ async function attachEngineDetourToolUsage<
   } catch (error) {
     await noteSettlementFault(
       runDirectory,
-      gateContext.notePackageFault === undefined
+      detourContext.notePackageFault === undefined
         ? undefined
-        : { notePackageFault: gateContext.notePackageFault },
+        : { notePackageFault: detourContext.notePackageFault },
       `engine detour read failed beside host terminal: ${describeErrorIdentity(error)}`,
     );
     return base;
@@ -1290,20 +1213,17 @@ async function attachEngineDetourToolUsage<
   };
 }
 
-/** Gate + detour projection context from admitted run + settlement scope. */
-function detourGateContext(
+/** Engine-detour usage context from admitted run + settlement scope. */
+function detourUsageContext(
   admitted: { readonly runDirectory: string },
   scope?: SettlementCourtScope,
 ): {
   readonly runDirectory: string;
-  readonly courtAttemptId?: string;
   readonly invocationScopeId?: string;
+  readonly notePackageFault?: SettlementCourtScope["notePackageFault"];
 } {
   return {
     runDirectory: admitted.runDirectory,
-    ...(scope?.courtAttemptId === undefined || scope.courtAttemptId.length === 0
-      ? {}
-      : { courtAttemptId: scope.courtAttemptId }),
     ...(scope?.invocationScopeId === undefined || scope.invocationScopeId.length === 0
       ? {}
       : { invocationScopeId: scope.invocationScopeId }),
@@ -1311,54 +1231,6 @@ function detourGateContext(
   };
 }
 
-async function withOptionalGateProjection<
-  T extends {
-    roleOutcome: TerminalRoleOutcome;
-    navigator: TerminalNavigatorFact;
-    artifacts: readonly TerminalArtifactRef[];
-  },
->(
-  base: T,
-  sessionDirectory: string,
-  gateContext: {
-    readonly runDirectory?: string;
-    readonly parentSessionFile?: string;
-    readonly courtAttemptId?: string;
-    readonly invocationScopeId?: string;
-    readonly notePackageFault?: SettlementCourtScope["notePackageFault"];
-  } = {},
-): Promise<T & { gate?: TerminalGateFact }> {
-  // A gate transport failure is already represented by typed evidence and has no
-  // accepted gate cycle to project. Re-reading that rejected receipt as an
-  // accepted cycle would replace the original failure with a projection error.
-  const secondaryEvidence = base.roleOutcome.kind === "failure"
-    ? base.roleOutcome.decisiveFacts.secondaryEvidence
-    : undefined;
-  const skipGate =
-    isRecord(secondaryEvidence)
-    && secondaryEvidence.kind === "role_infrastructure_failure"
-    && packagedSkipsGateOnInfrastructureStage(secondaryEvidence.stage);
-
-  let next: T & { gate?: TerminalGateFact } = base;
-  if (!skipGate) {
-    try {
-      const gate = await extractGateFactFromSessionDirectory(sessionDirectory, gateContext);
-      if (gate !== undefined) next = { ...base, gate };
-    } catch (error) {
-      const runDirectory = gateContext.runDirectory ?? runDirectoryFromSessionDirectory(sessionDirectory);
-      await noteSettlementFault(
-        runDirectory,
-        gateContext.notePackageFault === undefined
-          ? undefined
-          : { notePackageFault: gateContext.notePackageFault },
-        `gate read failed beside host terminal: ${describeErrorIdentity(error)}`,
-      );
-    }
-  }
-
-  return attachEngineDetourToolUsage(next, sessionDirectory, gateContext);
-}
-
 function routePlaybookFailureMessage(entries: readonly SessionEntry[]): string | undefined {
   for (let i = entries.length - 1; i >= 0; i -= 1) {
     const entry = entries[i];
@@ -1620,12 +1492,12 @@ async function finishLawfulSeat(
   const artifacts = scope?.previewOnly === true
     ? []
     : await publishDeclaredSeatArtifacts(admitted, roleOutcome, coordinates, entries, scope?.recordAttemptHistory === true);
-  const terminal = await withOptionalGateProjection({
+  const terminal = await attachEngineDetourToolUsage({
     roleOutcome,
     navigator: extractNavigatorFact(entries),
     artifacts,
     runId: admitted.runId,
-  }, coordinates.sessionDirectory, detourGateContext(admitted, scope));
+  }, coordinates.sessionDirectory, detourUsageContext(admitted, scope));
   return attachRecordedSubmissions(admitted, terminal, scope);
 }
 
@@ -1933,33 +1805,18 @@ async function applySecretariatCountersignTerminal(
 }
 
 /**
- * After the audit gate returns, attach gate rounds and the secretariat officer
- * fact onto the terminal this turn already settled. Does not publish again —
- * a second publish would append another attempt-history row for the same attempt.
+ * After the audit gate returns, attach the secretariat officer fact onto the
+ * terminal this turn already settled. Does not publish again — a second publish
+ * would append another attempt-history row for the same attempt.
  */
-export async function attachPostAuditProjection(
+export async function attachPostAuditCountersignFact(
   admitted: AdmittedRoleInvocation,
   authority: DurablePrincipalAuthority,
   terminal: TerminalResult,
   scope?: SettlementCourtScope,
 ): Promise<TerminalResult> {
-  const { sessionDirectory, sessionFile } = coordinatesFromAdmitted(authority, admitted);
-  let gate: TerminalGateFact | undefined;
-  try {
-    gate = await extractGateFactFromSessionDirectory(sessionDirectory, {
-      runDirectory: admitted.runDirectory,
-      parentSessionFile: sessionFile,
-    });
-  } catch (error) {
-    await noteSettlementFault(
-      admitted.runDirectory,
-      scope,
-      `gate read failed beside host terminal: ${describeErrorIdentity(error)}`,
-    );
-  }
-  const withGate = gate === undefined ? terminal : { ...terminal, gate };
-  if (admitted.role !== "secretariat") return withGate;
-  return applySecretariatCountersignTerminal(admitted, authority, withGate, scope);
+  if (admitted.role !== "secretariat") return terminal;
+  return applySecretariatCountersignTerminal(admitted, authority, terminal, scope);
 }
 
 /** One failed attempt to place a durable failure artifact (path is private layout). */
@@ -2246,10 +2103,10 @@ export async function settleFailureTerminalResult(
     diagnostic: failure.diagnostic,
     decisiveFacts,
   };
-  return withOptionalGateProjection(
+  return attachEngineDetourToolUsage(
     { roleOutcome, navigator, artifacts, runId: admitted.runId },
     sessionDirectory,
-    detourGateContext(admitted, options),
+    detourUsageContext(admitted, options),
   );
 }
 

package/src/public-cli/terminal.ts

@@ -103,44 +103,6 @@ export type TerminalNavigatorFact =
       advisoryDiagnostic?: string;
     };
 
-/** Current English gate seat faces projected on Terminal (#478). */
-export type TerminalGateSeat = "gatekeeper" | "inspector" | "notary";
-
-/** Honest discriminant: direct summons vs historical province dispatch. */
-export type TerminalGateDispatch =
-  | { readonly kind: "direct"; readonly officer: "inspector" | "notary" }
-  | {
-      readonly kind: "historical_dispatch";
-      readonly officer: "inspector" | "notary";
-      /** Present only when the accepted dispatch wrote a non-empty reason. */
-      readonly reason?: string;
-    };
-
-/** One accepted officer report: seat, status, full typed findings. */
-export type TerminalGateOfficerReport = {
-  readonly seat: "inspector" | "notary";
-  readonly status: string;
-  readonly findings: readonly unknown[];
-};
-
-/** One direct or historical paired gate round on the public Terminal. */
-export type TerminalGateRound = {
-  readonly roundIndex: number;
-  readonly dispatch: TerminalGateDispatch;
-  readonly officer: TerminalGateOfficerReport;
-};
-
-/**
- * Optional gate projection (#478).
- * Absent when no accepted officer rounds exist. Only durable accepted child
- * receipts — never soul-derived expected/missing seats.
- */
-export type TerminalGateFact = {
-  /** Seats that actually ran, derived from accepted receipts. */
-  readonly actualSeats: readonly TerminalGateSeat[];
-  readonly rounds: readonly TerminalGateRound[];
-};
-
 /**
  * Parent-facing current reply: a court's own accepted/audit payloads only.
  * Run-scoped history stays on TerminalResult.submissions (#879 / #836), and a
@@ -177,11 +139,6 @@ export type TerminalResult = {
    * (#953 — not copied onto failure.payloads).
    */
   submissions?: readonly unknown[];
-  /**
-   * Optional gate facts (#478). Present when accepted direct or historical
-   * paired rounds exist under session/auditor-roles; omitted on no-gate runs.
-   */
-  gate?: TerminalGateFact;
   /** Call-local auto-resume observation (0..2) for this single LLM call; read-only, not persisted. */
   autoResumeCount?: number;
 } & (
@@ -272,23 +229,6 @@ export function formatTerminalResult(result: TerminalResult): string {
   for (const artifact of result.artifacts) {
     lines.push(`artifact\t${artifact.kind}\t${encodeTerminalField(artifact.path)}`);
   }
-  // Gate region is unfrozen presentation of typed facts (ADR 0052) — machines
-  // read result.gate, never these row labels.
-  if (result.gate !== undefined) {
-    lines.push(
-      `gate\t${encodeTerminalField(result.gate.actualSeats.join(","))}\t${result.gate.rounds.length}`,
-    );
-    for (const round of result.gate.rounds) {
-      const reason =
-        round.dispatch.kind === "historical_dispatch"
-        && round.dispatch.reason !== undefined
-          ? encodeTerminalField(round.dispatch.reason)
-          : "";
-      lines.push(
-        `gate-round\t${round.roundIndex}\t${round.dispatch.kind}\t${round.dispatch.officer}\t${reason}\t${round.officer.seat}\t${encodeTerminalField(round.officer.status)}\t${encodeTerminalField(JSON.stringify(round.officer.findings))}`,
-      );
-    }
-  }
   if (result.reviewerChildOutcomes !== undefined) {
     for (const axis of ["completeness", "correctness"] as const) {
       const child = result.reviewerChildOutcomes[axis];

package/src/role-envelope.ts

@@ -1,7 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { appendFile, mkdir, writeFile } from "node:fs/promises";
 import { createServer, type Server, type Socket } from "node:net";
-import { dirname, join } from "node:path";
+import { dirname } from "node:path";
+
+import { sessionFileOf } from "./role-run-placement.ts";
 import { fileURLToPath } from "node:url";
 
 import {
@@ -124,7 +126,7 @@ export async function prepareRoleEnvelope(options: {
   // navigator attendance, no-receipt) MUST flush so parent settlement can read
   // them after the headless process ends — memory-only books left extractNavigatorFact
   // with no durable terminal / attendance on codex/claude/ACP parents.
-  let sessionFile = options.sessionFile ?? join(request.runDirectory, "session", "session.jsonl");
+  let sessionFile = options.sessionFile ?? sessionFileOf(request.runDirectory);
   await mkdir(dirname(sessionFile), { recursive: true });
   if (request.continuation.kind !== "resume") {
     try {

package/src/role-run-placement.ts

@@ -1,5 +1,5 @@
 import { readdir } from "node:fs/promises";
-import { join } from "node:path";
+import { basename, dirname, join } from "node:path";
 
 import {
   activationBookDirectory,
@@ -21,6 +21,45 @@ export type RoleRunPlacement = {
   readonly attachmentsDirectory: string;
 };
 
+/** Writer leaf `<runId>@<role>`. Empty sides stay empty; this is not a validator. */
+export function formatRunLeaf(runId: string, role: string): string {
+  return `${runId}@${role}`;
+}
+
+/**
+ * Inverse of formatRunLeaf: last `@`, both sides non-empty.
+ * `a@b@c` is runId `a@b`, role `c`. Charset is not a second grammar.
+ */
+export function parseRunLeaf(name: string): { readonly runId: string; readonly role: string } | undefined {
+  const at = name.lastIndexOf("@");
+  if (at <= 0 || at === name.length - 1) return undefined;
+  return { runId: name.slice(0, at), role: name.slice(at + 1) };
+}
+
+export function sessionDirectoryOf(runDirectory: string): string {
+  return join(runDirectory, "session");
+}
+
+export const ROLE_RUN_SESSION_FILENAME = "session.jsonl";
+
+export function sessionFileIn(sessionDirectory: string): string {
+  return join(sessionDirectory, ROLE_RUN_SESSION_FILENAME);
+}
+
+export function sessionFileOf(runDirectory: string): string {
+  return sessionFileIn(sessionDirectoryOf(runDirectory));
+}
+
+/** `<run>/session/session.jsonl` → run directory. */
+export function runDirectoryOfSessionFile(sessionFile: string): string {
+  return dirname(dirname(sessionFile));
+}
+
+/** `<run>/session` → run directory. */
+export function runDirectoryFromSessionDirectory(sessionDirectory: string): string {
+  return dirname(sessionDirectory);
+}
+
 /**
  * Sole book-level run directory walk: flat legacy `runs/` plus each
  * `subject/runs/` child (ticket / unbound). One authority for read-side
@@ -64,6 +103,26 @@ export async function listBookRunDirectories(bookDir: string): Promise<string[]>
   return out.sort();
 }
 
+/** Resolve a complete run identity across the caller's books; ambiguity is never readdir-first. */
+export async function findRoleRunDirectory(
+  bookDirectories: readonly string[],
+  runId: string,
+  onlyRole?: string,
+): Promise<string | undefined> {
+  const matches: string[] = [];
+  for (const bookDirectory of bookDirectories) {
+    for (const runDirectory of await listBookRunDirectories(bookDirectory)) {
+      const parsed = parseRunLeaf(basename(runDirectory));
+      if (parsed === undefined || parsed.runId !== runId) continue;
+      if (onlyRole !== undefined && parsed.role !== onlyRole) continue;
+      matches.push(runDirectory);
+    }
+  }
+  if (matches.length === 0) return undefined;
+  if (matches.length === 1) return matches[0];
+  throw new Error(`ambiguous role run id ${runId}: ${matches.join(", ")}`);
+}
+
 /** The single authority for every path belonging to an admitted role run. */
 export function roleRunPlacement(
   ledgerHome: string,
@@ -84,13 +143,13 @@ export function roleRunPlacement(
     activationBookDirectory(ledgerHome, input.bookKey),
     subjectDirectory,
     "runs",
-    `${input.runId}@${input.role}`,
+    formatRunLeaf(input.runId, input.role),
   );
-  const sessionDirectory = join(runDirectory, "session");
+  const sessionDirectory = sessionDirectoryOf(runDirectory);
   return {
     runDirectory,
     sessionDirectory,
-    sessionFile: join(sessionDirectory, "session.jsonl"),
+    sessionFile: sessionFileIn(sessionDirectory),
     artifactsDirectory: roleRunArtifactsDirectory(runDirectory),
     attachmentsDirectory: join(runDirectory, "attachments"),
   };

package/src/role-run-relocation.ts

@@ -1,6 +1,6 @@
 /**
  * Single authority for rewriting durable run pages after a run directory moves.
- * Live unbound→ticket relocate and book-topology migration both call this.
+ * Live callers project typed fields; only historical migrators walk durable pages.
  *
  * Scope is typed machine-consumed path fields only — never free text, never
  * frozen attachment/artifact bytes. Nested walk is confined to package-owned
@@ -8,7 +8,11 @@
  */
 import { existsSync } from "node:fs";
 import { readdir, readFile, writeFile } from "node:fs/promises";
-import { join, sep } from "node:path";
+import { dirname, join, sep } from "node:path";
+
+import { activationBookDirectory, physicalPathIdentity } from "./activation-ledger-topology.ts";
+import { readRoleRunIdentity } from "./public-cli/run-lifecycle.ts";
+import { findRoleRunDirectory, roleRunPlacement } from "./role-run-placement.ts";
 
 import { AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE } from "./compliance-transport.ts";
 
@@ -67,6 +71,39 @@ export function rewriteRunDirectoryPathValue(
   return value;
 }
 
+/** Match physical aliases or a normal unbound→ticket bind, never historical migration layouts. */
+export async function retainedRunPathsMatch(
+  recordedPath: unknown,
+  currentPath: string,
+  currentRunDirectory?: string,
+): Promise<boolean> {
+  if (recordedPath === currentPath) return true;
+  if (typeof recordedPath !== "string") return false;
+  const recordedPathIdentity = physicalPathIdentity(recordedPath);
+  const currentPathIdentity = physicalPathIdentity(currentPath);
+  if (recordedPathIdentity === currentPathIdentity) return true;
+  if (currentRunDirectory === undefined) return false;
+  const runDirectory = physicalPathIdentity(currentRunDirectory);
+  const identity = await readRoleRunIdentity(runDirectory);
+  if (identity === undefined) return false;
+  for (let directory = runDirectory; dirname(directory) !== directory; directory = dirname(directory)) {
+    const ledgerHome = dirname(dirname(directory));
+    if (directory !== activationBookDirectory(ledgerHome, identity.bookKey)) continue;
+    const unbound = roleRunPlacement(ledgerHome, {
+      bookKey: identity.bookKey,
+      subject: { unbound: true },
+      runId: identity.runId,
+      role: identity.role,
+    });
+    if (rewriteRunDirectoryPathValue(recordedPathIdentity, unbound.runDirectory, runDirectory) !== currentPathIdentity) {
+      return false;
+    }
+    const placed = await findRoleRunDirectory([directory], identity.runId, identity.role);
+    return placed !== undefined && physicalPathIdentity(placed) === runDirectory;
+  }
+  return false;
+}
+
 /**
  * Apply the longest matching oldRunDirectory rewrite. Longer keys win so a
  * nested run path is not partially claimed by a shorter sibling prefix.