@akagilnc/pi-workflow-roles 0.1.4444 → 0.1.4489

package/dist/method-host-plugin/skills/diagnosing-bugs/scripts/hitl-loop.template.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Human-in-the-loop reproduction loop.
+# Copy this file, edit the steps below, and run it.
+# The agent runs the script; the user follows prompts in their terminal.
+#
+# Usage:
+#   bash hitl-loop.template.sh
+#
+# Two helpers:
+#   step "<instruction>"          → show instruction, wait for Enter
+#   capture VAR "<question>"      → show question, read response into VAR
+#
+# At the end, captured values are printed as KEY=VALUE for the agent to parse.
+
+set -euo pipefail
+
+step() {
+  printf '\n>>> %s\n' "$1"
+  read -r -p "    [Enter when done] " _
+}
+
+capture() {
+  local var="$1" question="$2" answer
+  printf '\n>>> %s\n' "$question"
+  read -r -p "    > " answer
+  printf -v "$var" '%s' "$answer"
+}
+
+# --- edit below ---------------------------------------------------------
+
+step "Open the app at http://localhost:3000 and sign in."
+
+capture ERRORED "Click the 'Export' button. Did it throw an error? (y/n)"
+
+capture ERROR_MSG "Paste the error message (or 'none'):"
+
+# --- edit above ---------------------------------------------------------
+
+printf '\n--- Captured ---\n'
+printf 'ERRORED=%s\n' "$ERRORED"
+printf 'ERROR_MSG=%s\n' "$ERROR_MSG"

package/dist/method-host-plugin/skills/resolving-merge-conflicts/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: resolving-merge-conflicts
+description: "Use when you need to resolve an in-progress ordinary two-parent git merge conflict without inventing new authority."
+---
+
+1. **See the current state** of the ordinary two-parent merge already in progress. Use the admitted Merger assignment envelope (target/source parents, complete conflict set, resolution scope, authorized checks). Check git history and the conflicting files. This method is **merge-only**: do **not** start, abort, or continue a rebase, and do **not** treat general non-merge conflict workflows as in scope.
+
+2. **Find the primary sources** for each conflict. Understand deeply why each change was made, and what the original intent was. Read the commit messages, check the PRs, check original issues/tickets. Prefer admitted task/authority materials and primary sources over guesswork.
+
+3. **Resolve each hunk within resolution scope.** Preserve both intents where possible. Where intents are compatible, keep both. Where incompatible, or where a new product or authority decision is required, stop and submit the existing typed **escalate** outcome with a clear diagnosis — do **not** invent new behaviour, do **not** guess authority, and do **not** silently pick a side that needs a new decision. Never `--abort` (the caller owns abort). Never continue a rebase.
+
+4. Run **authorized checks** from the admitted assignment when present. When the assignment lists none, discover the project's automated checks within the role boundary — typically typecheck, then tests, then format — and run them. Fix anything the merge resolution broke that stays inside scope.
+
+5. **Finish the ordinary two-parent merge commit** within resolution scope. Stage in-scope resolutions and create the merge commit with the frozen target then source parents. Title it `ak-roles: merge: …` (factory worker prefix first). Do **not** publish, push, or route another role. Do **not** broaden into rebase or general conflict cleanup outside the admitted merge.

package/dist/method-host-plugin/skills/resolving-merge-conflicts/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Resolving Merge Conflicts"
+  short_description: "Resolve ordinary two-parent merge conflicts; escalate new authority"

package/dist/method-host-plugin/skills/resolving-merge-conflicts/provenance.json

@@ -0,0 +1,26 @@
+{
+  "name": "resolving-merge-conflicts",
+  "kind": "role-method-skill",
+  "upstream": {
+    "repository": "https://github.com/mattpocock/skills",
+    "path": "skills/engineering/resolving-merge-conflicts",
+    "commit": "8b36d4fb2635b3c21998dcd8144439c9e5ba7302",
+    "tag": "v1.2.2",
+    "license": "MIT",
+    "copyright": "Copyright (c) 2026 Matt Pocock",
+    "attribution": "mattpocock/skills"
+  },
+  "packageAdaptation": "merger-merge-only-escalate-new-intent",
+  "files": {
+    "SKILL.md": {
+      "sha256": "a7be3300cd1457cb9b4065935271f37759531ebb366a352896a7a617d8d9c18a",
+      "byteLength": 2015,
+      "gitBlob": "b88102a6e903c2e60d3b4898552a0931a2fa4c91"
+    },
+    "agents/openai.yaml": {
+      "sha256": "f283f1ac11525de29d2615163fc3239b979f67c8e88560644364ca6e1a3b8100",
+      "byteLength": 146,
+      "gitBlob": "dc388c3df1d0a72ae2cfe7c78a23747f26e96822"
+    }
+  }
+}

package/dist/method-host-plugin/skills/tdd/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: tdd
+description: Test-driven development. Use when the user wants to build features or fix bugs test-first, mentions "red-green-refactor", or wants integration tests.
+---
+
+# Test-Driven Development
+
+TDD commonly uses a red → green loop. This skill is a reference for producing tests worth keeping: what a good test is, where tests go, the anti-patterns, and the practices of the loop. Consult the sections before and during the loop when they help; they are method guidance, not retrospective delivery gates.
+
+When exploring the codebase, read `CONTEXT.md` (if it exists) so test names and interface vocabulary match the project's domain language, and respect ADRs in the area you're touching.
+
+## What a good test is
+
+Tests verify behavior through public interfaces, not implementation details. Code can change entirely; tests shouldn't. A good test reads like a specification — "user can checkout with valid cart" tells you exactly what capability exists — and survives refactors because it doesn't care about internal structure.
+
+See [tests.md](tests.md) for examples and [mocking.md](mocking.md) for mocking guidelines.
+
+## Seams — where tests go
+
+A **seam** is the public boundary you test at: the interface where you observe behavior without reaching inside. Tests live at seams, never against internals.
+
+**Test only at pre-agreed seams.** Before writing any test, write down the seams under test and confirm them with the user. No test is written at an unconfirmed seam. You can't test everything — agreeing the seams up front is how testing effort lands on the critical paths and complex logic instead of every edge case.
+
+Ask: "What's the public interface, and which seams should we test?"
+
+When the shape of that interface is itself in question — how deep the module is, where the seam belongs, what the interface should expose — use the `/codebase-design` skill for the vocabulary. It is the shared source of the module, interface, depth, seam, adapter, leverage and locality terms, and it is a reference to consult, not a session to run.
+
+## Anti-patterns
+
+- **Implementation-coupled** — mocks internal collaborators, tests private methods, or verifies through a side channel (querying the database instead of using the interface). The tell: the test breaks when you refactor but behavior hasn't changed.
+- **Tautological** — the assertion recomputes the expected value the way the code does (`expect(add(a, b)).toBe(a + b)`, a snapshot derived by hand the same way, a constant asserted equal to itself), so it passes by construction and can never disagree with the code. Expected values must come from an independent source of truth — a known-good literal, a worked example, the spec.
+- **Horizontal slicing** — writing all tests first, then all implementation. Bulk tests verify _imagined_ behavior: you test the _shape_ of things rather than user-facing behavior, the tests go insensitive to real changes, and you commit to test structure before understanding the implementation. Work in **vertical slices** instead — one test → one implementation → repeat, each test a **tracer bullet** that responds to what the last cycle taught you.
+
+## Rules of the loop
+
+- **Prefer red before green.** When practical, write the failing test first, then only enough code to pass it. If that historical order cannot be demonstrated, disclose the deviation; assess delivery from the current code, behavior, and evidence rather than rejecting it for sequence alone. Don't anticipate future tests or add speculative features.
+- **One slice at a time.** One seam, one test, one minimal implementation per cycle.
+- **Refactoring is not part of the loop.** It belongs to the review stage (see the `code-review` skill), not the red → green implementation cycle.

package/dist/method-host-plugin/skills/tdd/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "TDD"
+  short_description: "Test-driven red-green-refactor"

package/dist/method-host-plugin/skills/tdd/mocking.md

@@ -0,0 +1,59 @@
+# When to Mock
+
+Mock at **system boundaries** only:
+
+- External APIs (payment, email, etc.)
+- Databases (sometimes - prefer test DB)
+- Time/randomness
+- File system (sometimes)
+
+Don't mock:
+
+- Your own classes/modules
+- Internal collaborators
+- Anything you control
+
+## Designing for Mockability
+
+At system boundaries, design interfaces that are easy to mock:
+
+**1. Use dependency injection**
+
+Pass external dependencies in rather than creating them internally:
+
+```typescript
+// Easy to mock
+function processPayment(order, paymentClient) {
+  return paymentClient.charge(order.total);
+}
+
+// Hard to mock
+function processPayment(order) {
+  const client = new StripeClient(process.env.STRIPE_KEY);
+  return client.charge(order.total);
+}
+```
+
+**2. Prefer SDK-style interfaces over generic fetchers**
+
+Create specific functions for each external operation instead of one generic function with conditional logic:
+
+```typescript
+// GOOD: Each function is independently mockable
+const api = {
+  getUser: (id) => fetch(`/users/${id}`),
+  getOrders: (userId) => fetch(`/users/${userId}/orders`),
+  createOrder: (data) => fetch('/orders', { method: 'POST', body: data }),
+};
+
+// BAD: Mocking requires conditional logic inside the mock
+const api = {
+  fetch: (endpoint, options) => fetch(endpoint, options),
+};
+```
+
+The SDK approach means:
+- Each mock returns one specific shape
+- No conditional logic in test setup
+- Easier to see which endpoints a test exercises
+- Type safety per endpoint

package/dist/method-host-plugin/skills/tdd/provenance.json

@@ -0,0 +1,36 @@
+{
+  "name": "tdd",
+  "kind": "role-method-skill",
+  "upstream": {
+    "repository": "https://github.com/mattpocock/skills",
+    "path": "skills/engineering/tdd",
+    "commit": "8b36d4fb2635b3c21998dcd8144439c9e5ba7302",
+    "tag": "v1.2.2",
+    "license": "MIT",
+    "copyright": "Copyright (c) 2026 Matt Pocock",
+    "attribution": "mattpocock/skills"
+  },
+  "packageAdaptation": "red-green-advisory-no-historical-compliance-gate",
+  "files": {
+    "SKILL.md": {
+      "sha256": "26c74168236078b8e43510b49f8c4b30784ec3cc7d4b1356792cbc8500d5cae6",
+      "byteLength": 3798,
+      "gitBlob": "d6b6bebaa1d1fed58812f8809b9ebc1ff9a5d1e4"
+    },
+    "tests.md": {
+      "sha256": "859f9e592c188fda4fc7277dd180e4ce9c7a2e13f6efe1f6f29eccc9d28c106a",
+      "byteLength": 2214,
+      "gitBlob": "7ab86479f925a1f9e8ba680af33cb3b12e015381"
+    },
+    "mocking.md": {
+      "sha256": "3ceb807fdf4a47d6a93d4d9a891e5ba6d362a6247bd08adc451feebfc17361ef",
+      "byteLength": 1481,
+      "gitBlob": "71cbfee674d93244ce81d1830b930ca9a69200bd"
+    },
+    "agents/openai.yaml": {
+      "sha256": "ea6f01cf1b8c06a4b0f5b649d74b1b8ce8685e72af1b38d70d877693e092af0b",
+      "byteLength": 87,
+      "gitBlob": "651b838a7663e027b1b8884491e867f26bb9a021"
+    }
+  }
+}

package/dist/method-host-plugin/skills/tdd/tests.md

@@ -0,0 +1,77 @@
+# Good and Bad Tests
+
+## Good Tests
+
+**Integration-style**: Test through real interfaces, not mocks of internal parts.
+
+```typescript
+// GOOD: Tests observable behavior
+test("user can checkout with valid cart", async () => {
+  const cart = createCart();
+  cart.add(product);
+  const result = await checkout(cart, paymentMethod);
+  expect(result.status).toBe("confirmed");
+});
+```
+
+Characteristics:
+
+- Tests behavior users/callers care about
+- Uses public API only
+- Survives internal refactors
+- Describes WHAT, not HOW
+- One logical assertion per test
+
+## Bad Tests
+
+**Implementation-detail tests**: Coupled to internal structure.
+
+```typescript
+// BAD: Tests implementation details
+test("checkout calls paymentService.process", async () => {
+  const mockPayment = jest.mock(paymentService);
+  await checkout(cart, payment);
+  expect(mockPayment.process).toHaveBeenCalledWith(cart.total);
+});
+```
+
+Red flags:
+
+- Mocking internal collaborators
+- Testing private methods
+- Asserting on call counts/order
+- Test breaks when refactoring without behavior change
+- Test name describes HOW not WHAT
+- Verifying through external means instead of interface
+
+```typescript
+// BAD: Bypasses interface to verify
+test("createUser saves to database", async () => {
+  await createUser({ name: "Alice" });
+  const row = await db.query("SELECT * FROM users WHERE name = ?", ["Alice"]);
+  expect(row).toBeDefined();
+});
+
+// GOOD: Verifies through interface
+test("createUser makes user retrievable", async () => {
+  const user = await createUser({ name: "Alice" });
+  const retrieved = await getUser(user.id);
+  expect(retrieved.name).toBe("Alice");
+});
+```
+
+**Tautological tests**: Expected value restates the implementation, so the test passes by construction.
+
+```typescript
+// BAD: Expected value is recomputed the way the code computes it
+test("calculateTotal sums line items", () => {
+  const items = [{ price: 10 }, { price: 5 }];
+  const expected = items.reduce((sum, i) => sum + i.price, 0);
+  expect(calculateTotal(items)).toBe(expected);
+});
+
+// GOOD: Expected value is an independent, known literal
+test("calculateTotal sums line items", () => {
+  expect(calculateTotal([{ price: 10 }, { price: 5 }])).toBe(15);
+});
+```

package/dist/public-cli/main.js

@@ -15308,13 +15308,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`. */
@@ -15327,12 +15324,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.
@@ -15351,7 +15343,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-",
@@ -15372,12 +15363,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",
@@ -24252,9 +24238,7 @@ 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");
 }
 var packageRootUrl, MAIN_ROLE_SESSION_MATERIALS, GATEKEEPER_SESSION_MATERIALS;
@@ -24285,6 +24269,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
@@ -24311,11 +24297,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"() {

package/dist/session-opening-materials.js

@@ -25,18 +25,29 @@ 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));
+}
 const MAIN_ROLE_SESSION_MATERIALS = {
   ...Object.fromEntries(
     PUBLIC_ROLE_RECORDS.map((record) => [record.role, record.sessionMaterials])
   )
 };
 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");
 }
 const GATEKEEPER_SESSION_MATERIALS = {
   // #639: single authority — the public gatekeeper record owns the province list.
@@ -45,13 +56,14 @@ const GATEKEEPER_SESSION_MATERIALS = {
   notary: NOTARY_SESSION_MATERIALS
 };
 function loadGatekeeperSessionMaterials(role) {
-  return joinPackageMaterials(GATEKEEPER_SESSION_MATERIALS[role]);
+  return loadSeparatedSessionPart(role, GATEKEEPER_SESSION_MATERIALS[role], "soul");
 }
 export {
   GATEKEEPER_SESSION_MATERIALS,
   MAIN_ROLE_SESSION_MATERIALS,
   joinPackageMaterials,
   loadGatekeeperSessionMaterials,
+  loadMainRoleReferenceMaterials,
   loadMainRoleSessionMaterials,
   readPackageMaterial,
   resolvePackageRootDir

package/extensions/role-runtime.ts

@@ -31,9 +31,14 @@ import { JUDGE_OUTPUT_TOOL_NAME } from "../src/package-contracts/judge-output.ts
 import { readOAuthKeepaliveProviders } from "../src/oauth-keepalive.ts";
 import {
   formatNavigatorRoleHelp,
+  type RoleRuntimeDependencies,
 } from "../src/role-runtime.ts";
 import { loadAuditorSoulFromSubjectInput } from "../src/auditor-soul.ts";
-import { loadGatekeeperSessionMaterials, loadMainRoleSessionMaterials } from "../src/session-opening-materials.ts";
+import { loadPackagedRoleReferenceMaterials } from "../src/role-runtime-dependencies.ts";
+import {
+  loadGatekeeperSessionMaterials,
+  loadMainRoleSessionMaterials,
+} from "../src/session-opening-materials.ts";
 const extensionPath = fileURLToPath(import.meta.url);
 const packageRoot = fileURLToPath(new URL("..", import.meta.url));
 const navigatorRoutePlaybookPath = fileURLToPath(new URL("../resources/navigator-route-playbook.md", import.meta.url));
@@ -105,12 +110,11 @@ export async function loadNavigatorWorkContext(
   });
 }
 
-export default function roleRuntime(pi: ExtensionAPI): void {
-  const oauthKeepaliveProviders = readOAuthKeepaliveProviders();
-  registerNavigatorModelCommand(pi);
+export function createPiRoleRuntimeDependencies(pi: ExtensionAPI): RoleRuntimeDependencies {
   const navigatorSessionFactory = createNativeNavigatorSessionFactory();
-  createPiRoleRuntimeExtension({
+  return {
     packageRoot,
+    loadRoleReferenceMaterials: loadPackagedRoleReferenceMaterials,
     loadJudgeSoul: () => loadMainRoleSessionMaterials("judge"),
     loadFixerSoul: () => loadMainRoleSessionMaterials("fixer"),
     loadFixPacket: (path) => readFile(path, "utf8"),
@@ -167,7 +171,13 @@ export default function roleRuntime(pi: ExtensionAPI): void {
       }
       return loadHomeCanonicalSkillBinding(name);
     },
-  }, {
+  };
+}
+
+export default function roleRuntime(pi: ExtensionAPI): void {
+  const oauthKeepaliveProviders = readOAuthKeepaliveProviders();
+  registerNavigatorModelCommand(pi);
+  createPiRoleRuntimeExtension(createPiRoleRuntimeDependencies(pi), {
     transcriptFromContext,
     oauthKeepalive: { providers: oauthKeepaliveProviders },
   })(pi);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akagilnc/pi-workflow-roles",
-  "version": "0.1.4444",
+  "version": "0.1.4489",
   "description": "Soul-bound workflow roles for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/resources/method-host-plugin/.claude-plugin/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "ak-methods",
+  "version": "0.0.0",
+  "description": "ak-roles packaged role method skills"
+}

package/scripts/build-package.mjs

@@ -1,4 +1,4 @@
-import { chmod, copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { chmod, copyFile, cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { build } from "esbuild";
@@ -200,6 +200,11 @@ export async function buildPackageArtifacts() {
   await buildAcpProductionHost();
   await buildHeadlessProductionHost();
   await buildMigrateBookTopology();
+  const pluginDir = join("dist", "method-host-plugin");
+  await rm(pluginDir, { recursive: true, force: true });
+  await mkdir(pluginDir, { recursive: true });
+  await cp("resources/method-host-plugin/.claude-plugin", join(pluginDir, ".claude-plugin"), { recursive: true });
+  await cp("resources/methods", join(pluginDir, "skills"), { recursive: true });
 }
 
 const isMain =

package/src/acp-host/description.ts

@@ -1,6 +1,6 @@
 /**
  * One ACP host description. Every host-specific value the generic ACP adapter
- * needs — binary location, argv shape, resume verb, binding filename, child env,
+ * needs — binary location, argv shape, resume verb, binding filename,
  * optional seat-profile soul — is data here; the lifecycle in role-turn-host.ts
  * stays one copy (#732).
  */
@@ -30,7 +30,6 @@ export type AcpHostDescription = Readonly<{
   boundResume: "session/load" | "session/new";
   /** Durable ACP binding filename written beside the session principal. */
   sessionBindingFile: string;
-  childEnv: Readonly<Record<string, string>>;
   /**
    * When set, the production factory ensures a seat profile whose SOUL.md is a
    * symlink to the packaged role soul, and prefixes argv with `flag <name>`.
@@ -44,8 +43,7 @@ export function resolveAcpBinary(description: AcpHostDescription, operatorHome:
   return join(operatorHome, ...description.binaryFromHome);
 }
 
-/** Stdio argv: optional profile flag, thinking flag (before the subcommand),
- * prefix, optional model flag pair, suffix. */
+/** Stdio argv: optional profile flag, thinking flag, prefix, model, suffix. */
 export function acpStdioArgs(
   description: AcpHostDescription,
   model?: { readonly model?: string; readonly thinking?: string },

package/src/acp-host/production-host.ts

@@ -55,7 +55,6 @@ export function createProductionAcpRoleTurnHost(options: ProductionAcpHostOption
   const { packageRoot, principalAuthority, description, hostName } = options;
   const env: NodeJS.ProcessEnv = {
     ...process.env,
-    ...description.childEnv,
     AK_PACKAGE_ROOT: packageRoot,
   };
 

package/src/auditor-soul.ts

@@ -85,10 +85,19 @@ export async function loadAuditorSoul(role: AuditorSoulRole): Promise<string> {
   if (soul.trim().length === 0) {
     throw new Error(`The ${role} auditor Soul is blank`);
   }
-  return joinPackageMaterials(materials);
+  return soul;
+}
+
+export function loadAuditorReferenceMaterials(role: AuditorSoulRole): Promise<string> {
+  const soulPath = auditorSoulRelativePath(role);
+  return joinPackageMaterials(AUDITOR_SESSION_MATERIALS[role].filter((path) => path !== soulPath));
 }
 
 /** Runtime loader: subject input decides which soul file to assemble. */
 export async function loadAuditorSoulFromSubjectInput(raw?: string): Promise<string> {
   return loadAuditorSoul(resolveAuditorSubject(raw));
 }
+
+export function loadAuditorReferenceMaterialsFromSubjectInput(raw?: string): Promise<string> {
+  return loadAuditorReferenceMaterials(resolveAuditorSubject(raw));
+}

package/src/headless-host/description.ts

@@ -90,6 +90,8 @@ export function headlessTurnArgs(options: {
   readonly effort?: string;
   /** Fresh session: pass as session id. Resume: pass as resume id. */
   readonly session: { readonly kind: "new"; readonly id: string } | { readonly kind: "resume"; readonly id: string };
+  /** Packaged method plugin dir (`--plugin-dir`). */
+  readonly pluginDir?: string;
 }): string[] {
   const { description } = options;
   const args: string[] = [
@@ -100,6 +102,7 @@ export function headlessTurnArgs(options: {
     description.jsonSchemaFlag,
     JSON.stringify(options.jsonSchema),
   ];
+  if (options.pluginDir) args.push("--plugin-dir", options.pluginDir);
   if (options.mcpConfigPath !== undefined && options.mcpConfigPath !== "") {
     args.push(description.mcpConfigFlag, options.mcpConfigPath);
   }
@@ -422,9 +425,7 @@ export function codexTurnArgs(options: {
 
   // JSONL event stream: thread_id + final agent_message + turn.completed/failed.
   args.push("--json");
-  // Operator config/MCP off; auth still uses CODEX_HOME (official).
-  // Project/system config and AGENTS.md have no official suppression switch.
-  args.push("--ignore-user-config", "--ignore-rules");
+  // Operator config/skills stay open (#922 host-native-loader). Auth uses CODEX_HOME.
   const roots = (options.writableRoots ?? []).filter((root) => root !== "");
   if (roots.length > 0) {
     // Resume has no --add-dir; the config key keeps extra roots available on both paths.