@akagilnc/pi-workflow-roles 0.1.5598 → 0.1.5614

package/dist/navigator-public-session.js

@@ -13,7 +13,6 @@ import { parseRunLeaf } from "./role-run-placement.js";
 import { CliUsageError } from "./public-cli/cli-errors.js";
 import { isNavigatorSeat } from "./packaged-role-registry.js";
 import {
-  attachWorkContextPointer,
   navigatorWorkContextFile
 } from "./navigator-work-base.js";
 import { isRecord } from "./unknown-value.js";
@@ -95,13 +94,14 @@ function createNativeNavigatorSessionFactory(deps) {
           if (disposed) return;
           const resumeRunId = hostRunId;
           const workContextPath = navigatorWorkContextFile(sessionManager.getSessionDir());
-          const argvText = existsSync(workContextPath) ? attachWorkContextPointer(text, workContextPath) : text;
+          const workContextLocator = existsSync(workContextPath) ? workContextPath : void 0;
           const baseSummon = {
             role: "navigator",
-            argv: [argvText],
+            argv: [text],
             cwd: context.cwd,
             ...summonHome === void 0 ? {} : { home: summonHome },
-            ...context.signal === void 0 ? {} : { signal: context.signal }
+            ...context.signal === void 0 ? {} : { signal: context.signal },
+            ...workContextLocator === void 0 ? {} : { navigatorWorkContextPath: workContextLocator }
           };
           const resumable = deps?.hostRunResumable ?? navigatorHostRunResumable;
           let summoned;

package/dist/navigator-work-base.js

@@ -4,6 +4,7 @@ import { basename, dirname, join, resolve } from "node:path";
 import { writeFileAtomically } from "./atomic-write.js";
 import { isEnoent, isRecord } from "./unknown-value.js";
 const NAVIGATOR_WORK_CONTEXT_BASENAME = "work-context.json";
+const AK_ROLE_NAVIGATOR_WORK_CONTEXT_ENV = "AK_ROLE_NAVIGATOR_WORK_CONTEXT";
 function navigatorWorkContextFile(sessionDir) {
   return join(sessionDir, NAVIGATOR_WORK_CONTEXT_BASENAME);
 }
@@ -60,33 +61,8 @@ async function readNavigatorWorkBase(path) {
   if (record.authority.trim() === "") return void 0;
   return { subject: record.subject, authority: record.authority };
 }
-function jsonObjectFromPrompt(prompt) {
-  const head = prompt.trimStart().split("\n\n", 1)[0] ?? "";
-  if (!head.startsWith("{")) return void 0;
-  try {
-    const parsed = JSON.parse(head);
-    if (!isRecord(parsed)) return void 0;
-    return parsed;
-  } catch {
-    return void 0;
-  }
-}
-function workContextPathFromPrompt(prompt) {
-  const record = jsonObjectFromPrompt(prompt);
-  const path = record?.workContextPath;
-  if (typeof path !== "string" || path.trim() === "") return void 0;
-  return isNavigatorWorkContextFile(path) ? path : void 0;
-}
-function attachWorkContextPointer(text, workContextPath) {
-  const record = jsonObjectFromPrompt(text);
-  if (record === void 0) 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}`;
-}
-async function loadNavigatorWorkBaseSuffix(prompt) {
-  const path = workContextPathFromPrompt(prompt);
+async function loadNavigatorWorkBaseSuffix(sessionDir, locatorPath) {
+  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 !== void 0 && sessionDir.trim() !== "" ? navigatorWorkContextFile(sessionDir) : void 0;
   if (path === void 0) return void 0;
   const body = await readNavigatorWorkBase(path);
   if (body === void 0) return void 0;
@@ -99,12 +75,11 @@ ${body.authority}
 </controlling_authority>`;
 }
 export {
+  AK_ROLE_NAVIGATOR_WORK_CONTEXT_ENV,
   NAVIGATOR_WORK_CONTEXT_BASENAME,
-  attachWorkContextPointer,
   isNavigatorWorkContextFile,
   loadNavigatorWorkBaseSuffix,
   navigatorWorkContextFile,
   persistNavigatorWorkBase,
-  readNavigatorWorkBase,
-  workContextPathFromPrompt
+  readNavigatorWorkBase
 };

package/dist/packaged-role-registry.js

@@ -363,7 +363,8 @@ 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. */
@@ -376,11 +377,12 @@ const PUBLIC_ROLE_RECORDS = [
     /** Court reask replaces the initial prompt. */
     reaskPrompt: true,
     gateStageLabel: "\u53F0\u9662",
+    /** 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"
       }

package/dist/pi/role-turn-host.js

@@ -339,7 +339,7 @@ export function createPiRoleTurnHost(config) {
             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() !== "") {
                 env.AK_ROLE_AUDITOR_SOURCE_RUN = process.env.AK_ROLE_AUDITOR_SOURCE_RUN;
@@ -349,6 +349,15 @@ export function createPiRoleTurnHost(config) {
                 && process.env.AK_ROLE_AUDITOR_SUBJECT.trim() !== "") {
                 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) {
                 await config.recordLaunchedRolePackageIdentity(request.runDirectory, await config.observeLaunchedRolePackageIdentity(config.packageRoot, roleEntry));

package/dist/public-cli/instruction-seat-run.js

@@ -4,8 +4,7 @@
  * starts two ordinary single-axis runs here.
  */
 import { dirname, resolve } from "node:path";
-import { isUnboundRunDirectory } from "../role-run-placement.js";
-import { AUDITOR_DOSSIER_PROMPT } from "../compliance-transport.js";
+import { isUnboundRunDirectory, sessionFileOf } from "../role-run-placement.js";
 import { bookDirectOfficerRunPointer, readDirectOfficerRunPointer } from "../archivist-record-pointer.js";
 import { createPiDoctorAuditor } from "../doctor-auditor.js";
 import { officerConclusionReask, gateOfficerForSubject } from "../gatekeeper-role.js";
@@ -27,10 +26,10 @@ import { NotarySourceRunError, resolveNotarySourceRunLocator } from "../notary-s
 import { packagedAdmitsCountersign, packagedBindsBoardTicket, packagedRebindSourceOnResume, packagedRoleMetadata, } from "../packaged-role-registry.js";
 import { readAuditorResumeBinding } from "../auditor-soul.js";
 import { CliUsageError } from "./cli-errors.js";
-import { admitPublicRole, bindAdmittedTicketNumber, buildInstructionTransportPrompt, materializeCountersignInvocation, persistAdmittedSourceRunPath, recordAdmittedCorrelation, recordChildDiaristRun, relocateAdmittedRunToTicket, } from "./invocation.js";
+import { admitPublicRole, bindAdmittedTicketNumber, appendCallerFileFlagPaths, buildInstructionTransportPrompt, materializeCountersignInvocation, persistAdmittedSourceRunPath, recordAdmittedCorrelation, recordChildDiaristRun, relocateAdmittedRunToTicket, } from "./invocation.js";
 import { bindDiaristAssertedTicketNumber, presentControlledFailure, packageFaultNoteFor, prepareSummonsResumeMaterials, roleTurnOptions, runPostAdmissionOneShot, runPostAdmissionResumable, runPostAdmissionSeatResume, showResumeErrorPointer, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
 import { presentTerminal } from "./auto-resume.js";
-import { buildAutoResumeContinuationPrompt, loadResumablePublicRole, markRunAdmitted, parentRunPathFromGatePointerInstruction, readCurrentCourt, } from "./run-lifecycle.js";
+import { buildAutoResumeContinuationPrompt, loadResumablePublicRole, markRunAdmitted, readCurrentCourt, } from "./run-lifecycle.js";
 import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
 import { presentStructuralRejection, readBoundSessionEntries, attachPostAuditCountersignFact, trySettlePublicSeat, } from "./settlement.js";
 import { warnMissingMethodSkills } from "./machine-method-skills.js";
@@ -168,11 +167,69 @@ function roleRecord(role) {
 export function buildInstructionSeatTurnRequest(admitted, options) {
     return projectRoleTurnRequest(admitted, admittedSeatTurnDetails(admitted, options.home, options.host), options);
 }
-function initialPrompt(admitted, env) {
-    const record = roleRecord(admitted.role);
-    const reask = env.reviewReask ?? env.gateReviewInstruction;
-    if (reask !== undefined && "reaskPrompt" in record && record.reaskPrompt === true) {
+/**
+ * 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, projectRoot, home) {
+    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) {
+    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) {
+    return "sourceRunPath" in admitted
+        && typeof admitted.sourceRunPath === "string"
+        ? admitted.sourceRunPath.trim()
+        : "";
+}
+async function resolveInitialPrompt(admitted, env) {
+    const record = roleRecord(admitted.role);
+    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);
 }
@@ -271,13 +328,17 @@ async function dispatchAdmitted(admitted, env, io) {
         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({
                 admitted,
                 env: activeEnv,
                 io: turnIo,
-                buildInitialRequest: () => buildInstructionSeatTurnRequest(admitted, roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) })),
+                buildInitialRequest: () => buildInstructionSeatTurnRequest(admitted, roleTurnOptions(activeEnv, admitted, {
+                    kind: "initial",
+                    prompt: initialPromptText,
+                })),
                 buildResumeRequest: () => buildInstructionSeatTurnRequest(admitted, roleTurnOptions(activeEnv, admitted, {
                     kind: "resume",
                     prompt: buildAutoResumeContinuationPrompt(),
@@ -290,7 +351,10 @@ async function dispatchAdmitted(admitted, env, io) {
             admitted,
             env: activeEnv,
             io: turnIo,
-            request: buildInstructionSeatTurnRequest(admitted, roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) })),
+            request: buildInstructionSeatTurnRequest(admitted, roleTurnOptions(activeEnv, admitted, {
+                kind: "initial",
+                prompt: initialPromptText,
+            })),
             adapters,
             ...(activeEnv.engine === undefined ? {} : { effectiveEngine: activeEnv.engine }),
         });
@@ -400,12 +464,23 @@ function resumeSameParentInstructionSeat(input) {
         resume: (runId, materials) => runPublicInstructionSeatResume({ runId, ...(materials === undefined ? {} : { summons: materials }) }, input.env, input.io),
     });
 }
-/** Re-ask words when the parent supplied them; otherwise the caller's own instruction. */
-function sameParentInstruction(env, fallback) {
-    const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
-    if (resumeInstruction === undefined)
-        return fallback;
-    return { instruction: resumeInstruction, instructionEmpty: false };
+/**
+ * Same delivery rule as resolveInitialPrompt for same-parent resume summons.
+ * Reask / explicit caller text / source-only ledger peer — one authority.
+ */
+async function sameParentDialogue(env, fallback, sourceRunPath, projectRoot) {
+    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;
 }
 /**
  * Countersign on the shared entry: gate parent resume, deferred materialization,
@@ -430,6 +505,9 @@ async function runCountersignBody(parsed, env, io) {
                 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)
@@ -462,10 +540,14 @@ async function runCountersignBody(parsed, env, io) {
                 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({
@@ -555,10 +637,10 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
             return { exitCode: 2 };
         const sourceDirectory = auditorSource;
         const summons = {
-            ...sameParentInstruction(env, {
+            ...(await sameParentDialogue(env, {
                 instruction: parsed.instruction ?? "",
                 instructionEmpty: (parsed.instruction ?? "").length === 0,
-            }),
+            }, sourceDirectory, projectRoot)),
             attachmentPaths: parsed.attachmentPaths ?? [],
         };
         const resumed = await withAuditorSoulEnv({
@@ -576,15 +658,30 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
         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;
+            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 = {
                 sourceRunPath: parentRunPath,
-                ...sameParentInstruction(env, {
+                ...(await sameParentDialogue(env, {
                     instruction: parsed.instruction ?? "",
                     instructionEmpty: (parsed.instruction ?? "").length === 0,
-                }),
+                }, parentRunPath, projectRoot)),
                 attachmentPaths: parsed.attachmentPaths ?? [],
             };
             const resumed = await resumeSameParentInstructionSeat({
@@ -615,13 +712,10 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
             }
             throw error;
         }
-        const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
         const summons = {
             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({
@@ -649,16 +743,18 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
             return rejected;
         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 };
     }
     if (record.sameParent === "subject-source" && auditorSource !== undefined) {
         await persistAdmittedSourceRunPath(admitted, auditorSource, auditorSubject);
+        admitted = { ...admitted, sourceRunPath: auditorSource };
     }
     const runAdmitted = async () => {
         await markRunAdmitted(admitted, env.principalAuthority);
@@ -997,8 +1093,7 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
                 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/dist/public-cli/invocation.js

@@ -1084,19 +1084,35 @@ function admittedTransportPromptKind(admitted) {
         return record.transportPrompt;
     return "instruction";
 }
+/** Append opaque caller file-flag paths after dialogue (#1165 / #1166 J11 / #1168). */
+export function appendCallerFileFlagPaths(body, attachments, requestManifestPath, prerequisitesPath) {
+    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(admitted) {
     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) {
@@ -1126,26 +1142,7 @@ export function buildInstructionTransportPrompt(admitted) {
         }
         return lines.join("\n");
     }
-    // #1165 J3 / #1168: assemble from the admitted instruction bytes themselves.
-    const lines = [admitted.instruction];
-    // #1164/#1165/#1168: each caller path keeps its file-flag provenance.
-    const flaggedPaths = [
-        ...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);
 }
 /** Persist a deferred Countersign admission after same-ticket lookup found no retained run. */
 export async function materializeCountersignInvocation(admitted, options) {