@akagilnc/pi-workflow-roles 0.1.5593 → 0.1.5614

package/src/navigator-work-base.ts

@@ -1,7 +1,7 @@
 /**
  * Durable work subject and controlling authority for one navigator nest.
- * Settlement user turns keep a path pointer; the navigator system prompt
- * loads the bytes once per agent start from this file (base material).
+ * Startup materials load these bytes from the nest session directory; the
+ * caller/summon prompt must not receive a package-injected path (#1166).
  */
 import { existsSync, realpathSync } from "node:fs";
 import { readFile } from "node:fs/promises";
@@ -12,6 +12,9 @@ import { isEnoent, isRecord } from "./unknown-value.ts";
 
 export const NAVIGATOR_WORK_CONTEXT_BASENAME = "work-context.json";
 
+/** Child-process / in-process locator for nest work-context bytes — not prompt material (#1166). */
+export const AK_ROLE_NAVIGATOR_WORK_CONTEXT_ENV = "AK_ROLE_NAVIGATOR_WORK_CONTEXT" as const;
+
 export type NavigatorWorkBase = {
   readonly subject: string;
   readonly authority: string;
@@ -81,38 +84,20 @@ export async function readNavigatorWorkBase(path: string): Promise<NavigatorWork
   return { subject: record.subject, authority: record.authority };
 }
 
-function jsonObjectFromPrompt(prompt: string): Record<string, unknown> | undefined {
-  const head = prompt.trimStart().split("\n\n", 1)[0] ?? "";
-  if (!head.startsWith("{")) return undefined;
-  try {
-    const parsed: unknown = JSON.parse(head);
-    if (!isRecord(parsed)) return undefined;
-    return parsed as Record<string, unknown>;
-  } catch {
-    return undefined;
-  }
-}
-
-export function workContextPathFromPrompt(prompt: string): string | undefined {
-  const record = jsonObjectFromPrompt(prompt);
-  const path = record?.workContextPath;
-  if (typeof path !== "string" || path.trim() === "") return undefined;
-  return isNavigatorWorkContextFile(path) ? path : undefined;
-}
-
-/** Settlement JSON gains the nest pointer. Non-JSON prompts stay unchanged. */
-export function attachWorkContextPointer(text: string, workContextPath: string): string {
-  const record = jsonObjectFromPrompt(text);
-  if (record === undefined) return text;
-  if (typeof record.workContextPath === "string" && record.workContextPath.trim() !== "") return text;
-  const head = text.trimStart().split("\n\n", 1)[0] ?? "";
-  const rest = text.trimStart().slice(head.length);
-  return `${JSON.stringify({ ...record, workContextPath })}${rest}`;
-}
-
-/** System-prompt base for one agent start. Absent or unreadable file yields undefined. */
-export async function loadNavigatorWorkBaseSuffix(prompt: string): Promise<string | undefined> {
-  const path = workContextPathFromPrompt(prompt);
+/** System-prompt base for one agent start. Prefer request locator, else nest session dir. */
+export async function loadNavigatorWorkBaseSuffix(
+  sessionDir: string | undefined,
+  locatorPath?: string,
+): Promise<string | undefined> {
+  const path =
+    typeof locatorPath === "string" && locatorPath.trim() !== ""
+      ? locatorPath.trim()
+      : typeof process.env[AK_ROLE_NAVIGATOR_WORK_CONTEXT_ENV] === "string"
+        && process.env[AK_ROLE_NAVIGATOR_WORK_CONTEXT_ENV].trim() !== ""
+        ? process.env[AK_ROLE_NAVIGATOR_WORK_CONTEXT_ENV].trim()
+        : sessionDir !== undefined && sessionDir.trim() !== ""
+          ? navigatorWorkContextFile(sessionDir)
+          : undefined;
   if (path === undefined) return undefined;
   const body = await readNavigatorWorkBase(path);
   if (body === undefined) return undefined;

package/src/notary-role.ts

@@ -9,6 +9,10 @@ import { isSafePositiveTicketNumber } from "./run-ticket-number.ts";
  * This module keeps evidence assembly + projection only.
  */
 
+import {
+  auditedRunIdentityFromParts,
+  auditedRunIdentityMaterial,
+} from "./audited-run-identity.ts";
 import {
   NOTARY_OUTPUT_TOOL_NAME,
   NOTARY_SOURCE_RUN_FLAG,
@@ -53,25 +57,15 @@ export function readNotaryTicketFlag(flag: unknown): number | undefined {
   return n;
 }
 
-/**
- * Typed session bound (locator + optional ticket).
- * Sole production projection for agent-start material + session custom entry.
- */
-export function projectNotarySessionBound(input: {
-  readonly sourceRun: NotarySourceRunLocator;
-  readonly ticketNumber?: number;
-}): {
+/** Agent-start reading material: identity `<runId>@<席>` only — no directory path. */
+export function projectNotaryAuditedRunIdentity(input: {
   readonly sourceRun: NotarySourceRunLocator;
-  readonly ticketNumber?: number;
-} {
-  return {
-    sourceRun: input.sourceRun,
-    ...(input.ticketNumber === undefined ? {} : { ticketNumber: input.ticketNumber }),
-  };
+}) {
+  return auditedRunIdentityMaterial(
+    auditedRunIdentityFromParts(input.sourceRun.runId, input.sourceRun.role),
+  );
 }
 
-export type NotarySessionBound = ReturnType<typeof projectNotarySessionBound>;
-
 /**
  * Session custom-entry type for typed notary bound (written by shared envelope).
  * Role module only projects; lifecycle write is envelope-owned (ADR 0018).
@@ -102,7 +96,7 @@ export function projectNotaryBoundFromFlags(
 }
 
 /** Assemble systemPrompt body from base + soul only (NO embedded bound JSON).
- * The typed session bound travels separately as `readingMaterial`; adapters fold
+ * Audited-run identity travels separately as `readingMaterial`; adapters fold
  * it into the provider-visible prompt at the send boundary. */
 export function assembleNotaryAgentStartPrompt(input: {
   readonly baseSystemPrompt: string;
@@ -172,11 +166,8 @@ export function createNotaryRoleRuntime(
               baseSystemPrompt: event.systemPrompt,
               soul: activation.soul,
             }),
-            readingMaterial: projectNotarySessionBound({
+            readingMaterial: projectNotaryAuditedRunIdentity({
               sourceRun: activation.sourceRun,
-              ...(activation.ticketNumber === undefined
-                ? {}
-                : { ticketNumber: activation.ticketNumber }),
             }),
           };
         });

package/src/package-contracts/worker-output.ts

@@ -13,26 +13,18 @@ import {
   type FixerOutput,
   type FixerPhase,
 } from "./fixer-output.ts";
-import { fixerPrerequisiteSchema, fixerPrerequisitesSchema, parseFixerPrerequisites, validateFixerPrerequisites } from "./fixer-packet.ts";
-import type { FixerInvocationInput, FixerPrerequisite } from "./fixer-packet.ts";
 import { withTerminatingOutputDeclarations } from "./terminating-infrastructure.ts";
 
 export {
   FIXER_OUTPUT_TOOL_NAME,
   fixerOutputSchema,
   validateFixerOutput,
-  fixerPrerequisiteSchema,
-  fixerPrerequisitesSchema,
-  parseFixerPrerequisites,
-  validateFixerPrerequisites,
 };
 export type {
   FixerBlocker,
   FixerClassResult,
   FixerOutput,
   FixerPhase,
-  FixerInvocationInput,
-  FixerPrerequisite,
 };
 
 export const CODER_OUTPUT_TOOL_NAME = "ak_coder_output";

package/src/packaged-role-registry.ts

@@ -115,10 +115,10 @@ export const PUBLIC_ROLE_RECORDS = [
       reportPhase: true,
     },
     boardPlacement: "marshal",
+    /** #1168: dispatch is first message; navigator reads admitted instruction. */
+    navigatorSubject: "public-instruction",
     activationFlags: [
-      { field: "packetPath", flag: "ak-fix-packet", binds: "input" },
       { field: "phase", flag: "ak-fixer-phase", binds: "phase" },
-      { field: "prerequisitesPath", flag: "ak-fixer-prerequisites" },
     ],
     activationStage: "load-and-install",
     sessionMaterials: [
@@ -145,8 +145,9 @@ export const PUBLIC_ROLE_RECORDS = [
     artifactFace: {
       reportPhase: true,
     },
+    /** #1168: dispatch is first message; navigator reads admitted instruction. */
+    navigatorSubject: "public-instruction",
     activationFlags: [
-      { field: "taskPath", flag: "ak-coder-task", binds: "input" },
       { field: "phase", flag: "ak-coder-phase", binds: "phase" },
     ],
     activationStage: "load-and-install",
@@ -389,7 +390,8 @@ export const PUBLIC_ROLE_RECORDS = [
     presentSettled: "always",
     summonResume: false,
     admission: "instruction",
-    sameParent: "gate-pointer",
+    /** Structured --source-run only; instruction stays opaque caller/peer bytes (#1166). */
+    sameParent: "source-run",
     /** Resume restores an optional source-run path onto the admitted face. */
     resumeSourcePath: true,
     /** 台院 is a review officer and inherits the gatekeeper model. */
@@ -402,11 +404,12 @@ export const PUBLIC_ROLE_RECORDS = [
     /** Court reask replaces the initial prompt. */
     reaskPrompt: true,
     gateStageLabel: "台院",
+    /** Gate summon binds --source-run; identity is startup material (#1166). */
+    gateSummon: "source-run",
     activationFlags: [
       {
         field: "sourceRun",
         from: "sourceRunPath",
-        fallback: "gate-pointer",
         flag: "ak-inspector-source-run",
         binds: "input",
       },
@@ -553,7 +556,6 @@ export function packagedModelParent(role: string): PackagedRole | undefined {
  * One seat's admitted → activation copy.
  * `field` is the activation key. `from` is the admitted path when it differs.
  * `text` writes a number as decimal text on the activation object.
- * `fallback: "gate-pointer"` is the inspector instruction pointer when sourceRunPath is blank.
  * `flag` omitted: the value stays on the activation object and is not a host flag
  * (secretariat and countersign ticketNumber).
  */
@@ -561,7 +563,6 @@ export type PackagedActivationFlag = {
   readonly field: string;
   readonly from?: string;
   readonly text?: true;
-  readonly fallback?: "gate-pointer";
   readonly flag?: string;
   readonly binds?: "input" | "phase";
 };

package/src/pi/role-turn-host.ts

@@ -429,7 +429,7 @@ export function createPiRoleTurnHost(config: PiRoleTurnHostConfig): RoleTurnHost
       if (request.deliveryRequestLimit === undefined) delete env[RECEIPT_DELIVERY_LIMIT_ENV];
       else env[RECEIPT_DELIVERY_LIMIT_ENV] = String(request.deliveryRequestLimit);
       applyEngineChildEnv(env, request.engine);
-      // Nested auditor dossier tool binds the parent run pointer when published.
+      // Nested auditor binds the audited source-run for identity / soul selection.
       if (
         typeof process.env.AK_ROLE_AUDITOR_SOURCE_RUN === "string"
         && process.env.AK_ROLE_AUDITOR_SOURCE_RUN.trim() !== ""
@@ -443,6 +443,16 @@ export function createPiRoleTurnHost(config: PiRoleTurnHostConfig): RoleTurnHost
       ) {
         env.AK_ROLE_AUDITOR_SUBJECT = process.env.AK_ROLE_AUDITOR_SUBJECT;
       }
+      // Navigator nest work-context locator for startup materials (#1166) —
+      // child-process scoped only from this turn request; never parent process.env.
+      if (
+        typeof request.navigatorWorkContextPath === "string"
+        && request.navigatorWorkContextPath.trim() !== ""
+      ) {
+        env.AK_ROLE_NAVIGATOR_WORK_CONTEXT = request.navigatorWorkContextPath.trim();
+      } else {
+        delete env.AK_ROLE_NAVIGATOR_WORK_CONTEXT;
+      }
       if (
         config.recordLaunchedRolePackageIdentity !== undefined &&
         config.observeLaunchedRolePackageIdentity !== undefined

package/src/public-cli/instruction-seat-run.ts

@@ -4,8 +4,7 @@
  * starts two ordinary single-axis runs here.
  */
 import { dirname, resolve } from "node:path";
-import { isUnboundRunDirectory } from "../role-run-placement.ts";
-import { AUDITOR_DOSSIER_PROMPT } from "../compliance-transport.ts";
+import { isUnboundRunDirectory, sessionFileOf } from "../role-run-placement.ts";
 import { bookDirectOfficerRunPointer, readDirectOfficerRunPointer } from "../archivist-record-pointer.ts";
 import { createPiDoctorAuditor } from "../doctor-auditor.ts";
 
@@ -42,6 +41,7 @@ import { CliUsageError } from "./cli-errors.ts";
 import {
   admitPublicRole,
   bindAdmittedTicketNumber,
+  appendCallerFileFlagPaths,
   buildInstructionTransportPrompt,
   materializeCountersignInvocation,
   persistAdmittedSourceRunPath,
@@ -72,7 +72,6 @@ import {
   buildAutoResumeContinuationPrompt,
   loadResumablePublicRole,
   markRunAdmitted,
-  parentRunPathFromGatePointerInstruction,
   readCurrentCourt,
   type PublicResumeRequest,
   type RunWriterLease,
@@ -291,14 +290,80 @@ export function buildInstructionSeatTurnRequest(
   );
 }
 
-function initialPrompt(
+/**
+ * Direct review-seat call: reconnect ledger peer-body delivery (ADR 0085 / #1166).
+ * Gate summons already ride gateReviewInstruction; direct --source-run must not
+ * leave a blank fixed-kickoff.
+ */
+async function loadLedgerPeerBody(
+  sourceRunDirectory: string,
+  projectRoot: string,
+  home: string,
+): Promise<string | undefined> {
+  const runId = runIdFromRunDirectory(sourceRunDirectory);
+  if (runId === undefined) return undefined;
+  // Bind to the already-resolved source directory — never re-discover by runId
+  // alone (another book may lawfully share the same id; #637 / #1166).
+  const rows = await readRecordedSubmissionRows(projectRoot, runId, {
+    home,
+    sessionParent: sessionFileOf(sourceRunDirectory),
+  });
+  // ADR 0085 / #1166 J10: ledger already keeps original words for every class —
+  // present the latest row as-is. Never filter current manuscript by accepted /
+  // terminal outcome kind (that resurrects a prior sealed draft).
+  const latest = rows.at(-1);
+  if (latest === undefined) return undefined;
+  return readableGateItem(latest.accepted);
+}
+
+/**
+ * One delivery rule for review-seat dialogue on new turns and same-parent resume
+ * (#1166 / ADR 0085 / ADR 0087): explicit reask → non-empty caller dispatch →
+ * source-only ledger peer body. Identity stays in startup materials.
+ */
+async function resolveReviewSeatDialogueBody(input: {
+  readonly reask?: string;
+  readonly callerInstruction?: string;
+  readonly sourceRunPath?: string;
+  readonly projectRoot: string;
+  readonly home: string;
+}): Promise<string | undefined> {
+  const reask = input.reask;
+  if (reask !== undefined && reask.length > 0) return reask;
+  const caller = input.callerInstruction ?? "";
+  if (caller.length > 0) return caller;
+  const sourceRunPath = input.sourceRunPath?.trim() ?? "";
+  if (sourceRunPath === "") return undefined;
+  return await loadLedgerPeerBody(sourceRunPath, input.projectRoot, input.home);
+}
+
+function admittedSourceRunPath(admitted: AdmittedRoleInvocation): string {
+  return "sourceRunPath" in admitted
+    && typeof (admitted as { sourceRunPath?: unknown }).sourceRunPath === "string"
+    ? (admitted as { sourceRunPath: string }).sourceRunPath.trim()
+    : "";
+}
+
+async function resolveInitialPrompt(
   admitted: AdmittedRoleInvocation,
   env: InstructionSeatRunEnv,
-): string {
+): Promise<string> {
   const record = roleRecord(admitted.role);
-  const reask = env.reviewReask ?? env.gateReviewInstruction;
-  if (reask !== undefined && "reaskPrompt" in record && record.reaskPrompt === true) {
-    return reask;
+  if ("reaskPrompt" in record && record.reaskPrompt === true) {
+    const sourceRunPath = admittedSourceRunPath(admitted);
+    const reask = env.reviewReask ?? env.gateReviewInstruction;
+    const body = await resolveReviewSeatDialogueBody({
+      ...(reask === undefined ? {} : { reask }),
+      callerInstruction: admitted.instruction,
+      ...(sourceRunPath === "" ? {} : { sourceRunPath }),
+      projectRoot: admitted.projectRoot,
+      home: env.home,
+    });
+    // #1166 J11: merge existing file-flag delivery — never early-return body alone
+    // when caller attach paths were admitted. Gate with no file flags stays body-only.
+    if (body !== undefined) {
+      return appendCallerFileFlagPaths(body, admitted.attachments);
+    }
   }
   return buildInstructionTransportPrompt(admitted);
 }
@@ -417,6 +482,7 @@ async function dispatchAdmitted(
     if (activeEnv.correlationId !== undefined && activeEnv.correlationId.trim() !== "") {
       await recordAdmittedCorrelation(admitted, activeEnv.correlationId);
     }
+    const initialPromptText = await resolveInitialPrompt(admitted, activeEnv);
     const auto = "inCallAutoResume" in record && record.inCallAutoResume === true;
     if (auto) {
       return await runPostAdmissionResumable({
@@ -425,7 +491,10 @@ async function dispatchAdmitted(
         io: turnIo,
         buildInitialRequest: () => buildInstructionSeatTurnRequest(
           admitted,
-          roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) }),
+          roleTurnOptions(activeEnv, admitted, {
+            kind: "initial",
+            prompt: initialPromptText,
+          }),
         ),
         buildResumeRequest: () => buildInstructionSeatTurnRequest(
           admitted,
@@ -444,7 +513,10 @@ async function dispatchAdmitted(
       io: turnIo,
       request: buildInstructionSeatTurnRequest(
         admitted,
-        roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) }),
+        roleTurnOptions(activeEnv, admitted, {
+          kind: "initial",
+          prompt: initialPromptText,
+        }),
       ),
       adapters,
       ...(activeEnv.engine === undefined ? {} : { effectiveEngine: activeEnv.engine }),
@@ -580,14 +652,28 @@ function resumeSameParentInstructionSeat(input: {
   });
 }
 
-/** Re-ask words when the parent supplied them; otherwise the caller's own instruction. */
-function sameParentInstruction(
+/**
+ * Same delivery rule as resolveInitialPrompt for same-parent resume summons.
+ * Reask / explicit caller text / source-only ledger peer — one authority.
+ */
+async function sameParentDialogue(
   env: InstructionSeatRunEnv,
   fallback: { readonly instruction: string; readonly instructionEmpty: boolean },
-): { readonly instruction: string; readonly instructionEmpty: boolean } {
-  const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
-  if (resumeInstruction === undefined) return fallback;
-  return { instruction: resumeInstruction, instructionEmpty: false };
+  sourceRunPath: string,
+  projectRoot: string,
+): Promise<{ readonly instruction: string; readonly instructionEmpty: boolean }> {
+  const reask = env.reviewReask ?? env.gateReviewInstruction;
+  const body = await resolveReviewSeatDialogueBody({
+    ...(reask === undefined ? {} : { reask }),
+    callerInstruction: fallback.instruction,
+    sourceRunPath,
+    projectRoot,
+    home: env.home,
+  });
+  if (body !== undefined) {
+    return { instruction: body, instructionEmpty: false };
+  }
+  return fallback;
 }
 
 /**
@@ -618,6 +704,9 @@ async function runCountersignBody(
         sourceRunPath: gateParentRunPath,
         instruction: resumeInstruction,
         instructionEmpty: resumeInstruction.length === 0,
+        // #1166 J11: same-parent resume delivers this call's file-flag paths
+        // through the shared summons → appendCallerFileFlagPaths rule.
+        attachmentPaths: parsed.attachmentPaths ?? [],
       },
     });
     if (resumed != null) return resumed;
@@ -652,10 +741,14 @@ async function runCountersignBody(
         await persistAdmittedSourceRunPath(admitted, gateParentRunPath);
         admitted = { ...admitted, sourceRunPath: gateParentRunPath };
       }
+      // #1166 J11: review-body branch must merge the same file-flag delivery as
+      // resolveInitialPrompt / resumeTurnRequestProjectionOptions — never body alone.
+      const reviewBody = env.reviewReask ?? env.gateReviewInstruction;
       const turnProjection = roleTurnOptions(env, admitted, {
         kind: "initial",
-        prompt: (env.reviewReask ?? env.gateReviewInstruction)
-          ?? buildInstructionTransportPrompt(admitted),
+        prompt: reviewBody !== undefined
+          ? appendCallerFileFlagPaths(reviewBody, admitted.attachments)
+          : buildInstructionTransportPrompt(admitted),
       });
       const turnRequest = buildInstructionSeatTurnRequest(admitted, turnProjection);
       const result = await runPostAdmissionOneShot({
@@ -746,10 +839,15 @@ export async function runPublicInstructionSeat(
     if (auditorSource === undefined) return { exitCode: 2 };
     const sourceDirectory = auditorSource;
     const summons: SameTicketSummonsMaterials = {
-      ...sameParentInstruction(env, {
-        instruction: parsed.instruction ?? "",
-        instructionEmpty: (parsed.instruction ?? "").length === 0,
-      }),
+      ...(await sameParentDialogue(
+        env,
+        {
+          instruction: parsed.instruction ?? "",
+          instructionEmpty: (parsed.instruction ?? "").length === 0,
+        },
+        sourceDirectory,
+        projectRoot,
+      )),
       attachmentPaths: parsed.attachmentPaths ?? [],
     };
     const resumed = await withAuditorSoulEnv({
@@ -767,15 +865,34 @@ export async function runPublicInstructionSeat(
     if (resumed != null) return resumed;
   }
 
-  if (record.sameParent === "gate-pointer") {
-    const parentRunPath = parentRunPathFromGatePointerInstruction(parsed.instruction ?? "");
-    if (parentRunPath !== undefined) {
+  if (record.sameParent === "source-run") {
+    // #1166: structured --source-run only. Instruction bytes stay opaque caller/peer text.
+    if (parsed.sourceRun !== undefined) {
+      let parentRunPath: string;
+      try {
+        parentRunPath = (await resolveNotarySourceRunLocator({
+          projectRoot,
+          sourceRun: parsed.sourceRun,
+          home: env.home,
+        })).runDirectory;
+      } catch (error) {
+        if (error instanceof NotarySourceRunError) {
+          presentStructuralRejection(new CliUsageError(error.message, { cause: error }), io);
+          return { exitCode: 2 };
+        }
+        throw error;
+      }
       const summons: SameTicketSummonsMaterials = {
         sourceRunPath: parentRunPath,
-        ...sameParentInstruction(env, {
-          instruction: parsed.instruction ?? "",
-          instructionEmpty: (parsed.instruction ?? "").length === 0,
-        }),
+        ...(await sameParentDialogue(
+          env,
+          {
+            instruction: parsed.instruction ?? "",
+            instructionEmpty: (parsed.instruction ?? "").length === 0,
+          },
+          parentRunPath,
+          projectRoot,
+        )),
         attachmentPaths: parsed.attachmentPaths ?? [],
       };
       const resumed = await resumeSameParentInstructionSeat({
@@ -805,13 +922,15 @@ export async function runPublicInstructionSeat(
       }
       throw error;
     }
-    const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
     const summons: SameTicketSummonsMaterials = {
       sourceRunPath: source.runDirectory,
       sourceRun: source,
-      ...(resumeInstruction === undefined
-        ? {}
-        : { instruction: resumeInstruction, instructionEmpty: false }),
+      ...(await sameParentDialogue(
+        env,
+        { instruction: "", instructionEmpty: true },
+        source.runDirectory,
+        projectRoot,
+      )),
     };
     resolvedNotarySource = source;
     const resumed = await resumeSameParentInstructionSeat({
@@ -843,16 +962,18 @@ export async function runPublicInstructionSeat(
     throw error;
   }
 
-  if (record.sameParent === "gate-pointer") {
-    const parentRunPath = parentRunPathFromGatePointerInstruction(parsed.instruction ?? "");
-    if (parentRunPath !== undefined) {
-      await persistAdmittedSourceRunPath(admitted, parentRunPath);
-      const sourcePatch = { sourceRunPath: parentRunPath };
-      admitted = { ...admitted, ...sourcePatch };
-    }
+  if (record.sameParent === "source-run" && parsed.sourceRun !== undefined) {
+    const parentRunPath = (await resolveNotarySourceRunLocator({
+      projectRoot,
+      sourceRun: parsed.sourceRun,
+      home: env.home,
+    })).runDirectory;
+    await persistAdmittedSourceRunPath(admitted, parentRunPath);
+    admitted = { ...admitted, sourceRunPath: parentRunPath } as AdmittedRoleInvocation;
   }
   if (record.sameParent === "subject-source" && auditorSource !== undefined) {
     await persistAdmittedSourceRunPath(admitted, auditorSource, auditorSubject);
+    admitted = { ...admitted, sourceRunPath: auditorSource } as AdmittedRoleInvocation;
   }
 
   const runAdmitted = async (): Promise<SeatRunResult> => {
@@ -1247,8 +1368,7 @@ async function auditSubmittedRole(
         summonAuditor: async (subject, sourceRunDirectory, signal, reask, submission) => {
           const summoned = await summonPublicRole({
             role: "auditor",
-            argv: ["--subject", subject, "--source-run", sourceRunDirectory,
-              `${AUDITOR_DOSSIER_PROMPT}${sourceRunDirectory}`],
+            argv: ["--subject", subject, "--source-run", sourceRunDirectory],
             cwd: admitted.projectRoot, home: env.home, packageRoot: env.packageRoot,
             principalAuthority: env.principalAuthority,
             correlationId: admitted.runId,