@akagilnc/pi-workflow-roles 0.1.5037 → 0.1.5066

package/src/public-cli/cli.ts

@@ -48,6 +48,7 @@ import { packagedModelParent } from "../packaged-role-registry.ts";
 import { seatModelOnly } from "./registry.ts";
 import { CliUsageError } from "./cli-errors.ts";
 import type { CliIo } from "./cli-io.ts";
+import { runMachineSkillSetup } from "./machine-method-skills.ts";
 import type { PostAdmissionEnv } from "./post-admission.ts";
 import type { RoleTurnHost } from "../host-contracts.ts";
 import { appendPiSessionCustomEntry } from "../pi/role-turn-host.ts";
@@ -1179,6 +1180,11 @@ export async function runAkRole(
       };
     }
 
+    if (parsed.command === "setup") {
+      if (parsed.args.length !== 0) throw new CliUsageError("setup takes no arguments");
+      return { exitCode: await runMachineSkillSetup(home, io.stdout) };
+    }
+
     // #724 explicit fresh summons: `ak-role new <role> …` — same role argv, always mint.
     // Rewrites onto the role command with freshSummons; auto-resume and resume stay intact.
     if (parsed.command === "new") {

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

@@ -10,15 +10,10 @@ import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contrac
 import { isSafePositiveTicketNumber, readBoardTicketNumber } from "../run-ticket-number.ts";
 import { NotarySourceRunError, resolveNotarySourceRunLocator } from "../notary-source-run.ts";
 import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.ts";
-import {
-  loadPackagedMethodSkillMaterial,
-  type PackagedMethodSkillMaterial,
-} from "../package-resources/method-skill.ts";
 import type { PackagedRole } from "../packaged-role-registry.ts";
 import {
   packagedAdmitsCountersign,
   packagedBindsBoardTicket,
-  packagedMethodLoadFailureCause,
   packagedRebindSourceOnResume,
   packagedRoleMetadata,
 } from "../packaged-role-registry.ts";
@@ -42,7 +37,6 @@ import {
 import {
   presentControlledFailure,
   prepareSummonsResumeMaterials,
-  resolveResumeMethodMaterialAdapters,
   roleTurnOptions,
   runPostAdmissionOneShot,
   runPostAdmissionResumable,
@@ -67,6 +61,7 @@ import {
   trySettlePublicSeat,
 } from "./settlement.ts";
 import type { CliIo } from "./cli-io.ts";
+import { warnMissingMethodSkills } from "./machine-method-skills.ts";
 import {
   formatTerminalResult,
   isLawfulTypedTerminalOutcome,
@@ -74,8 +69,8 @@ import {
 } from "./terminal.ts";
 import {
   admittedSeatTurnDetails,
-  packagedSettleSkill,
   projectRoleTurnRequest,
+  requiredMethodSkills,
   type RoleTurnRequestProjectionOptions,
 } from "./turn-request.ts";
 import {
@@ -110,7 +105,7 @@ export function buildInstructionSeatTurnRequest(
 ): RoleTurnRequest {
   return projectRoleTurnRequest(
     admitted,
-    admittedSeatTurnDetails(admitted, options.packageRoot),
+    admittedSeatTurnDetails(admitted, options.home, options.host),
     options,
   );
 }
@@ -160,13 +155,12 @@ async function bindAndRelocateDiarist(
 function seatAdapters(
   admitted: AdmittedRoleInvocation,
   env: InstructionSeatRunEnv,
-  material?: PackagedMethodSkillMaterial,
 ): PostAdmissionAdapters<AdmittedRoleInvocation> {
   const record = roleRecord(admitted.role);
   const present = "presentSettled" in record ? record.presentSettled : "default";
   return {
     trySettle: (seat, authority, scope) =>
-      trySettlePublicSeat(seat, authority, scope, material, env.packageRoot),
+      trySettlePublicSeat(seat, authority, scope),
     ...(present === "always" ? { shouldPresentSettled: () => true } : {}),
     ...(present === "typed"
       ? { shouldPresentSettled: (terminal: TerminalResult) => isLawfulTypedTerminalOutcome(terminal.roleOutcome) }
@@ -233,23 +227,8 @@ async function dispatchAdmitted(
   io: CliIo,
 ): Promise<SeatRunResult> {
   const record = roleRecord(admitted.role);
-  let material: PackagedMethodSkillMaterial | undefined;
-  const skill = packagedSettleSkill(admitted);
-  if (skill !== undefined) {
-    try {
-      material = await loadPackagedMethodSkillMaterial(env.packageRoot, skill);
-    } catch (error) {
-      const knownCause = packagedMethodLoadFailureCause(admitted.role);
-      return await presentControlledFailure(admitted, {
-        timedOut: false,
-        code: null,
-        stderr: "",
-        thrown: error,
-        ...(knownCause === undefined ? {} : { knownCause }),
-      }, seatAdapters(admitted, env), env.principalAuthority, io) as SeatRunResult;
-    }
-  }
-  const adapters = seatAdapters(admitted, env, material);
+  await warnMissingMethodSkills(env.home, env.host, admitted.role, requiredMethodSkills(admitted), io.stdout);
+  const adapters = seatAdapters(admitted, env);
   const execute = async (activeEnv: InstructionSeatRunEnv): Promise<SeatRunResult> => {
     const auto = "inCallAutoResume" in record && record.inCallAutoResume === true;
     if (auto) {
@@ -818,21 +797,9 @@ export async function runPublicInstructionSeatResume(
     adapters: {
       trySettle: async () => undefined,
     },
-    afterAdmittedLoad: (admitted) => {
-      const skill = packagedSettleSkill(admitted);
-      if (skill === undefined) {
-        return Promise.resolve({ kind: "continue" as const, adapters: seatAdapters(admitted, env) });
-      }
-      const knownCause = packagedMethodLoadFailureCause(admitted.role);
-      return resolveResumeMethodMaterialAdapters({
-        admitted,
-        authority: env.principalAuthority,
-        io,
-        loadMaterial: () => loadPackagedMethodSkillMaterial(env.packageRoot, skill),
-        adaptersWith: (material) => seatAdapters(admitted, env, material),
-        emptyAdapters: seatAdapters(admitted, env),
-        ...(knownCause === undefined ? {} : { knownCause }),
-      });
+    afterAdmittedLoad: async (admitted) => {
+      await warnMissingMethodSkills(env.home, env.host, admitted.role, requiredMethodSkills(admitted), io.stdout);
+      return { kind: "continue" as const, adapters: seatAdapters(admitted, env) };
     },
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });

package/src/public-cli/machine-method-skills.ts

@@ -0,0 +1,153 @@
+import { accessSync, constants, statSync } from "node:fs";
+import { lstat, mkdir, symlink } from "node:fs/promises";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { HEADLESS_HOST_DESCRIPTIONS, HOST_DESCRIPTIONS } from "../host-descriptions.ts";
+import { packagedMethodSkillNames } from "../packaged-role-registry.ts";
+
+/** Install source only. Which names are required comes from the role registry. */
+const SKILL_SOURCE: Readonly<Record<string, string>> = {
+  tdd: "mattpocock/skills",
+  "diagnosing-bugs": "mattpocock/skills",
+  "resolving-merge-conflicts": "mattpocock/skills",
+  "ak-cross-m-review": "Akagilnc/ak-cross-m-review",
+};
+
+function skillRoot(home: string): string {
+  return join(home, ".agents/skills");
+}
+
+export function installedMethodSkillPath(home: string, name: string): string | undefined {
+  return installedSkillPath(skillRoot(home), name);
+}
+
+function installedSkillPath(root: string, name: string): string | undefined {
+  const path = join(root, name, "SKILL.md");
+  try {
+    if (!statSync(path).isFile()) return undefined;
+    accessSync(path, constants.R_OK);
+    return path;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "EPERM" || code === "ELOOP") return undefined;
+    throw error;
+  }
+}
+
+function linkedSkillRoot(home: string, host: string | undefined): string | undefined {
+  if (host === "claude" || host === "claude-code") {
+    return join(process.env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude"), "skills");
+  }
+  if (host === "hermes") return join(home, ".hermes/skills");
+  return undefined;
+}
+
+async function occupied(path: string): Promise<boolean> {
+  try {
+    await lstat(path);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    return false;
+  }
+}
+
+function warnOccupied(path: string, stdout: (text: string) => void): void {
+  stdout(`Warning: ${path} is already occupied; left untouched.\n`);
+}
+
+export async function warnMissingMethodSkills(
+  home: string,
+  host: string | undefined,
+  role: string,
+  skills: readonly string[],
+  stdout: (text: string) => void,
+): Promise<void> {
+  const missing: string[] = [];
+  const linkedRoot = linkedSkillRoot(home, host);
+  for (const skill of skills) {
+    if (installedMethodSkillPath(home, skill) === undefined ||
+      (linkedRoot !== undefined && installedSkillPath(linkedRoot, skill) === undefined)) missing.push(skill);
+  }
+  for (const skill of missing) {
+    stdout(`Warning: required machine Skill "${skill}" is missing for ${role}; its method guidance may be unavailable and reduce work quality. Run \`ak-role setup\` to install required Skills.\n`);
+  }
+}
+
+function runSkillsCli(args: readonly string[], home: string): boolean {
+  const result = spawnSync("npx", ["--yes", "skills", ...args], {
+    stdio: "inherit",
+    env: { ...process.env, HOME: home },
+  });
+  if (result.error !== undefined) throw result.error;
+  return result.status === 0;
+}
+
+function addSkills(source: string, skills: readonly string[], home: string): boolean {
+  if (skills.length === 0) return true;
+  return runSkillsCli([
+    "add", source,
+    ...skills.flatMap((skill) => ["--skill", skill]),
+    "--agent", "codex", "--global", "--yes",
+  ], home);
+}
+
+function updateRequiredSkills(home: string): boolean {
+  const names = packagedMethodSkillNames();
+  if (names.length === 0) return true;
+  return runSkillsCli(["update", "-g", "-y", ...names], home);
+}
+
+/** Explicit user-run setup; delegates acquisition/install to the ecosystem Skills CLI. */
+export async function runMachineSkillSetup(home: string, stdout: (text: string) => void): Promise<number> {
+  const canonical = skillRoot(home);
+  const missingBySource = new Map<string, string[]>();
+  let unsourced = false;
+  for (const name of packagedMethodSkillNames()) {
+    const path = join(canonical, name);
+    if (await occupied(path)) {
+      warnOccupied(path, stdout);
+      continue;
+    }
+    const source = SKILL_SOURCE[name];
+    if (source === undefined) {
+      unsourced = true;
+      stdout(`Warning: required machine Skill "${name}" has no install source; setup did not install it.\n`);
+      continue;
+    }
+    const missing = missingBySource.get(source) ?? [];
+    missing.push(name);
+    missingBySource.set(source, missing);
+  }
+  for (const [source, missing] of missingBySource) {
+    if (!addSkills(source, missing, home)) return 1;
+  }
+  if (unsourced) return 1;
+
+  for (const host of ["claude-code", "hermes"] as const) {
+    const root = linkedSkillRoot(home, host)!;
+    const binaryFromHome = host === "claude-code"
+      ? HEADLESS_HOST_DESCRIPTIONS.claude!.binaryFromHome
+      : HOST_DESCRIPTIONS.hermes!.binaryFromHome;
+    try {
+      accessSync(join(home, ...binaryFromHome), constants.X_OK);
+    } catch (error) {
+      if (["ENOENT", "ENOTDIR", "EACCES"].includes((error as NodeJS.ErrnoException).code ?? "")) continue;
+      throw error;
+    }
+    for (const name of packagedMethodSkillNames()) {
+      const target = join(canonical, name);
+      if (installedMethodSkillPath(home, name) === undefined) continue;
+      const link = join(root, name);
+      if (await occupied(link)) {
+        warnOccupied(link, stdout);
+        continue;
+      }
+      await mkdir(root, { recursive: true });
+      await symlink(target, link, "dir");
+    }
+  }
+  if (!updateRequiredSkills(home)) return 1;
+  stdout("Machine method Skills setup finished. Existing same-name Skills were left untouched.\n");
+  return 0;
+}

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

@@ -1367,6 +1367,7 @@ export function resumeTurnRequestProjectionOptions(
   return {
     packageRoot: env.packageRoot,
     home: env.home,
+    ...(env.host === undefined ? {} : { host: env.host }),
     agentDir: env.agentDir,
     ...(env.model === undefined ? {} : { model: env.model }),
     ...pickEngineAxis(env),
@@ -1393,6 +1394,7 @@ export function roleTurnOptions(
   return {
     packageRoot: env.packageRoot,
     home: env.home,
+    ...(env.host === undefined ? {} : { host: env.host }),
     agentDir: env.agentDir,
     ...(env.model === undefined ? {} : { model: env.model }),
     ...pickEngineAxis(env),

package/src/public-cli/registry.ts

@@ -28,6 +28,7 @@ export const PUBLIC_CLI_SUPPORT_COMMANDS = [
   "help",
   "resume",
   "new",
+  "setup",
 ] as const;
 
 export type PublicCliSupportCommand = (typeof PUBLIC_CLI_SUPPORT_COMMANDS)[number];

package/src/public-cli/settlement.ts

@@ -92,14 +92,6 @@ import {
   SECRETARIAT_COUNTERSIGN_TERMINAL_FACT_KEY,
   SECRETARIAT_GATE_OFFICER_ENTRY_TYPE,
 } from "../secretariat-contracts.ts";
-import {
-  observePackagedMethodSkillInvocation,
-  resolvePackagedMethodSkillPath,
-  type ObservedPackagedMethodSkillInvocation,
-  type PackagedMethodSkillMaterial,
-  type PackagedMethodSkillName,
-  type PackagedMethodSkillProvenance,
-} from "../package-resources/method-skill.ts";
 import {
   classifyPackagedRoleTerminalResult,
   findLatestDurablePackagedRoleTerminal,
@@ -2482,21 +2474,14 @@ async function publishAcceptedTerminalArtifacts(
   ];
 }
 
-type MethodPublicationOptions = {
-  readonly methodProvenance?: PackagedMethodSkillProvenance;
-  readonly methodSkillPath?: string;
-  readonly methodSkillConfiguredPath?: string;
-};
-
 /** Publish one accepted seat's report/evidence face from the shared leaf table. */
 export async function publishSeatAcceptedArtifacts(
   admitted: AdmittedRoleInvocation,
   roleOutcome: TerminalRoleOutcome,
   coordinates: DurablePrincipalCoordinates,
   entries: readonly SessionEntry[] = [],
-  options: MethodPublicationOptions = {},
 ): Promise<TerminalArtifactRef[]> {
-  return publishDeclaredSeatArtifacts(admitted, roleOutcome, coordinates, entries, options);
+  return publishDeclaredSeatArtifacts(admitted, roleOutcome, coordinates, entries);
 }
 
 /**
@@ -2623,13 +2608,12 @@ async function settleSealedAcceptedOrToolResidual(
 /**
  * One settlement for every registered seat. The registry `settlement` leaf
  * picks sealed ledger, sealed-or-residual, or the accepted-tool scan.
- * Seat evidence and the observed-method tail stay on the artifact face.
+ * Seat evidence stays on the artifact face.
  */
 async function settleSeat(
   admitted: AdmittedRoleInvocation,
   authority: DurablePrincipalAuthority,
   scope: SettlementCourtScope | undefined,
-  options: MethodPublicationOptions,
 ): Promise<TerminalResult | undefined> {
   const record = packagedRoleMetadata(admitted.role);
   if (record === undefined) {
@@ -2642,7 +2626,7 @@ async function settleSeat(
     roleOutcome: Extract<TerminalRoleOutcome, { kind: "accepted" | "audit_escalation" }>,
     coordinates: DurablePrincipalCoordinates,
     entries: readonly SessionEntry[],
-  ) => publishDeclaredSeatArtifacts(admitted, roleOutcome, coordinates, entries, options);
+  ) => publishDeclaredSeatArtifacts(admitted, roleOutcome, coordinates, entries);
   if (record.settlement === "residual") {
     return settleSealedAcceptedOrToolResidual(
       admitted,
@@ -2669,10 +2653,9 @@ async function settleSeat(
 export async function trySettleSeatTerminalResult(
   admitted: AdmittedRoleInvocation,
   authority: DurablePrincipalAuthority,
-  options: MethodPublicationOptions = {},
   scope?: SettlementCourtScope,
 ): Promise<TerminalResult | undefined> {
-  return settleSeat(admitted, authority, scope, options);
+  return settleSeat(admitted, authority, scope);
 }
 
 /**
@@ -2682,10 +2665,9 @@ export async function trySettleSeatTerminalResult(
 export async function settleSeatTerminalResult(
   admitted: AdmittedRoleInvocation,
   authority: DurablePrincipalAuthority,
-  options: MethodPublicationOptions = {},
   scope?: SettlementCourtScope,
 ): Promise<TerminalResult> {
-  const settled = await settleSeat(admitted, authority, scope, options);
+  const settled = await settleSeat(admitted, authority, scope);
   if (settled === undefined) {
     const label = admitted.role.charAt(0).toUpperCase() + admitted.role.slice(1);
     throw new Error(
@@ -2695,71 +2677,6 @@ export async function settleSeatTerminalResult(
   return settled;
 }
 
-function sessionMessageText(message: SessionMessage | undefined): string {
-  if (message === undefined) return "";
-  if (typeof message.content === "string") return message.content;
-  if (!Array.isArray(message.content)) return "";
-  const parts: string[] = [];
-  for (const part of message.content) {
-    if (
-      typeof part === "object" &&
-      part !== null &&
-      !Array.isArray(part) &&
-      (part as { type?: unknown }).type === "text" &&
-      typeof (part as { text?: unknown }).text === "string"
-    ) {
-      parts.push((part as { text: string }).text);
-    }
-  }
-  return parts.join("\n");
-}
-
-/**
- * Locations a loaded packaged method may be observed at.
- * The name is the loaded material; the configured path is the package copy.
- */
-export function observedMethodSkillOptions(
-  packageRoot: string,
-  material: PackagedMethodSkillMaterial,
-): {
-  readonly methodProvenance: PackagedMethodSkillProvenance;
-  readonly methodSkillPath: string;
-  readonly methodSkillConfiguredPath: string;
-} {
-  return {
-    methodProvenance: material.provenance,
-    methodSkillPath: material.skillPath,
-    methodSkillConfiguredPath: resolvePackagedMethodSkillPath(packageRoot, material.name),
-  };
-}
-
-/**
- * Observe packaged method Skill expansions from the session.
- * The skill name is the caller's packaged method; home locations never count.
- */
-function extractObservedMethodInvocations(
-  entries: readonly SessionEntry[],
-  options: {
-    readonly name: PackagedMethodSkillName;
-    readonly allowedLocations: readonly string[];
-  },
-): readonly ObservedPackagedMethodSkillInvocation[] {
-  const observed: ObservedPackagedMethodSkillInvocation[] = [];
-  for (const entry of entries) {
-    if (entry?.type !== "message") continue;
-    const message = entry.message;
-    if (message?.role !== "user") continue;
-    const text = sessionMessageText(message);
-    if (text.length === 0) continue;
-    const hit = observePackagedMethodSkillInvocation(text, {
-      name: options.name,
-      allowedLocations: options.allowedLocations,
-    });
-    if (hit !== undefined) observed.push(hit);
-  }
-  return Object.freeze(observed);
-}
-
 /**
  * #836: cost and the auditor's no-receipt facts ride beside the role's
  * testimony on the current attempt's candidate entry. Absence is omitted,
@@ -2834,49 +2751,11 @@ function doctorReportFacts(
   };
 }
 
-function observedMethodTail(
-  face: PackagedArtifactFace,
-  entries: readonly SessionEntry[],
-  options: {
-    readonly methodProvenance?: PackagedMethodSkillProvenance;
-    readonly methodSkillPath?: string;
-    readonly methodSkillConfiguredPath?: string;
-  },
-): Record<string, unknown> {
-  if (face.method === undefined) return {};
-  if (face.method === "optional") {
-    return options.methodProvenance === undefined
-      ? {}
-      : { methodProvenance: options.methodProvenance };
-  }
-  if (
-    options.methodProvenance === undefined
-    || options.methodSkillPath === undefined
-    || options.methodSkillConfiguredPath === undefined
-  ) {
-    throw new Error("observed method publication is missing packaged method coordinates");
-  }
-  const methodInvocations = extractObservedMethodInvocations(entries, {
-    name: options.methodProvenance.name,
-    allowedLocations: [options.methodSkillPath, options.methodSkillConfiguredPath],
-  });
-  return {
-    methodProvenance: options.methodProvenance,
-    methodInvocationObserved: methodInvocations.length > 0,
-    methodInvocations,
-  };
-}
-
 async function publishDeclaredSeatArtifacts(
   admitted: AdmittedRoleInvocation,
   roleOutcome: TerminalRoleOutcome,
   coordinates: DurablePrincipalCoordinates,
   entries: readonly SessionEntry[],
-  options: {
-    readonly methodProvenance?: PackagedMethodSkillProvenance;
-    readonly methodSkillPath?: string;
-    readonly methodSkillConfiguredPath?: string;
-  } = {},
 ): Promise<TerminalArtifactRef[]> {
   const face = seatArtifactFace(admitted.role);
   const phase = face.reportPhase === true
@@ -2898,7 +2777,6 @@ async function publishDeclaredSeatArtifacts(
       sessionFile: coordinates.sessionFile,
       admittedRequestPath: admitted.admittedRequestPath,
       attachments: acceptedArtifactAttachmentRefs(admitted.attachments),
-      ...observedMethodTail(face, entries, options),
     },
   });
 }
@@ -3040,18 +2918,8 @@ export async function trySettlePublicSeat(
   admitted: AdmittedRoleInvocation,
   authority: DurablePrincipalAuthority,
   scope: { readonly courtAttemptId?: string } | undefined,
-  material: PackagedMethodSkillMaterial | undefined,
-  packageRoot: string,
 ): Promise<TerminalResult | undefined> {
-  const face = seatArtifactFace(admitted.role);
-  if (face.method === "observed" && material === undefined) return undefined;
-  const options: MethodPublicationOptions =
-    face.method === "observed" && material !== undefined
-      ? observedMethodSkillOptions(packageRoot, material)
-      : face.method === "optional" && material !== undefined
-        ? { methodProvenance: material.provenance }
-        : {};
-  return settleSeat(admitted, authority, scope, options);
+  return settleSeat(admitted, authority, scope);
 }
 
 /**

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

@@ -10,16 +10,13 @@ import type {
   RoleTurnRequest,
 } from "../host-contracts.ts";
 import { pickEngineAxis } from "../package-resources/engine-material.ts";
-import {
-  resolvePackagedMethodSkillPath,
-  type PackagedMethodSkillName,
-} from "../package-resources/method-skill.ts";
 import {
   packagedRoleActivationFlags,
   packagedRoleMetadata,
 } from "../packaged-role-registry.ts";
 import type { SeatModelConfig } from "./config.ts";
 import type { AdmittedRoleInvocation } from "./invocation.ts";
+import { installedMethodSkillPath } from "./machine-method-skills.ts";
 import { parentRunPathFromGatePointerInstruction } from "./run-lifecycle.ts";
 import type { PublicThinkingLevel } from "./registry.ts";
 
@@ -33,6 +30,7 @@ export type ResumeModelConfig = {
 export type RoleTurnRequestProjectionOptions = {
   packageRoot: string;
   home: string;
+  host?: string;
   agentDir: string;
   model?: SeatModelConfig;
   engine?: string;
@@ -103,7 +101,7 @@ export function projectRoleTurnRequest(
  */
 export function packagedSettleSkill(
   admitted: AdmittedRoleInvocation,
-): PackagedMethodSkillName | undefined {
+): string | undefined {
   const record = packagedRoleMetadata(admitted.role);
   if (record === undefined) return undefined;
   if ("applyMethod" in record && record.applyMethod !== undefined) {
@@ -148,33 +146,43 @@ function activationForAdmitted(admitted: AdmittedRoleInvocation): RoleTurnActiva
 }
 
 /** Skill bindings declared on the composition-root record for this admitted run. */
-function methodBindings(
-  admitted: AdmittedRoleInvocation,
-  packageRoot: string,
-): readonly MethodBinding[] {
+export function requiredMethodSkills(admitted: AdmittedRoleInvocation): readonly string[] {
   const record = packagedRoleMetadata(admitted.role);
-  const names: PackagedMethodSkillName[] = [];
+  const names: string[] = [];
   if (record !== undefined && "methodSkills" in record && record.methodSkills !== undefined) {
     names.push(...record.methodSkills);
   }
   const apply = packagedSettleSkill(admitted);
   if (apply !== undefined && !names.includes(apply)) names.push(apply);
-  return names.map((name) => ({
-    kind: "skill" as const,
-    path: resolvePackagedMethodSkillPath(packageRoot, name),
-  }));
+  return names;
+}
+
+function methodBindings(
+  admitted: AdmittedRoleInvocation,
+  home: string,
+  host: string | undefined,
+): readonly MethodBinding[] {
+  if (host !== undefined && host !== "pi") return [];
+  return requiredMethodSkills(admitted).flatMap((name) => {
+    const path = installedMethodSkillPath(home, name);
+    return path === undefined ? [] : [{
+      kind: "skill" as const,
+      path,
+    }];
+  });
 }
 
 /** Registry activation and method bindings for one admitted public seat. */
 export function admittedSeatTurnDetails(
   admitted: AdmittedRoleInvocation,
-  packageRoot: string,
+  home: string,
+  host: string | undefined,
 ): {
   readonly activation: RoleTurnActivation;
   readonly methods: readonly MethodBinding[];
 } {
   return {
     activation: activationForAdmitted(admitted),
-    methods: methodBindings(admitted, packageRoot),
+    methods: methodBindings(admitted, home, host),
   };
 }