@akagilnc/pi-workflow-roles 0.1.3556 → 0.1.3565

package/dist/acp-host/description.js

@@ -0,0 +1,21 @@
+/**
+ * One ACP host description. Every host-specific value the generic ACP adapter
+ * needs — binary location, argv shape, resume verb, binding filename, child env
+ * — is data here; the lifecycle in role-turn-host.ts stays one copy (#732).
+ */
+import { join } from "node:path";
+/** Absolute agent binary for one operator home. */
+export function resolveAcpBinary(description, operatorHome) {
+    return join(operatorHome, ...description.binaryFromHome);
+}
+/** Stdio argv: prefix, optional model/thinking flag pairs, suffix. */
+export function acpStdioArgs(description, model) {
+    const { prefix, suffix, modelFlag, thinkingFlag } = description.argv;
+    const pair = (flag, value) => flag === undefined || value === undefined ? [] : [flag, value];
+    return [
+        ...prefix,
+        ...pair(modelFlag, model?.model),
+        ...pair(thinkingFlag, model?.thinking),
+        ...suffix,
+    ];
+}

package/dist/{grok → acp-host}/mcp-relay.mjs

@@ -2,9 +2,9 @@
 import { connect } from "node:net";
 import { createInterface } from "node:readline";
 
-const socketPath = process.env.AK_GROK_MCP_SOCKET;
-const token = process.env.AK_GROK_MCP_TOKEN;
-if (!socketPath || !token) throw new Error("AK Grok MCP relay identity is missing");
+const socketPath = process.env.AK_ACP_MCP_SOCKET;
+const token = process.env.AK_ACP_MCP_TOKEN;
+if (!socketPath || !token) throw new Error("AK ACP MCP relay identity is missing");
 
 const upstream = connect(socketPath);
 const waiters = new Map();
@@ -45,7 +45,7 @@ upstream.on("error", (error) => settle(error));
 upstream.on("close", () => {
   // Shutdown may already be requested (stdin EOF) while an RPC is still
   // in flight. Outstanding waiters must still settle, or drain never ends.
-  if (!exiting) settle(new Error("AK Grok MCP upstream closed"));
+  if (!exiting) settle(new Error("AK ACP MCP upstream closed"));
   maybeExit();
 });
 createInterface({ input: upstream }).on("line", (line) => {
@@ -56,7 +56,7 @@ createInterface({ input: upstream }).on("line", (line) => {
   if (waiter === undefined) return;
   waiters.delete(message.id);
   if (message.error !== undefined) {
-    const error = new Error(typeof message.error.message === "string" ? message.error.message : "AK Grok MCP relay failure");
+    const error = new Error(typeof message.error.message === "string" ? message.error.message : "AK ACP MCP relay failure");
     error.code = message.error.code;
     error.cause = message.error;
     waiter.reject(error);

package/dist/{grok → acp-host}/production-host.js

@@ -1238,9 +1238,8 @@ var init_in_process_session = __esm({
   }
 });
 
-// src/grok/production-host.ts
+// src/acp-host/production-host.ts
 import { readFile as readFile15 } from "node:fs/promises";
-import { join as join24 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/canonical-skill-binding.ts
@@ -3696,6 +3695,29 @@ function appendEngineSessionMaterial(lines, engineMaterial) {
   return out;
 }
 
+// src/host-descriptions.ts
+var PRIVATE_COMPAT_ENV = Object.fromEntries(
+  ["CLAUDE", "CURSOR", "CODEX"].flatMap((vendor) => ["SKILLS", "RULES", "AGENTS", "MCPS", "HOOKS", "SESSIONS"].map((kind) => [`GROK_${vendor}_${kind}_ENABLED`, "false"]))
+);
+var HOST_DESCRIPTIONS = Object.freeze({
+  /** Operator home `~/.grok`, native session/load resume, `agent [--model X] stdio`. */
+  "grok-build": Object.freeze({
+    binaryFromHome: Object.freeze([".grok", "bin", "grok"]),
+    argv: Object.freeze({
+      prefix: Object.freeze(["agent"]),
+      suffix: Object.freeze(["stdio"]),
+      modelFlag: "--model"
+    }),
+    boundResume: "session/load",
+    sessionBindingFile: "grok-acp-session.json",
+    childEnv: Object.freeze({
+      ...PRIVATE_COMPAT_ENV,
+      GROK_MEMORY: "0",
+      GROK_SUBAGENTS: "0"
+    })
+  })
+});
+
 // src/institutional-resolution.ts
 import { readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join7 } from "node:path";
@@ -13564,14 +13586,30 @@ function createRoleRuntimeExtension(dependencies) {
   };
 }
 
-// src/grok/role-envelope.ts
+// src/acp-host/description.ts
+import { join as join22 } from "node:path";
+function resolveAcpBinary(description, operatorHome) {
+  return join22(operatorHome, ...description.binaryFromHome);
+}
+function acpStdioArgs(description, model) {
+  const { prefix, suffix, modelFlag, thinkingFlag } = description.argv;
+  const pair = (flag, value) => flag === void 0 || value === void 0 ? [] : [flag, value];
+  return [
+    ...prefix,
+    ...pair(modelFlag, model?.model),
+    ...pair(thinkingFlag, model?.thinking),
+    ...suffix
+  ];
+}
+
+// src/acp-host/role-envelope.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { mkdir as mkdir3, readFile as readFile13, writeFile as writeFile7 } from "node:fs/promises";
 import { createServer } from "node:net";
-import { basename as basename7, dirname as dirname15, join as join22 } from "node:path";
+import { basename as basename7, dirname as dirname15, join as join23 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
-// src/grok/role-turn-host.ts
+// src/acp-host/role-turn-host.ts
 import { spawn as spawn4 } from "node:child_process";
 import { createInterface } from "node:readline";
 
@@ -13581,8 +13619,8 @@ function renderAgentStartMaterials(body, materials) {
   return [body, ...materials.map((material) => JSON.stringify(material))].join("\n\n");
 }
 
-// src/grok/role-turn-host.ts
-function renderGrokSystemPromptOverride(authority) {
+// src/acp-host/role-turn-host.ts
+function renderAcpSystemPromptOverride(authority) {
   return renderAgentStartMaterials(authority.body, authority.materials);
 }
 function failure(cause, name, code, details) {
@@ -13598,19 +13636,13 @@ function failure(cause, name, code, details) {
   };
 }
 function hostAbortedError() {
-  return Object.assign(new Error("Grok host aborted"), { code: "host-aborted" });
+  return Object.assign(new Error("ACP host aborted"), { code: "host-aborted" });
 }
 function acpError(code, message, cause) {
   return Object.assign(new Error(message, cause === void 0 ? void 0 : { cause }), { code });
 }
-function connectGrokAcpStdio(options) {
-  const args = [
-    "agent",
-    ...options.model === void 0 ? [] : ["--model", options.model],
-    "stdio"
-  ];
-  const env = options.toolset === void 0 ? options.env : { ...options.env, GROK_CONFIG: JSON.stringify({ toolset: options.toolset }) };
-  const child = spawn4(options.binary, args, { cwd: options.cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+function connectAcpStdio(options) {
+  const child = spawn4(options.binary, [...options.args], { cwd: options.cwd, env: options.env, stdio: ["pipe", "pipe", "pipe"] });
   const pending = /* @__PURE__ */ new Map();
   const notificationHandlers = [];
   if (options.onNotification !== void 0) notificationHandlers.push(options.onNotification);
@@ -13633,13 +13665,13 @@ function connectGrokAcpStdio(options) {
   child.stderr.setEncoding("utf8").on("data", (chunk) => {
     stderr += chunk;
   });
-  child.on("error", (error) => settleClosed(acpError("acp-process-error", `Grok ACP process error: ${error.message}`, error)));
+  child.on("error", (error) => settleClosed(acpError("acp-process-error", `ACP process error: ${error.message}`, error)));
   createInterface({ input: child.stdout }).on("line", (line2) => {
     let message;
     try {
       message = JSON.parse(line2);
     } catch (error) {
-      terminate(acpError("acp-invalid-json", `Invalid Grok ACP JSON: ${String(error)}`, error));
+      terminate(acpError("acp-invalid-json", `Invalid ACP JSON: ${String(error)}`, error));
       return;
     }
     if (typeof message.method === "string") {
@@ -13647,13 +13679,13 @@ function connectGrokAcpStdio(options) {
       for (const handler of notificationHandlers) handler(message.method, params);
       if (typeof message.id === "number") {
         if (message.method !== "session/request_permission") {
-          terminate(acpError("acp-unsupported-client-request", `Unsupported Grok ACP client request: ${message.method}`));
+          terminate(acpError("acp-unsupported-client-request", `Unsupported ACP client request: ${message.method}`));
           return;
         }
         const choices = Array.isArray(params.options) ? params.options : [];
         const selected = choices.find((value) => typeof value === "object" && value !== null && value.kind === "allow_once");
         if (typeof selected?.optionId !== "string") {
-          terminate(acpError("acp-permission-missing-allow-once", "Grok ACP permission request omitted allow_once"));
+          terminate(acpError("acp-permission-missing-allow-once", "ACP permission request omitted allow_once"));
           return;
         }
         child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id: message.id, result: { outcome: { outcome: "selected", optionId: selected.optionId } } })}
@@ -13665,13 +13697,13 @@ function connectGrokAcpStdio(options) {
     const waiter = pending.get(message.id);
     if (waiter === void 0) return;
     pending.delete(message.id);
-    if (message.error !== void 0) waiter.reject(acpError("acp-upstream-error", `Grok ACP error: ${JSON.stringify(message.error)}`));
+    if (message.error !== void 0) waiter.reject(acpError("acp-upstream-error", `ACP error: ${JSON.stringify(message.error)}`));
     else waiter.resolve(message.result ?? {});
   });
-  child.on("close", (code) => settleClosed(acpError("acp-closed", `Grok ACP closed (${String(code)}): ${stderr}`)));
+  child.on("close", (code) => settleClosed(acpError("acp-closed", `ACP closed (${String(code)}): ${stderr}`)));
   return Promise.resolve({
     request(method, params) {
-      if (closed) return Promise.reject(terminalError ?? acpError("acp-connection-closed", "Grok ACP connection is closed"));
+      if (closed) return Promise.reject(terminalError ?? acpError("acp-connection-closed", "ACP connection is closed"));
       const id = ++nextId;
       return new Promise((resolve17, reject) => {
         pending.set(id, { resolve: resolve17, reject });
@@ -13681,12 +13713,12 @@ function connectGrokAcpStdio(options) {
           const waiter = pending.get(id);
           if (waiter === void 0) return;
           pending.delete(id);
-          waiter.reject(acpError("acp-write-failed", `Grok ACP write failed: ${error.message}`, error));
+          waiter.reject(acpError("acp-write-failed", `ACP write failed: ${error.message}`, error));
         });
       });
     },
     notify(method, params) {
-      if (closed) throw terminalError ?? acpError("acp-connection-closed", "Grok ACP connection is closed");
+      if (closed) throw terminalError ?? acpError("acp-connection-closed", "ACP connection is closed");
       child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
 `);
     },
@@ -13695,14 +13727,14 @@ function connectGrokAcpStdio(options) {
     },
     async close() {
       if (closed) return;
-      settleClosed(acpError("acp-connection-closed", "Grok ACP connection is closed"));
+      settleClosed(acpError("acp-connection-closed", "ACP connection is closed"));
       child.stdin.end();
       child.kill("SIGTERM");
       await new Promise((resolve17) => child.once("close", () => resolve17()));
     }
   });
 }
-function createGrokRoleTurnHost(config) {
+function createAcpRoleTurnHost(config) {
   let serial = Promise.resolve();
   return {
     executeTurn(request) {
@@ -13714,7 +13746,7 @@ function createGrokRoleTurnHost(config) {
         let accepted = false;
         try {
           if (prepared.mcpServers.length === 0) {
-            return failure("activation", "UncontrolledGrokSession", "ak-config-missing");
+            return failure("activation", "UncontrolledAcpSession", "ak-config-missing");
           }
           connection = await config.connect(request);
           const initialized = await connection.request("initialize", {
@@ -13725,49 +13757,36 @@ function createGrokRoleTurnHost(config) {
           const modelState = initializeMeta?.modelState;
           const availableModels = Array.isArray(modelState?.availableModels) ? modelState.availableModels : void 0;
           if (request.model !== void 0 && availableModels !== void 0 && !availableModels.some((entry) => typeof entry === "object" && entry !== null && entry.modelId === request.model?.model)) {
-            return failure("activation", "GrokHostModelMismatch", "host-model-mismatch", {
+            return failure("activation", "AcpHostModelMismatch", "host-model-mismatch", {
               provider: request.model.provider,
               model: request.model.model
             });
           }
-          const priorNativePaths = continuation.kind === "resume" && request.hostTransition?.previousHost === "pi" ? request.hostTransition.priorNativePaths : void 0;
-          if (continuation.kind === "resume") {
+          const priorNativePaths = continuation.kind === "resume" ? request.hostTransition?.priorNativePaths : void 0;
+          if (continuation.kind === "resume" && config.boundResume === "session/load") {
             const boundSessionId = await config.sessionIdentity.load(request.principal);
             if (boundSessionId !== void 0 && boundSessionId !== "") {
               const loaded = await connection.request("session/load", {
                 sessionId: boundSessionId,
                 cwd: request.cwd,
                 mcpServers: prepared.mcpServers,
-                _meta: { systemPromptOverride: renderGrokSystemPromptOverride(prepared.systemPrompt), yoloMode: false }
+                _meta: { systemPromptOverride: renderAcpSystemPromptOverride(prepared.systemPrompt), yoloMode: false }
               });
               sessionId = typeof loaded.sessionId === "string" && loaded.sessionId !== "" ? loaded.sessionId : boundSessionId;
-            } else {
-              const session = await connection.request(
-                "session/new",
-                {
-                  cwd: request.cwd,
-                  mcpServers: prepared.mcpServers,
-                  _meta: { systemPromptOverride: renderGrokSystemPromptOverride(prepared.systemPrompt), yoloMode: false }
-                }
-              );
-              sessionId = typeof session.sessionId === "string" ? session.sessionId : void 0;
-              if (sessionId === void 0 || sessionId === "") {
-                return failure("session", "GrokAcpSessionFailure", "session-id-missing");
-              }
-              await config.sessionIdentity.bind(request.principal, sessionId);
             }
-          } else {
+          }
+          if (sessionId === void 0) {
             const session = await connection.request(
               "session/new",
               {
                 cwd: request.cwd,
                 mcpServers: prepared.mcpServers,
-                _meta: { systemPromptOverride: renderGrokSystemPromptOverride(prepared.systemPrompt), yoloMode: false }
+                _meta: { systemPromptOverride: renderAcpSystemPromptOverride(prepared.systemPrompt), yoloMode: false }
               }
             );
             sessionId = typeof session.sessionId === "string" ? session.sessionId : void 0;
             if (sessionId === void 0 || sessionId === "") {
-              return failure("session", "GrokAcpSessionFailure", "session-id-missing");
+              return failure("session", "AcpSessionFailure", "session-id-missing");
             }
             await config.sessionIdentity.bind(request.principal, sessionId);
           }
@@ -13828,7 +13847,7 @@ ${priorNativePaths.join("\n")}` : prepared.prompt;
               throw error;
             }
             if (result2.stopReason === "refusal") {
-              return failure("output", "GrokAcpRefusal", "refusal", { sessionId });
+              return failure("output", "AcpRefusal", "refusal", { sessionId });
             }
             const closure = await prepared.closeRound();
             if (closure.accepted) {
@@ -13841,7 +13860,7 @@ ${priorNativePaths.join("\n")}` : prepared.prompt;
             }
             prompt = `The prior terminal submission was rejected (${closure.retry.code}). Resubmit it as the sole terminal tool call. Rejected call ids: ${closure.retry.toolCallIds.join(", ") || "none"}.`;
           }
-          return failure("output", "GrokAcpRoundLimit", "round-retry-limit", { sessionId });
+          return failure("output", "AcpRoundLimit", "round-retry-limit", { sessionId });
         } finally {
           if (connection !== void 0) {
             if (sessionId !== void 0 && !accepted) {
@@ -13866,25 +13885,14 @@ ${priorNativePaths.join("\n")}` : prepared.prompt;
     }
   };
 }
-var PRIVATE_COMPAT_ENV = Object.fromEntries(
-  ["CLAUDE", "CURSOR", "CODEX"].flatMap((vendor) => ["SKILLS", "RULES", "AGENTS", "MCPS", "HOOKS", "SESSIONS"].map((kind) => [`GROK_${vendor}_${kind}_ENABLED`, "false"]))
-);
-function controlledGrokChildEnv(base) {
-  return {
-    ...base,
-    ...PRIVATE_COMPAT_ENV,
-    GROK_MEMORY: "0",
-    GROK_SUBAGENTS: "0"
-  };
-}
 
-// src/grok/role-envelope.ts
+// src/acp-host/role-envelope.ts
 function parseCanonicalSkillInvocation(prompt) {
   const match = /^\/skill:([A-Za-z0-9_-]+)(?:\s+([\s\S]*))?$/s.exec(prompt.trim());
   if (match === null) return void 0;
   return { name: match[1], userMessage: (match[2] ?? "").trim() };
 }
-function buildGrokSkillExpansion(methodSkills, prompt) {
+function buildAcpSkillExpansion(methodSkills, prompt) {
   const parsed = parseCanonicalSkillInvocation(prompt);
   if (parsed === void 0) return void 0;
   const method = methodSkills.get(parsed.name);
@@ -13898,7 +13906,7 @@ ${method.body}`,
     userMessage: parsed.userMessage
   });
 }
-function projectGrokActivationFlags(request) {
+function projectAcpActivationFlags(request) {
   const activation = request.activation;
   const flags = /* @__PURE__ */ new Map([["ak-role", activation.role]]);
   const inputFlag = packagedRoleInputFlag(activation.role);
@@ -13936,21 +13944,21 @@ async function listen(server, path) {
     });
   });
 }
-function createComposedGrokRoleTurnHost(config) {
-  return createGrokRoleTurnHost({
+function createComposedAcpRoleTurnHost(config) {
+  return createAcpRoleTurnHost({
     ...config,
-    prepare: (request) => prepareGrokRoleEnvelope({
+    prepare: (request) => prepareAcpRoleEnvelope({
       request,
       dependencies: config.roleRuntimeDependencies,
       // Same durable-principal path settlement uses for isAvailable (#617 DK-4 layout).
       sessionFile: config.sessionIdentity.resolveSessionFile(request.principal),
-      socketPath: config.socketPath?.(request) ?? `/tmp/ak-grok-mcp-${randomUUID2()}.sock`
+      socketPath: config.socketPath?.(request) ?? `/tmp/ak-acp-mcp-${randomUUID2()}.sock`
     })
   });
 }
-async function prepareGrokRoleEnvelope(options) {
+async function prepareAcpRoleEnvelope(options) {
   const { request } = options;
-  const flags = projectGrokActivationFlags(request);
+  const flags = projectAcpActivationFlags(request);
   const tools = /* @__PURE__ */ new Map();
   const handlers = /* @__PURE__ */ new Map();
   const calls = [];
@@ -13969,7 +13977,7 @@ async function prepareGrokRoleEnvelope(options) {
     const raw = await readFile13(method.path, "utf8");
     methodSkills.set(name, { path: method.path, body: stripSkillFrontmatter(raw).trim() });
   }
-  let sessionFile = options.sessionFile ?? join22(request.runDirectory, "session", "session.jsonl");
+  let sessionFile = options.sessionFile ?? join23(request.runDirectory, "session", "session.jsonl");
   await mkdir3(dirname15(sessionFile), { recursive: true });
   if (request.continuation.kind !== "resume") {
     try {
@@ -14034,7 +14042,7 @@ async function prepareGrokRoleEnvelope(options) {
     },
     capabilities: {
       skillExpansion(prompt) {
-        return buildGrokSkillExpansion(methodSkills, prompt);
+        return buildAcpSkillExpansion(methodSkills, prompt);
       }
     },
     registerFlag(name, definition) {
@@ -14046,12 +14054,12 @@ async function prepareGrokRoleEnvelope(options) {
     registerTool(tool2) {
       tools.set(tool2.name, tool2);
     },
-    // The real AK-owned surface only; Grok's builtin surface is host-side and
+    // The real AK-owned surface only; the host builtin surface is host-side and
     // observable after session/new, never echoed back into role-requested names.
     getAllTools() {
       return [...tools.keys()].map((name) => ({ name }));
     },
-    // Grok receives tool choice as role guidance; every tool registered for the
+    // The host receives tool choice as role guidance; every tool registered for the
     // seat remains reachable through MCP.
     setActiveTools(names) {
       preferredTools = [...names];
@@ -14333,7 +14341,7 @@ async function prepareGrokRoleEnvelope(options) {
     }
     if (cleanupFailures.length === 1) throw cleanupFailures[0];
     if (cleanupFailures.length > 1) {
-      throw new AggregateError(cleanupFailures, "Grok envelope dispose cleanup failures", {
+      throw new AggregateError(cleanupFailures, "ACP envelope dispose cleanup failures", {
         cause: cleanupFailures[0]
       });
     }
@@ -14410,8 +14418,8 @@ async function prepareGrokRoleEnvelope(options) {
         command: process.execPath,
         args: [relay],
         env: [
-          { name: "AK_GROK_MCP_SOCKET", value: options.socketPath },
-          { name: "AK_GROK_MCP_TOKEN", value: token }
+          { name: "AK_ACP_MCP_SOCKET", value: options.socketPath },
+          { name: "AK_ACP_MCP_TOKEN", value: token }
         ]
       }],
       systemPrompt: { body: systemPromptBody, materials: readingMaterials },
@@ -14426,7 +14434,7 @@ async function prepareGrokRoleEnvelope(options) {
     } catch (cleanupFailure) {
       throw new AggregateError(
         [error, cleanupFailure],
-        "prepareGrokRoleEnvelope activation failed and its dispose cleanup also failed",
+        "prepareAcpRoleEnvelope activation failed and its dispose cleanup also failed",
         { cause: error }
       );
     }
@@ -14434,12 +14442,11 @@ async function prepareGrokRoleEnvelope(options) {
   }
 }
 
-// src/grok/session-identity.ts
+// src/acp-host/session-identity.ts
 import { mkdir as mkdir4, readFile as readFile14, rename, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname16, join as join23 } from "node:path";
-var GROK_ACP_SESSION_BINDING = "grok-acp-session.json";
-function createGrokSessionIdentityAuthority(authority) {
-  const bindingPath = (principal) => join23(authority.decode(principal).sessionDirectory, GROK_ACP_SESSION_BINDING);
+import { dirname as dirname16, join as join24 } from "node:path";
+function createAcpSessionIdentityAuthority(authority, sessionBindingFile) {
+  const bindingPath = (principal) => join24(authority.decode(principal).sessionDirectory, sessionBindingFile);
   return {
     resolveSessionFile(principal) {
       return authority.decode(principal).sessionFile;
@@ -14448,7 +14455,7 @@ function createGrokSessionIdentityAuthority(authority) {
       try {
         const value = JSON.parse(await readFile14(bindingPath(principal), "utf8"));
         if (typeof value !== "object" || value === null || typeof value.sessionId !== "string") {
-          throw new Error("durable Grok ACP session binding is invalid");
+          throw new Error("durable ACP session binding is invalid");
         }
         return value.sessionId;
       } catch (error) {
@@ -14467,20 +14474,11 @@ function createGrokSessionIdentityAuthority(authority) {
   };
 }
 
-// src/grok/production-host.ts
-function resolveGrokBinary(operatorHome) {
-  return join24(operatorHome, ".grok", "bin", "grok");
-}
-function childEnv(packageRoot) {
-  return {
-    ...controlledGrokChildEnv(process.env),
-    AK_PACKAGE_ROOT: packageRoot
-  };
-}
+// src/acp-host/production-host.ts
 var navigatorRoutePlaybookPath = fileURLToPath3(
   new URL("../../resources/navigator-route-playbook.md", import.meta.url)
 );
-function createGrokRoleRuntimeDependencies(packageRoot) {
+function createAcpRoleRuntimeDependencies(packageRoot) {
   const judgeAuditor = createPiJudgeAuditor();
   const doctorAuditor = createPiDoctorAuditor();
   const reviewerAgent = createPerDispatchReviewerAgent({ packageRoot });
@@ -14544,23 +14542,28 @@ function createGrokRoleRuntimeDependencies(packageRoot) {
     })
   };
 }
-function createProductionGrokRoleTurnHost(options) {
-  const { packageRoot, principalAuthority } = options;
-  const env = childEnv(packageRoot);
-  return createComposedGrokRoleTurnHost({
-    sessionIdentity: createGrokSessionIdentityAuthority(principalAuthority),
-    roleRuntimeDependencies: createGrokRoleRuntimeDependencies(packageRoot),
+function createProductionAcpRoleTurnHost(options) {
+  const { packageRoot, principalAuthority, description } = options;
+  const env = {
+    ...process.env,
+    ...description.childEnv,
+    AK_PACKAGE_ROOT: packageRoot
+  };
+  return createComposedAcpRoleTurnHost({
+    sessionIdentity: createAcpSessionIdentityAuthority(principalAuthority, description.sessionBindingFile),
+    boundResume: description.boundResume,
+    roleRuntimeDependencies: createAcpRoleRuntimeDependencies(packageRoot),
     async connect(request) {
-      return connectGrokAcpStdio({
-        binary: resolveGrokBinary(request.home),
+      return connectAcpStdio({
+        binary: resolveAcpBinary(description, request.home),
+        args: acpStdioArgs(description, request.model),
         cwd: request.cwd,
-        env,
-        ...request.model === void 0 ? {} : { model: request.model.model }
+        env
       });
     }
   });
 }
 export {
-  createGrokRoleRuntimeDependencies,
-  createProductionGrokRoleTurnHost
+  createAcpRoleRuntimeDependencies,
+  createProductionAcpRoleTurnHost
 };

package/dist/host-descriptions.js

@@ -0,0 +1,34 @@
+/** Grok CLI reads vendor-private compat surfaces unless each is disabled by name. */
+const PRIVATE_COMPAT_ENV = Object.fromEntries(["CLAUDE", "CURSOR", "CODEX"].flatMap((vendor) => ["SKILLS", "RULES", "AGENTS", "MCPS", "HOOKS", "SESSIONS"].map((kind) => [`GROK_${vendor}_${kind}_ENABLED`, "false"])));
+export const DEFAULT_ROLE_TURN_HOST = "pi";
+export const HOST_DESCRIPTIONS = Object.freeze({
+    /** Operator home `~/.grok`, native session/load resume, `agent [--model X] stdio`. */
+    "grok-build": Object.freeze({
+        binaryFromHome: Object.freeze([".grok", "bin", "grok"]),
+        argv: Object.freeze({
+            prefix: Object.freeze(["agent"]),
+            suffix: Object.freeze(["stdio"]),
+            modelFlag: "--model",
+        }),
+        boundResume: "session/load",
+        sessionBindingFile: "grok-acp-session.json",
+        childEnv: Object.freeze({
+            ...PRIVATE_COMPAT_ENV,
+            GROK_MEMORY: "0",
+            GROK_SUBAGENTS: "0",
+        }),
+    }),
+});
+export function lookupHostDescription(host) {
+    return Object.hasOwn(HOST_DESCRIPTIONS, host) ? HOST_DESCRIPTIONS[host] : undefined;
+}
+export function packagedExternalHostNames() {
+    return Object.keys(HOST_DESCRIPTIONS);
+}
+/** Legal persistent/invocation host: default pi, or a table key. */
+export function assertRegisteredHostName(host) {
+    if (host === DEFAULT_ROLE_TURN_HOST || lookupHostDescription(host) !== undefined) {
+        return host;
+    }
+    throw new Error(`unregistered host: ${host}`);
+}

package/dist/public-cli/config.js

@@ -1,5 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import { assertRegisteredHostName, DEFAULT_ROLE_TURN_HOST } from "../host-descriptions.js";
 import { assertLegalEngineName } from "../package-resources/engine-material.js";
 import { resolveConfiguredProvinceOfficer } from "../institutional-resolution.js";
 import {
@@ -95,7 +96,8 @@ function setPersistentSeatHost(config, seat, host) {
     }
     return { ...config, seats: { ...config.seats, [seat]: rest } };
   }
-  return { ...config, seats: { ...config.seats, [seat]: { ...previous, host } } };
+  const registered = assertRegisteredHostName(host);
+  return { ...config, seats: { ...config.seats, [seat]: { ...previous, host: registered } } };
 }
 function setPersistentSeatEngine(config, seat, engine) {
   const previous = config.seats[seat];
@@ -140,14 +142,25 @@ function setAutoResumeLimit(config, limit) {
 function validatePublicCliConfigAxes(config, _packageRoot) {
   for (const seat of Object.keys(config.seats)) {
     const row = config.seats[seat];
-    if (row?.engine === void 0) continue;
-    try {
-      assertLegalEngineName(row.engine);
-    } catch (error) {
-      throw new Error(
-        `config seat ${seat} engine is illegal: ${row.engine}`,
-        { cause: error }
-      );
+    if (row?.engine !== void 0) {
+      try {
+        assertLegalEngineName(row.engine);
+      } catch (error) {
+        throw new Error(
+          `config seat ${seat} engine is illegal: ${row.engine}`,
+          { cause: error }
+        );
+      }
+    }
+    if (row?.host !== void 0) {
+      try {
+        assertRegisteredHostName(row.host);
+      } catch (error) {
+        throw new Error(
+          `config seat ${seat} host is unregistered: ${row.host}`,
+          { cause: error }
+        );
+      }
     }
   }
 }
@@ -304,7 +317,7 @@ function attachHostAxis(seat, config, invocation) {
   if (invocation?.host !== void 0) return { ...seat, host: invocation.host, hostSource: "invocation" };
   const persistent = config.seats[seat.seat]?.host;
   if (persistent !== void 0) return { ...seat, host: persistent, hostSource: "persistent" };
-  return { ...seat, host: "pi", hostSource: "default" };
+  return { ...seat, host: DEFAULT_ROLE_TURN_HOST, hostSource: "default" };
 }
 function attachEngineAxis(seat, config, invocation) {
   if (!isPublicCallableRole(seat.seat)) {