@akagilnc/pi-workflow-roles 0.1.4444 → 0.1.4503

package/dist/headless-host/production-host.js

@@ -1559,10 +1559,10 @@ __export(session_assistant_usage_exports, {
 });
 import { join as join5 } from "node:path";
 async function readAssistantUsageFromSessionFile(sessionFile) {
-  const { readFile: readFile24 } = await import("node:fs/promises");
+  const { readFile: readFile23 } = await import("node:fs/promises");
   let text;
   try {
-    text = await readFile24(sessionFile, "utf8");
+    text = await readFile23(sessionFile, "utf8");
   } catch (error) {
     if (error?.code === "ENOENT") return void 0;
     throw error;
@@ -3801,13 +3801,10 @@ function assertRegisteredHostName(host) {
   }
   throw new Error(`unregistered host: ${host}`);
 }
-var PRIVATE_COMPAT_ENV, DEFAULT_ROLE_TURN_HOST, HOST_DESCRIPTIONS, HEADLESS_HOST_DESCRIPTIONS;
+var DEFAULT_ROLE_TURN_HOST, HOST_DESCRIPTIONS, HEADLESS_HOST_DESCRIPTIONS;
 var init_host_descriptions = __esm({
   "src/host-descriptions.ts"() {
     "use strict";
-    PRIVATE_COMPAT_ENV = Object.fromEntries(
-      ["CLAUDE", "CURSOR", "CODEX"].flatMap((vendor) => ["SKILLS", "RULES", "AGENTS", "MCPS", "HOOKS", "SESSIONS"].map((kind) => [`GROK_${vendor}_${kind}_ENABLED`, "false"]))
-    );
     DEFAULT_ROLE_TURN_HOST = "pi";
     HOST_DESCRIPTIONS = Object.freeze({
       /** Operator home `~/.grok`, native session/load resume, `agent [--model X] stdio`. */
@@ -3820,12 +3817,7 @@ var init_host_descriptions = __esm({
         }),
         modelPassing: "argv",
         boundResume: "session/load",
-        sessionBindingFile: "grok-acp-session.json",
-        childEnv: Object.freeze({
-          ...PRIVATE_COMPAT_ENV,
-          GROK_MEMORY: "0",
-          GROK_SUBAGENTS: "0"
-        })
+        sessionBindingFile: "grok-acp-session.json"
       }),
       /**
        * Operator home `~/.hermes`, native session/load resume, `acp` subcommand.
@@ -3844,7 +3836,6 @@ var init_host_descriptions = __esm({
         modelPassing: "set_model",
         boundResume: "session/load",
         sessionBindingFile: "hermes-acp-session.json",
-        childEnv: Object.freeze({}),
         seatProfileSoul: Object.freeze({
           flag: "-p",
           namePrefix: "ak-",
@@ -3865,12 +3856,7 @@ var init_host_descriptions = __esm({
           // 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"
+          "bypassPermissions"
         ]),
         promptFlag: "-p",
         modelFlag: "--model",
@@ -7172,10 +7158,12 @@ __export(invocation_exports, {
   deriveMergerEnvelopeFromActiveMerge: () => deriveMergerEnvelopeFromActiveMerge,
   ensureRunArtifactsDir: () => ensureRunArtifactsDir,
   freezeAttachmentsIntoRun: () => freezeAttachmentsIntoRun,
+  freezePreparedAttachmentsIntoRun: () => freezePreparedAttachmentsIntoRun,
   homeFromRunDirectory: () => homeFromRunDirectory,
   isReviewerLens: () => isReviewerLens,
   issueAdmissionPlacement: () => issueAdmissionPlacement,
   loadAdmittedJudgeRequest: () => loadAdmittedJudgeRequest,
+  materializeCountersignInvocation: () => materializeCountersignInvocation,
   observeLaunchedRolePackageIdentity: () => observeLaunchedRolePackageIdentity,
   parseAnalystArgv: () => parseAnalystArgv,
   parseAnalystCohortIssueToken: () => parseAnalystCohortIssueToken,
@@ -7199,6 +7187,7 @@ __export(invocation_exports, {
   parseReviewerArgv: () => parseReviewerArgv,
   parseSecretariatArgv: () => parseSecretariatArgv,
   persistAdmittedSourceRunPath: () => persistAdmittedSourceRunPath,
+  recordAdmittedCorrelation: () => recordAdmittedCorrelation,
   recordEffectiveInvocationModel: () => recordEffectiveInvocationModel,
   recordLaunchedPiIdentity: () => recordLaunchedPiIdentity,
   recordLaunchedRolePackageIdentity: () => recordLaunchedRolePackageIdentity,
@@ -7207,17 +7196,21 @@ __export(invocation_exports, {
   requireReviewerBaseRevision: () => requireReviewerBaseRevision,
   requireReviewerLens: () => requireReviewerLens,
   resolveDoctorCaseRunsPath: () => resolveDoctorCaseRunsPath,
-  resolveGitHubRemoteRepository: () => resolveGitHubRemoteRepository
+  resolveGitHubRemoteRepository: () => resolveGitHubRemoteRepository,
+  withPreparedAttachments: () => withPreparedAttachments
 });
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync5 } from "node:fs";
 import {
   lstat as lstat4,
+  mkdtemp as mkdtemp2,
   readFile as readFile11,
   realpath as realpath5,
   rename,
+  rm as rm2,
   writeFile as writeFile5
 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
 import { basename as basename6, dirname as dirname9, isAbsolute as isAbsolute7, join as join15, resolve as resolve9, sep as sep4 } from "node:path";
 function issueAdmissionPlacement(authority, request) {
   const ledgerHome = resolveActivationLedgerHome(request.home);
@@ -7228,7 +7221,7 @@ function issueAdmissionPlacement(authority, request) {
     runId: request.runId,
     role: request.role
   });
-  ensureRoleRunPlacement(ledgerHome, placement);
+  if (request.materialize !== false) ensureRoleRunPlacement(ledgerHome, placement);
   return {
     principal: authority.seal(placement),
     ...placement,
@@ -7353,6 +7346,31 @@ async function bindAdmittedTicketNumber(admitted, ticketNumber) {
   await bindTicketNumberOnRunDirectory(admitted.runDirectory, ticketNumber);
   admitted.ticketNumber = ticketNumber;
 }
+async function recordAdmittedCorrelation(admitted, correlationId) {
+  const current = JSON.parse(
+    await readFile11(admitted.admittedRequestPath, "utf8")
+  );
+  const prior = [
+    ...Array.isArray(current.correlationIds) ? current.correlationIds.filter(
+      (value) => typeof value === "string" && value.trim() !== ""
+    ) : [],
+    ...typeof current.correlationId === "string" && current.correlationId.trim() !== "" ? [current.correlationId] : []
+  ];
+  const correlationIds = [.../* @__PURE__ */ new Set([...prior, correlationId])];
+  await writeFile5(
+    admitted.admittedRequestPath,
+    `${JSON.stringify({ ...current, correlationId, correlationIds }, null, 2)}
+`,
+    "utf8"
+  );
+  await mergeInvocationIdentityPage(admitted.runDirectory, {
+    correlationId,
+    correlationIds
+  });
+  const mutable = admitted;
+  mutable.correlationId = correlationId;
+  mutable.correlationIds = correlationIds;
+}
 async function bindCourtTicketNumbersOnAdmitted(admitted, courtTicketNumbers) {
   if (admitted.ticketNumber === void 0) {
     throw new Error(
@@ -7743,7 +7761,7 @@ function parseFixerArgv(args) {
     ...project === void 0 ? {} : { project }
   };
 }
-async function freezeRegularFileAttachment(sourcePath, destinationDir, index) {
+async function readRegularFileAttachment(sourcePath) {
   const absolute = isAbsolute7(sourcePath) ? sourcePath : resolve9(sourcePath);
   let st;
   try {
@@ -7759,18 +7777,72 @@ async function freezeRegularFileAttachment(sourcePath, destinationDir, index) {
       `attachment must be a regular file (not a directory or symlink): ${sourcePath}`
     );
   }
-  const bytes = await readFile11(absolute);
-  const name = `${String(index).padStart(2, "0")}-${basename6(absolute)}`;
-  const frozenPath = join15(destinationDir, name);
+  try {
+    return { absolute, bytes: await readFile11(absolute) };
+  } catch (error) {
+    throw new CliUsageError(
+      `attachment is not a readable regular file: ${sourcePath}`,
+      { cause: error }
+    );
+  }
+}
+async function removePreparedAttachmentDirectory(stagingDirectory) {
+  await rm2(stagingDirectory, { recursive: true, force: true });
+}
+async function withPreparedAttachments(attachmentPaths, use) {
+  if (attachmentPaths.length === 0) return await use([]);
+  const stagingDirectory = await mkdtemp2(join15(tmpdir2(), "ak-role-attachments-"));
+  const prepared = [];
+  let result;
+  try {
+    for (let index = 0; index < attachmentPaths.length; index += 1) {
+      const { absolute, bytes } = await readRegularFileAttachment(attachmentPaths[index]);
+      const snapshotPath = join15(stagingDirectory, String(index).padStart(6, "0"));
+      await writeFile5(snapshotPath, bytes);
+      prepared.push({ absolute, snapshotPath });
+    }
+    result = await use(prepared);
+  } catch (primary) {
+    try {
+      await removePreparedAttachmentDirectory(stagingDirectory);
+    } catch (cleanup) {
+      throw new AggregateError(
+        [primary, cleanup],
+        "attachment snapshot operation failed and cleanup also failed",
+        { cause: primary }
+      );
+    }
+    throw primary;
+  }
+  await removePreparedAttachmentDirectory(stagingDirectory);
+  return result;
+}
+async function freezeAttachmentBytes(provenancePath, bytes, destinationDir, index) {
+  const frozenPath = join15(
+    destinationDir,
+    `${String(index).padStart(2, "0")}-${basename6(provenancePath)}`
+  );
   await writeFile5(frozenPath, bytes);
   return {
-    attachment: {
-      provenancePath: absolute,
-      frozenPath,
-      byteLength: bytes.byteLength,
-      sha256: sha256Hex(bytes),
-      mediaKind: "regular-file"
-    },
+    provenancePath,
+    frozenPath,
+    byteLength: bytes.byteLength,
+    sha256: sha256Hex(bytes),
+    mediaKind: "regular-file"
+  };
+}
+async function freezePreparedAttachment(prepared, destinationDir, index) {
+  return freezeAttachmentBytes(
+    prepared.absolute,
+    await readFile11(prepared.snapshotPath),
+    destinationDir,
+    index
+  );
+}
+async function freezeRegularFileAttachment(sourcePath, destinationDir, index) {
+  const { absolute, bytes } = await readRegularFileAttachment(sourcePath);
+  return {
+    attachment: await freezeAttachmentBytes(absolute, bytes, destinationDir, index),
     body: bytes
   };
 }
@@ -7793,6 +7865,17 @@ async function freezeAttachmentsIntoRun(attachmentPaths, runDirectory, summonsKe
   ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
   return freezeAttachments(attachmentPaths, attachmentsDirectory);
 }
+async function freezePreparedAttachmentsIntoRun(prepared, runDirectory, summonsKey) {
+  if (prepared.length === 0) return [];
+  const ledgerHome = resolveActivationLedgerHome(homeFromRunDirectory(runDirectory));
+  const attachmentsDirectory = summonsKey === void 0 ? join15(runDirectory, "attachments") : join15(runDirectory, "attachments", summonsKey);
+  ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
+  const attachments = [];
+  for (let index = 0; index < prepared.length; index += 1) {
+    attachments.push(await freezePreparedAttachment(prepared[index], attachmentsDirectory, index));
+  }
+  return attachments;
+}
 function ticketAdmissionFields(ticketNumber) {
   if (ticketNumber === void 0) return {};
   return {
@@ -7932,9 +8015,10 @@ async function admitCountersignInvocation(options) {
     runId,
     role: "countersign",
     subject: { unbound: true },
-    home: options.home
+    home: options.home,
+    materialize: options.deferPersistence !== true
   });
-  const attachments = await freezeAttachments(options.attachmentPaths, attachmentsDirectory);
+  const attachments = options.deferPersistence === true ? [] : await freezeAttachments(options.attachmentPaths, attachmentsDirectory);
   const instruction = options.instruction;
   const instructionEmpty = instruction.trim() === "";
   const admitted = {
@@ -7956,11 +8040,13 @@ async function admitCountersignInvocation(options) {
     }))
   };
   const admittedRequestPath = join15(runDirectory, "admitted-request.json");
-  await writeAdmittedRequestPersistence(admittedRequestPath, admitted, {
-    sessionDirectory,
-    sessionFile
-  });
-  await writeRoleInvocationLedger({ ...admitted, sessionDirectory, sessionFile }, admitted.role, options.model);
+  if (options.deferPersistence !== true) {
+    await writeAdmittedRequestPersistence(admittedRequestPath, admitted, {
+      sessionDirectory,
+      sessionFile
+    });
+    await writeRoleInvocationLedger({ ...admitted, sessionDirectory, sessionFile }, admitted.role, options.model);
+  }
   return {
     role: "countersign",
     runId,
@@ -7975,6 +8061,29 @@ async function admitCountersignInvocation(options) {
     ...options.correlationId === void 0 ? {} : { correlationId: options.correlationId }
   };
 }
+async function materializeCountersignInvocation(admitted, options) {
+  const placement = issueAdmissionPlacement(options.principalAuthority, {
+    cwd: admitted.projectRoot,
+    runId: admitted.runId,
+    role: "countersign",
+    subject: { unbound: true },
+    home: options.home
+  });
+  const attachments = await freezePreparedAttachmentsIntoRun(
+    options.preparedAttachments,
+    admitted.runDirectory
+  );
+  admitted.attachments = attachments;
+  await writeAdmittedRequestPersistence(admitted.admittedRequestPath, admitted, {
+    sessionDirectory: placement.sessionDirectory,
+    sessionFile: placement.sessionFile
+  });
+  await writeRoleInvocationLedger(
+    { ...admitted, sessionDirectory: placement.sessionDirectory, sessionFile: placement.sessionFile },
+    admitted.role,
+    options.model
+  );
+}
 function buildCountersignTransportPrompt(admitted, engineMaterial) {
   return buildInstructionTransportPrompt(admitted, engineMaterial);
 }
@@ -10765,10 +10874,10 @@ function pairGateRounds(volumes) {
   return rounds.sort((a, b) => a.officerStartedAt.localeCompare(b.officerStartedAt)).map((round, index) => ({ ...round, roundIndex: index + 1 }));
 }
 async function resolveOfficerSessionFromPointerFile(pointerPath) {
-  const { readFile: readFile24 } = await import("node:fs/promises");
+  const { readFile: readFile23 } = await import("node:fs/promises");
   let raw;
   try {
-    raw = JSON.parse(await readFile24(pointerPath, "utf8"));
+    raw = JSON.parse(await readFile23(pointerPath, "utf8"));
   } catch (error) {
     throw new Error(
       `direct officer run pointer unreadable in ${pointerPath}: ${error instanceof Error ? error.message : String(error)}`,
@@ -11369,16 +11478,27 @@ async function readPackageMaterial(relativePath) {
 }
 async function joinPackageMaterials(relativePaths) {
   const chunks = [];
-  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, materials) {
+  const suffix = `/souls/${role}.md`;
+  const path = materials.find((candidate) => `/${candidate}`.endsWith(suffix));
+  if (path === void 0) throw new Error(`session materials omit the ${role} Soul`);
+  return path;
+}
+async function loadSeparatedSessionPart(role, materials, part) {
+  const soul = roleSoulPath(role, materials);
+  return part === "soul" ? readPackageMaterial(soul) : joinPackageMaterials(materials.filter((path) => path !== soul));
+}
 function loadMainRoleSessionMaterials(role) {
-  return joinPackageMaterials(MAIN_ROLE_SESSION_MATERIALS[role]);
+  return loadSeparatedSessionPart(role, MAIN_ROLE_SESSION_MATERIALS[role], "soul");
+}
+function loadMainRoleReferenceMaterials(role) {
+  return loadSeparatedSessionPart(role, MAIN_ROLE_SESSION_MATERIALS[role], "references");
 }
 function loadGatekeeperSessionMaterials(role) {
-  return joinPackageMaterials(GATEKEEPER_SESSION_MATERIALS[role]);
+  return loadSeparatedSessionPart(role, GATEKEEPER_SESSION_MATERIALS[role], "soul");
 }
 var packageRootUrl, MAIN_ROLE_SESSION_MATERIALS, GATEKEEPER_SESSION_MATERIALS;
 var init_session_opening_materials = __esm({
@@ -11408,6 +11528,8 @@ __export(auditor_soul_exports, {
   AUDITOR_SESSION_MATERIALS: () => AUDITOR_SESSION_MATERIALS,
   AUDITOR_SOUL_ROLES: () => AUDITOR_SOUL_ROLES,
   isAuditorSoulRole: () => isAuditorSoulRole,
+  loadAuditorReferenceMaterials: () => loadAuditorReferenceMaterials,
+  loadAuditorReferenceMaterialsFromSubjectInput: () => loadAuditorReferenceMaterialsFromSubjectInput,
   loadAuditorSoul: () => loadAuditorSoul,
   loadAuditorSoulFromSubjectInput: () => loadAuditorSoulFromSubjectInput,
   resolveAuditorSubject: () => resolveAuditorSubject
@@ -11434,11 +11556,18 @@ async function loadAuditorSoul(role) {
   if (soul.trim().length === 0) {
     throw new Error(`The ${role} auditor Soul is blank`);
   }
-  return joinPackageMaterials(materials);
+  return soul;
+}
+function loadAuditorReferenceMaterials(role) {
+  const soulPath = auditorSoulRelativePath(role);
+  return joinPackageMaterials(AUDITOR_SESSION_MATERIALS[role].filter((path) => path !== soulPath));
 }
 async function loadAuditorSoulFromSubjectInput(raw) {
   return loadAuditorSoul(resolveAuditorSubject(raw));
 }
+function loadAuditorReferenceMaterialsFromSubjectInput(raw) {
+  return loadAuditorReferenceMaterials(resolveAuditorSubject(raw));
+}
 var AUDITOR_SOUL_ROLES, AK_ROLE_AUDITOR_SUBJECT_ENV, AK_ROLE_AUDITOR_SOURCE_RUN_ENV, AUDITOR_SESSION_MATERIALS;
 var init_auditor_soul = __esm({
   "src/auditor-soul.ts"() {
@@ -16927,8 +17056,8 @@ __export(case_dossier_delivery_exports, {
   loadCaseDossierReadingMaterial: () => loadCaseDossierReadingMaterial,
   projectCaseDossierPointerSection: () => projectCaseDossierPointerSection
 });
-import { mkdtemp as mkdtemp2, readFile as readFile19, rm as rm2, writeFile as writeFile9 } from "node:fs/promises";
-import { tmpdir as tmpdir2 } from "node:os";
+import { mkdtemp as mkdtemp3, readFile as readFile19, rm as rm3, writeFile as writeFile9 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
 import { join as join29 } from "node:path";
 async function projectCaseDossierPointerSection(input) {
   if (input.ticketNumber === void 0) {
@@ -16956,7 +17085,7 @@ async function deliverCaseDossierAsAttachment(input) {
     projectRoot: input.projectRoot,
     home: input.home
   });
-  const stagingDir = await mkdtemp2(join29(tmpdir2(), "ak-case-dossier-"));
+  const stagingDir = await mkdtemp3(join29(tmpdir3(), "ak-case-dossier-"));
   try {
     const stagingPath = join29(stagingDir, CASE_DOSSIER_ATTACH_FILE);
     await writeFile9(stagingPath, `${section}
@@ -16967,7 +17096,7 @@ async function deliverCaseDossierAsAttachment(input) {
       CASE_DOSSIER_ATTACH_KEY
     );
   } finally {
-    await rm2(stagingDir, { recursive: true, force: true });
+    await rm3(stagingDir, { recursive: true, force: true });
   }
 }
 async function loadCaseDossierReadingMaterial(runDirectory) {
@@ -19269,6 +19398,9 @@ function diaristAdapters(env) {
     shouldPresentSettled: () => true,
     // Resume interrupted state: board ticket already on pages, run still under unbound/.
     beforeDispatch: async (admitted, lease) => {
+      if (env.correlationId !== void 0 && env.correlationId.trim() !== "") {
+        await recordAdmittedCorrelation(admitted, env.correlationId);
+      }
       await bindAndRelocateDiaristIfBoardBound(admitted, env.principalAuthority, lease);
     },
     // First post-turn assert: accept hook wrote board pages; relocate before lease release.
@@ -19453,7 +19585,8 @@ function courtDiaristEscalated(roleOutcome) {
   if (roleOutcome.kind === "audit_escalation") return true;
   if (roleOutcome.kind !== "accepted") return false;
   return (roleOutcome.payloads ?? []).some((payload) => {
-    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return false;
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload))
+      return false;
     const record4 = payload;
     return record4.status === "escalate" || record4.countersignStatus === "escalate";
   });
@@ -19506,7 +19639,10 @@ async function invokeCourtDiarist(input, env, io) {
   }
   const asserted = result.admitted?.ticketNumber;
   if (isSafePositiveTicketNumber(asserted)) {
-    const courtTicketNumbers = courtTicketNumbersFromOutcome(roleOutcome, asserted);
+    const courtTicketNumbers = courtTicketNumbersFromOutcome(
+      roleOutcome,
+      asserted
+    );
     return {
       identity: {
         kind: "ticket",
@@ -19555,7 +19691,9 @@ async function runCountersignCourtDiaristStation(admitted, env, io) {
       );
     }
     if (outcome.failedWithoutEscalate !== void 0) {
-      throw new StationChildExhaustedError(outcome.failedWithoutEscalate.diagnostic);
+      throw new StationChildExhaustedError(
+        outcome.failedWithoutEscalate.diagnostic
+      );
     }
   }
 }
@@ -19581,7 +19719,8 @@ async function runPublicCountersign(argv, env, io, parseCountersignArgv2) {
       ...parsed.project === void 0 ? {} : { project: parsed.project },
       ...env.createRunId === void 0 ? {} : { createRunId: env.createRunId },
       ...env.model === void 0 ? {} : { model: env.model },
-      ...env.correlationId === void 0 ? {} : { correlationId: env.correlationId }
+      ...env.correlationId === void 0 ? {} : { correlationId: env.correlationId },
+      deferPersistence: true
     });
   } catch (error) {
     if (error instanceof CliUsageError) {
@@ -19590,160 +19729,216 @@ async function runPublicCountersign(argv, env, io, parseCountersignArgv2) {
     }
     throw error;
   }
-  await markRunAdmitted(admitted, env.principalAuthority);
-  let typedTicket;
-  let typedCourtTicketNumbers;
-  let identityDiaristRan = false;
-  if (env.runCourtDiaristStation === void 0) {
-    const outcome = await invokeCourtDiarist(
-      {
-        instruction: parsed.instruction,
-        projectRoot: admitted.projectRoot,
-        failureLabel: "unbound summons",
-        correlationId: admitted.runId
-      },
-      env,
-      io
-    );
-    identityDiaristRan = true;
-    if (outcome.identity.kind === "escalate") {
-      return await presentControlledFailure2(
-        admitted,
-        {
-          timedOut: false,
-          code: null,
-          stderr: "",
-          thrown: new Error(
-            "court diarist station escalated (cannot identify court target)"
-          )
-        },
-        countersignAdapters(),
-        env.principalAuthority,
-        io
-      );
-    }
-    if (outcome.failedWithoutEscalate !== void 0) {
-      return await presentControlledFailure2(
-        admitted,
-        {
-          timedOut: false,
-          code: null,
-          stderr: "",
-          thrown: new Error(outcome.failedWithoutEscalate.diagnostic)
-        },
-        countersignAdapters(),
-        env.principalAuthority,
-        io
-      );
-    }
-    if (outcome.identity.kind === "ticket") {
-      const assertedTicket = outcome.identity.ticketNumber;
-      typedTicket = assertedTicket;
-      typedCourtTicketNumbers = outcome.identity.courtTicketNumbers;
-      const summons = {
-        instruction: parsed.instruction,
-        instructionEmpty: parsed.instruction.trim() === "",
-        attachmentPaths: parsed.attachmentPaths
-      };
-      const resumed = await tryResumeSameTicketSeatRun({
-        home: env.home,
-        projectRoot: admitted.projectRoot,
-        role: "countersign",
-        ticketNumber: typedTicket,
-        freshSummons: env.freshSummons,
-        summons,
-        resume: async (runId, materials) => {
-          await bindAdmittedTicketNumber(admitted, assertedTicket);
-          await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
-          await markRunTerminal(admitted.runDirectory);
-          return await runPublicCountersignResume(
-            {
-              runId,
-              ...materials === void 0 ? {} : { summons: materials }
-            },
-            {
-              ...env,
-              ...typedCourtTicketNumbers === void 0 ? {} : { pendingCourtTicketNumbers: typedCourtTicketNumbers }
-            },
-            io
-          );
+  try {
+    return await withPreparedAttachments(
+      parsed.attachmentPaths,
+      async (preparedAttachments) => {
+        const materializeAdmission = async () => {
+          await materializeCountersignInvocation(admitted, {
+            home: env.home,
+            principalAuthority: env.principalAuthority,
+            preparedAttachments,
+            ...env.model === void 0 ? {} : { model: env.model }
+          });
+        };
+        let typedTicket;
+        let typedCourtTicketNumbers;
+        let identityDiaristRan = false;
+        if (env.runCourtDiaristStation === void 0) {
+          let outcome;
+          try {
+            outcome = await invokeCourtDiarist(
+              {
+                instruction: parsed.instruction,
+                projectRoot: admitted.projectRoot,
+                failureLabel: "unbound summons"
+              },
+              env,
+              io
+            );
+          } catch (error) {
+            await materializeAdmission();
+            await markRunAdmitted(admitted, env.principalAuthority);
+            return await presentControlledFailure2(
+              admitted,
+              { timedOut: false, code: null, stderr: "", thrown: error },
+              countersignAdapters(),
+              env.principalAuthority,
+              io
+            );
+          }
+          identityDiaristRan = true;
+          if (outcome.identity.kind === "escalate") {
+            await materializeAdmission();
+            await markRunAdmitted(admitted, env.principalAuthority);
+            return await presentControlledFailure2(
+              admitted,
+              {
+                timedOut: false,
+                code: null,
+                stderr: "",
+                thrown: new Error(
+                  "court diarist station escalated (cannot identify court target)"
+                )
+              },
+              countersignAdapters(),
+              env.principalAuthority,
+              io
+            );
+          }
+          if (outcome.failedWithoutEscalate !== void 0) {
+            await materializeAdmission();
+            await markRunAdmitted(admitted, env.principalAuthority);
+            return await presentControlledFailure2(
+              admitted,
+              {
+                timedOut: false,
+                code: null,
+                stderr: "",
+                thrown: new Error(outcome.failedWithoutEscalate.diagnostic)
+              },
+              countersignAdapters(),
+              env.principalAuthority,
+              io
+            );
+          }
+          if (outcome.identity.kind === "ticket") {
+            const assertedTicket = outcome.identity.ticketNumber;
+            typedTicket = assertedTicket;
+            typedCourtTicketNumbers = outcome.identity.courtTicketNumbers;
+            const summons = {
+              instruction: parsed.instruction,
+              instructionEmpty: parsed.instruction.trim() === ""
+            };
+            const resumed = await tryResumeSameTicketSeatRun({
+              home: env.home,
+              projectRoot: admitted.projectRoot,
+              role: "countersign",
+              ticketNumber: typedTicket,
+              freshSummons: env.freshSummons,
+              summons,
+              resume: async (runId, materials) => {
+                const retained = await loadResumableCountersignRun(
+                  env.home,
+                  runId,
+                  env.principalAuthority
+                );
+                if (retained.admitted === void 0) {
+                  throw new Error(
+                    `retained countersign run disappeared before resume: ${runId}`
+                  );
+                }
+                const frozenPaths = (await freezePreparedAttachmentsIntoRun(
+                  preparedAttachments,
+                  retained.admitted.runDirectory,
+                  `s-${Date.now().toString(36)}`
+                )).map((attachment) => attachment.frozenPath);
+                const preparedMaterials = {
+                  ...materials ?? {},
+                  ...frozenPaths.length === 0 ? {} : { attachmentPaths: frozenPaths }
+                };
+                return await runPublicCountersignResume(
+                  {
+                    runId,
+                    summons: preparedMaterials
+                  },
+                  {
+                    ...env,
+                    ...typedCourtTicketNumbers === void 0 ? {} : { pendingCourtTicketNumbers: typedCourtTicketNumbers }
+                  },
+                  io
+                );
+              }
+            });
+            if (resumed !== void 0) {
+              return resumed;
+            }
+          }
         }
-      });
-      if (resumed !== void 0) {
-        return resumed;
-      }
-    }
-  }
-  if (identityDiaristRan && typedTicket !== void 0) {
-    try {
-      await bindAdmittedTicketNumber(admitted, typedTicket);
-      await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
-      await bindCourtTicketNumbersOnAdmitted(
-        admitted,
-        typedCourtTicketNumbers ?? [typedTicket]
-      );
-    } catch (error) {
-      return await presentControlledFailure2(
-        admitted,
-        {
-          timedOut: false,
-          code: null,
-          stderr: "",
-          thrown: error
-        },
-        countersignAdapters(),
-        env.principalAuthority,
-        io
-      );
-    }
-  }
-  const turnProjection = {
-    packageRoot: env.packageRoot,
-    home: env.home,
-    agentDir: env.agentDir,
-    ...env.model === void 0 ? {} : { model: env.model },
-    ...pickEngineAxis(env),
-    ...env.timeoutMs === void 0 ? {} : { timeoutMs: env.timeoutMs },
-    ...env.correlationId === void 0 || env.correlationId.trim() === "" ? {} : { correlationId: env.correlationId },
-    continuation: {
-      kind: "initial",
-      prompt: buildCountersignTransportPrompt(
-        admitted,
-        engineSessionMaterialFromOptions({
-          ...pickEngineAxis(env),
-          packageRoot: env.packageRoot
-        })
-      )
-    }
-  };
-  const turnRequest = buildCountersignTurnRequest(admitted, turnProjection);
-  const result = await runPostAdmissionOneShot({
-    admitted,
-    env,
-    io,
-    request: turnRequest,
-    adapters: countersignAdapters({
-      beforeDispatch: async (admittedSeat, lease) => {
-        if (!identityDiaristRan) {
-          await runCountersignCourtDiaristStation(admittedSeat, env, io);
-        } else if (typedTicket !== void 0) {
-          await runCountersignCourtDiaristStation(admittedSeat, env, io);
+        await materializeAdmission();
+        await markRunAdmitted(admitted, env.principalAuthority);
+        if (identityDiaristRan && typedTicket !== void 0) {
+          try {
+            await bindAdmittedTicketNumber(admitted, typedTicket);
+            await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
+            await bindCourtTicketNumbersOnAdmitted(
+              admitted,
+              typedCourtTicketNumbers ?? [typedTicket]
+            );
+          } catch (error) {
+            return await presentControlledFailure2(
+              admitted,
+              {
+                timedOut: false,
+                code: null,
+                stderr: "",
+                thrown: error
+              },
+              countersignAdapters(),
+              env.principalAuthority,
+              io
+            );
+          }
         }
-        await relocateAdmittedRunToTicket(
-          admittedSeat,
-          env.principalAuthority,
-          lease
-        );
-        Object.assign(
-          turnRequest,
-          buildCountersignTurnRequest(admittedSeat, turnProjection)
+        const turnProjection = {
+          packageRoot: env.packageRoot,
+          home: env.home,
+          agentDir: env.agentDir,
+          ...env.model === void 0 ? {} : { model: env.model },
+          ...pickEngineAxis(env),
+          ...env.timeoutMs === void 0 ? {} : { timeoutMs: env.timeoutMs },
+          ...env.correlationId === void 0 || env.correlationId.trim() === "" ? {} : { correlationId: env.correlationId },
+          continuation: {
+            kind: "initial",
+            prompt: buildCountersignTransportPrompt(
+              admitted,
+              engineSessionMaterialFromOptions({
+                ...pickEngineAxis(env),
+                packageRoot: env.packageRoot
+              })
+            )
+          }
+        };
+        const turnRequest = buildCountersignTurnRequest(
+          admitted,
+          turnProjection
         );
+        const result = await runPostAdmissionOneShot({
+          admitted,
+          env,
+          io,
+          request: turnRequest,
+          adapters: countersignAdapters({
+            beforeDispatch: async (admittedSeat, lease) => {
+              if (!identityDiaristRan) {
+                await runCountersignCourtDiaristStation(admittedSeat, env, io);
+              } else if (typedTicket !== void 0) {
+                await runCountersignCourtDiaristStation(admittedSeat, env, io);
+              }
+              await relocateAdmittedRunToTicket(
+                admittedSeat,
+                env.principalAuthority,
+                lease
+              );
+              Object.assign(
+                turnRequest,
+                buildCountersignTurnRequest(admittedSeat, turnProjection)
+              );
+            }
+          }),
+          ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
+        });
+        await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
+        return result;
       }
-    }),
-    ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
-  });
-  await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
-  return result;
+    );
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
 }
 function countersignAdapters(options) {
   return {
@@ -19781,7 +19976,9 @@ async function runPublicCountersignResume(request, env, io) {
     adapters: countersignAdapters({
       beforeDispatch: async (admitted) => {
         if (admitted.courtTicketNumbersDamage !== void 0) {
-          throw new StationChildExhaustedError(admitted.courtTicketNumbersDamage);
+          throw new StationChildExhaustedError(
+            admitted.courtTicketNumbersDamage
+          );
         }
         if (env.pendingCourtTicketNumbers !== void 0) {
           await bindCourtTicketNumbersOnAdmitted(
@@ -22449,7 +22646,7 @@ import { join as join38, sep as sep5 } from "node:path";
 
 // src/atomic-write.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { rename as rename3, rm as rm3, writeFile as writeFile11 } from "node:fs/promises";
+import { rename as rename3, rm as rm4, writeFile as writeFile11 } from "node:fs/promises";
 import { dirname as dirname22, join as join37 } from "node:path";
 async function writeFileAtomically(destination, contents) {
   const parent = dirname22(destination);
@@ -22458,7 +22655,7 @@ async function writeFileAtomically(destination, contents) {
     await writeFile11(temporary, contents);
     await rename3(temporary, destination);
   } catch (error) {
-    await rm3(temporary, { force: true }).catch(() => void 0);
+    await rm4(temporary, { force: true }).catch(() => void 0);
     throw error;
   }
 }
@@ -25266,6 +25463,7 @@ function createRoleRuntimeExtension(dependencies) {
     });
     let admitted = false;
     let selectedRole;
+    let roleReferenceMaterials = "";
     let activeReviewerParent;
     let reviewerOriginalRequest;
     let reviewerExpansionCaptured = false;
@@ -25359,10 +25557,10 @@ function createRoleRuntimeExtension(dependencies) {
           activeReviewerParent.skillBinding.name,
           text
         ) ?? text;
-        return text === event.text ? { action: "continue" } : { action: "transform", text };
       }
-      return text === event.text ? { action: "continue" } : { action: "transform", text };
+      return { action: "continue" };
     });
+    roleHost.on("before_agent_start", () => roleReferenceMaterials === "" ? void 0 : { 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;
@@ -25928,6 +26126,7 @@ function createRoleRuntimeExtension(dependencies) {
       }
       admitted = false;
       selectedRole = void 0;
+      roleReferenceMaterials = "";
       activeReviewerParent = void 0;
       reviewerOriginalRequest = void 0;
       reviewerExpansionCaptured = false;
@@ -26062,6 +26261,7 @@ function createRoleRuntimeExtension(dependencies) {
           }
         }
         await executeActivationStage(entry.role, activationStage(entry.role, runtime), { clock, writeTrace });
+        roleReferenceMaterials = await dependencies.loadRoleReferenceMaterials?.(entry.role) ?? "";
         if (!engineDetourRegistered) {
           engineDetourRegistered = registerEngineDetourTool(roleHost, hostActions);
         }
@@ -26101,11 +26301,15 @@ var navigatorRoutePlaybookPath = fileURLToPath2(
 var collectorHandbookSeedPath = fileURLToPath2(
   new URL("../resources/collector-bot-handbook.md", import.meta.url)
 );
+function loadPackagedRoleReferenceMaterials(role) {
+  return role === "auditor" ? loadAuditorReferenceMaterialsFromSubjectInput() : loadMainRoleReferenceMaterials(role);
+}
 function createRoleRuntimeDependencies(packageRoot) {
   const doctorAuditor = createPiDoctorAuditor();
   const navigatorSessionFactory = createNativeNavigatorSessionFactory();
   return {
     packageRoot,
+    loadRoleReferenceMaterials: loadPackagedRoleReferenceMaterials,
     loadJudgeSoul: () => loadMainRoleSessionMaterials("judge"),
     loadFixerSoul: () => loadMainRoleSessionMaterials("fixer"),
     loadFixPacket: (path) => readFile22(path, "utf8"),
@@ -26166,9 +26370,9 @@ function createRoleRuntimeDependencies(packageRoot) {
 // src/role-envelope.ts
 init_engine_detour();
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { mkdir as mkdir5, readFile as readFile23, writeFile as writeFile12 } from "node:fs/promises";
+import { mkdir as mkdir6, writeFile as writeFile12 } from "node:fs/promises";
 import { createServer } from "node:net";
-import { basename as basename9, dirname as dirname23, join as join40 } from "node:path";
+import { dirname as dirname24, join as join41 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/gatekeeper-pass-envelope.ts
@@ -26253,25 +26457,68 @@ async function requireGatekeeperPass(options) {
   }
 }
 
+// src/host-native-method.ts
+import { lstat as lstat7, mkdir as mkdir5, readlink, realpath as realpath7, symlink } from "node:fs/promises";
+import { basename as basename9, dirname as dirname23, join as join40 } from "node:path";
+var HOST_METHOD_PLUGIN_NAME = "ak-methods";
+var packagedMethodsDir = (root) => join40(root, "resources", "methods");
+var packagedMethodPluginDir = (root) => join40(root, "dist", "method-host-plugin");
+function hostMethodSkills(methods) {
+  return Object.freeze(methods.flatMap((method) => {
+    if (method.kind !== "skill") return [];
+    const name = basename9(dirname23(method.path));
+    return name ? [Object.freeze({ name })] : [];
+  }));
+}
+var alreadyPrefixed = (prompt, token) => {
+  const text = prompt.trimStart();
+  return text === token || text.startsWith(`${token} `) || text.startsWith(`${token}
+`);
+};
+function prefixMethodInvocation(token, prompt) {
+  if (alreadyPrefixed(prompt, token)) return prompt;
+  return prompt ? `${token} ${prompt}` : token;
+}
+function applyClaudeSkillInvocation(methods, prompt) {
+  const skills = hostMethodSkills(methods);
+  if (skills.length !== 1) return prompt;
+  return prefixMethodInvocation(`/${HOST_METHOD_PLUGIN_NAME}:${skills[0].name}`, prompt);
+}
+function applyCodexSkillInvocation(methods, prompt) {
+  return hostMethodSkills(methods).reduceRight(
+    (invocation, skill) => prefixMethodInvocation(`$${skill.name}`, invocation),
+    prompt
+  );
+}
+async function installWorkspaceMethodSkills(cwd, packageRoot) {
+  const target = await realpath7(packagedMethodsDir(packageRoot));
+  const link = join40(cwd, ".agents", "skills");
+  try {
+    const stat2 = await lstat7(link);
+    if (!stat2.isSymbolicLink() || await realpath7(link) !== target) {
+      const detail = stat2.isSymbolicLink() ? `symlink to ${await readlink(link)}` : "non-symlink entry";
+      throw new Error(`workspace method catalog conflict at ${link}: ${detail}`);
+    }
+    return;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  await mkdir5(dirname23(link), { recursive: true });
+  try {
+    await symlink(target, link);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    if (await realpath7(link).catch(() => "") !== target) {
+      throw new Error(`workspace method catalog conflict at ${link}`);
+    }
+  }
+}
+
 // src/role-envelope.ts
 init_packaged_role_registry();
-init_method_skill();
 init_role_activation_flags();
 init_submission_correctable_error();
 init_navigator_invocation_identity();
-function buildSkillExpansion(methodSkills, prompt) {
-  if (methodSkills.size !== 1) return void 0;
-  const entry = methodSkills.entries().next().value;
-  if (entry === void 0) return void 0;
-  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, path) {
   await new Promise((resolve21, reject) => {
     server.once("error", reject);
@@ -26306,21 +26553,14 @@ async function prepareRoleEnvelope(options) {
   const calls = [];
   const customEntries = [];
   const sessionEntries = [];
-  const methodSkills = /* @__PURE__ */ new Map();
   let preferredTools = [];
   let rejection;
   let infrastructureRoundFailure;
   const hostAbort = new AbortController();
   const runId = request.runDirectory.split("/").filter(Boolean).at(-1) ?? randomUUID8();
-  await mkdir5(request.runDirectory, { recursive: true });
-  for (const method of request.methods) {
-    if (method.kind !== "skill") continue;
-    const name = basename9(dirname23(method.path));
-    const raw = await readFile23(method.path, "utf8");
-    methodSkills.set(name, { path: method.path, body: stripSkillFrontmatter(raw).trim() });
-  }
-  let sessionFile = options.sessionFile ?? join40(request.runDirectory, "session", "session.jsonl");
-  await mkdir5(dirname23(sessionFile), { recursive: true });
+  await mkdir6(request.runDirectory, { recursive: true });
+  let sessionFile = options.sessionFile ?? join41(request.runDirectory, "session", "session.jsonl");
+  await mkdir6(dirname24(sessionFile), { recursive: true });
   if (request.continuation.kind !== "resume") {
     try {
       await writeFile12(
@@ -26351,7 +26591,7 @@ async function prepareRoleEnvelope(options) {
       getLeafEntry: () => sessionEntries.at(-1),
       getLeafId: () => runId,
       getEntries: () => sessionEntries,
-      getSessionDir: () => dirname23(sessionFile),
+      getSessionDir: () => dirname24(sessionFile),
       getSessionFile: () => sessionFile,
       getHeader: () => ({ type: "session", id: runId }),
       setSessionFile(path) {
@@ -26386,8 +26626,9 @@ async function prepareRoleEnvelope(options) {
     deliverSubmissionRejection(_value) {
     },
     capabilities: {
-      skillExpansion(prompt) {
-        return buildSkillExpansion(methodSkills, prompt);
+      // #922: native loaders own expansion; package does not pre-read bodies (ADR 0032).
+      skillExpansion() {
+        return void 0;
       }
     },
     registerFlag(name, definition) {
@@ -26726,10 +26967,9 @@ async function prepareRoleEnvelope(options) {
         message: { role: "user", content: prompt }
       });
     }
-    const methodPrompt = (await Promise.all(request.methods.map(({ path }) => readFile23(path, "utf8")))).join("\n\n");
     const promptResults = await emit("before_agent_start", {
       prompt,
-      systemPrompt: methodPrompt,
+      systemPrompt: "",
       systemPromptOptions: {}
     });
     const systemPromptParts = promptResults.flatMap((value) => {
@@ -26737,7 +26977,7 @@ 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");
     const readingMaterials = [];
     for (const value of promptResults) {
       if (typeof value !== "object" || value === null) continue;
@@ -26750,6 +26990,13 @@ 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}`,
@@ -26787,7 +27034,7 @@ async function prepareRoleEnvelope(options) {
 init_session_identity();
 
 // src/headless-host/description.ts
-import { join as join41 } from "node:path";
+import { join as join42 } from "node:path";
 function isClaudePrintDescription(description) {
   return description.protocol === "claude-print";
 }
@@ -26795,7 +27042,7 @@ function isCodexExecDescription(description) {
   return description.protocol === "codex-exec";
 }
 function resolveHeadlessBinary(description, operatorHome) {
-  return join41(operatorHome, ...description.binaryFromHome);
+  return join42(operatorHome, ...description.binaryFromHome);
 }
 function headlessTurnArgs(options) {
   const { description } = options;
@@ -26807,6 +27054,7 @@ function headlessTurnArgs(options) {
     description.jsonSchemaFlag,
     JSON.stringify(options.jsonSchema)
   ];
+  if (options.pluginDir) args.push("--plugin-dir", options.pluginDir);
   if (options.mcpConfigPath !== void 0 && options.mcpConfigPath !== "") {
     args.push(description.mcpConfigFlag, options.mcpConfigPath);
   }
@@ -27003,7 +27251,6 @@ function codexTurnArgs(options) {
     args.push("resume", options.session.id);
   }
   args.push("--json");
-  args.push("--ignore-user-config", "--ignore-rules");
   const roots = (options.writableRoots ?? []).filter((root) => root !== "");
   if (roots.length > 0) {
     args.push(
@@ -27051,7 +27298,7 @@ import { spawn as spawn4, spawnSync } from "node:child_process";
 import { randomUUID as randomUUID9 } from "node:crypto";
 import { existsSync as existsSync13 } from "node:fs";
 import { writeFile as writeFile13 } from "node:fs/promises";
-import { dirname as dirname24, isAbsolute as isAbsolute11, join as join42, resolve as resolve20 } from "node:path";
+import { dirname as dirname25, isAbsolute as isAbsolute11, join as join43, resolve as resolve20 } from "node:path";
 
 // src/external-host-turn-loop.ts
 init_host_contracts();
@@ -27270,8 +27517,8 @@ function formatCodexFailurePayload(payload) {
 function cwdIsGitWorkTree(cwd) {
   let dir = cwd;
   for (; ; ) {
-    if (existsSync13(join42(dir, ".git"))) return true;
-    const parent = dirname24(dir);
+    if (existsSync13(join43(dir, ".git"))) return true;
+    const parent = dirname25(dir);
     if (parent === dir) return false;
     dir = parent;
   }
@@ -27460,7 +27707,8 @@ function buildTurnArgs(options) {
     mcpConfigPath: options.mcpConfigPath,
     ...options.model === void 0 ? {} : { model: options.model },
     ...options.effort === void 0 ? {} : { effort: options.effort },
-    session: { kind: options.sessionKind, id: options.sessionId }
+    session: { kind: options.sessionKind, id: options.sessionId },
+    ...options.pluginDir === void 0 ? {} : { pluginDir: options.pluginDir }
   });
 }
 function createHeadlessRoleTurnHost(config) {
@@ -27477,23 +27725,36 @@ function createHeadlessRoleTurnHost(config) {
         await config.sessionIdentity.bind(request.principal, sessionId);
       }
       const env = { ...process.env, ...config.env ?? {} };
-      const systemPromptPath = join42(request.runDirectory, "headless-system-prompt.txt");
+      const systemPromptPath = join43(request.runDirectory, "headless-system-prompt.txt");
       await writeFile13(systemPromptPath, systemPrompt, "utf8");
       let mcpConfigPath;
       let outputSchemaPath;
+      let pluginDir;
+      let applyMethodPrompt = codex ? (prompt) => applyCodexSkillInvocation(request.methods, prompt) : (prompt) => prompt;
       if (codex) {
-        outputSchemaPath = join42(request.runDirectory, "headless-output-schema.json");
-        const closed = closeJsonSchemaForCodex(prepared.jsonSchema);
-        await writeFile13(outputSchemaPath, `${JSON.stringify(closed, null, 2)}
-`, "utf8");
+        outputSchemaPath = join43(request.runDirectory, "headless-output-schema.json");
+        await writeFile13(
+          outputSchemaPath,
+          `${JSON.stringify(closeJsonSchemaForCodex(prepared.jsonSchema), null, 2)}
+`,
+          "utf8"
+        );
       } else {
-        mcpConfigPath = join42(request.runDirectory, "headless-mcp-config.json");
+        mcpConfigPath = join43(request.runDirectory, "headless-mcp-config.json");
         await writeFile13(
           mcpConfigPath,
           `${JSON.stringify(headlessMcpConfigDocument(prepared.mcpServers), null, 2)}
 `,
           "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);
       outcome = await driveExternalRoleTurnRounds(prepared, request, {
@@ -27518,7 +27779,8 @@ function createHeadlessRoleTurnHost(config) {
               sessionId,
               sessionKind,
               cwd: request.cwd,
-              ...gitCommonDir === void 0 ? {} : { writableRoots: [gitCommonDir] }
+              ...gitCommonDir === void 0 ? {} : { writableRoots: [gitCommonDir] },
+              ...pluginDir === void 0 ? {} : { pluginDir }
             });
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -27535,7 +27797,7 @@ function createHeadlessRoleTurnHost(config) {
               args,
               cwd: request.cwd,
               env,
-              stdin: prompt,
+              stdin: applyMethodPrompt(prompt),
               ...abortSignal === void 0 ? {} : { signal: abortSignal },
               ...request.timeoutMs === void 0 ? {} : { timeoutMs: request.timeoutMs },
               onStdoutLine(line2) {