@akagilnc/pi-workflow-roles 0.1.4444 → 0.1.4489

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

@@ -23,6 +23,12 @@ import {
 } from "../prepared-role-turn.ts";
 
 import { reportHostSessionEvent } from "../host-session-record.ts";
+import {
+  applyClaudeSkillInvocation,
+  applyCodexSkillInvocation,
+  hostMethodSkills,
+  packagedMethodPluginDir,
+} from "../host-native-method.ts";
 import {
   closeJsonSchemaForCodex,
   codexTurnArgs,
@@ -410,6 +416,7 @@ function buildTurnArgs(options: {
   readonly sessionKind: "new" | "resume";
   readonly cwd: string;
   readonly writableRoots?: readonly string[];
+  readonly pluginDir?: string;
 }): readonly string[] {
   if (isCodexExecDescription(options.description)) {
     if (options.sessionKind === "resume" && !options.sessionId) {
@@ -441,6 +448,7 @@ function buildTurnArgs(options: {
     ...(options.model === undefined ? {} : { model: options.model }),
     ...(options.effort === undefined ? {} : { effort: options.effort }),
     session: { kind: options.sessionKind, id: options.sessionId },
+    ...(options.pluginDir === undefined ? {} : { pluginDir: options.pluginDir }),
   });
 }
 
@@ -469,11 +477,17 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
       await writeFile(systemPromptPath, systemPrompt, "utf8");
       let mcpConfigPath: string | undefined;
       let outputSchemaPath: string | undefined;
+      let pluginDir: string | undefined;
+      let applyMethodPrompt: (prompt: string) => string = codex
+        ? (prompt) => applyCodexSkillInvocation(request.methods, prompt)
+        : (prompt) => prompt;
       if (codex) {
-        // Codex --output-schema needs a closed transport projection on disk.
         outputSchemaPath = join(request.runDirectory, "headless-output-schema.json");
-        const closed = closeJsonSchemaForCodex(prepared.jsonSchema);
-        await writeFile(outputSchemaPath, `${JSON.stringify(closed, null, 2)}\n`, "utf8");
+        await writeFile(
+          outputSchemaPath,
+          `${JSON.stringify(closeJsonSchemaForCodex(prepared.jsonSchema), null, 2)}\n`,
+          "utf8",
+        );
       } else {
         mcpConfigPath = join(request.runDirectory, "headless-mcp-config.json");
         await writeFile(
@@ -481,6 +495,14 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
           `${JSON.stringify(headlessMcpConfigDocument(prepared.mcpServers), null, 2)}\n`,
           "utf8",
         );
+        if (hostMethodSkills(request.methods).length > 0) {
+          const packageRoot = env.AK_PACKAGE_ROOT ?? process.env.AK_PACKAGE_ROOT;
+          if (typeof packageRoot !== "string" || packageRoot === "") {
+            throw new Error("claude method plugin-dir requires AK_PACKAGE_ROOT");
+          }
+          pluginDir = packagedMethodPluginDir(packageRoot);
+          applyMethodPrompt = (prompt) => applyClaudeSkillInvocation(request.methods, prompt);
+        }
       }
 
       const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
@@ -505,6 +527,7 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
               sessionKind,
               cwd: request.cwd,
               ...(gitCommonDir === undefined ? {} : { writableRoots: [gitCommonDir] }),
+              ...(pluginDir === undefined ? {} : { pluginDir }),
             });
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -522,7 +545,7 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
               args,
               cwd: request.cwd,
               env,
-              stdin: prompt,
+              stdin: applyMethodPrompt(prompt),
               ...(abortSignal === undefined ? {} : { signal: abortSignal }),
               ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
               onStdoutLine(line) {

package/src/host-descriptions.ts

@@ -9,13 +9,6 @@
 import type { AcpHostDescription } from "./acp-host/description.ts";
 import type { HeadlessHostDescription } from "./headless-host/description.ts";
 
-/** Grok CLI reads vendor-private compat surfaces unless each is disabled by name. */
-const PRIVATE_COMPAT_ENV = Object.fromEntries(
-  ["CLAUDE", "CURSOR", "CODEX"].flatMap((vendor) =>
-    ["SKILLS", "RULES", "AGENTS", "MCPS", "HOOKS", "SESSIONS"].map((kind) =>
-      [`GROK_${vendor}_${kind}_ENABLED`, "false"] as const)),
-);
-
 export const DEFAULT_ROLE_TURN_HOST = "pi" as const;
 
 export type HostFamily = "acp" | "headless";
@@ -32,11 +25,6 @@ export const HOST_DESCRIPTIONS: Readonly<Record<string, AcpHostDescription>> = O
     modelPassing: "argv",
     boundResume: "session/load",
     sessionBindingFile: "grok-acp-session.json",
-    childEnv: Object.freeze({
-      ...PRIVATE_COMPAT_ENV,
-      GROK_MEMORY: "0",
-      GROK_SUBAGENTS: "0",
-    }),
   }),
   /**
    * Operator home `~/.hermes`, native session/load resume, `acp` subcommand.
@@ -55,7 +43,6 @@ export const HOST_DESCRIPTIONS: Readonly<Record<string, AcpHostDescription>> = O
     modelPassing: "set_model",
     boundResume: "session/load",
     sessionBindingFile: "hermes-acp-session.json",
-    childEnv: Object.freeze({}),
     seatProfileSoul: Object.freeze({
       flag: "-p",
       namePrefix: "ak-",
@@ -69,12 +56,9 @@ export const HOST_DESCRIPTIONS: Readonly<Record<string, AcpHostDescription>> = O
  * Headless CLI family (#645 / #646). Claude print-mode is the first row;
  * codex exec (#646) adds another. Protocol-specific argv/parse live in
  * headless-host helpers (#752 per-host impl).
- * Claude fixedArgs: print mode, isolation without `--bare` (OAuth stays), full
- * permissions. stream-json + verbose: live host events for sitian records
- * (#811); result is last line. `--setting-sources` empty = load no
- * user/project/local CLAUDE.md/hooks/skills (role envelope is delivered via
- * `--system-prompt` wholesale replace). `--strict-mcp-config` with no
- * `--mcp-config` drops operator MCP + claude.ai connectors.
+ * Claude fixedArgs: print mode, full permissions. stream-json + verbose: live
+ * host events for sitian records (#811); result is last line. Forced methods
+ * ride `--plugin-dir` (#922); operator skill/setting surfaces stay open.
  */
 export const HEADLESS_HOST_DESCRIPTIONS: Readonly<Record<string, HeadlessHostDescription>> = Object.freeze({
   "claude": Object.freeze({
@@ -87,10 +71,6 @@ export const HEADLESS_HOST_DESCRIPTIONS: Readonly<Record<string, HeadlessHostDes
       // Intermediate assistant/tool/system events require verbose with stream-json.
       "--verbose",
       "--permission-mode", "bypassPermissions",
-      // Empty sources: no user/project/local operator surface (envelope owns materials).
-      "--setting-sources", "",
-      // With adapter-supplied --mcp-config only (AK relay); drops operator + claude.ai MCP.
-      "--strict-mcp-config",
     ]),
     promptFlag: "-p",
     modelFlag: "--model",

package/src/host-native-method.ts

@@ -0,0 +1,67 @@
+/** #922 host-native packaged method delivery. */
+import { lstat, mkdir, readlink, realpath, symlink } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import type { MethodBinding } from "./host-contracts.ts";
+
+type HostMethodSkill = Readonly<{ name: string }>;
+export const HOST_METHOD_PLUGIN_NAME = "ak-methods" as const;
+export const packagedMethodsDir = (root: string) => join(root, "resources", "methods");
+export const packagedMethodPluginDir = (root: string) => join(root, "dist", "method-host-plugin");
+
+export function hostMethodSkills(methods: readonly MethodBinding[]): readonly HostMethodSkill[] {
+  return Object.freeze(methods.flatMap((method) => {
+    if (method.kind !== "skill") return [];
+    const name = basename(dirname(method.path));
+    return name ? [Object.freeze({ name })] : [];
+  }));
+}
+
+const alreadyPrefixed = (prompt: string, token: string) => {
+  const text = prompt.trimStart();
+  return text === token || text.startsWith(`${token} `) || text.startsWith(`${token}\n`);
+};
+
+function prefixMethodInvocation(token: string, prompt: string): string {
+  if (alreadyPrefixed(prompt, token)) return prompt;
+  return prompt ? `${token} ${prompt}` : token;
+}
+
+/** Claude's documented plugin Skill invocation syntax. */
+export function applyClaudeSkillInvocation(methods: readonly MethodBinding[], prompt: string): string {
+  const skills = hostMethodSkills(methods);
+  if (skills.length !== 1) return prompt;
+  return prefixMethodInvocation(`/${HOST_METHOD_PLUGIN_NAME}:${skills[0]!.name}`, prompt);
+}
+
+/** Codex's documented explicit Skill invocation syntax. */
+export function applyCodexSkillInvocation(methods: readonly MethodBinding[], prompt: string): string {
+  return hostMethodSkills(methods).reduceRight(
+    (invocation, skill) => prefixMethodInvocation(`$${skill.name}`, invocation),
+    prompt,
+  );
+}
+
+/** Install the documented project Skill catalog once and leave it in place. */
+export async function installWorkspaceMethodSkills(cwd: string, packageRoot: string): Promise<void> {
+  const target = await realpath(packagedMethodsDir(packageRoot));
+  const link = join(cwd, ".agents", "skills");
+  try {
+    const stat = await lstat(link);
+    if (!stat.isSymbolicLink() || await realpath(link) !== target) {
+      const detail = stat.isSymbolicLink() ? `symlink to ${await readlink(link)}` : "non-symlink entry";
+      throw new Error(`workspace method catalog conflict at ${link}: ${detail}`);
+    }
+    return;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+  }
+  await mkdir(dirname(link), { recursive: true });
+  try {
+    await symlink(target, link);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+    if ((await realpath(link).catch(() => "")) !== target) {
+      throw new Error(`workspace method catalog conflict at ${link}`);
+    }
+  }
+}

package/src/role-envelope.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
 import { createServer, type Server, type Socket } from "node:net";
-import { basename, dirname, join } from "node:path";
+import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import {
@@ -13,15 +13,14 @@ import { requireGatekeeperPass } from "./gatekeeper-pass-envelope.ts";
 import type {
   HostContext,
   HostEventRegistration,
-  HostSkillExpansionEvidence,
   HostToolDefinition,
   RoleEnvelopeHost,
   RoleHost,
   RoleTurnKnownFailure,
   RoleTurnRequest,
 } from "./host-contracts.ts";
+import { hostMethodSkills, installWorkspaceMethodSkills } from "./host-native-method.ts";
 import { packagedRoleOutputTool } from "./packaged-role-registry.ts";
-import { stripSkillFrontmatter } from "./package-resources/method-skill.ts";
 import {
   createRoleRuntimeExtension,
   type RoleRuntimeDependencies,
@@ -44,30 +43,6 @@ type RpcRequest = { readonly id: number; readonly token: string; readonly method
 type ToolCallParams = { readonly name?: unknown; readonly arguments?: unknown };
 type ContentPart = { type: "text"; text: string } | { type: "image"; data: string; mimeType: string };
 
-/**
- * Build host-side Skill expansion evidence from pre-read RoleTurnRequest.methods.
- * Non-pi hosts never parse Pi `/skill:` syntax (ADR 0082: pi is one adapter with
- * no privilege; Pi-only seams stay inside the pi adapter);
- * a single bound method treats the plain prompt as the preserved user message.
- * Pi-native slash forms stay inside `src/pi/` only.
- */
-export function buildSkillExpansion(
-  methodSkills: ReadonlyMap<string, { readonly path: string; readonly body: string }>,
-  prompt: string,
-): HostSkillExpansionEvidence | undefined {
-  if (methodSkills.size !== 1) return undefined;
-  const entry = methodSkills.entries().next().value;
-  if (entry === undefined) return undefined;
-  const [name, method] = entry;
-  return Object.freeze({
-    name,
-    location: method.path,
-    content: method.body,
-    // Non-pi typed chain keeps original task bytes (ticket #822 r3); no consumer trim.
-    userMessage: prompt,
-  });
-}
-
 async function listen(server: Server, path: string): Promise<void> {
   await new Promise<void>((resolve, reject) => {
     server.once("error", reject);
@@ -129,7 +104,6 @@ export async function prepareRoleEnvelope(options: {
   const customEntries: Array<{ customType: string; data: unknown }> = [];
   /** In-memory turn books for role lifecycle and audit subjects. */
   const sessionEntries: Array<Record<string, unknown>> = [];
-  const methodSkills = new Map<string, { path: string; body: string }>();
   let preferredTools: string[] = [];
   let rejection:
     | { readonly code: string; readonly toolCallIds: readonly string[]; readonly message: string }
@@ -140,14 +114,6 @@ export async function prepareRoleEnvelope(options: {
   const runId = request.runDirectory.split("/").filter(Boolean).at(-1) ?? randomUUID();
   await mkdir(request.runDirectory, { recursive: true });
 
-  // Canonical Skill expansion consumes RoleTurnRequest.methods (typed true source).
-  for (const method of request.methods) {
-    if (method.kind !== "skill") continue;
-    const name = basename(dirname(method.path));
-    const raw = await readFile(method.path, "utf8");
-    methodSkills.set(name, { path: method.path, body: stripSkillFrontmatter(raw).trim() });
-  }
-
   // Durable principal file for isAvailable / resumable settlement (public-cli).
   // #617 DK-4: header layout only — never host conversation/tool writeback into Pi JSONL.
   let sessionFile = options.sessionFile ?? join(request.runDirectory, "session", "session.jsonl");
@@ -219,9 +185,8 @@ export async function prepareRoleEnvelope(options: {
       // #836 删 1/A4.5: do not arm closeRound retry with「终局交卷并非本轮唯一工具调用」.
     },
     capabilities: {
-      skillExpansion(prompt): HostSkillExpansionEvidence | undefined {
-        return buildSkillExpansion(methodSkills, prompt);
-      },
+      // #922: native loaders own expansion; package does not pre-read bodies (ADR 0032).
+      skillExpansion() { return undefined; },
     },
     registerFlag(name, definition) { if (!flags.has(name) && definition.default !== undefined) flags.set(name, definition.default); },
     getFlag(name) { return flags.get(name); },
@@ -625,14 +590,10 @@ export async function prepareRoleEnvelope(options: {
         message: { role: "user", content: prompt },
       });
     }
-    // Method notes only here — role before_agent_start injects soul once.
-    // Preloading session materials duplicated soul under the role tag (#632).
-    // #879: case-dossier owner reads runDirectory from this turn's HostContext.
-
-    const methodPrompt = (await Promise.all(request.methods.map(({ path }) => readFile(path, "utf8")))).join("\n\n");
+    // Soul/materials only — forced methods use host-native loaders (#922/#632/#879).
     const promptResults = await emit("before_agent_start", {
       prompt,
-      systemPrompt: methodPrompt,
+      systemPrompt: "",
       systemPromptOptions: {},
     });
     const systemPromptParts = promptResults.flatMap((value) => {
@@ -640,7 +601,7 @@ export async function prepareRoleEnvelope(options: {
       if (!("systemPrompt" in value) || typeof value.systemPrompt !== "string") return [];
       return [value.systemPrompt];
     });
-    const systemPromptBody = systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : methodPrompt;
+    const systemPromptBody = systemPromptParts.join("\n\n");
     // Typed reading materials from agent-start handlers (incl. single shared
     // case-dossier owner). Folded into provider-visible systemPrompt at send.
     const readingMaterials: unknown[] = [];
@@ -656,6 +617,15 @@ export async function prepareRoleEnvelope(options: {
       throw new Error(`terminating tool not registered after activation: ${terminatingToolName}`);
     }
     const jsonSchema = terminatingToolJsonSchema(terminating.parameters);
+
+    if (request.host === "codex" && hostMethodSkills(request.methods).length > 0) {
+      const packageRoot = options.dependencies.packageRoot;
+      if (typeof packageRoot !== "string" || packageRoot === "") {
+        throw new Error("codex project Skill catalog requires packageRoot");
+      }
+      await installWorkspaceMethodSkills(request.cwd, packageRoot);
+    }
+
     return {
       mcpServers: [{
         name: `ak-${request.activation.role}`,

package/src/role-runtime-dependencies.ts

@@ -10,8 +10,15 @@ import { loadNavigatorWorkContext } from "./navigator-work-context.ts";
 import { loadNotarySourceRunLocator } from "./notary-source-run.ts";
 import { loadPackagedCanonicalSkillBinding } from "./package-resources/method-skill-binding.ts";
 import { formatNavigatorRoleHelp, type RoleRuntimeDependencies } from "./role-runtime.ts";
-import { loadAuditorSoulFromSubjectInput } from "./auditor-soul.ts";
-import { loadGatekeeperSessionMaterials, loadMainRoleSessionMaterials } from "./session-opening-materials.ts";
+import {
+  loadAuditorReferenceMaterialsFromSubjectInput,
+  loadAuditorSoulFromSubjectInput,
+} from "./auditor-soul.ts";
+import {
+  loadGatekeeperSessionMaterials,
+  loadMainRoleReferenceMaterials,
+  loadMainRoleSessionMaterials,
+} from "./session-opening-materials.ts";
 
 const navigatorRoutePlaybookPath = fileURLToPath(
   new URL("../resources/navigator-route-playbook.md", import.meta.url),
@@ -20,12 +27,20 @@ const collectorHandbookSeedPath = fileURLToPath(
   new URL("../resources/collector-bot-handbook.md", import.meta.url),
 );
 
+/** Single packaged source for reference materials across production composition roots. */
+export function loadPackagedRoleReferenceMaterials(role: Parameters<NonNullable<RoleRuntimeDependencies["loadRoleReferenceMaterials"]>>[0]): Promise<string> {
+  return role === "auditor"
+    ? loadAuditorReferenceMaterialsFromSubjectInput()
+    : loadMainRoleReferenceMaterials(role);
+}
+
 /** Host-neutral packaged role runtime deps for the parent-process envelope. */
 export function createRoleRuntimeDependencies(packageRoot: string): RoleRuntimeDependencies {
   const doctorAuditor = createPiDoctorAuditor();
   const navigatorSessionFactory = createNativeNavigatorSessionFactory();
   return {
     packageRoot,
+    loadRoleReferenceMaterials: loadPackagedRoleReferenceMaterials,
     loadJudgeSoul: () => loadMainRoleSessionMaterials("judge"),
     loadFixerSoul: () => loadMainRoleSessionMaterials("fixer"),
     loadFixPacket: (path) => readFile(path, "utf8"),

package/src/role-runtime.ts

@@ -580,6 +580,8 @@ type NavigatorAttendanceDependency = Omit<NavigatorAttendance, "knownRoutePlaybo
 export type RoleRuntimeDependencies = {
   /** Package root for packaged engine-note resolution (#879). */
   packageRoot?: string;
+  /** Non-identity opening materials delivered in the ordinary role brief. */
+  loadRoleReferenceMaterials?(role: PackagedRole): Promise<string>;
   loadJudgeSoul(): Promise<string>;
   loadFixerSoul?(): Promise<string>;
   loadFixPacket?(path: string): Promise<string>;
@@ -1266,7 +1268,8 @@ export function createRoleRuntimeExtension(
     });
 
     let admitted = false;
-    let selectedRole: string | undefined;
+    let selectedRole: PackagedRole | undefined;
+    let roleReferenceMaterials = "";
     /** Live Reviewer parent activation for envelope agent_start prompt assembly. */
     let activeReviewerParent: ReviewerActivation | undefined;
     /** Envelope-owned Reviewer Skill expansion state (ADR 0018 — not a role-module facade). */
@@ -1379,14 +1382,14 @@ export function createRoleRuntimeExtension(
             activeReviewerParent.skillBinding.name,
             text,
           ) ?? text;
-        return text === event.text
-          ? { action: "continue" as const }
-          : { action: "transform" as const, text };
       }
-      return text === event.text
-        ? { action: "continue" as const }
-        : { action: "transform" as const, text };
+      return { action: "continue" as const };
     });
+    // Reference law/guides use the existing typed reading-material channel;
+    // they are not rewritten into operator dialogue or the identity Soul.
+    roleHost.on("before_agent_start", () => roleReferenceMaterials === ""
+      ? undefined
+      : { readingMaterial: { kind: "role-reference-materials", content: roleReferenceMaterials } });
     roleHost.on("before_agent_start", async (event, ctx) => {
       const role = roleHost.getFlag(ROLE_FLAG.name);
       const prompt = event.prompt;
@@ -2070,6 +2073,7 @@ export function createRoleRuntimeExtension(
       }
       admitted = false;
       selectedRole = undefined;
+      roleReferenceMaterials = "";
       activeReviewerParent = undefined;
       reviewerOriginalRequest = undefined;
       reviewerExpansionCaptured = false;
@@ -2230,6 +2234,7 @@ export function createRoleRuntimeExtension(
         }
 
         await executeActivationStage(entry.role, activationStage(entry.role, runtime), { clock, writeTrace });
+        roleReferenceMaterials = await dependencies.loadRoleReferenceMaterials?.(entry.role) ?? "";
         // #357 T2 / #378 / #380 / #391 / #818: any role+engine activation registers the package detour tool once.
         // Gate is resolveEngineName (RoleHost flag → env fallback) — no per-engine execute branch; no role-module spawn.
         if (!engineDetourRegistered) {

package/src/session-opening-materials.ts

@@ -50,12 +50,28 @@ export async function joinPackageMaterials(
   relativePaths: readonly string[],
 ): Promise<string> {
   const chunks: string[] = [];
-  for (const relativePath of relativePaths) {
-    chunks.push(await readPackageMaterial(relativePath));
-  }
+  for (const relativePath of relativePaths) chunks.push(await readPackageMaterial(relativePath));
   return chunks.join("\n\n");
 }
 
+function roleSoulPath(role: string, materials: readonly string[]): string {
+  const suffix = `/souls/${role}.md`;
+  const path = materials.find((candidate) => `/${candidate}`.endsWith(suffix));
+  if (path === undefined) throw new Error(`session materials omit the ${role} Soul`);
+  return path;
+}
+
+async function loadSeparatedSessionPart(
+  role: string,
+  materials: readonly string[],
+  part: "soul" | "references",
+): Promise<string> {
+  const soul = roleSoulPath(role, materials);
+  return part === "soul"
+    ? readPackageMaterial(soul)
+    : joinPackageMaterials(materials.filter((path) => path !== soul));
+}
+
 type PublicRoleMaterials = {
   readonly [Role in PackagedRole]: Extract<
     (typeof PUBLIC_ROLE_RECORDS)[number],
@@ -72,10 +88,12 @@ export const MAIN_ROLE_SESSION_MATERIALS = {
 
 export type MainRoleSession = keyof typeof MAIN_ROLE_SESSION_MATERIALS;
 
-export function loadMainRoleSessionMaterials(
-  role: MainRoleSession,
-): Promise<string> {
-  return joinPackageMaterials(MAIN_ROLE_SESSION_MATERIALS[role]);
+export function loadMainRoleSessionMaterials(role: MainRoleSession): Promise<string> {
+  return loadSeparatedSessionPart(role, MAIN_ROLE_SESSION_MATERIALS[role], "soul");
+}
+
+export function loadMainRoleReferenceMaterials(role: MainRoleSession): Promise<string> {
+  return loadSeparatedSessionPart(role, MAIN_ROLE_SESSION_MATERIALS[role], "references");
 }
 
 /** Gatekeeper province; notary reuses the public notary materials definition. */
@@ -88,8 +106,6 @@ export const GATEKEEPER_SESSION_MATERIALS = {
 
 export type GatekeeperSessionRole = keyof typeof GATEKEEPER_SESSION_MATERIALS;
 
-export function loadGatekeeperSessionMaterials(
-  role: GatekeeperSessionRole,
-): Promise<string> {
-  return joinPackageMaterials(GATEKEEPER_SESSION_MATERIALS[role]);
+export function loadGatekeeperSessionMaterials(role: GatekeeperSessionRole): Promise<string> {
+  return loadSeparatedSessionPart(role, GATEKEEPER_SESSION_MATERIALS[role], "soul");
 }