@akagilnc/pi-workflow-roles 0.1.5598 → 0.1.5614

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,

package/src/public-cli/invocation.ts

@@ -183,6 +183,8 @@ export type AdmittedNavigatorInvocation = AdmittedRoleInvocationBase & {
 
 export type AdmittedAuditorInvocation = AdmittedRoleInvocationBase & {
   readonly role: "auditor";
+  /** Audited source-run directory (#1166 identity / ADR 0085 peer-body load). */
+  readonly sourceRunPath?: string;
 };
 
 export type AdmittedDiaristInvocation = AdmittedRoleInvocationBase & {
@@ -1817,10 +1819,32 @@ function admittedTransportPromptKind(
   return "instruction";
 }
 
+/** Append opaque caller file-flag paths after dialogue (#1165 / #1166 J11 / #1168). */
+export function appendCallerFileFlagPaths(
+  body: string,
+  attachments: readonly { readonly path: string }[],
+  requestManifestPath?: string,
+  prerequisitesPath?: string,
+): string {
+  const flaggedPaths = [
+    ...attachments.map((attachment) => `--attach ${attachment.path}`),
+    ...(requestManifestPath === undefined
+      ? []
+      : [`--request-manifest ${requestManifestPath}`]),
+    ...(prerequisitesPath === undefined
+      ? []
+      : [`--prerequisites ${prerequisitesPath}`]),
+  ];
+  if (flaggedPaths.length === 0) return body;
+  // ADR 0087 / #1165 / #1166 J13: after caller words, only necessary file flags
+  // and original paths — no package-authored title or list wrapper.
+  return [body, "", ...flaggedPaths].join("\n");
+}
+
 /**
  * One initial prompt transport. The registry `transportPrompt` leaf selects
- * a fixed kickoff, a bound baseline, or frozen skill args. Absent means the
- * caller instruction plus caller attachment paths as-is (#1165).
+ * a fixed kickoff, a bound baseline, or skill args. Absent means the caller
+ * instruction plus caller file-flag paths (ADR 0087).
  * Engine / outsourcing material rides startup readingMaterial (#1167), not here.
  */
 export function buildInstructionTransportPrompt(
@@ -1828,10 +1852,9 @@ export function buildInstructionTransportPrompt(
 ): string {
   const kind = admittedTransportPromptKind(admitted);
   if (kind === "fixed-kickoff") {
-    if (admitted.sourceRunPath === undefined || admitted.sourceRunPath.trim() === "") {
-      throw new Error("fixed-kickoff transport prompt is missing the source run pointer");
-    }
-    return admitted.sourceRunPath;
+    // #1166 / ADR 0087: audited-run identity rides startup materials; dialogue
+    // prompt is peer body / reask only — never a package-computed directory path.
+    return "";
   }
   if (kind === "baseline") {
     if (admitted.baseRevision === undefined) {
@@ -1863,26 +1886,12 @@ export function buildInstructionTransportPrompt(
     }
     return lines.join("\n");
   }
-  // #1165 J3 / #1168: assemble from the admitted instruction bytes themselves.
-  const lines: string[] = [admitted.instruction];
-  // #1164/#1165/#1168: each caller path keeps its file-flag provenance.
-  const flaggedPaths: string[] = [
-    ...admitted.attachments.map((attachment) => `--attach ${attachment.path}`),
-    ...(admitted.requestManifestPath === undefined
-      ? []
-      : [`--request-manifest ${admitted.requestManifestPath}`]),
-    ...(admitted.prerequisitesPath === undefined
-      ? []
-      : [`--prerequisites ${admitted.prerequisitesPath}`]),
-  ];
-  if (flaggedPaths.length > 0) {
-    lines.push("");
-    lines.push("已受理附件：");
-    for (const entry of flaggedPaths) {
-      lines.push(`- ${entry}`);
-    }
-  }
-  return lines.join("\n");
+  return appendCallerFileFlagPaths(
+    admitted.instruction,
+    admitted.attachments,
+    admitted.requestManifestPath,
+    admitted.prerequisitesPath,
+  );
 }
 
 export type AdmitCountersignInvocationOptions = {

package/src/public-cli/option-definitions.ts

@@ -612,6 +612,25 @@ const NOTARY_OPTIONS = [
   },
 ] as const satisfies readonly PublicOptionDefinition[];
 
+/** 台院: optional --source-run binds the audited leg; gate summons always pass it (#1166). */
+const INSPECTOR_OPTIONS = [
+  ...projectAndAttach("inspector"),
+  {
+    id: "source-run",
+    owner: "inspector",
+    canonical: "--source-run",
+    aliases: [],
+    valueMetavar: "runId@role|path",
+    required: false,
+    repeatable: false,
+    form: "option",
+    description: {
+      en: "Optional audited source-run locator (runId@role or path). Gate summons always supply it; identity rides startup materials.",
+      zh: "可选被审腿定位符（runId@role 或路径）。闸传召必带；身份在启动材料里。",
+    },
+  },
+] as const satisfies readonly PublicOptionDefinition[];
+
 const MERGER_OPTIONS = [
   // Merger project face: worktree whose Git materials are handed to the role.
   {
@@ -779,6 +798,7 @@ const SEAT_OPTION_ROWS: Partial<
   merger: MERGER_OPTIONS,
   notary: NOTARY_OPTIONS,
   auditor: AUDITOR_OPTIONS,
+  inspector: INSPECTOR_OPTIONS,
 };
 
 function seatOptionRows(role: PublicCallableRole): readonly PublicOptionDefinition[] {

package/src/public-cli/post-admission.ts

@@ -19,8 +19,8 @@ import {
 import { CliUsageError } from "./cli-errors.ts";
 import { projectPublicTurnAxes, type RoleTurnRequestProjectionOptions } from "./turn-request.ts";
 import {
+  appendCallerFileFlagPaths,
   bindAdmittedTicketNumber,
-  buildInstructionTransportPrompt,
   relocateAdmittedRunToTicket,
 } from "./invocation.ts";
 import { readRecordedSubmissionRows } from "../submission-ledger.ts";
@@ -326,6 +326,11 @@ export type PostAdmissionEnv = {
   boundTicketNumber?: number;
   /** Station child role run (#840): omit automatic navigator attendance. */
   stationChild?: boolean;
+  /**
+   * Navigator nest work-context locator (#1166). Request-scoped; never folded
+   * into dialogue. Child spawn may mirror onto child env only.
+   */
+  navigatorWorkContextPath?: string;
 };
 
 /**
@@ -1458,8 +1463,8 @@ export async function dispatchPostAdmissionTurn<
  * Shared resume continuation projection (#471 / #600 / #633 / #637 / #755 / #879):
  * seat-table model/engine/timeout axes, restored correlation, and either
  * - manual resume (no same-ticket summons): caller message bytes, or
- * - same-ticket summons (审核循环续话): caller/peer words + optional frozen
- *   attachment paths only — no「请重读」、no code-authored content substitute,
+ * - same-ticket summons (审核循环续话): caller/peer words + optional caller file-flag
+ *   paths only — no「请重读」、no code-authored content substitute,
  *   no engine handbook packaging (#750/#755/#879).
  * Caller message wins as prompt base when supplied (bytes unchanged, including
  * blank/whitespace); else summons instruction (parent payload or reask).
@@ -1477,22 +1482,17 @@ export function resumeTurnRequestProjectionOptions(
     readonly attachments: readonly { path: string }[];
   },
 ): RoleTurnRequestProjectionOptions {
-  // #879: officer dialogue content is caller/peer words only — no「请重读」,
-  // no code-authored constant substitute, no attachment-list wrap of peer body.
-  // Binding pointer stays on summons sourceRunPath / activation / attachments.
+  // #879: officer dialogue is caller/peer words; #1166 J11 merges caller file-flag
+  // paths when present. Gate with no file flags stays body-only (ADR 0085).
   const officerDialogue = isStationChildOfficerDialogue(admitted.role, env);
+  const fileFlags = summonsPrepared?.attachments ?? [];
   let prompt: string;
   if (request.message !== undefined) {
     if (summonsPrepared !== undefined) {
-      // #755: same-ticket review / open-court — caller words.
-      // #879 station-child officer: words only (paths remain on summons materials).
-      prompt = officerDialogue
+      // #755: same-ticket review / open-court — caller words + caller file flags.
+      prompt = officerDialogue && fileFlags.length === 0
         ? request.message
-        : buildInstructionTransportPrompt({
-            instruction: request.message,
-            instructionEmpty: false,
-            attachments: summonsPrepared.attachments,
-          });
+        : appendCallerFileFlagPaths(request.message, fileFlags);
     } else if (request.summons !== undefined) {
       // #755: same-ticket summons without prepared materials — caller words only.
       prompt = request.message;
@@ -1500,13 +1500,11 @@ export function resumeTurnRequestProjectionOptions(
       prompt = request.message;
     }
   } else if (summonsPrepared !== undefined) {
-    // #879 station-child officer: instruction bytes === peer body/reask (no wrap).
-    // Other seats keep #755 instruction + optional attachment path listing.
-    // #1165 J3: officer dialogue is raw instruction bytes; do not gate on
-    // instructionEmpty metadata (resume of older admitted pages).
-    prompt = officerDialogue
-      ? summonsPrepared.instruction
-      : buildInstructionTransportPrompt(summonsPrepared);
+    const body = summonsPrepared.instruction;
+    // No file flags: body alone (gate peer words). With flags: merge delivery.
+    prompt = officerDialogue && fileFlags.length === 0
+      ? body
+      : appendCallerFileFlagPaths(body, fileFlags);
   } else if (request.summons !== undefined) {
     // #879: same-ticket summons with no instruction (e.g. notary source-run binding
     // only). Pointer is activation/sourceRun material — not dialogue content.
@@ -1527,6 +1525,10 @@ export function resumeTurnRequestProjectionOptions(
     ...(env.stationChild === undefined ? {} : { stationChild: env.stationChild }),
     // #1132: one configured ceiling, already resolved by the caller (#422).
     deliveryRequestLimit: deliveryLimitFromConfig(env.autoResumeLimit),
+    ...(env.navigatorWorkContextPath === undefined
+      || env.navigatorWorkContextPath.trim() === ""
+      ? {}
+      : { navigatorWorkContextPath: env.navigatorWorkContextPath }),
   };
 }
 
@@ -1547,6 +1549,10 @@ export function roleTurnOptions(
     ...(env.stationChild === undefined ? {} : { stationChild: env.stationChild }),
     // #1132: one configured ceiling, already resolved by the caller (#422).
     deliveryRequestLimit: deliveryLimitFromConfig(env.autoResumeLimit),
+    ...(env.navigatorWorkContextPath === undefined
+      || env.navigatorWorkContextPath.trim() === ""
+      ? {}
+      : { navigatorWorkContextPath: env.navigatorWorkContextPath }),
   };
 }
 
@@ -1668,7 +1674,7 @@ export async function prepareSummonsResumeMaterials(
  * validation, turn builder, and adapters stay on the seat.
  *
  * Court handling (#637): public manual resume reads only the open court's
- * settlement identity; internal re-summons may freeze and record its materials.
+ * settlement identity; internal re-summons passes caller file-flag paths as-is.
  */
 export async function runPostAdmissionSeatResume<
   A extends AdmittedRoleInvocation,

package/src/public-cli/run-lifecycle.ts

@@ -885,21 +885,9 @@ export async function findRunDirectoryById(
   );
 }
 
-/** Code-owned gate inspector summons prefix (public-role-summons / #747). */
-export const GATE_DOSSIER_POINTER_PREFIX = "卷宗指针：" as const;
-
-/** Parent path from a code-owned inspector 卷宗指针 instruction; else undefined. */
-export function parentRunPathFromGatePointerInstruction(
-  instruction: string,
-): string | undefined {
-  if (!instruction.startsWith(GATE_DOSSIER_POINTER_PREFIX)) return undefined;
-  const path = instruction.slice(GATE_DOSSIER_POINTER_PREFIX.length).trim();
-  return path === "" ? undefined : path;
-}
-
 /**
- * Parent-run binding on a retained officer run (#747).
- * Notary/auditor: typed sourceRunPath. Inspector: exact code-owned 卷宗指针 instruction.
+ * Parent-run binding on a retained officer run (#747 / #1166).
+ * Typed sourceRunPath only — instruction bytes are never a path protocol.
  * Missing page → undefined; damage / non-ENOENT IO propagates.
  */
 export async function readRunParentPath(
@@ -910,9 +898,6 @@ export async function readRunParentPath(
   if (typeof record.sourceRunPath === "string" && record.sourceRunPath.trim() !== "") {
     return record.sourceRunPath;
   }
-  if (typeof record.instruction === "string") {
-    return parentRunPathFromGatePointerInstruction(record.instruction);
-  }
   return undefined;
 }
 

package/src/public-cli/turn-request.ts

@@ -17,7 +17,6 @@ import {
 import type { SeatModelConfig } from "./config.ts";
 import type { AdmittedRoleInvocation } from "./invocation.ts";
 import { installedMethodSkillPath } from "./machine-method-skills.ts";
-import { parentRunPathFromGatePointerInstruction } from "./run-lifecycle.ts";
 import type { PublicThinkingLevel } from "./registry.ts";
 
 /** Structural model shape shared by the seam so seat/env sources fit. */
@@ -77,6 +76,11 @@ export type RoleTurnRequestProjectionOptions = {
    * execution seam count with the same configured number.
    */
   readonly deliveryRequestLimit?: number;
+  /**
+   * Navigator nest work-context locator (#1166). Request-scoped internal path —
+   * not dialogue content.
+   */
+  readonly navigatorWorkContextPath?: string;
 };
 
 export type AdmittedTurnInvocation = {
@@ -127,6 +131,10 @@ export function projectRoleTurnRequest(
     ...(options.deliveryRequestLimit === undefined
       ? {}
       : { deliveryRequestLimit: options.deliveryRequestLimit }),
+    ...(options.navigatorWorkContextPath === undefined
+      || options.navigatorWorkContextPath.trim() === ""
+      ? {}
+      : { navigatorWorkContextPath: options.navigatorWorkContextPath }),
   };
 }
 
@@ -163,13 +171,6 @@ function activationForAdmitted(admitted: AdmittedRoleInvocation): RoleTurnActiva
   const activation: Record<string, unknown> = { role: admitted.role };
   for (const spec of packagedRoleActivationFlags(admitted.role)) {
     let value = readAdmittedPath(admitted, spec.from ?? spec.field);
-    if (spec.fallback === "gate-pointer") {
-      const trimmed = typeof value === "string" ? value.trim() : "";
-      value = trimmed !== ""
-        ? trimmed
-        : parentRunPathFromGatePointerInstruction(admitted.instruction);
-      if (typeof value !== "string" || value === "") continue;
-    }
     if (value === undefined) continue;
     if (spec.text === true) {
       if (typeof value !== "number") continue;