@akagilnc/pi-workflow-roles 0.1.3545 → 0.1.3549

package/README.md

@@ -40,7 +40,7 @@ ak-role judge --attach ./plan.md "Review this plan." > result.txt
 
 Exit status reports lifecycle honesty, not business success: every lawful typed result (including `audit_escalation`) exits zero; a failure without a lawful result exits nonzero, and its Terminal carries the Error Artifact ref and original cause instead of a fabricated receipt.
 
-`ak-role resume <runId> [message]` reopens that run under the **current seat table** for model / host / engine — the same resolution as starting a new leg (`--flag` → persistent seat → package default). Standard chain after a role `escalate`s: take the owner ruling and feed it back with `ak-role resume <runId> "<ruling>"` so the same run continues to a terminal. `[message]` applies only to seats that accept caller instruction: for those seats the optional `message` after `runId` is passed through unchanged as the continuation prompt (opaque: not parsed as flags); omit it to use the package resume envelope. Notary/符宝郎 must omit `message` and derives evidence from the existing source-run/dossier binding. Global `--model` / `--host` / `--engine` override the table for that resume only. On a real host switch (live seat host differs from the previous invocation host), prior native records of the previous host are delivered once as context to the target host; same-host resume does not re-inject. Each host writes only its native volume (Pi: `session/session.jsonl`, Grok: `runDirectory/grok-home`), with unified ledger entries recorded in 司天台 (Sitian). Whether to resume is the caller's decision: the command does not require a typed HTTP 429 or a `resumable` state. Unknown run IDs and missing session principals are rejected. Every callable role accepts manual resume; Countersign and Gleaner-Left gained it in #599, Collector, Doctor, Notary, and Inspector in #633.
+`ak-role resume <runId> [message]` reopens that run under the **current seat table** for model / host / engine — the same resolution as starting a new leg (`--flag` → persistent seat → package default). Standard chain after a role `escalate`s: take the owner ruling and feed it back with `ak-role resume <runId> "<ruling>"` so the same run continues to a terminal. `[message]` applies only to seats that accept caller instruction: for those seats the optional `message` after `runId` is passed through unchanged as the continuation prompt (opaque: not parsed as flags); omit it to use the package resume envelope. Notary/符宝郎 must omit `message` and derives evidence from the existing source-run/dossier binding. Global `--model` / `--host` / `--engine` override the table for that resume only. On a real host switch (live seat host differs from the previous invocation host), prior native records of the previous host are delivered once as context to the target host; same-host resume does not re-inject. Each host writes only its native volume (Pi: `session/session.jsonl`; Grok CLI journals stay in the operator grok home, factory dossier is sitian records on the run), with unified ledger entries recorded in 司天台 (Sitian). Whether to resume is the caller's decision: the command does not require a typed HTTP 429 or a `resumable` state. Unknown run IDs and missing session principals are rejected. Every callable role accepts manual resume; Countersign and Gleaner-Left gained it in #599, Collector, Doctor, Notary, and Inspector in #633.
 
 Judge, coder, fixer, reviewer, and merger also retry a non-lawful LLM call in place (same `runId` and session) up to `autoResumeLimit` times. Unset defaults to 2; `ak-role config set-auto-resume-limit <N>` writes the ceiling (`0` disables). Lawful typed terminals (`accepted`, `audit_escalation`, `no_receipt`) stop immediately. Manual `ak-role resume` stays available.
 

package/README.zh-CN.md

@@ -38,7 +38,7 @@ ak-role judge --attach ./plan.md "Review this plan." > result.txt
 
 退出码报的是生命周期诚实，不是业务成败：一切合法 typed 终态（含 `audit_escalation`）退出零；无合法终态的失败退出非零，其 Terminal 携带 Error Artifact 引用与原始原因，不伪造回执。
 
-`ak-role resume <runId> [message]` 按**现行席位表**的 model / host / engine 续跑该次运行——与新起角色腿同一解析（调用旗 → 席位持久 → 包默认）。角色 `escalate`（直通御前）后拿到 owner 裁定，标准续跑是 `ak-role resume <runId> "<裁定>"`——把裁定喂回同一 run，角色继续走到终局。`[message]` 只适用于接收 caller instruction 的席位：对这些席位，`runId` 后可选的 `message` 原样作为续跑 prompt（opaque：不进全局旗标语法）；省略则用包自带 resume envelope。Notary/符宝郎必须省略 `message`，仅从既有 source-run/案卷绑定自取证。全局 `--model` / `--host` / `--engine` 仅覆盖本次 resume。真实换宿主时（现行席位 host 与上一次 invocation host 不同），将前序宿主原生卷宗一次性作为 context 交付目标宿主；同宿主续跑不重复注入。各宿主仅直写自身原生卷宗（Pi：`session/session.jsonl`，Grok：`runDirectory/grok-home`），统一账目归入司天台。要不要续跑由调用者决定：不再要求 typed HTTP 429，也不要求 `resumable` 状态。未知 run ID、session 主体不在则拒绝。所有可调用角色均可手动 resume：给事中、左拾遗始于 #599，通进司、太医署、符宝郎、察院始于 #633。
+`ak-role resume <runId> [message]` 按**现行席位表**的 model / host / engine 续跑该次运行——与新起角色腿同一解析（调用旗 → 席位持久 → 包默认）。角色 `escalate`（直通御前）后拿到 owner 裁定，标准续跑是 `ak-role resume <runId> "<裁定>"`——把裁定喂回同一 run，角色继续走到终局。`[message]` 只适用于接收 caller instruction 的席位：对这些席位，`runId` 后可选的 `message` 原样作为续跑 prompt（opaque：不进全局旗标语法）；省略则用包自带 resume envelope。Notary/符宝郎必须省略 `message`，仅从既有 source-run/案卷绑定自取证。全局 `--model` / `--host` / `--engine` 仅覆盖本次 resume。真实换宿主时（现行席位 host 与上一次 invocation host 不同），将前序宿主原生卷宗一次性作为 context 交付目标宿主；同宿主续跑不重复注入。各宿主仅直写自身原生卷宗（Pi：`session/session.jsonl`；Grok CLI 原始会话留在操作员 grok 家，工厂卷宗为该 run 的司天台记录），统一账目归入司天台。要不要续跑由调用者决定：不再要求 typed HTTP 429，也不要求 `resumable` 状态。未知 run ID、session 主体不在则拒绝。所有可调用角色均可手动 resume：给事中、左拾遗始于 #599，通进司、太医署、符宝郎、察院始于 #633。
 
 大理寺、将作监、修内司、御史台、校书郎在单次调用内对非 lawful LLM 终态原地续跑（同一 `runId` 与 session），次数上限为 `autoResumeLimit`。缺键默认 2；`ak-role config set-auto-resume-limit <N>` 写入（`0` 关闭自动续）。lawful typed 终态（`accepted` / `audit_escalation` / `no_receipt`）立即停止。手动 `ak-role resume` 仍可用。
 

package/dist/grok/production-host.js

@@ -1239,8 +1239,8 @@ var init_in_process_session = __esm({
 });
 
 // src/grok/production-host.ts
-import { readFile as readFile15, rm as rm6, writeFile as writeFile10 } from "node:fs/promises";
-import { join as join26 } from "node:path";
+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
@@ -5284,14 +5284,12 @@ function acceptedFacts(toolName, details) {
 function record2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var GROK_HOME_DIR_NAME = "grok-home";
 async function discoverCaseFiles(root) {
   const found = [];
   async function walk(dir, depth) {
     for (const item of await readdir(dir, { withFileTypes: true })) {
       const path = resolve8(dir, item.name);
       if (item.isDirectory()) {
-        if (item.name === GROK_HOME_DIR_NAME) continue;
         await walk(path, depth + 1);
       } else if (item.isFile() && (item.name.endsWith(".jsonl") || item.name === "stderr.log" && depth === 1)) found.push(path);
     }
@@ -13558,17 +13556,14 @@ function createRoleRuntimeExtension(dependencies) {
 
 // src/grok/role-envelope.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir as mkdir5, readFile as readFile13, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile13, writeFile as writeFile7 } from "node:fs/promises";
 import { createServer } from "node:net";
-import { basename as basename8, dirname as dirname16, join as join24 } from "node:path";
+import { basename as basename7, dirname as dirname15, join as join22 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/grok/role-turn-host.ts
-import { execFile as execFile3, spawn as spawn4 } from "node:child_process";
-import { copyFile, lstat as lstat3, mkdir as mkdir4, open as open2, realpath as realpath7, rm as rm5 } from "node:fs/promises";
-import { basename as basename7, dirname as dirname15, isAbsolute as isAbsolute7, join as join23, relative as pathRelative } from "node:path";
+import { spawn as spawn4 } from "node:child_process";
 import { createInterface } from "node:readline";
-import { promisify as promisify3 } from "node:util";
 
 // src/agent-start-materials.ts
 function renderAgentStartMaterials(body, materials) {
@@ -13576,60 +13571,6 @@ function renderAgentStartMaterials(body, materials) {
   return [body, ...materials.map((material) => JSON.stringify(material))].join("\n\n");
 }
 
-// src/grok/bash-seatbelt.ts
-import { mkdir as mkdir3, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join22 } from "node:path";
-function renderGrokBashSeatbeltHookScript() {
-  const reasons = Object.fromEntries(
-    FIXER_BASH_FORBIDDEN_LITERALS.map((literal) => [literal, fixerBashSeatbeltDenyReason(literal)])
-  );
-  return `#!/usr/bin/env node
-const LITERALS = ${JSON.stringify([...FIXER_BASH_FORBIDDEN_LITERALS])};
-const REASONS = ${JSON.stringify(reasons)};
-let raw = "";
-process.stdin.setEncoding("utf8");
-process.stdin.on("data", (chunk) => { raw += chunk; });
-process.stdin.on("end", () => {
-  let event = {};
-  try { event = JSON.parse(raw); } catch { /* fail-open on malformed host payload */ }
-  const input = event && typeof event === "object" ? event.toolInput : undefined;
-  const command = input && typeof input === "object" && typeof input.command === "string"
-    ? input.command : undefined;
-  const matched = typeof command === "string"
-    ? LITERALS.find((literal) => command.includes(literal))
-    : undefined;
-  const decision = matched === undefined
-    ? { decision: "allow" }
-    : { decision: "deny", reason: REASONS[matched] };
-  process.stdout.write(JSON.stringify(decision));
-});
-`;
-}
-async function installGrokPreToolUseDeny(controlledHome) {
-  const hooksDir = join22(controlledHome, "hooks");
-  await mkdir3(hooksDir, { recursive: true });
-  const scriptName = "ak-bash-seatbelt.mjs";
-  const scriptPath = join22(hooksDir, scriptName);
-  await writeFile7(scriptPath, renderGrokBashSeatbeltHookScript(), { mode: 493 });
-  await writeFile7(join22(hooksDir, "ak-bash-seatbelt.json"), `${JSON.stringify({
-    hooks: {
-      PreToolUse: [
-        {
-          matcher: "Bash|run_terminal_command",
-          hooks: [
-            {
-              type: "command",
-              command: process.execPath + " " + JSON.stringify(scriptPath),
-              timeout: 5
-            }
-          ]
-        }
-      ]
-    }
-  }, null, 2)}
-`);
-}
-
 // src/grok/role-turn-host.ts
 function renderGrokSystemPromptOverride(authority) {
   return renderAgentStartMaterials(authority.body, authority.materials);
@@ -13756,12 +13697,6 @@ function createGrokRoleTurnHost(config) {
   return {
     executeTurn(request) {
       const execution = serial.then(async () => {
-        const inspected = await config.inspect(request);
-        if (inspected.privateActive.length !== 0) {
-          return failure("activation", "UncontrolledGrokSession", "private-config-active", {
-            privateActive: [...inspected.privateActive]
-          });
-        }
         const continuation = request.continuation;
         const prepared = await config.prepare(request);
         let connection;
@@ -13777,15 +13712,6 @@ function createGrokRoleTurnHost(config) {
             clientCapabilities: {}
           });
           const initializeMeta = initialized._meta;
-          const hookMeta = initialized._meta;
-          const hookCapability = hookMeta?.["x.ai/hooks"];
-          const canDeny = Array.isArray(hookCapability?.blockingEvents) && hookCapability.blockingEvents.includes("pre_tool_use") && Array.isArray(hookCapability.decisions) && hookCapability.decisions.includes("deny");
-          let preToolUseDeny = false;
-          if (canDeny && request.activation.role === "fixer") {
-            await installGrokPreToolUseDeny(request.home);
-            preToolUseDeny = true;
-          }
-          await config.recordCapabilities(request, { nativeToolNarrowing: false, preToolUseDeny });
           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)) {
@@ -13933,222 +13859,10 @@ ${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"]))
 );
-var execFileAsync3 = promisify3(execFile3);
-function errnoCode2(error) {
-  if (typeof error !== "object" || error === null || !("code" in error)) return void 0;
-  const code = error.code;
-  return typeof code === "string" ? code : void 0;
-}
-async function realpathIfPresent(path) {
-  try {
-    return await realpath7(path);
-  } catch (error) {
-    if (errnoCode2(error) === "ENOENT") return void 0;
-    throw error;
-  }
-}
-async function worktreeFilePresence(path) {
-  try {
-    const handle = await open2(path, "r");
-    await handle.close();
-    return "present";
-  } catch (error) {
-    if (errnoCode2(error) === "ENOENT") return "absent";
-    throw error;
-  }
-}
-async function resolveHeadTreePath(topLevel, relativePath) {
-  const { stdout: exactOut } = await execFileAsync3(
-    "git",
-    ["ls-tree", "--name-only", "HEAD", "--", relativePath],
-    { cwd: topLevel, encoding: "utf8" }
-  );
-  const exactHits = exactOut.split("\n").map((name) => name.trim()).filter((name) => name !== "");
-  if (exactHits.includes(relativePath)) return relativePath;
-  const parent = dirname15(relativePath);
-  const leaf = basename7(relativePath);
-  if (parent !== ".") {
-    const { stdout: parentOut } = await execFileAsync3(
-      "git",
-      ["ls-tree", "--name-only", "HEAD", "--", parent],
-      { cwd: topLevel, encoding: "utf8" }
-    );
-    const parentHits = parentOut.split("\n").map((name) => name.trim()).filter((name) => name !== "");
-    if (!parentHits.includes(parent)) return void 0;
-  }
-  const { stdout: listing } = parent === "." ? await execFileAsync3("git", ["ls-tree", "--name-only", "HEAD"], {
-    cwd: topLevel,
-    encoding: "utf8"
-  }) : await execFileAsync3("git", ["ls-tree", "--name-only", `HEAD:${parent}`], {
-    cwd: topLevel,
-    encoding: "utf8"
-  });
-  const needle = leaf.toLowerCase();
-  const hits = listing.split("\n").map((name) => name.trim()).filter((name) => name !== "" && basename7(name).toLowerCase() === needle).map((name) => parent === "." ? basename7(name) : join23(parent, basename7(name)));
-  return hits.length === 1 ? hits[0] : void 0;
-}
-async function isHeadMatchedProjectInstruction(repositoryCwd, absolutePath) {
-  if (absolutePath === "" || absolutePath.includes("\0")) return false;
-  const { stdout: topLevelOut } = await execFileAsync3("git", ["rev-parse", "--show-toplevel"], {
-    cwd: repositoryCwd,
-    encoding: "utf8"
-  });
-  await execFileAsync3("git", ["rev-parse", "--verify", "HEAD"], {
-    cwd: repositoryCwd,
-    encoding: "utf8"
-  });
-  const topLevel = await realpath7(topLevelOut.trim());
-  const parent = await realpathIfPresent(dirname15(absolutePath));
-  if (parent === void 0) return false;
-  const leaf = basename7(absolutePath);
-  if (leaf === "" || leaf === "." || leaf === "..") return false;
-  const candidate = join23(parent, leaf);
-  const relative3 = pathRelative(topLevel, candidate);
-  if (relative3 === "" || relative3.startsWith("..") || isAbsolute7(relative3) || relative3.includes("\0")) {
-    return false;
-  }
-  const headRel = await resolveHeadTreePath(topLevel, relative3);
-  if (headRel === void 0) return false;
-  const headFile = join23(topLevel, headRel);
-  const { stdout: headBlobOut } = await execFileAsync3(
-    "git",
-    ["rev-parse", "--verify", `HEAD:${headRel}`],
-    { cwd: topLevel, encoding: "utf8" }
-  );
-  const headBlob = headBlobOut.trim();
-  let hashTarget = candidate;
-  const candidatePresence = await worktreeFilePresence(candidate);
-  if (candidatePresence === "absent") {
-    if (candidate === headFile) return false;
-    const headPresence = await worktreeFilePresence(headFile);
-    if (headPresence === "absent") return false;
-    hashTarget = headFile;
-  }
-  const { stdout } = await execFileAsync3("git", ["hash-object", "--", hashTarget], {
-    cwd: topLevel,
-    encoding: "utf8"
-  });
-  return headBlob === stdout.trim();
-}
-function inspectItemPath(value) {
-  if (typeof value.source?.path === "string") return value.source.path;
-  if (typeof value.path === "string") return value.path;
-  return "";
-}
-function isInspectItemActive(value) {
-  return value.disabled !== true && value.enabled !== false && value.compatibilityStatus !== "disabled";
-}
-function listActiveProjectInstructionPaths(document) {
-  const items = document.projectInstructions;
-  if (!Array.isArray(items)) return [];
-  const paths = [];
-  for (const value of items) {
-    if (!isInspectItemActive(value)) continue;
-    const path = inspectItemPath(value);
-    if (path !== "") paths.push(path);
-  }
-  return paths;
-}
-function classifyGrokInspection(document, packageRoot, options = {}) {
-  const privateActive = /* @__PURE__ */ new Set();
-  const akActive = /* @__PURE__ */ new Set();
-  const headMatched = options.headMatchedProjectInstructionPaths ?? /* @__PURE__ */ new Set();
-  const externalCompat = document.externalCompat;
-  if (Array.isArray(externalCompat?.cells)) {
-    for (const cell of externalCompat.cells) {
-      if (cell.enabled !== true) continue;
-      privateActive.add(`externalCompat:${String(cell.vendor)}:${String(cell.surface)}`);
-    }
-  }
-  for (const section of ["skills", "agents", "plugins", "mcpServers", "hooks", "projectInstructions"]) {
-    const items = document[section];
-    if (!Array.isArray(items)) continue;
-    for (const value of items) {
-      if (!isInspectItemActive(value)) continue;
-      const sourceType = value.source?.type;
-      const path = inspectItemPath(value);
-      const identity = `${section}:${typeof value.name === "string" ? value.name : path}`;
-      if (sourceType === "builtin" || sourceType === "bundled") continue;
-      if (path === packageRoot || path.startsWith(`${packageRoot}/`)) akActive.add(identity);
-      else if (section === "projectInstructions" && headMatched.has(path)) continue;
-      else privateActive.add(identity);
-    }
-  }
-  return { privateActive: [...privateActive].sort(), akActive: [...akActive].sort() };
-}
-var AK_BASH_SEATBELT_HOOK_FILES = ["ak-bash-seatbelt.json", "ak-bash-seatbelt.mjs"];
-function isMissingPathError2(error) {
-  return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
-}
-async function assertControlledGrokHomeIsRealDirectory(controlledHome) {
-  let st;
-  try {
-    st = await lstat3(controlledHome);
-  } catch (error) {
-    if (isMissingPathError2(error)) return;
-    throw error;
-  }
-  if (st.isSymbolicLink()) {
-    throw new Error(`controlled grok home must not be a symlink: ${controlledHome}`);
-  }
-  if (!st.isDirectory()) {
-    throw new Error(`controlled grok home must be a real directory: ${controlledHome}`);
-  }
-}
-async function assertControlledGrokAuthIsNotSymlink(authPath) {
-  let st;
-  try {
-    st = await lstat3(authPath);
-  } catch (error) {
-    if (isMissingPathError2(error)) return;
-    throw error;
-  }
-  if (st.isSymbolicLink()) {
-    throw new Error(`controlled grok auth must not be a symlink: ${authPath}`);
-  }
-}
-async function scrubAkBashSeatbeltHooks(controlledHome) {
-  const hooksDir = join23(controlledHome, "hooks");
-  for (const name of AK_BASH_SEATBELT_HOOK_FILES) {
-    await rm5(join23(hooksDir, name), { force: true });
-  }
-}
-async function prepareControlledGrokHome(sourceHome, controlledHome) {
-  await assertControlledGrokHomeIsRealDirectory(controlledHome);
-  await mkdir4(controlledHome, { recursive: true, mode: 448 });
-  await assertControlledGrokHomeIsRealDirectory(controlledHome);
-  const authPath = join23(controlledHome, "auth.json");
-  await assertControlledGrokAuthIsNotSymlink(authPath);
-  await rm5(authPath, { force: true });
-  await scrubAkBashSeatbeltHooks(controlledHome);
-  await copyFile(join23(sourceHome, ".grok", "auth.json"), authPath);
-}
-async function inspectControlledGrok(options) {
-  const { stdout } = await execFileAsync3(options.binary, ["inspect", "--json"], {
-    cwd: options.cwd,
-    env: options.env,
-    encoding: "utf8"
-  });
-  const document = JSON.parse(stdout);
-  if (typeof document !== "object" || document === null || Array.isArray(document)) {
-    throw new Error("Grok structured inspection did not return an object");
-  }
-  const record4 = document;
-  const headMatchedProjectInstructionPaths = /* @__PURE__ */ new Set();
-  for (const path of listActiveProjectInstructionPaths(record4)) {
-    if (path === options.packageRoot || path.startsWith(`${options.packageRoot}/`)) continue;
-    if (await isHeadMatchedProjectInstruction(options.cwd, path)) {
-      headMatchedProjectInstructionPaths.add(path);
-    }
-  }
-  return classifyGrokInspection(record4, options.packageRoot, { headMatchedProjectInstructionPaths });
-}
-function controlledGrokChildEnv(base, grokHome) {
+function controlledGrokChildEnv(base) {
   return {
     ...base,
     ...PRIVATE_COMPAT_ENV,
-    HOME: grokHome,
-    GROK_HOME: grokHome,
     GROK_MEMORY: "0",
     GROK_SUBAGENTS: "0"
   };
@@ -14168,7 +13882,7 @@ function buildGrokSkillExpansion(methodSkills, prompt) {
   return Object.freeze({
     name: parsed.name,
     location: method.path,
-    content: `References are relative to ${dirname16(method.path)}.
+    content: `References are relative to ${dirname15(method.path)}.
 
 ${method.body}`,
     userMessage: parsed.userMessage
@@ -14238,18 +13952,18 @@ async function prepareGrokRoleEnvelope(options) {
   let infrastructureRoundFailure;
   const hostAbort = new AbortController();
   const runId = request.runDirectory.split("/").filter(Boolean).at(-1) ?? randomUUID2();
-  await mkdir5(request.runDirectory, { recursive: true });
+  await mkdir3(request.runDirectory, { recursive: true });
   for (const method of request.methods) {
     if (method.kind !== "skill") continue;
-    const name = basename8(dirname16(method.path));
+    const name = basename7(dirname15(method.path));
     const raw = await readFile13(method.path, "utf8");
     methodSkills.set(name, { path: method.path, body: stripSkillFrontmatter(raw).trim() });
   }
-  let sessionFile = options.sessionFile ?? join24(request.runDirectory, "session", "session.jsonl");
-  await mkdir5(dirname16(sessionFile), { recursive: true });
+  let sessionFile = options.sessionFile ?? join22(request.runDirectory, "session", "session.jsonl");
+  await mkdir3(dirname15(sessionFile), { recursive: true });
   if (request.continuation.kind !== "resume") {
     try {
-      await writeFile8(
+      await writeFile7(
         sessionFile,
         `${JSON.stringify({
           type: "session",
@@ -14273,7 +13987,7 @@ async function prepareGrokRoleEnvelope(options) {
       getLeafEntry: () => sessionEntries.at(-1),
       getLeafId: () => runId,
       getEntries: () => sessionEntries,
-      getSessionDir: () => dirname16(sessionFile),
+      getSessionDir: () => dirname15(sessionFile),
       getSessionFile: () => sessionFile,
       getHeader: () => ({ type: "session", id: runId }),
       setSessionFile(path) {
@@ -14711,11 +14425,11 @@ async function prepareGrokRoleEnvelope(options) {
 }
 
 // src/grok/session-identity.ts
-import { mkdir as mkdir6, readFile as readFile14, rename, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname17, join as join25 } from "node:path";
+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) => join25(authority.decode(principal).sessionDirectory, GROK_ACP_SESSION_BINDING);
+  const bindingPath = (principal) => join23(authority.decode(principal).sessionDirectory, GROK_ACP_SESSION_BINDING);
   return {
     resolveSessionFile(principal) {
       return authority.decode(principal).sessionFile;
@@ -14734,9 +14448,9 @@ function createGrokSessionIdentityAuthority(authority) {
     },
     async bind(principal, sessionId) {
       const target = bindingPath(principal);
-      await mkdir6(dirname17(target), { recursive: true });
+      await mkdir4(dirname16(target), { recursive: true });
       const temporary = `${target}.${process.pid}.tmp`;
-      await writeFile9(temporary, `${JSON.stringify({ sessionId })}
+      await writeFile8(temporary, `${JSON.stringify({ sessionId })}
 `, { encoding: "utf8", mode: 384 });
       await rename(temporary, target);
     }
@@ -14745,79 +14459,14 @@ function createGrokSessionIdentityAuthority(authority) {
 
 // src/grok/production-host.ts
 function resolveGrokBinary(operatorHome) {
-  return join26(operatorHome, ".grok", "bin", "grok");
+  return join24(operatorHome, ".grok", "bin", "grok");
 }
-var NO_PRODUCTION_GROK_PRIMARY_FAILURE = {
-  present: false
-};
-async function settleProductionGrokHomeCleanup(controlledHome, primaryFailure, concurrentMessage) {
-  try {
-    await assertControlledGrokHomeIsRealDirectory(controlledHome);
-    const authPath = join26(controlledHome, "auth.json");
-    await assertControlledGrokAuthIsNotSymlink(authPath);
-    await rm6(authPath, { force: true });
-    await scrubAkBashSeatbeltHooks(controlledHome);
-  } catch (cleanupFailure) {
-    if (primaryFailure.present) {
-      throw new AggregateError([primaryFailure.value, cleanupFailure], concurrentMessage, {
-        cause: primaryFailure.value
-      });
-    }
-    throw cleanupFailure;
-  }
-  if (primaryFailure.present) {
-    throw primaryFailure.value;
-  }
-}
-async function openProductionGrokHome(runDirectory, operatorHome) {
-  const controlledHome = join26(runDirectory, "grok-home");
-  try {
-    await prepareControlledGrokHome(operatorHome, controlledHome);
-    return controlledHome;
-  } catch (error) {
-    await settleProductionGrokHomeCleanup(
-      controlledHome,
-      { present: true, value: error },
-      "production grok home open failed and its cleanup also failed"
-    );
-    throw error;
-  }
-}
-function childEnv(controlledHome, packageRoot) {
+function childEnv(packageRoot) {
   return {
-    ...controlledGrokChildEnv(process.env, controlledHome),
+    ...controlledGrokChildEnv(process.env),
     AK_PACKAGE_ROOT: packageRoot
   };
 }
-async function bindProductionGrokIsolation(runDirectory, operatorHome, packageRoot) {
-  const controlledHome = await openProductionGrokHome(runDirectory, operatorHome);
-  return {
-    operatorHome,
-    controlledHome,
-    binary: resolveGrokBinary(operatorHome),
-    env: childEnv(controlledHome, packageRoot)
-  };
-}
-async function withProductionGrokIsolation(runDirectory, operatorHome, packageRoot, run) {
-  let binding;
-  let primaryFailure = NO_PRODUCTION_GROK_PRIMARY_FAILURE;
-  let value;
-  try {
-    binding = await bindProductionGrokIsolation(runDirectory, operatorHome, packageRoot);
-    value = await run(binding);
-  } catch (error) {
-    primaryFailure = { present: true, value: error };
-  }
-  if (binding !== void 0) {
-    await settleProductionGrokHomeCleanup(
-      binding.controlledHome,
-      primaryFailure,
-      "production grok isolation turn and cleanup failed"
-    );
-  }
-  if (primaryFailure.present) throw primaryFailure.value;
-  return value;
-}
 var navigatorRoutePlaybookPath = fileURLToPath3(
   new URL("../../resources/navigator-route-playbook.md", import.meta.url)
 );
@@ -14885,76 +14534,23 @@ function createGrokRoleRuntimeDependencies(packageRoot) {
     })
   };
 }
-async function recordGrokCapabilities(request, declaration) {
-  await writeFile10(
-    join26(request.runDirectory, "grok-capabilities.json"),
-    `${JSON.stringify(declaration)}
-`,
-    "utf8"
-  );
-}
 function createProductionGrokRoleTurnHost(options) {
   const { packageRoot, principalAuthority } = options;
-  let turn;
-  let serial = Promise.resolve();
-  const inner = createComposedGrokRoleTurnHost({
+  const env = childEnv(packageRoot);
+  return createComposedGrokRoleTurnHost({
     sessionIdentity: createGrokSessionIdentityAuthority(principalAuthority),
     roleRuntimeDependencies: createGrokRoleRuntimeDependencies(packageRoot),
-    recordCapabilities: recordGrokCapabilities,
-    async inspect(request) {
-      if (turn === void 0) {
-        throw new Error("production grok inspect requires an active isolated turn");
-      }
-      return inspectControlledGrok({
-        binary: turn.binary,
-        cwd: request.cwd,
-        env: turn.env,
-        packageRoot
-      });
-    },
     async connect(request) {
-      if (turn === void 0) {
-        throw new Error("production grok connect requires an active isolated turn");
-      }
       return connectGrokAcpStdio({
-        binary: turn.binary,
+        binary: resolveGrokBinary(request.home),
         cwd: request.cwd,
-        env: turn.env,
+        env,
         ...request.model === void 0 ? {} : { model: request.model.model }
       });
     }
   });
-  return {
-    executeTurn(request) {
-      const execution = serial.then(
-        () => withProductionGrokIsolation(
-          request.runDirectory,
-          request.home,
-          packageRoot,
-          async (binding) => {
-            turn = binding;
-            try {
-              return await inner.executeTurn({ ...request, home: binding.controlledHome });
-            } finally {
-              turn = void 0;
-            }
-          }
-        )
-      );
-      serial = execution.then(
-        () => void 0,
-        () => void 0
-      );
-      return execution;
-    }
-  };
 }
 export {
-  NO_PRODUCTION_GROK_PRIMARY_FAILURE,
-  bindProductionGrokIsolation,
   createGrokRoleRuntimeDependencies,
-  createProductionGrokRoleTurnHost,
-  openProductionGrokHome,
-  settleProductionGrokHomeCleanup,
-  withProductionGrokIsolation
+  createProductionGrokRoleTurnHost
 };