@amaster.ai/employee-runtime-connector 0.1.13-beta.0 → 0.1.13-beta.2

package/dist/amaster-runtime-daemon.mjs

@@ -83,7 +83,7 @@ function withAuditCorrelationEnvironment(environment, command) {
 }
 
 // src/amaster-runtime-daemon.mjs
-import { createHash as createHash20, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash20, randomUUID as randomUUID3 } from "node:crypto";
 import { createRequire } from "node:module";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
@@ -19214,10 +19214,10 @@ var MIRRORX_DRIVE_AGENT_RULES = [
 ].join("\n");
 
 // src/amaster-runtime-daemon.mjs
-import { chmodSync as chmodSync8, copyFileSync as copyFileSync2, existsSync as existsSync18, lstatSync as lstatSync15, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync5, readFileSync as readFileSync20, readdirSync as readdirSync13, realpathSync as realpathSync12, renameSync as renameSync11, rmSync as rmSync12, statSync as statSync12, symlinkSync as symlinkSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "node:fs";
+import { chmodSync as chmodSync9, copyFileSync as copyFileSync2, existsSync as existsSync18, lstatSync as lstatSync16, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync5, readFileSync as readFileSync21, readdirSync as readdirSync14, realpathSync as realpathSync12, renameSync as renameSync12, rmSync as rmSync12, statSync as statSync12, symlinkSync as symlinkSync2, unlinkSync as unlinkSync4, writeFileSync as writeFileSync15 } from "node:fs";
 import { arch as arch4, homedir as homedir7, hostname as hostname2, platform as platform4, tmpdir } from "node:os";
-import { basename as basename8, delimiter as delimiter3, dirname as dirname13, extname as extname3, isAbsolute as isAbsolute13, join as join25, relative as relative9, resolve as resolve19 } from "node:path";
-import { spawn, spawnSync as spawnSync5 } from "node:child_process";
+import { basename as basename8, delimiter as delimiter3, dirname as dirname14, extname as extname3, isAbsolute as isAbsolute13, join as join26, relative as relative9, resolve as resolve20 } from "node:path";
+import { spawn, spawnSync as spawnSync6 } from "node:child_process";
 
 // src/amaster-runtime-daemon/common.mjs
 import { homedir } from "node:os";
@@ -19725,7 +19725,7 @@ async function postRuntimeConnectorJsonWithRetry(config, path, payload, options
     } catch (error) {
       lastError = error;
       if (attempt >= maxAttempts || !retryableRuntimeConnectorPost(error)) throw error;
-      if (delayMs > 0) await new Promise((resolve20) => setTimeout(resolve20, delayMs));
+      if (delayMs > 0) await new Promise((resolve21) => setTimeout(resolve21, delayMs));
     }
   }
   throw lastError;
@@ -20106,12 +20106,167 @@ function preparePiExecutorAccess(input) {
   return { uid, gid };
 }
 
+// src/amaster-runtime-daemon/browser-session-profile.mjs
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  chmodSync as chmodSync2,
+  chownSync as chownSync2,
+  lstatSync as lstatSync4,
+  mkdirSync as mkdirSync3,
+  readFileSync,
+  readdirSync as readdirSync2,
+  rmdirSync,
+  unlinkSync,
+  writeFileSync as writeFileSync3,
+  renameSync as renameSync2
+} from "node:fs";
+import { parse, resolve as resolve4, join as join5, dirname as dirname2 } from "node:path";
+import { spawnSync } from "node:child_process";
+var MARKERS = ".owners";
+function statOrNull(path) {
+  try {
+    return lstatSync4(path);
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function fail() {
+  throw new Error("browser_session_profile_path_invalid");
+}
+function assertRootControlledAncestors(path) {
+  for (let current = resolve4(path); ; current = dirname2(current)) {
+    const stat = statOrNull(current);
+    if (!stat?.isDirectory() || stat.isSymbolicLink() || stat.uid !== 0 || (stat.mode & 18) !== 0) fail();
+    if (current === parse(current).root) break;
+  }
+}
+function assertDirectory(path, uid, gid, mode) {
+  const stat = statOrNull(path);
+  if (!stat?.isDirectory() || stat.isSymbolicLink() || stat.uid !== uid || stat.gid !== gid || (stat.mode & 511) !== mode) fail();
+}
+function markerPath(root, opaqueRef) {
+  return join5(root, MARKERS, `${opaqueRef}.json`);
+}
+function assertIdentityMarker(path, identity) {
+  const stat = statOrNull(path);
+  if (!stat?.isFile() || stat.isSymbolicLink() || stat.uid !== 0 || (stat.mode & 511) !== 384) fail();
+  let stored;
+  try {
+    stored = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    fail();
+  }
+  if (JSON.stringify(stored) !== JSON.stringify(identity)) {
+    throw new Error("browser_session_profile_identity_invalid");
+  }
+}
+function assertInput(input) {
+  const { root, identity, uid, gid } = input;
+  if (process.getuid?.() !== 0 || !Number.isSafeInteger(uid) || uid <= 0 || !Number.isSafeInteger(gid) || gid <= 0 || !/^profile_[a-z0-9]{16,64}$/iu.test(identity?.localOpaqueRef ?? "") || resolve4(root) === parse(resolve4(root)).root) fail();
+  return { root: resolve4(root), profile: join5(resolve4(root), identity.localOpaqueRef), marker: markerPath(resolve4(root), identity.localOpaqueRef) };
+}
+function assertRootPaths(root) {
+  assertRootControlledAncestors(dirname2(root));
+  const rootStat = statOrNull(root);
+  if (rootStat && (!rootStat.isDirectory() || rootStat.isSymbolicLink() || rootStat.uid !== 0 || rootStat.gid !== 0 || (rootStat.mode & 18) !== 0)) fail();
+  if (!rootStat) mkdirSync3(root, { mode: 448 });
+  const registry = join5(root, MARKERS);
+  const registryStat = statOrNull(registry);
+  if (registryStat && (!registryStat.isDirectory() || registryStat.isSymbolicLink() || registryStat.uid !== 0 || registryStat.gid !== 0 || (registryStat.mode & 63) !== 0)) fail();
+  if (!registryStat) mkdirSync3(registry, { mode: 448 });
+  chmodSync2(registry, 448);
+  chmodSync2(root, 457);
+  assertDirectory(root, 0, 0, 457);
+  assertDirectory(registry, 0, 0, 448);
+}
+function ensureUnprivilegedBrowserSessionProfile(input) {
+  const { root, profile, marker } = assertInput(input);
+  assertRootPaths(root);
+  let profileStat = statOrNull(profile);
+  let markerStat = statOrNull(marker);
+  if (profileStat && !markerStat) {
+    assertDirectory(profile, 0, 0, 448);
+    if (readdirSync2(profile).length !== 0) fail();
+    rmdirSync(profile);
+    profileStat = null;
+  }
+  if (!profileStat && markerStat) {
+    assertIdentityMarker(marker, input.identity);
+    unlinkSync(marker);
+    markerStat = null;
+  }
+  if (profileStat) {
+    assertIdentityMarker(marker, input.identity);
+    if (profileStat.uid === 0 && profileStat.gid === 0) {
+      assertDirectory(profile, 0, 0, 448);
+      if (readdirSync2(profile).length !== 0) fail();
+      chownSync2(profile, input.uid, input.gid);
+    }
+    assertDirectory(profile, input.uid, input.gid, 448);
+  } else {
+    mkdirSync3(profile, { mode: 448 });
+    assertDirectory(profile, 0, 0, 448);
+    const temporary = `${marker}.${randomUUID2()}.tmp`;
+    writeFileSync3(temporary, `${JSON.stringify(input.identity)}
+`, { mode: 384, flag: "wx" });
+    renameSync2(temporary, marker);
+    assertIdentityMarker(marker, input.identity);
+    chownSync2(profile, input.uid, input.gid);
+    assertDirectory(profile, input.uid, input.gid, 448);
+  }
+  return { profileRoot: root, userDataDir: profile, identity: input.identity };
+}
+function cleanupUnprivilegedBrowserSessionProfile(input) {
+  const { root, profile, marker } = assertInput(input);
+  assertRootPaths(root);
+  const profileStat = statOrNull(profile);
+  const markerStat = statOrNull(marker);
+  if (!profileStat && !markerStat) return { outcome: "absent", identity: input.identity };
+  if (!profileStat && markerStat) {
+    assertIdentityMarker(marker, input.identity);
+    unlinkSync(marker);
+    return { outcome: "deleted", identity: input.identity };
+  }
+  if (profileStat && !markerStat) {
+    assertDirectory(profile, 0, 0, 448);
+    if (readdirSync2(profile).length !== 0) fail();
+    rmdirSync(profile);
+    return { outcome: "deleted", identity: input.identity };
+  }
+  assertIdentityMarker(marker, input.identity);
+  if (profileStat.uid === 0 && profileStat.gid === 0) {
+    assertDirectory(profile, 0, 0, 448);
+    if (readdirSync2(profile).length !== 0) fail();
+    rmdirSync(profile);
+    unlinkSync(marker);
+    return { outcome: "deleted", identity: input.identity };
+  }
+  assertDirectory(profile, input.uid, input.gid, 448);
+  const cleanup = spawnSync(process.execPath, ["-e", `
+    const fs = require('node:fs');
+    const path = require('node:path');
+    const root = process.argv[1];
+    for (const name of fs.readdirSync(root)) fs.rmSync(path.join(root, name), { recursive: true, force: true });
+  `, profile], {
+    uid: input.uid,
+    gid: input.gid,
+    env: {},
+    stdio: "ignore",
+    timeout: 3e4
+  });
+  if (cleanup.status !== 0 || cleanup.error || readdirSync2(profile).length !== 0) fail();
+  rmdirSync(profile);
+  unlinkSync(marker);
+  return { outcome: "deleted", identity: input.identity };
+}
+
 // src/amaster-runtime-daemon/codex-managed-mcp-profile.mjs
 import { createHash as createHash5 } from "node:crypto";
-import { chmodSync as chmodSync2, existsSync as existsSync3, lstatSync as lstatSync4, mkdirSync as mkdirSync3, readFileSync, realpathSync as realpathSync4, readdirSync as readdirSync2, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { chmodSync as chmodSync3, existsSync as existsSync3, lstatSync as lstatSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync2, realpathSync as realpathSync4, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { arch, platform } from "node:os";
-import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join as join6, relative, resolve as resolve4 } from "node:path";
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join7, relative, resolve as resolve5 } from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
 
 // ../../node_modules/.pnpm/smol-toml@1.7.0/node_modules/smol-toml/dist/date.js
 var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
@@ -20728,7 +20883,7 @@ function peekTable(key, table, meta, type) {
   }
   return [k, t, state.c];
 }
-function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+function parse2(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
   let res = {};
   let meta = {};
   let tbl = res;
@@ -20935,9 +21090,9 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
 }
 
 // src/amaster-runtime-daemon/executor-discovery.mjs
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync2, realpathSync as realpathSync3, statSync } from "node:fs";
-import { delimiter, isAbsolute, join as join5 } from "node:path";
+import { delimiter, isAbsolute, join as join6 } from "node:path";
 
 // src/amaster-runtime-daemon/codebuddy-isolation-env.mjs
 var CODEBUDDY_ISOLATION_ENV = Object.freeze({
@@ -21019,7 +21174,7 @@ function commandExists(command, env = process.env) {
     return Boolean(resolveExecutorCommand(command, env));
   }
   const commandEnv = executorDiscoveryEnv(env);
-  const result2 = spawnSync("sh", ["-lc", `command -v ${quoteShell(command)} >/dev/null 2>&1`], {
+  const result2 = spawnSync2("sh", ["-lc", `command -v ${quoteShell(command)} >/dev/null 2>&1`], {
     env: commandEnv,
     stdio: "ignore"
   });
@@ -21029,7 +21184,7 @@ function commandVersion(command, env = process.env) {
   const commandEnv = executorDiscoveryEnv(env);
   const executable = resolveExecutorCommand(command, env);
   if (!executable) return void 0;
-  const result2 = spawnSync(executable, ["--version"], {
+  const result2 = spawnSync2(executable, ["--version"], {
     env: commandEnv,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "ignore"],
@@ -21052,7 +21207,7 @@ function resolveExecutorCommand(command, env = process.env) {
     return null;
   }
   const commandEnv = executorDiscoveryEnv(env);
-  const result2 = spawnSync("where.exe", [normalized], {
+  const result2 = spawnSync2("where.exe", [normalized], {
     env: commandEnv,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "ignore"]
@@ -21092,7 +21247,7 @@ function parseCodebuddyVersion(output) {
 function codebuddyExecutableIdentity(executable, env) {
   let candidate = executable;
   if (!isAbsolute(candidate) && !candidate.includes("/") && !candidate.includes("\\")) {
-    candidate = String(env.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => join5(directory, candidate)).find((path) => {
+    candidate = String(env.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => join6(directory, candidate)).find((path) => {
       try {
         return statSync(path).isFile();
       } catch {
@@ -21139,7 +21294,7 @@ function attestCodebuddyCommand(command, env = process.env, cwd = void 0) {
   const cachedVersion = cachedCodebuddyAttestation(cacheKey, now);
   if (cachedVersion) return { executable, executorVersion: cachedVersion };
   const shell = isWindowsCommandShim(executable) ? { shell: true } : {};
-  const version = spawnSync(executable, ["--version"], {
+  const version = spawnSync2(executable, ["--version"], {
     ...cwd ? { cwd } : {},
     env: commandEnv,
     encoding: "utf8",
@@ -21151,7 +21306,7 @@ function attestCodebuddyCommand(command, env = process.env, cwd = void 0) {
     throw new Error(`codebuddy_executor_attestation_failed: --version exit=${version.status ?? "spawn_error"}`);
   }
   const executorVersion = parseCodebuddyVersion(version.stdout);
-  const help2 = spawnSync(executable, ["--help"], {
+  const help2 = spawnSync2(executable, ["--help"], {
     ...cwd ? { cwd } : {},
     env: commandEnv,
     encoding: "utf8",
@@ -21296,14 +21451,14 @@ function within(candidate, root) {
   return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
 }
 function writePrivateFile(filePath, contents) {
-  writeFileSync3(filePath, contents, { mode: 384, flag: "wx" });
-  chmodSync2(filePath, 384);
+  writeFileSync4(filePath, contents, { mode: 384, flag: "wx" });
+  chmodSync3(filePath, 384);
   const mode = statSync2(filePath).mode & 511;
   if (mode !== 384) throw new Error(`codex_managed_mcp_permissions_failed: ${filePath} mode=${mode.toString(8)}`);
 }
 function makePrivateDir(dirPath) {
-  mkdirSync3(dirPath, { recursive: true, mode: 448 });
-  chmodSync2(dirPath, 448);
+  mkdirSync4(dirPath, { recursive: true, mode: 448 });
+  chmodSync3(dirPath, 448);
 }
 function findSessionRollout(sessionsRoot, sessionId) {
   if (!existsSync3(sessionsRoot)) return null;
@@ -21311,12 +21466,12 @@ function findSessionRollout(sessionsRoot, sessionId) {
   const pending = [sessionsRoot];
   while (pending.length > 0) {
     const current = pending.pop();
-    const currentStat = lstatSync4(current);
+    const currentStat = lstatSync5(current);
     if (!currentStat.isDirectory() || currentStat.isSymbolicLink()) {
       throw new Error("codex_managed_mcp_session_rollout_unsafe: sessions path is not a private directory");
     }
-    for (const entry of readdirSync2(current, { withFileTypes: true })) {
-      const candidate = join6(current, entry.name);
+    for (const entry of readdirSync3(current, { withFileTypes: true })) {
+      const candidate = join7(current, entry.name);
       if (entry.isSymbolicLink()) throw new Error("codex_managed_mcp_session_rollout_unsafe: symlinks are forbidden");
       if (entry.isDirectory()) pending.push(candidate);
       else if (entry.isFile() && entry.name.endsWith(`-${sessionId}.jsonl`)) matches.push(candidate);
@@ -21340,33 +21495,33 @@ function restoreManagedCodexSessionRollout(input, codexHome, runDir, executorHom
     nonEmpty(session.invocationId, "nativeSession.invocationId");
   }
   const sourceWorkspacePath = nonEmpty(session.cwd, "nativeSession.cwd");
-  const issueRoot = dirname2(runDir);
+  const issueRoot = dirname3(runDir);
   const managedSourceRunDirName = `${sourceRunId}-${createHash5("sha256").update(sourceRunId).digest("hex").slice(0, 8)}`;
-  const sourceRunDirs = readdirSync2(issueRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.isSymbolicLink() && (entry.name === sourceRunId || entry.name === managedSourceRunDirName)).map((entry) => join6(issueRoot, entry.name));
+  const sourceRunDirs = readdirSync3(issueRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.isSymbolicLink() && (entry.name === sourceRunId || entry.name === managedSourceRunDirName)).map((entry) => join7(issueRoot, entry.name));
   if (sourceRunDirs.length !== 1) {
     throw new Error(`codex_managed_mcp_session_rollout_missing: expected one source run directory for ${sourceRunId}, received ${sourceRunDirs.length}`);
   }
   const executorRelativePath = relative(runDir, executorHome);
-  const cacheRoot = join6(sourceRunDirs[0], executorRelativePath, "session-rollout");
-  const markerPath = join6(cacheRoot, SESSION_ROLLOUT_MARKER);
-  if (!existsSync3(markerPath) || lstatSync4(markerPath).isSymbolicLink() || !lstatSync4(markerPath).isFile()) {
+  const cacheRoot = join7(sourceRunDirs[0], executorRelativePath, "session-rollout");
+  const markerPath2 = join7(cacheRoot, SESSION_ROLLOUT_MARKER);
+  if (!existsSync3(markerPath2) || lstatSync5(markerPath2).isSymbolicLink() || !lstatSync5(markerPath2).isFile()) {
     throw new Error("codex_managed_mcp_session_rollout_missing: source rollout marker is unavailable");
   }
-  const marker = JSON.parse(readFileSync(markerPath, "utf8"));
+  const marker = JSON.parse(readFileSync2(markerPath2, "utf8"));
   if (marker?.version !== 1 || marker?.companyId !== authority.companyId || marker?.agentId !== authority.agentId || marker?.issueId !== authority.issueId || marker?.sourceRunId !== sourceRunId || marker?.sourceCommandId !== sourceCommandId || marker?.sessionId !== sessionId || marker?.sourceWorkspacePath !== sourceWorkspacePath) {
     throw new Error("codex_managed_mcp_session_rollout_authority_mismatch: source rollout does not match the governed continuation");
   }
-  const sourceRollout = resolve4(cacheRoot, nonEmpty(marker.rolloutRelativePath, "rolloutRelativePath"));
-  if (!within(sourceRollout, cacheRoot) || lstatSync4(sourceRollout).isSymbolicLink() || !lstatSync4(sourceRollout).isFile()) {
+  const sourceRollout = resolve5(cacheRoot, nonEmpty(marker.rolloutRelativePath, "rolloutRelativePath"));
+  if (!within(sourceRollout, cacheRoot) || lstatSync5(sourceRollout).isSymbolicLink() || !lstatSync5(sourceRollout).isFile()) {
     throw new Error("codex_managed_mcp_session_rollout_unsafe: source rollout path is invalid");
   }
-  const targetSessionsRoot = join6(codexHome, "sessions");
-  const targetRollout = resolve4(targetSessionsRoot, marker.rolloutRelativePath);
+  const targetSessionsRoot = join7(codexHome, "sessions");
+  const targetRollout = resolve5(targetSessionsRoot, marker.rolloutRelativePath);
   if (!within(targetRollout, targetSessionsRoot)) {
     throw new Error("codex_managed_mcp_session_rollout_unsafe: target rollout path is invalid");
   }
-  makePrivateDir(dirname2(targetRollout));
-  writePrivateFile(targetRollout, readFileSync(sourceRollout));
+  makePrivateDir(dirname3(targetRollout));
+  writePrivateFile(targetRollout, readFileSync2(sourceRollout));
   return { sessionId, sourceRunId, sourceCommandId, rolloutPath: targetRollout, cacheRoot };
 }
 function resolveManagedCodexSessionRollout(input, codexHome, runDir, executorHome, authority) {
@@ -21404,12 +21559,12 @@ function collectAuthSecretStrings(value, output = []) {
   return output;
 }
 function sharedCodexModelRoute(sourceHome) {
-  const configPath = join6(sourceHome, "config.toml");
+  const configPath = join7(sourceHome, "config.toml");
   if (!existsSync3(configPath)) return { root: [], table: [], mode: "default", protectedValues: [] };
   if (!statSync2(configPath).isFile()) throw new Error("codex_managed_mcp_source_config_invalid: config.toml is not a file");
   let config;
   try {
-    config = parse(readFileSync(configPath, "utf8"));
+    config = parse2(readFileSync2(configPath, "utf8"));
   } catch {
     throw new Error("codex_managed_mcp_source_config_invalid: config.toml is not valid TOML");
   }
@@ -21489,12 +21644,12 @@ function parseCodexVersion(stdout) {
 function runAttestation(executorCommand, env, cwd, gatewayUrl, expectedHeaders) {
   const resolvedExecutorCommand = resolveExecutorCommand(executorCommand, env) ?? executorCommand;
   const shellOptions = isWindowsCommandShim(resolvedExecutorCommand) ? { shell: true } : {};
-  const versionResult = spawnSync2(resolvedExecutorCommand, ["--version"], { cwd, env, encoding: "utf8", timeout: 1e4, maxBuffer: 1024 * 1024, ...shellOptions });
+  const versionResult = spawnSync3(resolvedExecutorCommand, ["--version"], { cwd, env, encoding: "utf8", timeout: 1e4, maxBuffer: 1024 * 1024, ...shellOptions });
   if (versionResult.error || versionResult.status !== 0) {
     throw new Error(`codex_managed_mcp_attestation_failed: --version exit=${versionResult.status ?? "spawn_error"}`);
   }
   const executorVersion = parseCodexVersion(versionResult.stdout);
-  const listResult = spawnSync2(resolvedExecutorCommand, ["mcp", "list", "--json"], { cwd, env, encoding: "utf8", timeout: 1e4, maxBuffer: 1024 * 1024, ...shellOptions });
+  const listResult = spawnSync3(resolvedExecutorCommand, ["mcp", "list", "--json"], { cwd, env, encoding: "utf8", timeout: 1e4, maxBuffer: 1024 * 1024, ...shellOptions });
   if (listResult.error || listResult.status !== 0) {
     throw new Error(`codex_managed_mcp_attestation_failed: mcp list exit=${listResult.status ?? "spawn_error"}`);
   }
@@ -21621,32 +21776,32 @@ function buildIsolatedEnvironment(baseEnv, commandEnv) {
   return { ...env, ...record4(commandEnv) };
 }
 function assertNoProjectAmasterOverride(cwd, runDir) {
-  let cursor = resolve4(cwd);
-  const boundary = resolve4(runDir);
+  let cursor = resolve5(cwd);
+  const boundary = resolve5(runDir);
   if (!within(cursor, boundary)) throw new Error("codex_managed_mcp_owner_mismatch: cwd is outside the managed run");
   while (within(cursor, boundary)) {
-    const configPath = join6(cursor, ".codex", "config.toml");
+    const configPath = join7(cursor, ".codex", "config.toml");
     if (existsSync3(configPath)) {
-      const source = readFileSync(configPath, "utf8");
+      const source = readFileSync2(configPath, "utf8");
       const sameName = /mcp_servers\s*(?:\.\s*(?:["']amaster["']|amaster)|=\s*\{[\s\S]*?(?:["']amaster["']|amaster)\s*=)/m.test(source);
       if (sameName) throw new Error(`codex_managed_mcp_project_override_blocked: ${configPath}`);
     }
     if (cursor === boundary) break;
-    cursor = dirname2(cursor);
+    cursor = dirname3(cursor);
   }
 }
 function seedCodexAuth(input, codexHome) {
   const apiKey = typeof input.commandEnv?.OPENAI_API_KEY === "string" ? input.commandEnv.OPENAI_API_KEY.trim() : "";
-  const target = join6(codexHome, "auth.json");
+  const target = join7(codexHome, "auth.json");
   if (apiKey) {
     writePrivateFile(target, `${JSON.stringify({ OPENAI_API_KEY: apiKey })}
 `);
     return { authMode: "api_key", protectedValues: [apiKey], modelRoute: { root: [], table: [], mode: "command_api_key" } };
   }
-  const sourceHome = typeof input.baseEnv?.CODEX_HOME === "string" && input.baseEnv.CODEX_HOME.trim() ? resolve4(input.baseEnv.CODEX_HOME) : join6(typeof input.baseEnv?.HOME === "string" && input.baseEnv.HOME.trim() ? resolve4(input.baseEnv.HOME) : dirname2(resolve4(input.executorHome)), ".codex");
-  const source = join6(sourceHome, "auth.json");
+  const sourceHome = typeof input.baseEnv?.CODEX_HOME === "string" && input.baseEnv.CODEX_HOME.trim() ? resolve5(input.baseEnv.CODEX_HOME) : join7(typeof input.baseEnv?.HOME === "string" && input.baseEnv.HOME.trim() ? resolve5(input.baseEnv.HOME) : dirname3(resolve5(input.executorHome)), ".codex");
+  const source = join7(sourceHome, "auth.json");
   if (!existsSync3(source) || !statSync2(source).isFile()) throw new Error("codex_managed_mcp_auth_missing: isolated Codex run has no usable auth source");
-  const sourceContents = readFileSync(source);
+  const sourceContents = readFileSync2(source);
   let parsedAuth;
   try {
     parsedAuth = JSON.parse(sourceContents.toString("utf8"));
@@ -21683,22 +21838,22 @@ function managedModelProviderConfig(commandEnv) {
 function prepareManagedCodexMcpProfile(input) {
   assertInvocationIsolation(input);
   const { gateway, gatewayUrl, sessionToken, headers, runId } = validateAuthority(input);
-  const runDir = resolve4(nonEmpty(input.runDir, "runDir"));
-  const executorHome = resolve4(nonEmpty(input.executorHome, "executorHome"));
-  if (!within(executorHome, join6(runDir, "executors"))) throw new Error("codex_managed_mcp_owner_mismatch: executorHome is outside the managed run");
+  const runDir = resolve5(nonEmpty(input.runDir, "runDir"));
+  const executorHome = resolve5(nonEmpty(input.executorHome, "executorHome"));
+  if (!within(executorHome, join7(runDir, "executors"))) throw new Error("codex_managed_mcp_owner_mismatch: executorHome is outside the managed run");
   assertNoProjectAmasterOverride(nonEmpty(input.cwd, "cwd"), runDir);
-  const profileRoot = join6(executorHome, "managed-mcp");
+  const profileRoot = join7(executorHome, "managed-mcp");
   if (existsSync3(profileRoot)) throw new Error(`codex_managed_mcp_profile_exists: ${profileRoot}`);
-  const home = join6(profileRoot, "home");
-  const codexHome = join6(profileRoot, "codex-home");
-  const tmp = join6(profileRoot, "tmp");
-  mkdirSync3(home, { recursive: true, mode: 448 });
-  mkdirSync3(codexHome, { recursive: true, mode: 448 });
-  mkdirSync3(tmp, { recursive: true, mode: 448 });
+  const home = join7(profileRoot, "home");
+  const codexHome = join7(profileRoot, "codex-home");
+  const tmp = join7(profileRoot, "tmp");
+  mkdirSync4(home, { recursive: true, mode: 448 });
+  mkdirSync4(codexHome, { recursive: true, mode: 448 });
+  mkdirSync4(tmp, { recursive: true, mode: 448 });
   try {
-    const markerPath = join6(profileRoot, PROFILE_MARKER);
+    const markerPath2 = join7(profileRoot, PROFILE_MARKER);
     const owner = Object.freeze({ commandId: input.commandId, runId });
-    writePrivateFile(markerPath, `${JSON.stringify({ version: 1, ...owner, profileRoot })}
+    writePrivateFile(markerPath2, `${JSON.stringify({ version: 1, ...owner, profileRoot })}
 `);
     const runtimeAuth = record4(input.runtimeAuth);
     const authority = Object.freeze({
@@ -21713,7 +21868,7 @@ function prepareManagedCodexMcpProfile(input) {
       nativeSessionRestoreSkippedReason
     } = resolveManagedCodexSessionRollout(input, codexHome, runDir, executorHome, authority);
     const auth = seedCodexAuth(input, codexHome);
-    const configPath = join6(codexHome, "config.toml");
+    const configPath = join7(codexHome, "config.toml");
     const allHeaders = { Authorization: `Bearer ${sessionToken}`, ...headers };
     const headerToml = Object.entries(allHeaders).map(([name, value]) => `${tomlString(name)} = ${tomlString(value)}`).join(", ");
     const modelProvider = managedModelProviderConfig(input.commandEnv);
@@ -21761,7 +21916,7 @@ function prepareManagedCodexMcpProfile(input) {
     return {
       profileRoot,
       configPath,
-      markerPath,
+      markerPath: markerPath2,
       env,
       owner,
       authority,
@@ -21783,19 +21938,19 @@ function prepareManagedCodexMcpProfile(input) {
 function preserveManagedCodexSessionRollout(profile, input) {
   const sessionId = nonEmpty(input?.sessionId, "sessionId");
   const sourceWorkspacePath = nonEmpty(input?.sourceWorkspacePath, "sourceWorkspacePath");
-  const sessionsRoot = join6(resolve4(nonEmpty(profile?.env?.CODEX_HOME, "profile.env.CODEX_HOME")), "sessions");
+  const sessionsRoot = join7(resolve5(nonEmpty(profile?.env?.CODEX_HOME, "profile.env.CODEX_HOME")), "sessions");
   const sourceRollout = findSessionRollout(sessionsRoot, sessionId);
   const rolloutRelativePath = relative(sessionsRoot, sourceRollout);
   if (!rolloutRelativePath || rolloutRelativePath.startsWith("..") || isAbsolute2(rolloutRelativePath)) {
     throw new Error("codex_managed_mcp_session_rollout_unsafe: rollout escaped the managed Codex home");
   }
-  const cacheRoot = join6(dirname2(resolve4(profile.profileRoot)), "session-rollout");
+  const cacheRoot = join7(dirname3(resolve5(profile.profileRoot)), "session-rollout");
   if (existsSync3(cacheRoot)) rmSync3(cacheRoot, { recursive: true, force: false });
   makePrivateDir(cacheRoot);
-  const targetRollout = join6(cacheRoot, rolloutRelativePath);
-  makePrivateDir(dirname2(targetRollout));
-  writePrivateFile(targetRollout, readFileSync(sourceRollout));
-  writePrivateFile(join6(cacheRoot, SESSION_ROLLOUT_MARKER), `${JSON.stringify({
+  const targetRollout = join7(cacheRoot, rolloutRelativePath);
+  makePrivateDir(dirname3(targetRollout));
+  writePrivateFile(targetRollout, readFileSync2(sourceRollout));
+  writePrivateFile(join7(cacheRoot, SESSION_ROLLOUT_MARKER), `${JSON.stringify({
     version: 1,
     cacheRoot,
     preservedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -21814,17 +21969,17 @@ function preserveManagedCodexSessionRollout(profile, input) {
 function cleanupRestoredManagedCodexSessionRollout(profile) {
   const restored = profile?.restoredNativeSession;
   if (!restored?.cacheRoot) return { status: "not_restored" };
-  const cacheRoot = resolve4(restored.cacheRoot);
+  const cacheRoot = resolve5(restored.cacheRoot);
   if (!existsSync3(cacheRoot)) return { status: "already_removed" };
-  const cacheStat = lstatSync4(cacheRoot);
+  const cacheStat = lstatSync5(cacheRoot);
   if (!cacheStat.isDirectory() || cacheStat.isSymbolicLink()) {
     throw new Error("codex_managed_mcp_session_rollout_cleanup_unsafe: cache root is not a private directory");
   }
-  const markerPath = join6(cacheRoot, SESSION_ROLLOUT_MARKER);
-  if (!existsSync3(markerPath) || lstatSync4(markerPath).isSymbolicLink() || !lstatSync4(markerPath).isFile()) {
+  const markerPath2 = join7(cacheRoot, SESSION_ROLLOUT_MARKER);
+  if (!existsSync3(markerPath2) || lstatSync5(markerPath2).isSymbolicLink() || !lstatSync5(markerPath2).isFile()) {
     throw new Error("codex_managed_mcp_session_rollout_cleanup_unsafe: ownership marker is unavailable");
   }
-  const marker = JSON.parse(readFileSync(markerPath, "utf8"));
+  const marker = JSON.parse(readFileSync2(markerPath2, "utf8"));
   if (marker?.companyId !== profile.authority.companyId || marker?.agentId !== profile.authority.agentId || marker?.issueId !== profile.authority.issueId || marker?.sourceRunId !== restored.sourceRunId || marker?.sourceCommandId !== restored.sourceCommandId || marker?.sessionId !== restored.sessionId) {
     throw new Error("codex_managed_mcp_session_rollout_cleanup_unsafe: ownership marker does not match restored authority");
   }
@@ -21833,20 +21988,20 @@ function cleanupRestoredManagedCodexSessionRollout(profile) {
   return { status: "removed" };
 }
 function cleanupManagedCodexMcpProfile(profile, owner) {
-  const profileRoot = resolve4(nonEmpty(profile?.profileRoot, "profileRoot"));
+  const profileRoot = resolve5(nonEmpty(profile?.profileRoot, "profileRoot"));
   if (!existsSync3(profileRoot)) return { status: "already_removed", profileRoot };
-  const rootStat = lstatSync4(profileRoot);
+  const rootStat = lstatSync5(profileRoot);
   if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
     throw new Error("codex_managed_mcp_cleanup_owner_mismatch: profile root is not an owned directory");
   }
-  const markerPath = join6(profileRoot, PROFILE_MARKER);
-  const markerStat = existsSync3(markerPath) ? lstatSync4(markerPath) : null;
+  const markerPath2 = join7(profileRoot, PROFILE_MARKER);
+  const markerStat = existsSync3(markerPath2) ? lstatSync5(markerPath2) : null;
   if (!markerStat?.isFile() || markerStat.isSymbolicLink()) {
     throw new Error("codex_managed_mcp_cleanup_owner_mismatch: ownership marker is missing or unsafe");
   }
   let marker;
   try {
-    marker = JSON.parse(readFileSync(markerPath, "utf8"));
+    marker = JSON.parse(readFileSync2(markerPath2, "utf8"));
   } catch {
     throw new Error("codex_managed_mcp_cleanup_owner_mismatch: ownership marker is invalid");
   }
@@ -21858,7 +22013,7 @@ function cleanupManagedCodexMcpProfile(profile, owner) {
   return { status: "removed", profileRoot };
 }
 function reconcileManagedCodexMcpProfiles(rootPath, options = {}) {
-  const root = resolve4(rootPath);
+  const root = resolve5(rootPath);
   if (!existsSync3(root)) return { scanned: 0, removed: 0, removedProfiles: 0, removedRollouts: 0, failed: 0, failures: [] };
   const canonicalRoot = realpathSync4(root);
   const profileMarkers = [];
@@ -21866,10 +22021,10 @@ function reconcileManagedCodexMcpProfiles(rootPath, options = {}) {
   const pending = [root];
   while (pending.length > 0) {
     const current = pending.pop();
-    const currentStat = lstatSync4(current);
+    const currentStat = lstatSync5(current);
     if (!currentStat.isDirectory() || currentStat.isSymbolicLink()) continue;
-    for (const entry of readdirSync2(current, { withFileTypes: true })) {
-      const fullPath = join6(current, entry.name);
+    for (const entry of readdirSync3(current, { withFileTypes: true })) {
+      const fullPath = join7(current, entry.name);
       if (entry.isDirectory() && !entry.isSymbolicLink()) pending.push(fullPath);
       else if (entry.isFile() && entry.name === PROFILE_MARKER) profileMarkers.push(fullPath);
       else if (entry.isFile() && entry.name === SESSION_ROLLOUT_MARKER) rolloutMarkers.push(fullPath);
@@ -21880,11 +22035,11 @@ function reconcileManagedCodexMcpProfiles(rootPath, options = {}) {
   let removedRollouts = 0;
   const failures = [];
   const protectedCommandIds = new Set(Array.isArray(options.protectedCommandIds) ? options.protectedCommandIds.filter((value) => typeof value === "string" && value) : []);
-  for (const markerPath of profileMarkers) {
-    const profileRoot = dirname2(markerPath);
+  for (const markerPath2 of profileMarkers) {
+    const profileRoot = dirname3(markerPath2);
     try {
-      const marker = JSON.parse(readFileSync(markerPath, "utf8"));
-      const markerProfileRoot = typeof marker?.profileRoot === "string" ? resolve4(marker.profileRoot) : null;
+      const marker = JSON.parse(readFileSync2(markerPath2, "utf8"));
+      const markerProfileRoot = typeof marker?.profileRoot === "string" ? resolve5(marker.profileRoot) : null;
       if (!markerProfileRoot || !existsSync3(markerProfileRoot) || !within(realpathSync4(profileRoot), canonicalRoot) || realpathSync4(markerProfileRoot) !== realpathSync4(profileRoot)) {
         throw new Error("ownership marker root mismatch");
       }
@@ -21900,13 +22055,13 @@ function reconcileManagedCodexMcpProfiles(rootPath, options = {}) {
   }
   const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
   const rolloutTtlMs = Number.isFinite(options.sessionRolloutTtlMs) && options.sessionRolloutTtlMs > 0 ? options.sessionRolloutTtlMs : DEFAULT_SESSION_ROLLOUT_TTL_MS;
-  for (const markerPath of rolloutMarkers) {
-    const cacheRoot = dirname2(markerPath);
+  for (const markerPath2 of rolloutMarkers) {
+    const cacheRoot = dirname3(markerPath2);
     try {
-      const markerStat = lstatSync4(markerPath);
-      const cacheStat = lstatSync4(cacheRoot);
-      const marker = JSON.parse(readFileSync(markerPath, "utf8"));
-      const markerCacheRoot = typeof marker?.cacheRoot === "string" ? resolve4(marker.cacheRoot) : null;
+      const markerStat = lstatSync5(markerPath2);
+      const cacheStat = lstatSync5(cacheRoot);
+      const marker = JSON.parse(readFileSync2(markerPath2, "utf8"));
+      const markerCacheRoot = typeof marker?.cacheRoot === "string" ? resolve5(marker.cacheRoot) : null;
       if (!within(realpathSync4(cacheRoot), canonicalRoot) || basename(cacheRoot) !== "session-rollout" || markerStat.isSymbolicLink() || !markerStat.isFile() || cacheStat.isSymbolicLink() || !cacheStat.isDirectory() || marker?.version !== 1 || typeof marker?.companyId !== "string" || typeof marker?.agentId !== "string" || typeof marker?.sourceRunId !== "string" || typeof marker?.sourceCommandId !== "string" || typeof marker?.sessionId !== "string" || markerCacheRoot != null && (!existsSync3(markerCacheRoot) || realpathSync4(markerCacheRoot) !== realpathSync4(cacheRoot))) {
         throw new Error("session rollout ownership marker mismatch");
       }
@@ -21934,23 +22089,23 @@ function reconcileManagedCodexMcpProfiles(rootPath, options = {}) {
 // src/amaster-runtime-daemon/codebuddy-managed-mcp-profile.mjs
 import { createHash as createHash8 } from "node:crypto";
 import {
-  chmodSync as chmodSync3,
+  chmodSync as chmodSync4,
   closeSync as closeSync3,
   constants as fsConstants,
   existsSync as existsSync4,
   fstatSync as fstatSync3,
-  lstatSync as lstatSync5,
-  mkdirSync as mkdirSync4,
+  lstatSync as lstatSync6,
+  mkdirSync as mkdirSync5,
   openSync as openSync3,
-  readFileSync as readFileSync2,
-  readdirSync as readdirSync3,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync4,
   realpathSync as realpathSync5,
   rmSync as rmSync4,
   statSync as statSync3,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "node:fs";
 import { arch as arch2, homedir as homedir2, platform as platform2 } from "node:os";
-import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute3, join as join7, parse as parse2, relative as relative2, resolve as resolve5, sep as sep2 } from "node:path";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute3, join as join8, parse as parse3, relative as relative2, resolve as resolve6, sep as sep2 } from "node:path";
 
 // src/amaster-runtime-daemon/codebuddy-profile-policy.mjs
 import { createHash as createHash7 } from "node:crypto";
@@ -22071,48 +22226,48 @@ var FULL_DIRECT_TYPED_V1_TOOL_NAMES = /* @__PURE__ */ new Set([
 function record5(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function requiredString(value, label, fail3) {
-  if (typeof value !== "string" || value.trim() === "") fail3(`${label} is required`);
+function requiredString(value, label, fail4) {
+  if (typeof value !== "string" || value.trim() === "") fail4(`${label} is required`);
   return value.trim();
 }
 function validateDirectTypedMcpCatalog(catalogValue, options = {}) {
   const errorPrefix = typeof options.errorPrefix === "string" && options.errorPrefix ? options.errorPrefix : "direct_typed_mcp_invalid";
-  const fail3 = (detail) => {
+  const fail4 = (detail) => {
     throw new Error(`${errorPrefix}: ${detail}`);
   };
   const admittedToolNames = options.admittedToolNames instanceof Set ? options.admittedToolNames : options.admittedToolNames == null ? null : new Set(options.admittedToolNames);
   const catalog = record5(catalogValue);
   if (catalog.schemaVersion !== DIRECT_TYPED_MCP_CATALOG_SCHEMA_VERSION) {
-    fail3("direct tool catalog schema mismatch");
+    fail4("direct tool catalog schema mismatch");
   }
   const rawTools = Array.isArray(catalog.tools) ? catalog.tools.map(record5) : [];
   const names = /* @__PURE__ */ new Set();
   const exposedNames = /* @__PURE__ */ new Set();
   const tools = rawTools.map((tool) => {
-    const name = requiredString(tool.name, "toolCatalog.tools.name", fail3);
+    const name = requiredString(tool.name, "toolCatalog.tools.name", fail4);
     if (admittedToolNames && !admittedToolNames.has(name) || names.has(name)) {
-      fail3("direct tool catalog name mismatch");
+      fail4("direct tool catalog name mismatch");
     }
     names.add(name);
-    const exposedName = requiredString(tool.exposedName, `toolCatalog.tools.exposedName:${name}`, fail3);
+    const exposedName = requiredString(tool.exposedName, `toolCatalog.tools.exposedName:${name}`, fail4);
     if (!PROVIDER_SAFE_DIRECT_TOOL_NAME.test(exposedName)) {
-      fail3(`direct tool exposed name is unsafe for ${name}`);
+      fail4(`direct tool exposed name is unsafe for ${name}`);
     }
     if (exposedNames.has(exposedName)) {
-      fail3(`direct tool exposed name collision for ${exposedName}`);
+      fail4(`direct tool exposed name collision for ${exposedName}`);
     }
     exposedNames.add(exposedName);
     const inputSchema = record5(tool.inputSchema);
     if (inputSchema.type !== "object" || inputSchema.additionalProperties !== false) {
-      fail3(`direct tool schema is not strict for ${name}`);
+      fail4(`direct tool schema is not strict for ${name}`);
     }
     const schemaHash = stablePiToolSchemaHash(inputSchema);
     if (tool.schemaHash !== schemaHash) {
-      fail3(`direct tool schema hash mismatch for ${name}`);
+      fail4(`direct tool schema hash mismatch for ${name}`);
     }
-    const riskLevel = requiredString(tool.riskLevel, `toolCatalog.tools.riskLevel:${name}`, fail3);
+    const riskLevel = requiredString(tool.riskLevel, `toolCatalog.tools.riskLevel:${name}`, fail4);
     if (!(/* @__PURE__ */ new Set(["read", "write", "destructive"])).has(riskLevel)) {
-      fail3(`direct tool risk level mismatch for ${name}`);
+      fail4(`direct tool risk level mismatch for ${name}`);
     }
     return {
       name,
@@ -22130,7 +22285,7 @@ function validateDirectTypedMcpCatalog(catalogValue, options = {}) {
     schemaHash: tool.schemaHash,
     riskLevel: tool.riskLevel
   })));
-  if (catalog.setHash !== setHash) fail3("direct tool catalog set hash mismatch");
+  if (catalog.setHash !== setHash) fail4("direct tool catalog set hash mismatch");
   return {
     setHash,
     tools: tools.sort((left, right) => left.name.localeCompare(right.name))
@@ -22304,7 +22459,7 @@ var CODEBUDDY_PROFILE_COMPATIBILITY_ALLOWLIST = Object.freeze([
 function record6(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function fail(detail) {
+function fail2(detail) {
   throw new Error(`codebuddy_managed_mcp_invalid: ${detail}`);
 }
 function sha256(value) {
@@ -22317,7 +22472,7 @@ function classifyCodebuddyFormalTool(tool) {
   const mustDirect = MUST_DIRECT_TOOL_NAMES.has(tool.name);
   const vettedRead = VETTED_DEFERRED_READ_TOOL_NAMES.has(tool.name);
   if (mustDirect === vettedRead || vettedRead && tool.riskLevel !== "read") {
-    fail(`direct tool classification mismatch for ${tool.name}`);
+    fail2(`direct tool classification mismatch for ${tool.name}`);
   }
   return { mustDirect, vettedRead };
 }
@@ -22329,12 +22484,12 @@ function assertFormalCatalogShape(rawTools) {
   const hasWikiWrite = names.has(FULL_DIRECT_TYPED_V1_WIKI_WRITE_TOOL_NAME);
   const connectorCount = countIn(FULL_DIRECT_TYPED_V1_CONNECTOR_TOOL_NAMES);
   const fullCatalog = rawTools.length === FULL_DIRECT_TYPED_V1_BASE_TOOL_NAMES.size + wikiReadCount + (hasWikiWrite ? 1 : 0) + connectorCount && covers(FULL_DIRECT_TYPED_V1_BASE_TOOL_NAMES) && (wikiReadCount === 0 && !hasWikiWrite || wikiReadCount === FULL_DIRECT_TYPED_V1_WIKI_READ_TOOL_NAMES.size) && (connectorCount === 0 || connectorCount === FULL_DIRECT_TYPED_V1_CONNECTOR_TOOL_NAMES.size) && rawTools.every((tool) => FULL_DIRECT_TYPED_V1_TOOL_NAMES.has(tool.name));
-  if (!fullCatalog) fail("direct tool catalog size mismatch");
+  if (!fullCatalog) fail2("direct tool catalog size mismatch");
 }
 function validateCodebuddyFormalToolCatalog(gatewayValue) {
   const gateway = record6(gatewayValue);
   if ((gateway.mcpToolMode ?? "direct_typed") !== "direct_typed") {
-    fail("direct tool mode required");
+    fail2("direct tool mode required");
   }
   const catalog = record6(gateway.toolCatalog);
   const rawTools = Array.isArray(catalog.tools) ? catalog.tools.map(record6) : [];
@@ -22392,14 +22547,14 @@ function codebuddyProfileSchemaBytesMatchCatalog(catalogValue, attestationValue)
 }
 function deriveCodebuddyProfilePolicy(input = {}) {
   const catalog = input.catalog;
-  if (!catalog || !Array.isArray(catalog.tools)) fail("validated catalog is required");
+  if (!catalog || !Array.isArray(catalog.tools)) fail2("validated catalog is required");
   const mcpMode = input.mcpMode;
   const bashMode = input.bashMode;
-  if (!CODEBUDDY_MCP_MODES.includes(mcpMode)) fail("mcp mode mismatch");
-  if (!CODEBUDDY_BASH_MODES.includes(bashMode)) fail("bash mode mismatch");
+  if (!CODEBUDDY_MCP_MODES.includes(mcpMode)) fail2("mcp mode mismatch");
+  if (!CODEBUDDY_BASH_MODES.includes(bashMode)) fail2("bash mode mismatch");
   const targetPlatform = input.platform ?? hostPlatform();
   if (bashMode === "sandboxed" && !["darwin", "linux"].includes(targetPlatform)) {
-    fail("sandboxed Bash platform unsupported");
+    fail2("sandboxed Bash platform unsupported");
   }
   const classifiedTools = catalog.tools.map((tool) => {
     const { vettedRead } = classifyCodebuddyFormalTool(tool);
@@ -22650,12 +22805,12 @@ function nonEmpty2(value, label) {
   return value.trim();
 }
 function privateDir(path) {
-  mkdirSync4(path, { recursive: true, mode: 448 });
-  chmodSync3(path, 448);
+  mkdirSync5(path, { recursive: true, mode: 448 });
+  chmodSync4(path, 448);
 }
 function privateFile(path, value) {
-  writeFileSync4(path, value, { flag: "wx", mode: 384 });
-  chmodSync3(path, 384);
+  writeFileSync5(path, value, { flag: "wx", mode: 384 });
+  chmodSync4(path, 384);
   if ((statSync3(path).mode & 511) !== 384) {
     throw new Error(`codebuddy_managed_mcp_permissions_failed: ${path}`);
   }
@@ -22666,16 +22821,16 @@ function within2(candidate, root) {
 }
 function codebuddyIsolatedAuthRelativePath(targetPlatform = platform2()) {
   if (targetPlatform === "darwin") {
-    return join7("Library", "Application Support", "CodeBuddyExtension", "Data", "Public", "auth");
+    return join8("Library", "Application Support", "CodeBuddyExtension", "Data", "Public", "auth");
   }
   if (targetPlatform === "linux") {
-    return join7(".local", "share", "CodeBuddyExtension", "Data", "Public", "auth");
+    return join8(".local", "share", "CodeBuddyExtension", "Data", "Public", "auth");
   }
   throw new Error(`codebuddy_managed_mcp_desktop_auth_unsupported: platform ${targetPlatform} is not supported`);
 }
 function codebuddyDesktopAuthDirectory(sourceHome, sourceEnv, targetPlatform) {
   if (targetPlatform === "darwin") {
-    return join7(sourceHome, codebuddyIsolatedAuthRelativePath(targetPlatform));
+    return join8(sourceHome, codebuddyIsolatedAuthRelativePath(targetPlatform));
   }
   if (targetPlatform === "linux") {
     const xdgDataHome = typeof sourceEnv?.XDG_DATA_HOME === "string" ? sourceEnv.XDG_DATA_HOME.trim() : "";
@@ -22683,20 +22838,20 @@ function codebuddyDesktopAuthDirectory(sourceHome, sourceEnv, targetPlatform) {
       if (!isAbsolute3(xdgDataHome)) {
         throw new Error("codebuddy_managed_mcp_desktop_auth_xdg_invalid: XDG_DATA_HOME must be absolute");
       }
-      const resolvedXdgDataHome = resolve5(xdgDataHome);
+      const resolvedXdgDataHome = resolve6(xdgDataHome);
       const canonicalXdgDataHome = existsSync4(resolvedXdgDataHome) ? realpathSync5(resolvedXdgDataHome) : resolvedXdgDataHome;
-      return join7(canonicalXdgDataHome, "CodeBuddyExtension", "Data", "Public", "auth");
+      return join8(canonicalXdgDataHome, "CodeBuddyExtension", "Data", "Public", "auth");
     }
-    return join7(sourceHome, codebuddyIsolatedAuthRelativePath(targetPlatform));
+    return join8(sourceHome, codebuddyIsolatedAuthRelativePath(targetPlatform));
   }
   throw new Error(`codebuddy_managed_mcp_desktop_auth_unsupported: platform ${targetPlatform} is not supported`);
 }
 function absolutePathChain(path) {
-  const absolute = resolve5(path);
-  const root = parse2(absolute).root;
+  const absolute = resolve6(path);
+  const root = parse3(absolute).root;
   const components = relative2(root, absolute).split(sep2).filter(Boolean);
   const chain = [root];
-  for (const component of components) chain.push(join7(chain.at(-1), component));
+  for (const component of components) chain.push(join8(chain.at(-1), component));
   return chain;
 }
 function sameFileIdentity(left, right) {
@@ -22707,7 +22862,7 @@ function sameTrustedFileMetadata(left, right) {
 }
 function lstatIfPresent(path) {
   try {
-    return lstatSync5(path);
+    return lstatSync6(path);
   } catch (error) {
     if (error && typeof error === "object" && error.code === "ENOENT") return null;
     throw error;
@@ -22715,12 +22870,12 @@ function lstatIfPresent(path) {
 }
 function inspectCodebuddyDesktopAuthDirectory(sourceHome = homedir2(), sourceEnv = process.env, targetPlatform = platform2()) {
   try {
-    const resolvedSourceHome = realpathSync5(resolve5(nonEmpty2(sourceHome, "desktopHome")));
+    const resolvedSourceHome = realpathSync5(resolve6(nonEmpty2(sourceHome, "desktopHome")));
     const sourceAuthDir = codebuddyDesktopAuthDirectory(resolvedSourceHome, sourceEnv, targetPlatform);
     if (!lstatIfPresent(sourceAuthDir)) {
       return { available: false, source: CODEBUDDY_DESKTOP_AUTH_SOURCE, reasonCode: "desktop_auth_directory_missing" };
     }
-    const sourceAuthFile = join7(sourceAuthDir, CODEBUDDY_WORKBUDDY_AUTH_FILE);
+    const sourceAuthFile = join8(sourceAuthDir, CODEBUDDY_WORKBUDDY_AUTH_FILE);
     if (!lstatIfPresent(sourceAuthFile)) {
       return { available: false, source: CODEBUDDY_DESKTOP_AUTH_SOURCE, reasonCode: "desktop_login_missing" };
     }
@@ -22731,7 +22886,7 @@ function inspectCodebuddyDesktopAuthDirectory(sourceHome = homedir2(), sourceEnv
     const currentUid = typeof process.getuid === "function" ? process.getuid() : null;
     const pathChain = [];
     for (const candidate of chain) {
-      const candidateStat = lstatSync5(candidate);
+      const candidateStat = lstatSync6(candidate);
       const isAuthFile = candidate === sourceAuthFile;
       const isAuthDir = candidate === sourceAuthDir;
       if (candidateStat.isSymbolicLink() || (isAuthFile ? !candidateStat.isFile() : !candidateStat.isDirectory())) {
@@ -22810,7 +22965,7 @@ function snapshotCodebuddyDesktopAuth(sourceHome, sourceEnv, isolatedHome) {
         if (!openedStat.isFile() || openedStat.size <= 0 || openedStat.size > MAX_CODEBUDDY_DESKTOP_AUTH_BYTES) {
           throw new Error("codebuddy_managed_mcp_desktop_auth_unsafe: source auth file is invalid");
         }
-        authSnapshot = readFileSync2(fd);
+        authSnapshot = readFileSync3(fd);
         const afterReadStat = fstatSync3(fd);
         if (!sameTrustedFileMetadata(openedStat, afterReadStat) || openedStat.size !== afterReadStat.size || openedStat.mtimeMs !== afterReadStat.mtimeMs || authSnapshot.length !== openedStat.size) {
           throw new Error("codebuddy_managed_mcp_desktop_auth_changed: source auth file changed during snapshot");
@@ -22818,7 +22973,7 @@ function snapshotCodebuddyDesktopAuth(sourceHome, sourceEnv, isolatedHome) {
       }
     }
     for (const entry of inspected.pathChain) {
-      const currentStat = lstatSync5(entry.path);
+      const currentStat = lstatSync6(entry.path);
       if (currentStat.isSymbolicLink() || !sameTrustedFileMetadata(currentStat, entry.stat)) {
         throw new Error("codebuddy_managed_mcp_desktop_auth_changed: source path changed during snapshot");
       }
@@ -22826,9 +22981,9 @@ function snapshotCodebuddyDesktopAuth(sourceHome, sourceEnv, isolatedHome) {
     if (lstatIfPresent(`${inspected.sourceAuthFile}.logged-out`)) {
       throw new Error("codebuddy_managed_mcp_desktop_auth_changed: desktop session logged out during snapshot");
     }
-    const targetAuthDir = join7(isolatedHome, codebuddyIsolatedAuthRelativePath());
+    const targetAuthDir = join8(isolatedHome, codebuddyIsolatedAuthRelativePath());
     privateDir(targetAuthDir);
-    const targetAuthFile = join7(targetAuthDir, CODEBUDDY_WORKBUDDY_AUTH_FILE);
+    const targetAuthFile = join8(targetAuthDir, CODEBUDDY_WORKBUDDY_AUTH_FILE);
     privateFile(targetAuthFile, authSnapshot);
     return {
       authMode: CODEBUDDY_DESKTOP_AUTH_SOURCE,
@@ -22846,7 +23001,7 @@ function snapshotCodebuddyDesktopAuth(sourceHome, sourceEnv, isolatedHome) {
   }
 }
 function findCodebuddySession(configDir, sessionId) {
-  const projectsRoot = join7(configDir, "projects");
+  const projectsRoot = join8(configDir, "projects");
   if (!existsSync4(projectsRoot)) {
     throw new Error(`codebuddy_managed_mcp_session_rollout_missing: projects root is unavailable for ${sessionId}`);
   }
@@ -22854,12 +23009,12 @@ function findCodebuddySession(configDir, sessionId) {
   const pending = [projectsRoot];
   while (pending.length > 0) {
     const current = pending.pop();
-    const currentStat = lstatSync5(current);
+    const currentStat = lstatSync6(current);
     if (!currentStat.isDirectory() || currentStat.isSymbolicLink()) {
       throw new Error("codebuddy_managed_mcp_session_rollout_unsafe: projects path is not a private directory");
     }
-    for (const entry of readdirSync3(current, { withFileTypes: true })) {
-      const candidate = join7(current, entry.name);
+    for (const entry of readdirSync4(current, { withFileTypes: true })) {
+      const candidate = join8(current, entry.name);
       if (entry.isSymbolicLink()) {
         throw new Error("codebuddy_managed_mcp_session_rollout_unsafe: symlinks are forbidden");
       }
@@ -22888,29 +23043,29 @@ function restoreManagedCodebuddySessionRollout(input, configDir, runDir, executo
     nonEmpty2(session.invocationId, "nativeSession.invocationId");
   }
   const sourceWorkspacePath = nonEmpty2(session.cwd, "nativeSession.cwd");
-  const issueRoot = dirname3(runDir);
+  const issueRoot = dirname4(runDir);
   const managedSourceRunName = `${sourceRunId}-${createHash8("sha256").update(sourceRunId).digest("hex").slice(0, 8)}`;
-  const sourceRuns = readdirSync3(issueRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.isSymbolicLink() && [sourceRunId, managedSourceRunName].includes(entry.name)).map((entry) => join7(issueRoot, entry.name));
+  const sourceRuns = readdirSync4(issueRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.isSymbolicLink() && [sourceRunId, managedSourceRunName].includes(entry.name)).map((entry) => join8(issueRoot, entry.name));
   if (sourceRuns.length !== 1) {
     throw new Error(`codebuddy_managed_mcp_session_rollout_missing: expected one source run directory for ${sourceRunId}, received ${sourceRuns.length}`);
   }
   const executorRelativePath = relative2(runDir, executorHome);
-  const cacheRoot = join7(sourceRuns[0], executorRelativePath, "session-rollout");
-  const markerPath = join7(cacheRoot, SESSION_ROLLOUT_MARKER2);
-  if (!existsSync4(markerPath) || lstatSync5(markerPath).isSymbolicLink() || !lstatSync5(markerPath).isFile()) {
+  const cacheRoot = join8(sourceRuns[0], executorRelativePath, "session-rollout");
+  const markerPath2 = join8(cacheRoot, SESSION_ROLLOUT_MARKER2);
+  if (!existsSync4(markerPath2) || lstatSync6(markerPath2).isSymbolicLink() || !lstatSync6(markerPath2).isFile()) {
     throw new Error("codebuddy_managed_mcp_session_rollout_missing: source rollout marker is unavailable");
   }
-  const marker = JSON.parse(readFileSync2(markerPath, "utf8"));
+  const marker = JSON.parse(readFileSync3(markerPath2, "utf8"));
   if (marker.version !== 1 || marker.companyId !== authority.companyId || marker.agentId !== authority.agentId || marker.issueId !== authority.issueId || marker.sourceRunId !== sourceRunId || marker.sourceCommandId !== sourceCommandId || marker.sessionId !== sessionId || marker.sourceWorkspacePath !== sourceWorkspacePath) {
     throw new Error("codebuddy_managed_mcp_session_rollout_authority_mismatch: source rollout does not match the governed continuation");
   }
-  const sourceRollout = resolve5(cacheRoot, nonEmpty2(marker.rolloutRelativePath, "rolloutRelativePath"));
-  if (!within2(sourceRollout, cacheRoot) || lstatSync5(sourceRollout).isSymbolicLink() || !lstatSync5(sourceRollout).isFile()) {
+  const sourceRollout = resolve6(cacheRoot, nonEmpty2(marker.rolloutRelativePath, "rolloutRelativePath"));
+  if (!within2(sourceRollout, cacheRoot) || lstatSync6(sourceRollout).isSymbolicLink() || !lstatSync6(sourceRollout).isFile()) {
     throw new Error("codebuddy_managed_mcp_session_rollout_unsafe: source rollout path is invalid");
   }
-  const targetRollout = join7(configDir, "projects", codebuddyProjectKey(input.cwd), `${sessionId}.jsonl`);
-  privateDir(dirname3(targetRollout));
-  privateFile(targetRollout, readFileSync2(sourceRollout));
+  const targetRollout = join8(configDir, "projects", codebuddyProjectKey(input.cwd), `${sessionId}.jsonl`);
+  privateDir(dirname4(targetRollout));
+  privateFile(targetRollout, readFileSync3(sourceRollout));
   return { sessionId, sourceRunId, sourceCommandId, rolloutPath: targetRollout, cacheRoot };
 }
 function resolveManagedCodebuddySessionRollout(input, configDir, runDir, executorHome, authority) {
@@ -23049,7 +23204,7 @@ function attestCli(executorCommand, env, cwd) {
   return attestCodebuddyCommand(executorCommand, env, cwd).executorVersion;
 }
 function canonicalCodebuddyCwd(value) {
-  const requestedCwd = resolve5(nonEmpty2(value, "cwd"));
+  const requestedCwd = resolve6(nonEmpty2(value, "cwd"));
   try {
     const canonicalCwd = realpathSync5(requestedCwd);
     if (!statSync3(canonicalCwd).isDirectory()) {
@@ -23065,19 +23220,19 @@ function canonicalCodebuddyCwd(value) {
 }
 function prepareManagedCodebuddyMcpProfile(input, options = {}) {
   const authority = validateAuthority2(input);
-  const runDir = resolve5(nonEmpty2(input.runDir, "runDir"));
-  const executorHome = resolve5(nonEmpty2(input.executorHome, "executorHome"));
+  const runDir = resolve6(nonEmpty2(input.runDir, "runDir"));
+  const executorHome = resolve6(nonEmpty2(input.executorHome, "executorHome"));
   const cwd = canonicalCodebuddyCwd(input.cwd);
-  if (!within2(executorHome, join7(runDir, "executors"))) {
+  if (!within2(executorHome, join8(runDir, "executors"))) {
     throw new Error("codebuddy_managed_mcp_owner_mismatch: executorHome is outside the managed run");
   }
-  const profileRoot = join7(executorHome, "managed-mcp");
+  const profileRoot = join8(executorHome, "managed-mcp");
   if (existsSync4(profileRoot)) throw new Error(`codebuddy_managed_mcp_profile_exists: ${profileRoot}`);
   privateDir(profileRoot);
   try {
-    const home = join7(profileRoot, "home");
-    const configDir = join7(profileRoot, "codebuddy-config");
-    const tmp = join7(profileRoot, "tmp");
+    const home = join8(profileRoot, "home");
+    const configDir = join8(profileRoot, "codebuddy-config");
+    const tmp = join8(profileRoot, "tmp");
     privateDir(home);
     privateDir(configDir);
     privateDir(tmp);
@@ -23089,11 +23244,11 @@ function prepareManagedCodebuddyMcpProfile(input, options = {}) {
       runId: owner.runId,
       commandId: owner.commandId
     });
-    const markerPath = join7(profileRoot, PROFILE_MARKER2);
-    privateFile(markerPath, `${JSON.stringify({ version: 1, ...owner, profileRoot })}
+    const markerPath2 = join8(profileRoot, PROFILE_MARKER2);
+    privateFile(markerPath2, `${JSON.stringify({ version: 1, ...owner, profileRoot })}
 `);
-    const mcpConfigPath = join7(profileRoot, "mcp.json");
-    const settingsPath = join7(profileRoot, "settings.json");
+    const mcpConfigPath = join8(profileRoot, "mcp.json");
+    const settingsPath = join8(profileRoot, "settings.json");
     const provider = codebuddyProviderEnvironment(input.baseEnv, input.commandEnv);
     const desktopAuthSnapshot = provider.authMode ? null : snapshotCodebuddyDesktopAuth(input.desktopHome ?? homedir2(), input.desktopEnv ?? process.env, home);
     const env = {
@@ -23190,7 +23345,7 @@ function prepareManagedCodebuddyMcpProfile(input, options = {}) {
     return {
       profileRoot,
       cwd,
-      markerPath,
+      markerPath: markerPath2,
       mcpConfigPath,
       settingsPath,
       env,
@@ -23222,15 +23377,15 @@ function prepareManagedCodebuddyMcpProfile(input, options = {}) {
 function preserveManagedCodebuddySessionRollout(profile, input) {
   const sessionId = nonEmpty2(input?.sessionId, "sessionId");
   const sourceWorkspacePath = nonEmpty2(input?.sourceWorkspacePath, "sourceWorkspacePath");
-  const configDir = resolve5(nonEmpty2(profile?.env?.CODEBUDDY_CONFIG_DIR, "profile.env.CODEBUDDY_CONFIG_DIR"));
+  const configDir = resolve6(nonEmpty2(profile?.env?.CODEBUDDY_CONFIG_DIR, "profile.env.CODEBUDDY_CONFIG_DIR"));
   const sourceSession = findCodebuddySession(configDir, sessionId);
-  const cacheRoot = join7(dirname3(resolve5(profile.profileRoot)), "session-rollout");
+  const cacheRoot = join8(dirname4(resolve6(profile.profileRoot)), "session-rollout");
   if (existsSync4(cacheRoot)) rmSync4(cacheRoot, { recursive: true, force: false });
   privateDir(cacheRoot);
   const rolloutRelativePath = `${sessionId}.jsonl`;
-  const targetSession = join7(cacheRoot, rolloutRelativePath);
-  privateFile(targetSession, readFileSync2(sourceSession));
-  privateFile(join7(cacheRoot, SESSION_ROLLOUT_MARKER2), `${JSON.stringify({
+  const targetSession = join8(cacheRoot, rolloutRelativePath);
+  privateFile(targetSession, readFileSync3(sourceSession));
+  privateFile(join8(cacheRoot, SESSION_ROLLOUT_MARKER2), `${JSON.stringify({
     version: 1,
     cacheRoot,
     preservedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -23249,16 +23404,16 @@ function preserveManagedCodebuddySessionRollout(profile, input) {
 function cleanupRestoredManagedCodebuddySessionRollout(profile) {
   const restored = profile?.restoredNativeSession;
   if (!restored?.cacheRoot) return { status: "not_restored" };
-  const cacheRoot = resolve5(restored.cacheRoot);
+  const cacheRoot = resolve6(restored.cacheRoot);
   if (!existsSync4(cacheRoot)) return { status: "already_removed" };
-  if (!lstatSync5(cacheRoot).isDirectory() || lstatSync5(cacheRoot).isSymbolicLink()) {
+  if (!lstatSync6(cacheRoot).isDirectory() || lstatSync6(cacheRoot).isSymbolicLink()) {
     throw new Error("codebuddy_managed_mcp_session_rollout_cleanup_unsafe: cache root is not a private directory");
   }
-  const markerPath = join7(cacheRoot, SESSION_ROLLOUT_MARKER2);
-  if (!existsSync4(markerPath) || lstatSync5(markerPath).isSymbolicLink() || !lstatSync5(markerPath).isFile()) {
+  const markerPath2 = join8(cacheRoot, SESSION_ROLLOUT_MARKER2);
+  if (!existsSync4(markerPath2) || lstatSync6(markerPath2).isSymbolicLink() || !lstatSync6(markerPath2).isFile()) {
     throw new Error("codebuddy_managed_mcp_session_rollout_cleanup_unsafe: ownership marker is unavailable");
   }
-  const marker = JSON.parse(readFileSync2(markerPath, "utf8"));
+  const marker = JSON.parse(readFileSync3(markerPath2, "utf8"));
   if (marker.companyId !== profile.authority.companyId || marker.agentId !== profile.authority.agentId || marker.issueId !== profile.authority.issueId || marker.sourceRunId !== restored.sourceRunId || marker.sourceCommandId !== restored.sourceCommandId || marker.sessionId !== restored.sessionId) {
     throw new Error("codebuddy_managed_mcp_session_rollout_cleanup_unsafe: ownership marker does not match restored authority");
   }
@@ -23269,20 +23424,20 @@ function cleanupRestoredManagedCodebuddySessionRollout(profile) {
   return { status: "removed" };
 }
 function cleanupManagedCodebuddyMcpProfile(profile, expectedOwner) {
-  const profileRoot = resolve5(nonEmpty2(profile?.profileRoot, "profileRoot"));
+  const profileRoot = resolve6(nonEmpty2(profile?.profileRoot, "profileRoot"));
   if (!existsSync4(profileRoot)) return { status: "already_removed", profileRoot };
-  const rootStat = lstatSync5(profileRoot);
+  const rootStat = lstatSync6(profileRoot);
   if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
     throw new Error("codebuddy_managed_mcp_cleanup_owner_mismatch: profile root is not an owned directory");
   }
-  const markerPath = join7(profileRoot, PROFILE_MARKER2);
-  const markerStat = existsSync4(markerPath) ? lstatSync5(markerPath) : null;
+  const markerPath2 = join8(profileRoot, PROFILE_MARKER2);
+  const markerStat = existsSync4(markerPath2) ? lstatSync6(markerPath2) : null;
   if (!markerStat?.isFile() || markerStat.isSymbolicLink()) {
     throw new Error("codebuddy_managed_mcp_cleanup_owner_mismatch: ownership marker is missing or unsafe");
   }
   let marker;
   try {
-    marker = JSON.parse(readFileSync2(markerPath, "utf8"));
+    marker = JSON.parse(readFileSync3(markerPath2, "utf8"));
   } catch {
     throw new Error("codebuddy_managed_mcp_cleanup_owner_mismatch: ownership marker is invalid");
   }
@@ -23294,7 +23449,7 @@ function cleanupManagedCodebuddyMcpProfile(profile, expectedOwner) {
   return { status: "removed", profileRoot };
 }
 function reconcileManagedCodebuddyMcpProfiles(rootPath, options = {}) {
-  const root = resolve5(rootPath);
+  const root = resolve6(rootPath);
   if (!existsSync4(root)) {
     return { scanned: 0, removed: 0, removedProfiles: 0, preservedProfiles: 0, removedRollouts: 0, failed: 0, failures: [] };
   }
@@ -23304,10 +23459,10 @@ function reconcileManagedCodebuddyMcpProfiles(rootPath, options = {}) {
   const pending = [root];
   while (pending.length > 0) {
     const current = pending.pop();
-    const currentStat = lstatSync5(current);
+    const currentStat = lstatSync6(current);
     if (!currentStat.isDirectory() || currentStat.isSymbolicLink()) continue;
-    for (const entry of readdirSync3(current, { withFileTypes: true })) {
-      const fullPath = join7(current, entry.name);
+    for (const entry of readdirSync4(current, { withFileTypes: true })) {
+      const fullPath = join8(current, entry.name);
       if (entry.isDirectory() && !entry.isSymbolicLink()) pending.push(fullPath);
       else if (entry.isFile() && entry.name === PROFILE_MARKER2) profileMarkers.push(fullPath);
       else if (entry.isFile() && entry.name === SESSION_ROLLOUT_MARKER2) rolloutMarkers.push(fullPath);
@@ -23318,11 +23473,11 @@ function reconcileManagedCodebuddyMcpProfiles(rootPath, options = {}) {
   let preservedProfiles = 0;
   let removedRollouts = 0;
   const failures = [];
-  for (const markerPath of profileMarkers) {
-    const profileRoot = dirname3(markerPath);
+  for (const markerPath2 of profileMarkers) {
+    const profileRoot = dirname4(markerPath2);
     try {
-      const marker = JSON.parse(readFileSync2(markerPath, "utf8"));
-      const markerProfileRoot = typeof marker.profileRoot === "string" ? resolve5(marker.profileRoot) : null;
+      const marker = JSON.parse(readFileSync3(markerPath2, "utf8"));
+      const markerProfileRoot = typeof marker.profileRoot === "string" ? resolve6(marker.profileRoot) : null;
       if (!markerProfileRoot || !existsSync4(markerProfileRoot) || !within2(realpathSync5(profileRoot), canonicalRoot) || realpathSync5(markerProfileRoot) !== realpathSync5(profileRoot)) throw new Error("ownership marker root mismatch");
       if (protectedCommandIds.has(marker.commandId)) {
         preservedProfiles += 1;
@@ -23339,13 +23494,13 @@ function reconcileManagedCodebuddyMcpProfiles(rootPath, options = {}) {
   }
   const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
   const rolloutTtlMs = Number.isFinite(options.sessionRolloutTtlMs) && options.sessionRolloutTtlMs > 0 ? options.sessionRolloutTtlMs : DEFAULT_SESSION_ROLLOUT_TTL_MS2;
-  for (const markerPath of rolloutMarkers) {
-    const cacheRoot = dirname3(markerPath);
+  for (const markerPath2 of rolloutMarkers) {
+    const cacheRoot = dirname4(markerPath2);
     try {
-      const markerStat = lstatSync5(markerPath);
-      const cacheStat = lstatSync5(cacheRoot);
-      const marker = JSON.parse(readFileSync2(markerPath, "utf8"));
-      if (!within2(realpathSync5(cacheRoot), canonicalRoot) || basename2(cacheRoot) !== "session-rollout" || markerStat.isSymbolicLink() || !markerStat.isFile() || cacheStat.isSymbolicLink() || !cacheStat.isDirectory() || marker.version !== 1 || resolve5(marker.cacheRoot) !== resolve5(cacheRoot)) throw new Error("session rollout ownership marker mismatch");
+      const markerStat = lstatSync6(markerPath2);
+      const cacheStat = lstatSync6(cacheRoot);
+      const marker = JSON.parse(readFileSync3(markerPath2, "utf8"));
+      if (!within2(realpathSync5(cacheRoot), canonicalRoot) || basename2(cacheRoot) !== "session-rollout" || markerStat.isSymbolicLink() || !markerStat.isFile() || cacheStat.isSymbolicLink() || !cacheStat.isDirectory() || marker.version !== 1 || resolve6(marker.cacheRoot) !== resolve6(cacheRoot)) throw new Error("session rollout ownership marker mismatch");
       const preservedAtMs = Date.parse(marker.preservedAt);
       const ageMs = nowMs - (Number.isFinite(preservedAtMs) ? preservedAtMs : markerStat.mtimeMs);
       if (ageMs < rolloutTtlMs) continue;
@@ -23373,14 +23528,14 @@ async function runInitializationCompletion({ plan, authority, call, sleep, now,
   const receipts = [];
   let stage = "upload";
   let callId;
-  const fail3 = (code, detail) => {
+  const fail4 = (code, detail) => {
     throw Object.assign(new Error(code), { detail });
   };
   async function invoke(name, args) {
-    if (now() >= deadline) fail3("initialization_completion_deadline");
+    if (now() >= deadline) fail4("initialization_completion_deadline");
     let envelope;
     for (let transportFailures = 0; ; ) {
-      if (now() >= deadline) fail3("initialization_completion_deadline");
+      if (now() >= deadline) fail4("initialization_completion_deadline");
       try {
         envelope = await call(name, args, Math.min(45e3, deadline - now()));
         break;
@@ -23394,10 +23549,10 @@ async function runInitializationCompletion({ plan, authority, call, sleep, now,
     }
     const content = envelope?.content;
     if (!envelope?.invocationId || !content || typeof content !== "object" || content?.toolName !== name.replace("runtime_action_", "runtime_action.")) {
-      fail3("initialization_completion_receipt_mismatch");
+      fail4("initialization_completion_receipt_mismatch");
     }
     if (envelope.status !== "succeeded" || !["accepted", "pending_reconcile"].includes(content.status)) {
-      fail3("initialization_completion_action_not_accepted", content.error ?? { status: envelope.status });
+      fail4("initialization_completion_action_not_accepted", content.error ?? { status: envelope.status });
     }
     const result2 = content.result;
     await onReceipt(envelope);
@@ -23408,19 +23563,19 @@ async function runInitializationCompletion({ plan, authority, call, sleep, now,
       planId: result2?.planId,
       status: result2?.status
     });
-    if (!result2 || result2.error) fail3("initialization_completion_action_failed", result2?.error);
+    if (!result2 || result2.error) fail4("initialization_completion_action_failed", result2?.error);
     return result2;
   }
   async function settleCall(value, actionType) {
     callId = value.callId;
-    if (!callId || value.actionType !== actionType) fail3("initialization_completion_call_mismatch");
+    if (!callId || value.actionType !== actionType) fail4("initialization_completion_call_mismatch");
     for (let attempt = 0; ; attempt++) {
-      if (value.callId !== callId || value.actionType !== actionType) fail3("initialization_completion_call_mismatch");
+      if (value.callId !== callId || value.actionType !== actionType) fail4("initialization_completion_call_mismatch");
       if (value.status === "succeeded") return value;
       if (!["pending_reconcile", "claimed", "executing"].includes(value.status)) {
-        fail3("initialization_completion_action_incomplete", { status: value.status, error: value.error });
+        fail4("initialization_completion_action_incomplete", { status: value.status, error: value.error });
       }
-      if (now() >= deadline) fail3("initialization_completion_deadline");
+      if (now() >= deadline) fail4("initialization_completion_deadline");
       await sleep(Math.min(1e3 * (attempt + 1), 5e3));
       value = await invoke("runtime_action_status", { callId });
     }
@@ -23429,7 +23584,7 @@ async function runInitializationCompletion({ plan, authority, call, sleep, now,
     const doc = plan.initializationDocument;
     const materialized = plan.initializationDocumentMaterialization;
     if (!plan.planId || !plan.revision || !["planned", "committing", "pending_reconcile", "completed"].includes(plan.status) || materialized?.status !== "materialized" || materialized.planId !== plan.planId || materialized.revision !== plan.revision || materialized.sha256 !== doc?.sha256 || materialized.byteSize !== doc?.byteSize || materialized.path !== doc?.path) {
-      fail3("initialization_completion_invalid_plan");
+      fail4("initialization_completion_invalid_plan");
     }
     const prefix = "initialization-complete:" + plan.planId;
     const { createHash: createHash21 } = await import("node:crypto");
@@ -23450,13 +23605,13 @@ async function runInitializationCompletion({ plan, authority, call, sleep, now,
       }
     }), "upload_artifact");
     if (upload.postcondition?.artifactFinalized !== true || upload.postcondition?.attachmentReadback !== true || upload.postcondition?.workProductReadback !== true || upload.effectResult?.sha256 !== doc.sha256 || upload.effectResult?.byteSize !== doc.byteSize || !upload.effectResult?.attachmentId || !upload.effectResult?.workProductId) {
-      fail3("initialization_completion_artifact_mismatch");
+      fail4("initialization_completion_artifact_mismatch");
     }
     stage = "commit";
     callId = void 0;
     const committed = await invoke("runtime_action_commit", { planId: plan.planId, revision: plan.revision });
     if (committed.planId !== plan.planId || committed.revision !== plan.revision || committed.status !== "completed" || committed.failure || committed.nextActionIndex !== committed.actionCount) {
-      fail3("initialization_completion_plan_incomplete", { status: committed.status, failure: committed.failure });
+      fail4("initialization_completion_plan_incomplete", { status: committed.status, failure: committed.failure });
     }
     stage = "ready";
     const completed = await settleCall(await invoke("runtime_action_submit", {
@@ -23464,7 +23619,7 @@ async function runInitializationCompletion({ plan, authority, call, sleep, now,
       action: { type: "update_parent", status: "done" }
     }), "update_parent");
     if (completed.effectResult?.issueId !== authority.issueId || completed.effectResult?.status !== "done" || completed.postcondition?.issuePersisted !== true || completed.postcondition?.status !== "done" || completed.postcondition?.issueTerminalizationDeferred === true) {
-      fail3("initialization_completion_ready_not_confirmed");
+      fail4("initialization_completion_ready_not_confirmed");
     }
     return {
       status: "completed",
@@ -23723,29 +23878,29 @@ export default function(pi) {
 // src/amaster-runtime-daemon/pi-managed-mcp-profile.mjs
 import { createHash as createHash9 } from "node:crypto";
 import {
-  chmodSync as chmodSync4,
-  chownSync as chownSync2,
+  chmodSync as chmodSync5,
+  chownSync as chownSync3,
   copyFileSync,
   existsSync as existsSync7,
-  lstatSync as lstatSync7,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync6,
+  lstatSync as lstatSync8,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync7,
   realpathSync as realpathSync8,
-  readdirSync as readdirSync4,
-  renameSync as renameSync3,
+  readdirSync as readdirSync5,
+  renameSync as renameSync4,
   rmSync as rmSync5,
-  rmdirSync,
+  rmdirSync as rmdirSync2,
   statSync as statSync4,
   symlinkSync,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "node:fs";
 import { arch as arch3, platform as platform3 } from "node:os";
-import { basename as basename3, delimiter as delimiter2, dirname as dirname5, isAbsolute as isAbsolute4, join as join10, relative as relative3, resolve as resolve7, sep as sep3 } from "node:path";
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { basename as basename3, delimiter as delimiter2, dirname as dirname6, isAbsolute as isAbsolute4, join as join11, relative as relative3, resolve as resolve8, sep as sep3 } from "node:path";
+import { spawnSync as spawnSync4 } from "node:child_process";
 
 // src/amaster-runtime-daemon/pi-provider-config.mjs
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname4, join as join8 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync4, renameSync as renameSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname5, join as join9 } from "node:path";
 var AMASTER_API_KEY_ENV_REFERENCE = "${AMASTER_API_KEY}";
 var AMASTER_BILLING_TURN_HEADER_ENV_REFERENCE = "${AMASTER_BILLING_TURN_ID}";
 var AMASTER_BILLING_HEADER_ENV_REFERENCES = Object.freeze({
@@ -23787,18 +23942,18 @@ function isRecord(value) {
 }
 function readJsonFile(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync3(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync4(filePath, "utf8"));
     return asRecord(parsed);
   } catch {
     return {};
   }
 }
 function writeJsonFileAtomic(filePath, value) {
-  mkdirSync5(dirname4(filePath), { recursive: true });
+  mkdirSync6(dirname5(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
-  writeFileSync5(tmpPath, `${JSON.stringify(value, null, 2)}
+  writeFileSync6(tmpPath, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
-  renameSync2(tmpPath, filePath);
+  renameSync3(tmpPath, filePath);
 }
 function imageGenBaseUrlFromProviderBaseUrl(value) {
   const input = readString(value);
@@ -23836,7 +23991,7 @@ function managedApiKeyConfigValue(executorEnv, apiKey) {
 function syncAmasterProviderModels(agentDir, executorEnv) {
   const apiKey = readString(executorEnv.AMASTER_API_KEY);
   if (!apiKey) return false;
-  const modelsPath = join8(agentDir, "models.json");
+  const modelsPath = join9(agentDir, "models.json");
   const config = readJsonFile(modelsPath);
   const providers = asRecord(config.providers);
   const amaster = { ...asRecord(providers.amaster) };
@@ -23859,7 +24014,7 @@ function syncAmasterProviderModels(agentDir, executorEnv) {
 function syncAmasterProviderSettings(agentDir, executorEnv) {
   const apiKey = readString(executorEnv.AMASTER_API_KEY);
   if (!apiKey) return false;
-  const settingsPath = join8(agentDir, "settings.json");
+  const settingsPath = join9(agentDir, "settings.json");
   if (!existsSync5(settingsPath)) return false;
   const settings = readJsonFile(settingsPath);
   const baseUrl = readString(executorEnv.AMASTER_PROVIDER_BASE_URL);
@@ -23981,7 +24136,7 @@ function modelCallOutputContractExtensionSource(maxOutputTokens) {
 `;
 }
 function assertPiModelConfigured(agentDir, provider, model) {
-  const modelsPath = join8(agentDir, "models.json");
+  const modelsPath = join9(agentDir, "models.json");
   const config = readJsonFile(modelsPath);
   const providers = asRecord(config.providers);
   const providerConfig = asRecord(providers[provider]);
@@ -24003,7 +24158,7 @@ function resolvePiModelCallTarget(agentDir, providerId, modelId, explicitSource
   let model = explicitModel;
   let source = explicitSource;
   if (!provider || !model) {
-    const settings = readJsonFile(join8(agentDir, "settings.json"));
+    const settings = readJsonFile(join9(agentDir, "settings.json"));
     const defaultProvider = readString(settings.defaultProvider);
     const defaultModel = normalizePiModelId(settings.defaultModel);
     if (Boolean(defaultProvider) !== Boolean(defaultModel)) {
@@ -24021,7 +24176,7 @@ function resolvePiModelCallTarget(agentDir, providerId, modelId, explicitSource
 }
 function resolvePiRunModelContext(agentDir, providerId, modelId) {
   const target = resolvePiModelCallTarget(agentDir, providerId, modelId, "runtime_override");
-  const modelsPath = join8(agentDir, "models.json");
+  const modelsPath = join9(agentDir, "models.json");
   const config = readJsonFile(modelsPath);
   const providerConfig = asRecord(asRecord(config.providers)[target.provider]);
   const configuredModel = (Array.isArray(providerConfig.models) ? providerConfig.models : []).map(asRecord).find((entry) => readString(entry.id) === target.model) ?? {};
@@ -24084,7 +24239,7 @@ function piMcpAdapterServerConfigIdentity(definition, adapterVersion) {
 }
 
 // src/amaster-runtime-daemon/pi-role-skills-visibility.mjs
-import { readFileSync as readFileSync4, realpathSync as realpathSync6 } from "node:fs";
+import { readFileSync as readFileSync5, realpathSync as realpathSync6 } from "node:fs";
 var MANAGED_PI_ROLE_SKILLS_VISIBILITY_FILENAME = "amaster-role-skills-visibility.js";
 function hostYamlString(value) {
   const trimmed = value.trim();
@@ -24119,7 +24274,7 @@ function hostEscapeXml(value) {
 }
 function readManagedPiSkillMetadata(filePath) {
   const resolvedFilePath = realpathSync6(filePath);
-  const source = readFileSync4(resolvedFilePath, "utf8");
+  const source = readFileSync5(resolvedFilePath, "utf8");
   const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
   if (!match) {
     return {
@@ -24186,15 +24341,15 @@ export default function amasterRoleSkillsVisibility(pi) {
 }
 
 // src/amaster-runtime-daemon/pi-mcp-adapter-readiness.mjs
-import { existsSync as existsSync6, lstatSync as lstatSync6, readFileSync as readFileSync5, realpathSync as realpathSync7 } from "node:fs";
-import { join as join9, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync6, lstatSync as lstatSync7, readFileSync as readFileSync6, realpathSync as realpathSync7 } from "node:fs";
+import { join as join10, resolve as resolve7 } from "node:path";
 var ADAPTER_PACKAGE_NAME = "pi-mcp-adapter";
 function unavailable(reasonCode) {
   return { ready: false, reasonCode };
 }
 function safeRegularFile(filePath) {
   if (!existsSync6(filePath)) return false;
-  const stat = lstatSync6(filePath);
+  const stat = lstatSync7(filePath);
   return stat.isFile() && !stat.isSymbolicLink();
 }
 function inspectDesktopPiMcpAdapterReadiness(input = {}) {
@@ -24202,27 +24357,27 @@ function inspectDesktopPiMcpAdapterReadiness(input = {}) {
   if (!configuredHome) return unavailable("desktop_pi_home_unavailable");
   let piHome;
   try {
-    piHome = resolve6(configuredHome);
-    const homeStat = lstatSync6(piHome);
+    piHome = resolve7(configuredHome);
+    const homeStat = lstatSync7(piHome);
     if (!homeStat.isDirectory() || homeStat.isSymbolicLink()) {
       return unavailable("desktop_pi_home_unsafe");
     }
   } catch {
     return unavailable("desktop_pi_home_unavailable");
   }
-  const configuredAdapterRoot = join9(piHome, "npm", "node_modules", ADAPTER_PACKAGE_NAME);
+  const configuredAdapterRoot = join10(piHome, "npm", "node_modules", ADAPTER_PACKAGE_NAME);
   try {
     const adapterRoot = realpathSync7(configuredAdapterRoot);
-    const adapterRootStat = lstatSync6(adapterRoot);
+    const adapterRootStat = lstatSync7(adapterRoot);
     if (!adapterRootStat.isDirectory() || adapterRootStat.isSymbolicLink()) {
       return unavailable("desktop_pi_mcp_adapter_unavailable");
     }
-    const packagePath = join9(adapterRoot, "package.json");
-    const extensionPath = join9(adapterRoot, "index.ts");
+    const packagePath = join10(adapterRoot, "package.json");
+    const extensionPath = join10(adapterRoot, "index.ts");
     if (![packagePath, extensionPath].every(safeRegularFile)) {
       return unavailable("desktop_pi_mcp_adapter_unavailable");
     }
-    const packageJson = JSON.parse(readFileSync5(packagePath, "utf8"));
+    const packageJson = JSON.parse(readFileSync6(packagePath, "utf8"));
     const adapterVersion = typeof packageJson?.version === "string" ? packageJson.version.trim() : "";
     if (packageJson?.name !== ADAPTER_PACKAGE_NAME || !/^\d+\.\d+\.\d+(?:[-+].+)?$/.test(adapterVersion)) {
       return unavailable("desktop_pi_mcp_adapter_invalid");
@@ -24363,10 +24518,10 @@ function applyManagedPiRunExitClosureArgs(args, profile) {
     try {
       return realpathSync8(filePath);
     } catch {
-      return resolve7(filePath);
+      return resolve8(filePath);
     }
   };
-  const roleSkillsVisibilityExtension = canonicalPath(resolve7(
+  const roleSkillsVisibilityExtension = canonicalPath(resolve8(
     profile.profileRoot,
     "extensions",
     MANAGED_PI_ROLE_SKILLS_VISIBILITY_FILENAME
@@ -24382,29 +24537,29 @@ function applyManagedPiRunExitClosureArgs(args, profile) {
   return closureArgs;
 }
 function resolveManagedPiMcpAdapterExtension(adapterRoot) {
-  const adapterRootStat = lstatSync7(adapterRoot);
+  const adapterRootStat = lstatSync8(adapterRoot);
   if (!adapterRootStat.isDirectory() || adapterRootStat.isSymbolicLink()) {
     throw new Error("pi_managed_mcp_adapter_extension_unsafe");
   }
-  const adapterManifest = JSON.parse(readFileSync6(join10(adapterRoot, "package.json"), "utf8"));
+  const adapterManifest = JSON.parse(readFileSync7(join11(adapterRoot, "package.json"), "utf8"));
   const entries = adapterManifest.pi?.extensions;
   const entry = entries === void 0 ? "index.ts" : Array.isArray(entries) && entries.length === 1 ? entries[0] : null;
   if (!["index.ts", "./index.ts", "index.js", "./index.js"].includes(entry)) {
     throw new Error("pi_managed_mcp_adapter_extension_unsafe");
   }
-  const adapterExtensionPath = join10(adapterRoot, entry);
+  const adapterExtensionPath = join11(adapterRoot, entry);
   if (!existsSync7(adapterExtensionPath)) {
     throw new Error("pi_managed_mcp_adapter_extension_missing");
   }
-  const adapterExtensionStat = lstatSync7(adapterExtensionPath);
+  const adapterExtensionStat = lstatSync8(adapterExtensionPath);
   if (!adapterExtensionStat.isFile() || adapterExtensionStat.isSymbolicLink()) {
     throw new Error("pi_managed_mcp_adapter_extension_unsafe");
   }
   return adapterExtensionPath;
 }
 function createManagedPiMcpProfileApi(options = {}) {
-  const spawnSyncImpl = typeof options.spawnSync === "function" ? options.spawnSync : spawnSync3;
-  const chownSyncImpl = typeof options.chownSync === "function" ? options.chownSync : chownSync2;
+  const spawnSyncImpl = typeof options.spawnSync === "function" ? options.spawnSync : spawnSync4;
+  const chownSyncImpl = typeof options.chownSync === "function" ? options.chownSync : chownSync3;
   const ownershipStatSyncImpl = typeof options.ownershipStatSync === "function" ? options.ownershipStatSync : statSync4;
   const nowImpl = typeof options.now === "function" ? options.now : Date.now;
   const SUPPORTED_SCHEMA_VERSION3 = "amaster.governed-mcp.v1";
@@ -24508,7 +24663,7 @@ function createManagedPiMcpProfileApi(options = {}) {
   function readJsonObjectFile(filePath) {
     if (!existsSync7(filePath)) return {};
     try {
-      const value = JSON.parse(readFileSync6(filePath, "utf8"));
+      const value = JSON.parse(readFileSync7(filePath, "utf8"));
       if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error("JSON value is not an object");
       }
@@ -24526,19 +24681,19 @@ function createManagedPiMcpProfileApi(options = {}) {
     return rel === "" || !rel.startsWith("..") && !isAbsolute4(rel);
   }
   function writePrivateFile2(filePath, contents) {
-    writeFileSync6(filePath, contents, { mode: 384, flag: "wx" });
-    chmodSync4(filePath, 384);
+    writeFileSync7(filePath, contents, { mode: 384, flag: "wx" });
+    chmodSync5(filePath, 384);
     const mode = statSync4(filePath).mode & 511;
     if (mode !== 384) throw new Error(`pi_managed_mcp_permissions_failed: ${filePath} mode=${mode.toString(8)}`);
   }
   function copyPrivateFile(source, target) {
     if (!existsSync7(source)) return false;
-    const sourceStat = lstatSync7(source);
+    const sourceStat = lstatSync8(source);
     if (!sourceStat.isFile() || sourceStat.isSymbolicLink()) {
       throw new Error(`pi_managed_mcp_source_config_unsafe: ${source}`);
     }
     copyFileSync(source, target, 0);
-    chmodSync4(target, 384);
+    chmodSync5(target, 384);
     return true;
   }
   function findPiSessionRollout(sessionsRoot, sessionId) {
@@ -24547,12 +24702,12 @@ function createManagedPiMcpProfileApi(options = {}) {
     const pending = [sessionsRoot];
     while (pending.length > 0) {
       const current = pending.pop();
-      const currentStat = lstatSync7(current);
+      const currentStat = lstatSync8(current);
       if (!currentStat.isDirectory() || currentStat.isSymbolicLink()) {
         throw new Error("pi_managed_mcp_session_rollout_unsafe: sessions path is not a private directory");
       }
-      for (const entry of readdirSync4(current, { withFileTypes: true })) {
-        const candidate = join10(current, entry.name);
+      for (const entry of readdirSync5(current, { withFileTypes: true })) {
+        const candidate = join11(current, entry.name);
         if (entry.isSymbolicLink()) throw new Error("pi_managed_mcp_session_rollout_unsafe: symlinks are forbidden");
         if (entry.isDirectory()) pending.push(candidate);
         else if (entry.isFile() && entry.name.endsWith(`_${sessionId}.jsonl`)) matches.push(candidate);
@@ -24583,31 +24738,31 @@ function createManagedPiMcpProfileApi(options = {}) {
       const installed = installPiSessionCheckpoint(sessionsRoot, input.portableNativeSession, sessionId);
       return { ...installed, sourceRunId, sourceCommandId, cacheRoot: null };
     }
-    const issueRoot = dirname5(runDir);
+    const issueRoot = dirname6(runDir);
     const managedSourceRunDirName = `${sourceRunId}-${createHash9("sha256").update(sourceRunId).digest("hex").slice(0, 8)}`;
-    const sourceRunDirs = readdirSync4(issueRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.isSymbolicLink() && (entry.name === sourceRunId || entry.name === managedSourceRunDirName)).map((entry) => join10(issueRoot, entry.name));
+    const sourceRunDirs = readdirSync5(issueRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.isSymbolicLink() && (entry.name === sourceRunId || entry.name === managedSourceRunDirName)).map((entry) => join11(issueRoot, entry.name));
     if (sourceRunDirs.length !== 1) {
       throw new Error(`pi_managed_mcp_session_rollout_missing: expected one source run directory for ${sourceRunId}, received ${sourceRunDirs.length}`);
     }
-    const cacheRoot = join10(sourceRunDirs[0], relative3(runDir, executorHome), "session-rollout");
-    const markerPath = join10(cacheRoot, SESSION_ROLLOUT_MARKER3);
-    if (!existsSync7(markerPath) || lstatSync7(markerPath).isSymbolicLink() || !lstatSync7(markerPath).isFile()) {
+    const cacheRoot = join11(sourceRunDirs[0], relative3(runDir, executorHome), "session-rollout");
+    const markerPath2 = join11(cacheRoot, SESSION_ROLLOUT_MARKER3);
+    if (!existsSync7(markerPath2) || lstatSync8(markerPath2).isSymbolicLink() || !lstatSync8(markerPath2).isFile()) {
       throw new Error("pi_managed_mcp_session_rollout_missing: source rollout marker is unavailable");
     }
-    const marker = JSON.parse(readFileSync6(markerPath, "utf8"));
+    const marker = JSON.parse(readFileSync7(markerPath2, "utf8"));
     if (marker?.version !== 1 || marker?.companyId !== authority.companyId || marker?.agentId !== authority.agentId || marker?.issueId !== authority.issueId || marker?.sourceRunId !== sourceRunId || marker?.sourceCommandId !== sourceCommandId || marker?.sessionId !== sessionId || marker?.sourceWorkspacePath !== sourceWorkspacePath) {
       throw new Error("pi_managed_mcp_session_rollout_authority_mismatch: source rollout does not match the governed continuation");
     }
-    const sourceRollout = resolve7(cacheRoot, nonEmpty3(marker.rolloutRelativePath, "rolloutRelativePath"));
-    if (!within3(sourceRollout, cacheRoot) || lstatSync7(sourceRollout).isSymbolicLink() || !lstatSync7(sourceRollout).isFile()) {
+    const sourceRollout = resolve8(cacheRoot, nonEmpty3(marker.rolloutRelativePath, "rolloutRelativePath"));
+    if (!within3(sourceRollout, cacheRoot) || lstatSync8(sourceRollout).isSymbolicLink() || !lstatSync8(sourceRollout).isFile()) {
       throw new Error("pi_managed_mcp_session_rollout_unsafe: source rollout path is invalid");
     }
-    const targetRollout = resolve7(sessionsRoot, marker.rolloutRelativePath);
+    const targetRollout = resolve8(sessionsRoot, marker.rolloutRelativePath);
     if (!within3(targetRollout, sessionsRoot)) {
       throw new Error("pi_managed_mcp_session_rollout_unsafe: target rollout path is invalid");
     }
-    mkdirSync6(dirname5(targetRollout), { recursive: true, mode: 448 });
-    writePrivateFile2(targetRollout, readFileSync6(sourceRollout));
+    mkdirSync7(dirname6(targetRollout), { recursive: true, mode: 448 });
+    writePrivateFile2(targetRollout, readFileSync7(sourceRollout));
     return { sessionId, sourceRunId, sourceCommandId, rolloutPath: targetRollout, cacheRoot };
   }
   function resolveManagedPiSessionRollout(input, sessionsRoot, runDir, executorHome, authority) {
@@ -24655,7 +24810,7 @@ function createManagedPiMcpProfileApi(options = {}) {
     return createHash9("sha256").update(value).digest("hex");
   }
   function trustedTreeDigest(rootPath, options2 = {}) {
-    const root = resolve7(rootPath);
+    const root = resolve8(rootPath);
     const ignoredRootEntries = new Set(Array.isArray(options2.ignoredRootEntries) ? options2.ignoredRootEntries : []);
     const hash3 = createHash9("sha256");
     hash3.update(`ignored-root:${[...ignoredRootEntries].sort().join(",")}
@@ -24663,28 +24818,28 @@ function createManagedPiMcpProfileApi(options = {}) {
     const pending = [root];
     while (pending.length > 0) {
       const current = pending.pop();
-      const currentStat = lstatSync7(current);
+      const currentStat = lstatSync8(current);
       if (currentStat.isSymbolicLink()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${current}`);
       const relativePath = relative3(root, current).split(sep3).join("/");
       if (currentStat.isDirectory()) {
         hash3.update(`d:${relativePath}
 `);
-        const children = readdirSync4(current).filter((child) => current !== root || !ignoredRootEntries.has(child)).sort().reverse();
-        for (const child of children) pending.push(join10(current, child));
+        const children = readdirSync5(current).filter((child) => current !== root || !ignoredRootEntries.has(child)).sort().reverse();
+        for (const child of children) pending.push(join11(current, child));
         continue;
       }
       if (!currentStat.isFile()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${current}`);
       hash3.update(`f:${relativePath}:${currentStat.mode & 73 ? "x" : "-"}:`);
-      hash3.update(readFileSync6(current));
+      hash3.update(readFileSync7(current));
       hash3.update("\n");
     }
     return hash3.digest("hex");
   }
   function piMcpAdapterVersion(piHome) {
-    const packagePath = join10(piHome, "npm", "node_modules", "pi-mcp-adapter", "package.json");
+    const packagePath = join11(piHome, "npm", "node_modules", "pi-mcp-adapter", "package.json");
     let packageJson;
     try {
-      packageJson = JSON.parse(readFileSync6(packagePath, "utf8"));
+      packageJson = JSON.parse(readFileSync7(packagePath, "utf8"));
     } catch {
       throw new Error("pi_managed_mcp_adapter_version_unavailable");
     }
@@ -24702,21 +24857,21 @@ function createManagedPiMcpProfileApi(options = {}) {
     if (configuredSources.length !== 1) {
       throw new Error("pi_managed_mcp_telemetry_package_source_invalid");
     }
-    const packageRoot = resolve7(
+    const packageRoot = resolve8(
       sharedRuntime.home,
       "npm",
       "node_modules",
       "@amaster.ai",
       "pi-telemetry"
     );
-    const packageJsonPath = join10(packageRoot, "package.json");
+    const packageJsonPath = join11(packageRoot, "package.json");
     let packageJson;
     try {
-      const packageStat = lstatSync7(packageRoot);
+      const packageStat = lstatSync8(packageRoot);
       if (!packageStat.isDirectory() || packageStat.isSymbolicLink()) throw new Error("unsafe package root");
-      const packageJsonStat = lstatSync7(packageJsonPath);
+      const packageJsonStat = lstatSync8(packageJsonPath);
       if (!packageJsonStat.isFile() || packageJsonStat.isSymbolicLink()) throw new Error("unsafe package manifest");
-      packageJson = record11(JSON.parse(readFileSync6(packageJsonPath, "utf8")));
+      packageJson = record11(JSON.parse(readFileSync7(packageJsonPath, "utf8")));
     } catch {
       throw new Error("pi_managed_mcp_telemetry_package_unavailable");
     }
@@ -24731,12 +24886,12 @@ function createManagedPiMcpProfileApi(options = {}) {
     if (declaredExtensions.length !== 1 || typeof declaredExtensions[0] !== "string") {
       throw new Error("pi_managed_mcp_telemetry_extension_invalid");
     }
-    const extensionPath = resolve7(packageRoot, declaredExtensions[0]);
+    const extensionPath = resolve8(packageRoot, declaredExtensions[0]);
     if (!within3(extensionPath, packageRoot)) {
       throw new Error("pi_managed_mcp_telemetry_extension_unsafe");
     }
     try {
-      const extensionStat = lstatSync7(extensionPath);
+      const extensionStat = lstatSync8(extensionPath);
       if (!extensionStat.isFile() || extensionStat.isSymbolicLink()) throw new Error("unsafe extension entry");
       const realPackageRoot = realpathSync8(packageRoot);
       const realExtensionPath = realpathSync8(extensionPath);
@@ -24755,7 +24910,7 @@ function createManagedPiMcpProfileApi(options = {}) {
       packageVersion: version,
       packageVersionSource: "installed_package_manifest",
       extensionPath,
-      extensionSha256: sha2563(readFileSync6(extensionPath)),
+      extensionSha256: sha2563(readFileSync7(extensionPath)),
       packageTreeSha256,
       langfuseEnabled: record11(record11(settings["pi-telemetry"]).langfuse).enabled === true
     };
@@ -24786,8 +24941,8 @@ function createManagedPiMcpProfileApi(options = {}) {
     const pathEntries = String(env?.PATH ?? "").split(delimiter2).filter(Boolean);
     for (const entry of pathEntries) {
       try {
-        const candidate = realpathSync8(join10(entry, executorCommand));
-        const stat = lstatSync7(candidate);
+        const candidate = realpathSync8(join11(entry, executorCommand));
+        const stat = lstatSync8(candidate);
         if (stat.isFile() && !stat.isSymbolicLink()) return candidate;
       } catch {
       }
@@ -24797,16 +24952,16 @@ function createManagedPiMcpProfileApi(options = {}) {
   function piExecutableIdentity(executorPath) {
     try {
       const realPath = realpathSync8(executorPath);
-      const executableStat = lstatSync7(realPath);
+      const executableStat = lstatSync8(realPath);
       if (!executableStat.isFile() || executableStat.isSymbolicLink()) {
         throw Object.assign(new Error("Pi executable is not a regular file"), { code: "EUNSAFE" });
       }
-      const contentSha256 = createHash9("sha256").update(readFileSync6(realPath)).digest("hex");
+      const contentSha256 = createHash9("sha256").update(readFileSync7(realPath)).digest("hex");
       let packageManifestSha256 = null;
-      for (let directory = dirname5(realPath); dirname5(directory) !== directory; directory = dirname5(directory)) {
-        const packagePath = join10(directory, "package.json");
+      for (let directory = dirname6(realPath); dirname6(directory) !== directory; directory = dirname6(directory)) {
+        const packagePath = join11(directory, "package.json");
         if (!existsSync7(packagePath)) continue;
-        packageManifestSha256 = sha2563(readFileSync6(packagePath));
+        packageManifestSha256 = sha2563(readFileSync7(packagePath));
         break;
       }
       return `sha256:${createHash9("sha256").update(JSON.stringify({ realPath, contentSha256, packageManifestSha256 })).digest("hex")}`;
@@ -24930,7 +25085,7 @@ function createManagedPiMcpProfileApi(options = {}) {
     if (!existsSync7(filePath)) return false;
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync6(filePath, "utf8"));
+      parsed = JSON.parse(readFileSync7(filePath, "utf8"));
     } catch {
       return true;
     }
@@ -24938,32 +25093,32 @@ function createManagedPiMcpProfileApi(options = {}) {
     return Object.keys(record11(config.mcpServers)).length > 0 || Object.keys(record11(config.servers)).length > 0 || Array.isArray(config.imports) && config.imports.length > 0;
   }
   function walkProjectMcpConfigs(cwd, runDir, visit) {
-    const start = resolve7(cwd);
-    const boundary = resolve7(runDir);
+    const start = resolve8(cwd);
+    const boundary = resolve8(runDir);
     if (!within3(start, boundary)) throw new Error("pi_managed_mcp_owner_mismatch: cwd is outside the managed run");
     let cursor = start;
     while (within3(cursor, boundary)) {
       visit(cursor, cursor === start);
       if (cursor === boundary) break;
-      cursor = dirname5(cursor);
+      cursor = dirname6(cursor);
     }
   }
   function assertNoProjectMcpOverride(cwd, runDir) {
     walkProjectMcpConfigs(cwd, runDir, (level) => {
-      for (const relativePath of [".mcp.json", join10(".pi", "mcp.json")]) {
-        const configPath = join10(level, relativePath);
+      for (const relativePath of [".mcp.json", join11(".pi", "mcp.json")]) {
+        const configPath = join11(level, relativePath);
         if (projectMcpConfigHasContent(configPath)) throw new Error(`pi_managed_mcp_project_override_blocked: ${configPath}`);
       }
     });
   }
   function assertWorkspaceMcpOverrideClear(cwd, runDir) {
     walkProjectMcpConfigs(cwd, runDir, (level, isCwd) => {
-      const sharedProjectConfig = join10(level, ".mcp.json");
+      const sharedProjectConfig = join11(level, ".mcp.json");
       if (projectMcpConfigHasContent(sharedProjectConfig)) {
         throw new Error(`pi_managed_mcp_project_override_blocked: ${sharedProjectConfig}`);
       }
       if (!isCwd) {
-        const ancestorPiConfig = join10(level, ".pi", "mcp.json");
+        const ancestorPiConfig = join11(level, ".pi", "mcp.json");
         if (projectMcpConfigHasContent(ancestorPiConfig)) {
           throw new Error(`pi_managed_mcp_project_override_blocked: ${ancestorPiConfig}`);
         }
@@ -24971,55 +25126,55 @@ function createManagedPiMcpProfileApi(options = {}) {
     });
   }
   function isWorkspaceMcpConfigPath(path) {
-    return resolve7(path).replaceAll("\\", "/").endsWith("/.pi/mcp.json");
+    return resolve8(path).replaceAll("\\", "/").endsWith("/.pi/mcp.json");
   }
   function managedRunRootForProfile(profileRoot) {
-    const executorsRoot = dirname5(dirname5(resolve7(profileRoot)));
+    const executorsRoot = dirname6(dirname6(resolve8(profileRoot)));
     if (basename3(executorsRoot) !== "executors") {
       throw new Error("pi_managed_mcp_cleanup_owner_mismatch: profile is outside a managed run");
     }
-    return dirname5(executorsRoot);
+    return dirname6(executorsRoot);
   }
   function workspaceMcpConfigBelongsToProfile(configPath, profileRoot) {
-    const target = resolve7(configPath);
+    const target = resolve8(configPath);
     return isWorkspaceMcpConfigPath(target) && within3(target, managedRunRootForProfile(profileRoot));
   }
   function writeOwnedFileAtomic(filePath, contents) {
     if (existsSync7(filePath)) {
-      const stat = lstatSync7(filePath);
+      const stat = lstatSync8(filePath);
       if (!stat.isFile() || stat.isSymbolicLink()) {
         throw new Error(`pi_managed_mcp_workspace_config_unsafe: ${filePath}`);
       }
     }
-    mkdirSync6(dirname5(filePath), { recursive: true, mode: 448 });
+    mkdirSync7(dirname6(filePath), { recursive: true, mode: 448 });
     const tempPath = `${filePath}.tmp.${process.pid}`;
-    writeFileSync6(tempPath, contents, { mode: 384 });
-    renameSync3(tempPath, filePath);
-    chmodSync4(filePath, 384);
+    writeFileSync7(tempPath, contents, { mode: 384 });
+    renameSync4(tempPath, filePath);
+    chmodSync5(filePath, 384);
     const mode = statSync4(filePath).mode & 511;
     if (mode !== 384) throw new Error(`pi_managed_mcp_permissions_failed: ${filePath} mode=${mode.toString(8)}`);
   }
   function sharedPiHomeSettingsEnv(baseEnv) {
-    const home = resolve7(nonEmpty3(baseEnv?.PI_CODING_AGENT_DIR, "sourcePiHome: PI_CODING_AGENT_DIR"));
-    const homeStat = lstatSync7(home);
+    const home = resolve8(nonEmpty3(baseEnv?.PI_CODING_AGENT_DIR, "sourcePiHome: PI_CODING_AGENT_DIR"));
+    const homeStat = lstatSync8(home);
     if (!homeStat.isDirectory() || homeStat.isSymbolicLink()) {
       throw new Error("pi_managed_mcp_source_config_unsafe: Pi home");
     }
-    const settingsPath = join10(home, "settings.json");
+    const settingsPath = join11(home, "settings.json");
     let settings = {};
     if (existsSync7(settingsPath)) {
       try {
-        settings = record11(JSON.parse(readFileSync6(settingsPath, "utf8")));
+        settings = record11(JSON.parse(readFileSync7(settingsPath, "utf8")));
       } catch {
         throw new Error("pi_managed_mcp_attestation_failed: source Pi settings are invalid");
       }
     }
     let userMcpServers = {};
-    const mcpPath = join10(home, "mcp.json");
+    const mcpPath = join11(home, "mcp.json");
     if (existsSync7(mcpPath)) {
       try {
         userMcpServers = Object.fromEntries(Object.entries(record11(
-          record11(JSON.parse(readFileSync6(mcpPath, "utf8"))).mcpServers
+          record11(JSON.parse(readFileSync7(mcpPath, "utf8"))).mcpServers
         )).filter(([serverName]) => serverName !== SUPPORTED_SERVER_NAME3));
       } catch {
         userMcpServers = {};
@@ -25099,20 +25254,20 @@ function createManagedPiMcpProfileApi(options = {}) {
   function materializeManagedSkillBundle(profileRoot, rawBundle) {
     const bundle = parseManagedSkillBundle(rawBundle);
     if (!bundle) return { entries: [] };
-    const root = join10(profileRoot, "company-skills");
-    mkdirSync6(root, { recursive: true, mode: 448 });
+    const root = join11(profileRoot, "company-skills");
+    mkdirSync7(root, { recursive: true, mode: 448 });
     const entries = bundle.skills.map((skill) => {
-      const skillRoot = join10(root, skill.runtimeName);
-      mkdirSync6(skillRoot, { recursive: true, mode: 448 });
+      const skillRoot = join11(root, skill.runtimeName);
+      mkdirSync7(skillRoot, { recursive: true, mode: 448 });
       for (const file of skill.files) {
-        const target = resolve7(skillRoot, file.path);
+        const target = resolve8(skillRoot, file.path);
         if (!within3(target, skillRoot)) {
           throw new Error(`pi_managed_mcp_company_skill_path_unsafe:${skill.runtimeName}:${file.path}`);
         }
-        mkdirSync6(dirname5(target), { recursive: true, mode: 448 });
+        mkdirSync7(dirname6(target), { recursive: true, mode: 448 });
         writePrivateFile2(target, file.contents);
       }
-      const metadata = readManagedPiSkillMetadata(join10(skillRoot, "SKILL.md"));
+      const metadata = readManagedPiSkillMetadata(join11(skillRoot, "SKILL.md"));
       return {
         name: metadata.name ?? skill.runtimeName,
         filePath: metadata.filePath
@@ -25121,22 +25276,22 @@ function createManagedPiMcpProfileApi(options = {}) {
     return { entries };
   }
   function readSkillProfile(piHome, skillProfile) {
-    const agentsRoot = resolve7(piHome, "agents");
-    const agentFile = resolve7(agentsRoot, `${skillProfile}.md`);
+    const agentsRoot = resolve8(piHome, "agents");
+    const agentFile = resolve8(agentsRoot, `${skillProfile}.md`);
     if (!SKILL_PROFILE_NAME.test(skillProfile) || !within3(agentFile, agentsRoot) || !existsSync7(agentFile)) {
       return [];
     }
-    const declared = readFileSync6(agentFile, "utf8").match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1].match(/^skills:\s*(.+)$/m)?.[1].split(",").map((entry) => entry.trim()).filter(Boolean) ?? [];
-    const bundlesRoot = resolve7(piHome, "bundles");
+    const declared = readFileSync7(agentFile, "utf8").match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1].match(/^skills:\s*(.+)$/m)?.[1].split(",").map((entry) => entry.trim()).filter(Boolean) ?? [];
+    const bundlesRoot = resolve8(piHome, "bundles");
     const profile = [];
     for (const name of declared) {
-      let source = join10(bundlesRoot, skillProfile, "skills", name);
-      if (!existsSync7(join10(source, "SKILL.md"))) {
+      let source = join11(bundlesRoot, skillProfile, "skills", name);
+      if (!existsSync7(join11(source, "SKILL.md"))) {
         const candidates = [];
-        for (const category of readdirSync4(bundlesRoot).sort()) {
+        for (const category of readdirSync5(bundlesRoot).sort()) {
           if (category === skillProfile) continue;
-          const candidate = join10(bundlesRoot, category, "skills", name);
-          if (existsSync7(join10(candidate, "SKILL.md"))) candidates.push(candidate);
+          const candidate = join11(bundlesRoot, category, "skills", name);
+          if (existsSync7(join11(candidate, "SKILL.md"))) candidates.push(candidate);
         }
         source = candidates[0];
       }
@@ -25145,20 +25300,20 @@ function createManagedPiMcpProfileApi(options = {}) {
     return profile;
   }
   function readCommonRoleSkills(piHome) {
-    const skillsRoot = resolve7(piHome, "bundles", "common", "skills");
+    const skillsRoot = resolve8(piHome, "bundles", "common", "skills");
     if (!existsSync7(skillsRoot)) return [];
-    return readdirSync4(skillsRoot).sort().flatMap((name) => {
-      const source = join10(skillsRoot, name);
-      return existsSync7(join10(source, "SKILL.md")) ? [{ name, source }] : [];
+    return readdirSync5(skillsRoot).sort().flatMap((name) => {
+      const source = join11(skillsRoot, name);
+      return existsSync7(join11(source, "SKILL.md")) ? [{ name, source }] : [];
     });
   }
   function readMainSkills(piHome) {
-    const skillsRoot = resolve7(piHome, "skills");
+    const skillsRoot = resolve8(piHome, "skills");
     if (!existsSync7(skillsRoot)) return [];
     const entriesByName = /* @__PURE__ */ new Map();
-    for (const directory of readdirSync4(skillsRoot).sort()) {
-      const source = join10(skillsRoot, directory);
-      const skillFilePath = join10(source, "SKILL.md");
+    for (const directory of readdirSync5(skillsRoot).sort()) {
+      const source = join11(skillsRoot, directory);
+      const skillFilePath = join11(source, "SKILL.md");
       if (!existsSync7(skillFilePath)) continue;
       const metadata = readManagedPiSkillMetadata(skillFilePath);
       const name = metadata.name ?? directory;
@@ -25196,7 +25351,7 @@ function createManagedPiMcpProfileApi(options = {}) {
     }
     const entries = [...entriesByName.values()].map((entry) => ({
       name: entry.name,
-      filePath: entry.filePath ?? realpathSync8(join10(entry.source, "SKILL.md"))
+      filePath: entry.filePath ?? realpathSync8(join11(entry.source, "SKILL.md"))
     }));
     const metadata = measureManagedPiRoleSkillMetadata(entries);
     return {
@@ -25214,26 +25369,26 @@ function createManagedPiMcpProfileApi(options = {}) {
     return requestedSkillProfiles(input);
   }
   function seedDelegatedPiRuntime(sourceHome, agentDir) {
-    const source = resolve7(nonEmpty3(sourceHome, "sourcePiHome"));
-    const sourceStat = lstatSync7(source);
+    const source = resolve8(nonEmpty3(sourceHome, "sourcePiHome"));
+    const sourceStat = lstatSync8(source);
     if (!sourceStat.isDirectory() || sourceStat.isSymbolicLink()) {
       throw new Error("pi_delegated_mcp_source_config_unsafe: Pi home");
     }
     const protectedValues = [];
-    for (const entry of readdirSync4(source, { withFileTypes: true })) {
+    for (const entry of readdirSync5(source, { withFileTypes: true })) {
       if (entry.name === "mcp.json" || entry.name === "mcp-cache.json") continue;
-      const sourcePath = join10(source, entry.name);
-      const targetPath = join10(agentDir, entry.name);
+      const sourcePath = join11(source, entry.name);
+      const targetPath = join11(agentDir, entry.name);
       if (entry.isDirectory()) {
         symlinkSync(sourcePath, targetPath, platform3() === "win32" ? "junction" : "dir");
       } else if (entry.isFile()) {
         copyPrivateFile(sourcePath, targetPath);
       }
     }
-    const authSource = join10(source, "auth.json");
+    const authSource = join11(source, "auth.json");
     if (existsSync7(authSource)) {
       try {
-        collectAuthSecretStrings2(JSON.parse(readFileSync6(authSource, "utf8")), protectedValues);
+        collectAuthSecretStrings2(JSON.parse(readFileSync7(authSource, "utf8")), protectedValues);
       } catch {
         throw new Error("pi_delegated_mcp_attestation_failed: source Pi auth is invalid");
       }
@@ -25376,24 +25531,24 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
   function prepareManagedPiMcpProfile2(input) {
     assertInvocationIsolation2(input);
     const { gateway, gatewayUrl, sessionToken, headers, runId, mcpToolMode, directCatalog } = validateAuthority3(input);
-    const runDir = resolve7(nonEmpty3(input.runDir, "runDir"));
-    const cwd = resolve7(nonEmpty3(input.cwd, "cwd"));
-    const executorHome = resolve7(nonEmpty3(input.executorHome, "executorHome"));
-    if (!within3(executorHome, join10(runDir, "executors"))) throw new Error("pi_managed_mcp_owner_mismatch: executorHome is outside the managed run");
+    const runDir = resolve8(nonEmpty3(input.runDir, "runDir"));
+    const cwd = resolve8(nonEmpty3(input.cwd, "cwd"));
+    const executorHome = resolve8(nonEmpty3(input.executorHome, "executorHome"));
+    if (!within3(executorHome, join11(runDir, "executors"))) throw new Error("pi_managed_mcp_owner_mismatch: executorHome is outside the managed run");
     assertWorkspaceMcpOverrideClear(cwd, runDir);
-    const profileRoot = join10(executorHome, "managed-mcp");
+    const profileRoot = join11(executorHome, "managed-mcp");
     if (existsSync7(profileRoot)) throw new Error(`pi_managed_mcp_profile_exists: ${profileRoot}`);
-    const home = join10(profileRoot, "home");
-    const piAgentHome = join10(profileRoot, "pi-agent-home");
-    const sessionsRoot = join10(profileRoot, "sessions");
-    const tmp = join10(profileRoot, "tmp");
-    for (const directory of [home, piAgentHome, sessionsRoot, tmp]) mkdirSync6(directory, { recursive: true, mode: 448 });
-    const workspaceMcpConfigPath = join10(cwd, ".pi", "mcp.json");
+    const home = join11(profileRoot, "home");
+    const piAgentHome = join11(profileRoot, "pi-agent-home");
+    const sessionsRoot = join11(profileRoot, "sessions");
+    const tmp = join11(profileRoot, "tmp");
+    for (const directory of [home, piAgentHome, sessionsRoot, tmp]) mkdirSync7(directory, { recursive: true, mode: 448 });
+    const workspaceMcpConfigPath = join11(cwd, ".pi", "mcp.json");
     const configPath = workspaceMcpConfigPath;
     try {
-      const markerPath = join10(profileRoot, PROFILE_MARKER3);
+      const markerPath2 = join11(profileRoot, PROFILE_MARKER3);
       const owner = Object.freeze({ commandId: input.commandId, runId });
-      writePrivateFile2(markerPath, `${JSON.stringify({
+      writePrivateFile2(markerPath2, `${JSON.stringify({
         version: 1,
         ...owner,
         profileRoot,
@@ -25436,17 +25591,17 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       writeOwnedFileAtomic(configPath, `${JSON.stringify(config, null, 2)}
 `);
       const extensionArgs = [];
-      const profileExtensionsDir = join10(profileRoot, "extensions");
+      const profileExtensionsDir = join11(profileRoot, "extensions");
       const writeProfileExtension = (fileName, source) => {
-        mkdirSync6(profileExtensionsDir, { recursive: true, mode: 448 });
-        const extensionPath = join10(profileExtensionsDir, fileName);
+        mkdirSync7(profileExtensionsDir, { recursive: true, mode: 448 });
+        const extensionPath = join11(profileExtensionsDir, fileName);
         writePrivateFile2(extensionPath, source);
         extensionArgs.push("--extension", extensionPath);
         return extensionPath;
       };
       if (directCatalog) {
         const adapterExtensionPath = resolveManagedPiMcpAdapterExtension(
-          join10(sharedRuntime.home, "npm", "node_modules", "pi-mcp-adapter")
+          join11(sharedRuntime.home, "npm", "node_modules", "pi-mcp-adapter")
         );
         extensionArgs.push("--extension", adapterExtensionPath);
         writeProfileExtension(
@@ -25468,7 +25623,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         cachePath,
         directToolProfile
       } = prepareDirectPiToolProfile({
-        cachePath: join10(profileRoot, "mcp-cache.json"),
+        cachePath: join11(profileRoot, "mcp-cache.json"),
         profileRoot,
         tmp,
         configPath,
@@ -25561,7 +25716,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         restoredNativeSession,
         nativeSessionRestoreSkippedReason,
         configPath,
-        markerPath,
+        markerPath: markerPath2,
         env,
         extensionArgs,
         spawnIdentity,
@@ -25618,14 +25773,14 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
     if (owner.commandId !== expectedOwner?.commandId || owner.runId !== expectedOwner?.runId) {
       throw new Error("pi_run_exit_closure_baseline_owner_mismatch");
     }
-    const profileRoot = resolve7(nonEmpty3(baseline.profileRoot, "runExitClosureBaseline.profileRoot"));
-    const cachePath = resolve7(nonEmpty3(baseline.cachePath, "runExitClosureBaseline.cachePath"));
+    const profileRoot = resolve8(nonEmpty3(baseline.profileRoot, "runExitClosureBaseline.profileRoot"));
+    const cachePath = resolve8(nonEmpty3(baseline.cachePath, "runExitClosureBaseline.cachePath"));
     if (!within3(cachePath, profileRoot)) throw new Error("pi_run_exit_closure_baseline_path_mismatch");
     const closureProfile = Object.keys(record11(baseline.closureProfile)).length > 0 ? record11(baseline.closureProfile) : null;
-    const configPath = closureProfile ? resolve7(nonEmpty3(closureProfile.configPath, "closureProfile.configPath")) : null;
+    const configPath = closureProfile ? resolve8(nonEmpty3(closureProfile.configPath, "closureProfile.configPath")) : null;
     for (const path of [cachePath, configPath].filter(Boolean)) {
       if (existsSync7(path)) {
-        const stat = lstatSync7(path);
+        const stat = lstatSync8(path);
         if (!stat.isFile() || stat.isSymbolicLink()) {
           throw new Error(`pi_run_exit_closure_baseline_unsafe: ${path}`);
         }
@@ -25676,22 +25831,22 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
   function prepareDelegatedPiMcpProfile2(input) {
     assertInvocationIsolation2(input);
     const { gateway, gatewayUrl, sessionToken, headers, runId, mcpToolMode, directCatalog } = validateAuthority3(input);
-    const runDir = resolve7(nonEmpty3(input.runDir, "runDir"));
-    const cwd = resolve7(nonEmpty3(input.cwd, "cwd"));
+    const runDir = resolve8(nonEmpty3(input.runDir, "runDir"));
+    const cwd = resolve8(nonEmpty3(input.cwd, "cwd"));
     if (!within3(cwd, runDir)) throw new Error("pi_delegated_mcp_owner_mismatch: cwd is outside the managed run");
     assertNoProjectMcpOverride(cwd, runDir);
-    const executorHome = resolve7(nonEmpty3(input.executorHome, "executorHome"));
-    if (!within3(executorHome, join10(runDir, "executors"))) throw new Error("pi_delegated_mcp_owner_mismatch: executorHome is outside the managed run");
-    const profileRoot = join10(executorHome, "delegated-mcp");
+    const executorHome = resolve8(nonEmpty3(input.executorHome, "executorHome"));
+    if (!within3(executorHome, join11(runDir, "executors"))) throw new Error("pi_delegated_mcp_owner_mismatch: executorHome is outside the managed run");
+    const profileRoot = join11(executorHome, "delegated-mcp");
     if (existsSync7(profileRoot)) throw new Error(`pi_delegated_mcp_profile_exists: ${profileRoot}`);
-    const piCodingAgentDir = join10(profileRoot, "pi-coding-agent-dir");
-    const sessionsRoot = join10(profileRoot, "sessions");
-    const tmp = join10(profileRoot, "tmp");
-    for (const directory of [profileRoot, piCodingAgentDir, sessionsRoot, tmp]) mkdirSync6(directory, { recursive: true, mode: 448 });
+    const piCodingAgentDir = join11(profileRoot, "pi-coding-agent-dir");
+    const sessionsRoot = join11(profileRoot, "sessions");
+    const tmp = join11(profileRoot, "tmp");
+    for (const directory of [profileRoot, piCodingAgentDir, sessionsRoot, tmp]) mkdirSync7(directory, { recursive: true, mode: 448 });
     try {
-      const markerPath = join10(profileRoot, DELEGATED_PROFILE_MARKER);
+      const markerPath2 = join11(profileRoot, DELEGATED_PROFILE_MARKER);
       const owner = Object.freeze({ commandId: input.commandId, runId });
-      writePrivateFile2(markerPath, `${JSON.stringify({ version: 1, ...owner, profileRoot, piCodingAgentDir })}
+      writePrivateFile2(markerPath2, `${JSON.stringify({ version: 1, ...owner, profileRoot, piCodingAgentDir })}
 `);
       const runtimeAuth = record11(input.runtimeAuth);
       const authority = Object.freeze({
@@ -25701,14 +25856,14 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         runId,
         commandId: input.commandId
       });
-      const sourcePiHome = resolve7(nonEmpty3(input.baseEnv?.PI_CODING_AGENT_DIR ?? input.baseEnv?.PI_AGENT_HOME, "sourcePiHome"));
-      const sourceStat = lstatSync7(sourcePiHome);
+      const sourcePiHome = resolve8(nonEmpty3(input.baseEnv?.PI_CODING_AGENT_DIR ?? input.baseEnv?.PI_AGENT_HOME, "sourcePiHome"));
+      const sourceStat = lstatSync8(sourcePiHome);
       if (!sourceStat.isDirectory() || sourceStat.isSymbolicLink()) {
         throw new Error("pi_delegated_mcp_source_config_unsafe: Pi home");
       }
       const seededRuntime = seedDelegatedPiRuntime(sourcePiHome, piCodingAgentDir);
-      const sourceMcp = readJsonObjectFile(join10(sourcePiHome, "mcp.json"));
-      const configPath = join10(piCodingAgentDir, "mcp.json");
+      const sourceMcp = readJsonObjectFile(join11(sourcePiHome, "mcp.json"));
+      const configPath = join11(piCodingAgentDir, "mcp.json");
       const directToolNames = directCatalog?.tools.map((tool) => tool.exposedName) ?? [];
       const serverConfig = {
         type: "http",
@@ -25737,10 +25892,10 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       writePrivateFile2(configPath, `${JSON.stringify(config, null, 2)}
 `);
       const extensionArgs = [];
-      const profileExtensionsDir = join10(profileRoot, "extensions");
+      const profileExtensionsDir = join11(profileRoot, "extensions");
       const writeProfileExtension = (fileName, source) => {
-        mkdirSync6(profileExtensionsDir, { recursive: true, mode: 448 });
-        const extensionPath = join10(profileExtensionsDir, fileName);
+        mkdirSync7(profileExtensionsDir, { recursive: true, mode: 448 });
+        const extensionPath = join11(profileExtensionsDir, fileName);
         writePrivateFile2(extensionPath, source);
         extensionArgs.push("--extension", extensionPath);
         return extensionPath;
@@ -25781,7 +25936,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       } = prepareDirectPiToolProfile({
         // Use the adapter's native path inside the isolated run home. Desktop
         // installs need no cache-override patch; never point this at sourcePiHome.
-        cachePath: join10(piCodingAgentDir, "mcp-cache.json"),
+        cachePath: join11(piCodingAgentDir, "mcp-cache.json"),
         profileRoot,
         tmp,
         configPath,
@@ -25846,7 +26001,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         authority,
         restoredNativeSession: null,
         configPath,
-        markerPath,
+        markerPath: markerPath2,
         env,
         extensionArgs,
         spawnIdentity,
@@ -25886,19 +26041,19 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
   function preserveManagedPiSessionRollout2(profile, input) {
     const sessionId = nonEmpty3(input?.sessionId, "sessionId");
     const sourceWorkspacePath = nonEmpty3(input?.sourceWorkspacePath, "sourceWorkspacePath");
-    const sessionsRoot = resolve7(nonEmpty3(profile?.env?.["AMASTER-CLI_CODING_AGENT_SESSION_DIR"], "profile session dir"));
+    const sessionsRoot = resolve8(nonEmpty3(profile?.env?.["AMASTER-CLI_CODING_AGENT_SESSION_DIR"], "profile session dir"));
     const sourceRollout = findPiSessionRollout(sessionsRoot, sessionId);
     const rolloutRelativePath = relative3(sessionsRoot, sourceRollout);
     if (!rolloutRelativePath || rolloutRelativePath.startsWith("..") || isAbsolute4(rolloutRelativePath)) {
       throw new Error("pi_managed_mcp_session_rollout_unsafe: rollout escaped the managed Pi home");
     }
-    const cacheRoot = join10(dirname5(resolve7(profile.profileRoot)), "session-rollout");
+    const cacheRoot = join11(dirname6(resolve8(profile.profileRoot)), "session-rollout");
     if (existsSync7(cacheRoot)) rmSync5(cacheRoot, { recursive: true, force: false });
-    mkdirSync6(cacheRoot, { recursive: true, mode: 448 });
-    const targetRollout = join10(cacheRoot, rolloutRelativePath);
-    mkdirSync6(dirname5(targetRollout), { recursive: true, mode: 448 });
-    writePrivateFile2(targetRollout, readFileSync6(sourceRollout));
-    writePrivateFile2(join10(cacheRoot, SESSION_ROLLOUT_MARKER3), `${JSON.stringify({
+    mkdirSync7(cacheRoot, { recursive: true, mode: 448 });
+    const targetRollout = join11(cacheRoot, rolloutRelativePath);
+    mkdirSync7(dirname6(targetRollout), { recursive: true, mode: 448 });
+    writePrivateFile2(targetRollout, readFileSync7(sourceRollout));
+    writePrivateFile2(join11(cacheRoot, SESSION_ROLLOUT_MARKER3), `${JSON.stringify({
       version: 1,
       cacheRoot,
       preservedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -25917,17 +26072,17 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
   function cleanupRestoredManagedPiSessionRollout2(profile) {
     const restored = profile?.restoredNativeSession;
     if (!restored?.cacheRoot) return { status: "not_restored" };
-    const cacheRoot = resolve7(restored.cacheRoot);
+    const cacheRoot = resolve8(restored.cacheRoot);
     if (!existsSync7(cacheRoot)) return { status: "already_removed" };
-    const cacheStat = lstatSync7(cacheRoot);
+    const cacheStat = lstatSync8(cacheRoot);
     if (!cacheStat.isDirectory() || cacheStat.isSymbolicLink()) {
       throw new Error("pi_managed_mcp_session_rollout_cleanup_unsafe: cache root is not a private directory");
     }
-    const markerPath = join10(cacheRoot, SESSION_ROLLOUT_MARKER3);
-    if (!existsSync7(markerPath) || lstatSync7(markerPath).isSymbolicLink() || !lstatSync7(markerPath).isFile()) {
+    const markerPath2 = join11(cacheRoot, SESSION_ROLLOUT_MARKER3);
+    if (!existsSync7(markerPath2) || lstatSync8(markerPath2).isSymbolicLink() || !lstatSync8(markerPath2).isFile()) {
       throw new Error("pi_managed_mcp_session_rollout_cleanup_unsafe: ownership marker is unavailable");
     }
-    const marker = JSON.parse(readFileSync6(markerPath, "utf8"));
+    const marker = JSON.parse(readFileSync7(markerPath2, "utf8"));
     if (marker?.companyId !== profile.authority.companyId || marker?.agentId !== profile.authority.agentId || marker?.issueId !== profile.authority.issueId || marker?.sourceRunId !== restored.sourceRunId || marker?.sourceCommandId !== restored.sourceCommandId || marker?.sessionId !== restored.sessionId) {
       throw new Error("pi_managed_mcp_session_rollout_cleanup_unsafe: ownership marker does not match restored authority");
     }
@@ -25936,42 +26091,42 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
     return { status: "removed" };
   }
   function removeWorkspaceMcpConfig(configPath, profileRoot) {
-    const target = resolve7(configPath);
+    const target = resolve8(configPath);
     if (!workspaceMcpConfigBelongsToProfile(target, profileRoot)) {
       throw new Error(`pi_managed_mcp_workspace_config_unsafe: ${target}`);
     }
     try {
-      const stat = lstatSync7(target);
+      const stat = lstatSync8(target);
       if (stat.isFile() && !stat.isSymbolicLink()) rmSync5(target);
     } catch (error) {
       if (error?.code !== "ENOENT") throw error;
     }
     try {
-      rmdirSync(dirname5(target));
+      rmdirSync2(dirname6(target));
     } catch (error) {
       if (!["ENOENT", "ENOTEMPTY", "ENOTDIR"].includes(error?.code)) throw error;
     }
   }
   function cleanupManagedPiMcpProfile2(profile, owner) {
-    const profileRoot = resolve7(nonEmpty3(profile?.profileRoot, "profileRoot"));
+    const profileRoot = resolve8(nonEmpty3(profile?.profileRoot, "profileRoot"));
     if (!existsSync7(profileRoot)) {
       if (typeof profile?.workspaceMcpConfigPath === "string") {
         removeWorkspaceMcpConfig(profile.workspaceMcpConfigPath, profileRoot);
       }
       return { status: "already_removed", profileRoot };
     }
-    const rootStat = lstatSync7(profileRoot);
+    const rootStat = lstatSync8(profileRoot);
     if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
       throw new Error("pi_managed_mcp_cleanup_owner_mismatch: profile root is not an owned directory");
     }
-    const markerPath = join10(profileRoot, PROFILE_MARKER3);
-    const markerStat = existsSync7(markerPath) ? lstatSync7(markerPath) : null;
+    const markerPath2 = join11(profileRoot, PROFILE_MARKER3);
+    const markerStat = existsSync7(markerPath2) ? lstatSync8(markerPath2) : null;
     if (!markerStat?.isFile() || markerStat.isSymbolicLink()) {
       throw new Error("pi_managed_mcp_cleanup_owner_mismatch: ownership marker is missing or unsafe");
     }
     let marker;
     try {
-      marker = JSON.parse(readFileSync6(markerPath, "utf8"));
+      marker = JSON.parse(readFileSync7(markerPath2, "utf8"));
     } catch {
       throw new Error("pi_managed_mcp_cleanup_owner_mismatch: ownership marker is invalid");
     }
@@ -25986,20 +26141,20 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
     return { status: "removed", profileRoot };
   }
   function cleanupDelegatedPiMcpProfile2(profile, owner) {
-    const profileRoot = resolve7(nonEmpty3(profile?.profileRoot, "profileRoot"));
+    const profileRoot = resolve8(nonEmpty3(profile?.profileRoot, "profileRoot"));
     if (!existsSync7(profileRoot)) return { status: "already_removed", profileRoot };
-    const rootStat = lstatSync7(profileRoot);
+    const rootStat = lstatSync8(profileRoot);
     if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
       throw new Error("pi_delegated_mcp_cleanup_owner_mismatch: profile root is not an owned directory");
     }
-    const markerPath = join10(profileRoot, DELEGATED_PROFILE_MARKER);
-    const markerStat = existsSync7(markerPath) ? lstatSync7(markerPath) : null;
+    const markerPath2 = join11(profileRoot, DELEGATED_PROFILE_MARKER);
+    const markerStat = existsSync7(markerPath2) ? lstatSync8(markerPath2) : null;
     if (!markerStat?.isFile() || markerStat.isSymbolicLink()) {
       throw new Error("pi_delegated_mcp_cleanup_owner_mismatch: ownership marker is missing or unsafe");
     }
     let marker;
     try {
-      marker = JSON.parse(readFileSync6(markerPath, "utf8"));
+      marker = JSON.parse(readFileSync7(markerPath2, "utf8"));
     } catch {
       throw new Error("pi_delegated_mcp_cleanup_owner_mismatch: ownership marker is invalid");
     }
@@ -26011,7 +26166,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
     return { status: "removed", profileRoot };
   }
   function reconcileManagedPiMcpProfiles2(rootPath, options2 = {}) {
-    const root = resolve7(rootPath);
+    const root = resolve8(rootPath);
     if (!existsSync7(root)) return { scanned: 0, removed: 0, removedProfiles: 0, removedRollouts: 0, failed: 0, failures: [] };
     const canonicalRoot = realpathSync8(root);
     const profileMarkers = [];
@@ -26019,10 +26174,10 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
     const pending = [root];
     while (pending.length > 0) {
       const current = pending.pop();
-      const currentStat = lstatSync7(current);
+      const currentStat = lstatSync8(current);
       if (!currentStat.isDirectory() || currentStat.isSymbolicLink()) continue;
-      for (const entry of readdirSync4(current, { withFileTypes: true })) {
-        const fullPath = join10(current, entry.name);
+      for (const entry of readdirSync5(current, { withFileTypes: true })) {
+        const fullPath = join11(current, entry.name);
         if (entry.isDirectory() && !entry.isSymbolicLink()) pending.push(fullPath);
         else if (entry.isFile() && entry.name === PROFILE_MARKER3) profileMarkers.push(fullPath);
         else if (entry.isFile() && entry.name === SESSION_ROLLOUT_MARKER3) rolloutMarkers.push(fullPath);
@@ -26033,11 +26188,11 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
     let removedRollouts = 0;
     const failures = [];
     const protectedCommandIds = new Set(Array.isArray(options2.protectedCommandIds) ? options2.protectedCommandIds.filter((value) => typeof value === "string" && value) : []);
-    for (const markerPath of profileMarkers) {
-      const profileRoot = dirname5(markerPath);
+    for (const markerPath2 of profileMarkers) {
+      const profileRoot = dirname6(markerPath2);
       try {
-        const marker = JSON.parse(readFileSync6(markerPath, "utf8"));
-        const markerProfileRoot = typeof marker?.profileRoot === "string" ? resolve7(marker.profileRoot) : null;
+        const marker = JSON.parse(readFileSync7(markerPath2, "utf8"));
+        const markerProfileRoot = typeof marker?.profileRoot === "string" ? resolve8(marker.profileRoot) : null;
         if (!markerProfileRoot || !existsSync7(markerProfileRoot) || !within3(realpathSync8(profileRoot), canonicalRoot) || realpathSync8(markerProfileRoot) !== realpathSync8(profileRoot)) throw new Error("ownership marker root mismatch");
         if (protectedCommandIds.has(marker?.commandId)) {
           preservedProfiles += 1;
@@ -26058,13 +26213,13 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
     }
     const nowMs = Number.isFinite(options2.nowMs) ? options2.nowMs : Date.now();
     const rolloutTtlMs = Number.isFinite(options2.sessionRolloutTtlMs) && options2.sessionRolloutTtlMs > 0 ? options2.sessionRolloutTtlMs : DEFAULT_SESSION_ROLLOUT_TTL_MS3;
-    for (const markerPath of rolloutMarkers) {
-      const cacheRoot = dirname5(markerPath);
+    for (const markerPath2 of rolloutMarkers) {
+      const cacheRoot = dirname6(markerPath2);
       try {
-        const markerStat = lstatSync7(markerPath);
-        const cacheStat = lstatSync7(cacheRoot);
-        const marker = JSON.parse(readFileSync6(markerPath, "utf8"));
-        const markerCacheRoot = typeof marker?.cacheRoot === "string" ? resolve7(marker.cacheRoot) : null;
+        const markerStat = lstatSync8(markerPath2);
+        const cacheStat = lstatSync8(cacheRoot);
+        const marker = JSON.parse(readFileSync7(markerPath2, "utf8"));
+        const markerCacheRoot = typeof marker?.cacheRoot === "string" ? resolve8(marker.cacheRoot) : null;
         if (!within3(realpathSync8(cacheRoot), canonicalRoot) || basename3(cacheRoot) !== "session-rollout" || markerStat.isSymbolicLink() || !markerStat.isFile() || cacheStat.isSymbolicLink() || !cacheStat.isDirectory() || marker?.version !== 1 || typeof marker?.companyId !== "string" || typeof marker?.agentId !== "string" || typeof marker?.sourceRunId !== "string" || typeof marker?.sourceCommandId !== "string" || typeof marker?.sessionId !== "string" || !markerCacheRoot || !existsSync7(markerCacheRoot) || realpathSync8(markerCacheRoot) !== realpathSync8(cacheRoot)) throw new Error("session rollout ownership marker mismatch");
         const preservedAtMs = typeof marker.preservedAt === "string" ? Date.parse(marker.preservedAt) : Number.NaN;
         const markerAgeMs = nowMs - (Number.isFinite(preservedAtMs) ? preservedAtMs : markerStat.mtimeMs);
@@ -26205,8 +26360,8 @@ function runtimeExactTaskResourceBinding(payload) {
 }
 
 // src/amaster-runtime-daemon/pi-exact-source-read.mjs
-import { chmodSync as chmodSync5, mkdirSync as mkdirSync7, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync7, writeSync } from "node:fs";
-import { dirname as dirname6, join as join11 } from "node:path";
+import { chmodSync as chmodSync6, mkdirSync as mkdirSync8, renameSync as renameSync5, rmSync as rmSync6, writeFileSync as writeFileSync8, writeSync } from "node:fs";
+import { dirname as dirname7, join as join12 } from "node:path";
 
 // src/amaster-runtime-daemon/public-network-scope.mjs
 import { BlockList, isIP } from "node:net";
@@ -26269,17 +26424,17 @@ export default function amasterExactSourceRead(pi) { registerExactSourceReadTool
 `;
 }
 function materializePiExactSourceReadExtension(profileRoot, binding) {
-  const extensionPath = join11(profileRoot, "extensions", "amaster-exact-source-read.js");
-  mkdirSync7(dirname6(extensionPath), { recursive: true, mode: 448 });
+  const extensionPath = join12(profileRoot, "extensions", "amaster-exact-source-read.js");
+  mkdirSync8(dirname7(extensionPath), { recursive: true, mode: 448 });
   const temporaryPath = `${extensionPath}.${process.pid}.tmp`;
   try {
-    writeFileSync7(temporaryPath, managedPiExactSourceReadExtensionSource(binding), {
+    writeFileSync8(temporaryPath, managedPiExactSourceReadExtensionSource(binding), {
       encoding: "utf8",
       mode: 384,
       flag: "wx"
     });
-    renameSync4(temporaryPath, extensionPath);
-    chmodSync5(extensionPath, 384);
+    renameSync5(temporaryPath, extensionPath);
+    chmodSync6(extensionPath, 384);
     return extensionPath;
   } finally {
     rmSync6(temporaryPath, { force: true });
@@ -26363,7 +26518,7 @@ function resolveCodebuddyCommandModel(command = {}, environmentModel = null) {
 }
 
 // src/amaster-runtime-daemon/executor-process.mjs
-import { readdirSync as readdirSync5, readFileSync as readFileSync7 } from "node:fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync8 } from "node:fs";
 var TERMINAL_LINUX_PROCESS_STATES = /* @__PURE__ */ new Set(["Z", "X", "x"]);
 function processGroupIdForChild(child, processPlatform = process.platform) {
   return processPlatform === "win32" || typeof child.pid !== "number" || child.pid <= 0 ? null : child.pid;
@@ -26376,7 +26531,7 @@ function linuxProcState(stat) {
   const processGroupId = Number.parseInt(fields[2], 10);
   return Number.isInteger(processGroupId) ? { state: fields[0], processGroupId } : null;
 }
-function linuxProcessGroupHasLiveMembers(processGroupId, procRoot = "/proc", fsApi = { readdirSync: readdirSync5, readFileSync: readFileSync7 }) {
+function linuxProcessGroupHasLiveMembers(processGroupId, procRoot = "/proc", fsApi = { readdirSync: readdirSync6, readFileSync: readFileSync8 }) {
   let entries;
   try {
     entries = fsApi.readdirSync(procRoot, { withFileTypes: true });
@@ -26423,7 +26578,7 @@ function isProcessIdAlive(pid, processApi = process) {
     processApi.kill(pid, 0);
     if (processApi.platform === "linux") {
       try {
-        const parsed = linuxProcState(readFileSync7(`/proc/${pid}/stat`, "utf8"));
+        const parsed = linuxProcState(readFileSync8(`/proc/${pid}/stat`, "utf8"));
         if (parsed && TERMINAL_LINUX_PROCESS_STATES.has(parsed.state)) return false;
       } catch {
       }
@@ -26522,8 +26677,8 @@ function isTerminalResultOutboxStatus(status) {
 }
 
 // src/amaster-runtime-daemon/run-completion-state.mjs
-import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync8, readdirSync as readdirSync6, renameSync as renameSync5, unlinkSync, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync9, readdirSync as readdirSync7, renameSync as renameSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join13 } from "node:path";
 
 // src/amaster-runtime-daemon/typed/run-completion-transitions.mjs
 var RUN_COMPLETION_PHASES = /* @__PURE__ */ new Set([
@@ -26785,24 +26940,24 @@ function assertValidRunCompletionState(value) {
 }
 function writeRunCompletionState(directory, state) {
   const valid = assertValidRunCompletionState(state);
-  mkdirSync8(directory, { recursive: true, mode: 448 });
-  const filePath = join12(directory, runCompletionStateFileName(valid.commandId));
+  mkdirSync9(directory, { recursive: true, mode: 448 });
+  const filePath = join13(directory, runCompletionStateFileName(valid.commandId));
   const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  writeFileSync8(temporaryPath, `${JSON.stringify(valid, null, 2)}
+  writeFileSync9(temporaryPath, `${JSON.stringify(valid, null, 2)}
 `, { mode: 384 });
-  renameSync5(temporaryPath, filePath);
+  renameSync6(temporaryPath, filePath);
   return filePath;
 }
 function readRunCompletionState(filePath) {
-  return assertValidRunCompletionState(JSON.parse(readFileSync8(filePath, "utf8")));
+  return assertValidRunCompletionState(JSON.parse(readFileSync9(filePath, "utf8")));
 }
 function listRunCompletionStateFiles(directory) {
   if (!existsSync8(directory)) return [];
-  return readdirSync6(directory).filter((name) => name.endsWith(".json")).sort().map((name) => join12(directory, name));
+  return readdirSync7(directory).filter((name) => name.endsWith(".json")).sort().map((name) => join13(directory, name));
 }
 function removeRunCompletionState(directory, commandId) {
-  const filePath = join12(directory, runCompletionStateFileName(commandId));
-  if (existsSync8(filePath)) unlinkSync(filePath);
+  const filePath = join13(directory, runCompletionStateFileName(commandId));
+  if (existsSync8(filePath)) unlinkSync2(filePath);
 }
 
 // src/amaster-runtime-daemon/run-completion/coordinator.mjs
@@ -29851,7 +30006,7 @@ function createRunCompletionRuntimePorts(input) {
     outbox,
     limits,
     now = () => (/* @__PURE__ */ new Date()).toISOString(),
-    sleep = (delayMs) => new Promise((resolve20) => setTimeout(resolve20, delayMs)),
+    sleep = (delayMs) => new Promise((resolve21) => setTimeout(resolve21, delayMs)),
     diagnostic = (message) => process.stderr.write(`${message}
 `)
   } = input;
@@ -32323,20 +32478,20 @@ ${resolvedDependencies.details.content}` : resolvedDependencies.details.content
 
 // src/amaster-runtime-daemon/agent-instruction-delivery.mjs
 import { createHash as createHash13, randomBytes } from "node:crypto";
-import { existsSync as existsSync10, lstatSync as lstatSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync10, readdirSync as readdirSync7, realpathSync as realpathSync9, renameSync as renameSync7, rmSync as rmSync8, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname8, isAbsolute as isAbsolute6, join as join14, relative as relative4, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync10, lstatSync as lstatSync9, mkdirSync as mkdirSync10, readFileSync as readFileSync11, readdirSync as readdirSync8, realpathSync as realpathSync9, renameSync as renameSync8, rmSync as rmSync8, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname9, isAbsolute as isAbsolute6, join as join15, relative as relative4, resolve as resolve9 } from "node:path";
 
 // src/amaster-runtime-daemon/workspace-manifest.mjs
-import { chownSync as chownSync3, existsSync as existsSync9, readFileSync as readFileSync9, renameSync as renameSync6, rmSync as rmSync7, statSync as statSync5, writeFileSync as writeFileSync9 } from "node:fs";
-import { basename as basename5, dirname as dirname7, join as join13 } from "node:path";
+import { chownSync as chownSync4, existsSync as existsSync9, readFileSync as readFileSync10, renameSync as renameSync7, rmSync as rmSync7, statSync as statSync5, writeFileSync as writeFileSync10 } from "node:fs";
+import { basename as basename5, dirname as dirname8, join as join14 } from "node:path";
 var WORKSPACE_MANIFEST_FILENAME = ".amaster-runtime.json";
 function syncManifestDirOwnership(manifestPath, deps = {}) {
   const stat = deps.statSync ?? statSync5;
-  const chown = deps.chownSync ?? chownSync3;
+  const chown = deps.chownSync ?? chownSync4;
   const geteuid = deps.geteuid ?? (typeof process.geteuid === "function" ? process.geteuid.bind(process) : () => null);
   try {
     if (geteuid() !== 0) return false;
-    const dirStat = stat(dirname7(manifestPath));
+    const dirStat = stat(dirname8(manifestPath));
     if (dirStat.uid === 0 && dirStat.gid === 0) return false;
     chown(manifestPath, dirStat.uid, dirStat.gid);
     return true;
@@ -32349,28 +32504,28 @@ function nowIso() {
 }
 function workspaceManifestPath(workspaceOrCwd) {
   if (!workspaceOrCwd) return null;
-  if (typeof workspaceOrCwd === "string") return join13(workspaceOrCwd, WORKSPACE_MANIFEST_FILENAME);
-  if (typeof workspaceOrCwd.cwd === "string") return join13(workspaceOrCwd.cwd, WORKSPACE_MANIFEST_FILENAME);
+  if (typeof workspaceOrCwd === "string") return join14(workspaceOrCwd, WORKSPACE_MANIFEST_FILENAME);
+  if (typeof workspaceOrCwd.cwd === "string") return join14(workspaceOrCwd.cwd, WORKSPACE_MANIFEST_FILENAME);
   return null;
 }
 function readWorkspaceManifest(manifestPath) {
   if (!manifestPath || !existsSync9(manifestPath)) return null;
   try {
-    const parsed = JSON.parse(readFileSync9(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync10(manifestPath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
 function writeWorkspaceManifest(manifestPath, manifest, deps) {
-  const tempPath = join13(
-    dirname7(manifestPath),
+  const tempPath = join14(
+    dirname8(manifestPath),
     `.${basename5(manifestPath)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`
   );
   try {
-    writeFileSync9(tempPath, `${JSON.stringify(manifest, null, 2)}
+    writeFileSync10(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { mode: 384 });
-    renameSync6(tempPath, manifestPath);
+    renameSync7(tempPath, manifestPath);
     syncManifestDirOwnership(manifestPath, deps);
   } catch (err) {
     rmSync7(tempPath, { force: true });
@@ -32443,7 +32598,7 @@ function pathWithin(candidate, root) {
 }
 function lstatIfPresent2(path) {
   try {
-    return lstatSync8(path);
+    return lstatSync9(path);
   } catch (error) {
     if (error?.code === "ENOENT") return null;
     throw error;
@@ -32451,9 +32606,9 @@ function lstatIfPresent2(path) {
 }
 function canonicalExistingPath(path) {
   try {
-    return realpathSync9(resolve8(path));
+    return realpathSync9(resolve9(path));
   } catch {
-    return resolve8(path);
+    return resolve9(path);
   }
 }
 function isManagedExecutionDirectory(directory, managedWorkspacesRoot) {
@@ -32461,11 +32616,11 @@ function isManagedExecutionDirectory(directory, managedWorkspacesRoot) {
   const managedRoot = canonicalExistingPath(managedWorkspacesRoot);
   const candidate = canonicalExistingPath(directory);
   if (!pathWithin(candidate, managedRoot)) return false;
-  const manifestPath = join14(candidate, WORKSPACE_MANIFEST_FILENAME);
+  const manifestPath = join15(candidate, WORKSPACE_MANIFEST_FILENAME);
   const manifestStat = lstatIfPresent2(manifestPath);
   if (!manifestStat?.isFile() || manifestStat.isSymbolicLink()) return false;
   try {
-    const manifest = JSON.parse(readFileSync10(manifestPath, "utf8"));
+    const manifest = JSON.parse(readFileSync11(manifestPath, "utf8"));
     if (!manifest || typeof manifest !== "object" || Array.isArray(manifest) || manifest.managed !== true) {
       return false;
     }
@@ -32475,7 +32630,7 @@ function isManagedExecutionDirectory(directory, managedWorkspacesRoot) {
   }
 }
 function inspectExternalWorkspaceProjectInstructions(sourceWorkspacePath, options = {}) {
-  const root = resolve8(sourceWorkspacePath);
+  const root = resolve9(sourceWorkspacePath);
   const pending = [root];
   const sources = [];
   const ignoredManagedExecutionDirectories = [];
@@ -32495,7 +32650,7 @@ function inspectExternalWorkspaceProjectInstructions(sourceWorkspacePath, option
     }
     let entries;
     try {
-      entries = readdirSync7(directory, { withFileTypes: true });
+      entries = readdirSync8(directory, { withFileTypes: true });
     } catch (error) {
       throw instructionTopologyError(
         "workspace_project_instruction_discovery_incomplete",
@@ -32506,7 +32661,7 @@ function inspectExternalWorkspaceProjectInstructions(sourceWorkspacePath, option
     entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
       if (entry.isDirectory() && PROJECT_INSTRUCTION_SCAN_IGNORED_DIRECTORIES.has(entry.name)) continue;
-      const absolutePath = resolve8(directory, entry.name);
+      const absolutePath = resolve9(directory, entry.name);
       const relativePath = relative4(root, absolutePath).replaceAll("\\", "/");
       if (entry.isSymbolicLink()) {
         if (PROJECT_INSTRUCTION_NAMES.has(entry.name)) {
@@ -32522,14 +32677,14 @@ function inspectExternalWorkspaceProjectInstructions(sourceWorkspacePath, option
         continue;
       }
       if (!PROJECT_INSTRUCTION_NAMES.has(entry.name)) continue;
-      const stat = lstatSync8(absolutePath);
+      const stat = lstatSync9(absolutePath);
       if (!stat.isFile()) {
         throw instructionTopologyError(
           "workspace_project_instruction_source_unsafe",
           `project instruction source is not a regular file: ${relativePath}`
         );
       }
-      const content = readFileSync10(absolutePath);
+      const content = readFileSync11(absolutePath);
       sources.push({
         path: relativePath,
         scope: relativePath.includes("/") ? relativePath.slice(0, relativePath.lastIndexOf("/")) : ".",
@@ -32577,7 +32732,7 @@ ${repositoryBlock}
 }
 function assertProjectionTargetAncestors(targetPath, targetRoot) {
   const pending = [];
-  let current = dirname8(targetPath);
+  let current = dirname9(targetPath);
   while (current !== targetRoot) {
     if (!pathWithin(current, targetRoot)) {
       throw instructionTopologyError(
@@ -32586,15 +32741,15 @@ function assertProjectionTargetAncestors(targetPath, targetRoot) {
       );
     }
     pending.push(current);
-    current = dirname8(current);
+    current = dirname9(current);
   }
   pending.push(targetRoot);
   for (const directory of pending.reverse()) {
     if (!existsSync10(directory)) {
-      mkdirSync9(directory, { mode: 448 });
+      mkdirSync10(directory, { mode: 448 });
       continue;
     }
-    const stat = lstatSync8(directory);
+    const stat = lstatSync9(directory);
     if (!stat.isDirectory() || stat.isSymbolicLink()) {
       throw instructionTopologyError(
         "workspace_project_instruction_projection_unsafe",
@@ -32604,8 +32759,8 @@ function assertProjectionTargetAncestors(targetPath, targetRoot) {
   }
 }
 function projectExternalWorkspaceProjectInstructions(sourceWorkspacePath, executionWorkspacePath, platformInstructions, options = {}) {
-  const sourceRoot = resolve8(sourceWorkspacePath);
-  const targetRoot = resolve8(executionWorkspacePath);
+  const sourceRoot = resolve9(sourceWorkspacePath);
+  const targetRoot = resolve9(executionWorkspacePath);
   if (sourceRoot === targetRoot || !platformInstructions?.trim()) {
     throw instructionTopologyError(
       "workspace_project_instruction_projection_invalid",
@@ -32621,21 +32776,21 @@ function projectExternalWorkspaceProjectInstructions(sourceWorkspacePath, execut
   }
   const projected = [];
   for (const source of inspection.sources) {
-    const sourcePath = resolve8(sourceRoot, source.path);
+    const sourcePath = resolve9(sourceRoot, source.path);
     if (!pathWithin(sourcePath, sourceRoot)) {
       throw instructionTopologyError(
         "workspace_project_instruction_projection_unsafe",
         `project instruction escaped its workspace: ${source.path}`
       );
     }
-    const sourceStat = lstatSync8(sourcePath);
+    const sourceStat = lstatSync9(sourcePath);
     if (!sourceStat.isFile() || sourceStat.isSymbolicLink()) {
       throw instructionTopologyError(
         "workspace_project_instruction_source_unsafe",
         `project instruction source changed during projection: ${source.path}`
       );
     }
-    const sourceContent = readFileSync10(sourcePath, "utf8");
+    const sourceContent = readFileSync11(sourcePath, "utf8");
     const sourceSha256 = createHash13("sha256").update(sourceContent, "utf8").digest("hex");
     if (sourceSha256 !== source.sha256) {
       throw instructionTopologyError(
@@ -32662,7 +32817,7 @@ function projectExternalWorkspaceProjectInstructions(sourceWorkspacePath, execut
   let modelFacingBytes = 0;
   let modelFacingSha256 = null;
   if (selectedSources.length > 0) {
-    const targetPath = resolve8(targetRoot, "AGENTS.md");
+    const targetPath = resolve9(targetRoot, "AGENTS.md");
     const targetStat = lstatIfPresent2(targetPath);
     if (!pathWithin(targetPath, targetRoot) || targetStat?.isSymbolicLink()) {
       throw instructionTopologyError(
@@ -32674,8 +32829,8 @@ function projectExternalWorkspaceProjectInstructions(sourceWorkspacePath, execut
     assertProjectionTargetAncestors(targetPath, targetRoot);
     const temporaryPath = `${targetPath}.mirrorx-${randomBytes(12).toString("hex")}.tmp`;
     try {
-      writeFileSync10(temporaryPath, projectedContent, { encoding: "utf8", flag: "wx", mode: 384 });
-      renameSync7(temporaryPath, targetPath);
+      writeFileSync11(temporaryPath, projectedContent, { encoding: "utf8", flag: "wx", mode: 384 });
+      renameSync8(temporaryPath, targetPath);
     } finally {
       rmSync8(temporaryPath, { force: true });
     }
@@ -32748,9 +32903,9 @@ function agentInstructionDeliveryAudit(bundle, delivery) {
 }
 
 // src/amaster-runtime-daemon/config-state.mjs
-import { existsSync as existsSync11, mkdirSync as mkdirSync10, readFileSync as readFileSync11, renameSync as renameSync8, rmSync as rmSync9, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync11, readFileSync as readFileSync12, renameSync as renameSync9, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "node:fs";
 import { homedir as homedir3, hostname } from "node:os";
-import { dirname as dirname9, join as join15, parse as parse3, resolve as resolve9 } from "node:path";
+import { dirname as dirname10, join as join16, parse as parse4, resolve as resolve10 } from "node:path";
 
 // src/amaster-runtime-daemon/capability-registry.mjs
 var BUILD_SUPPORTED_CAPABILITIES = Object.freeze([
@@ -32896,19 +33051,19 @@ function defaultMachineId() {
 }
 function runtimeHome(env) {
   return expandHomePath(String(
-    env.AMASTER_RUNTIME_STATE_HOME || env.AMASTER_RUNTIME_HOME || join15(homedir3(), ".amaster-employee")
+    env.AMASTER_RUNTIME_STATE_HOME || env.AMASTER_RUNTIME_HOME || join16(homedir3(), ".amaster-employee")
   ));
 }
 function runtimeTemplatesRoot(env, home) {
   const configured = String(env.AMASTER_RUNTIME_TEMPLATES_ROOT ?? "").trim();
-  const resolved = configured ? resolve9(expandHomePath(configured)) : resolve9(String(env.PI_CODING_AGENT_DIR ?? "")) === "/data/.pi" ? "/data/templates" : resolve9(join15(home, "templates"));
-  if (resolved === parse3(resolved).root) {
+  const resolved = configured ? resolve10(expandHomePath(configured)) : resolve10(String(env.PI_CODING_AGENT_DIR ?? "")) === "/data/.pi" ? "/data/templates" : resolve10(join16(home, "templates"));
+  if (resolved === parse4(resolved).root) {
     throw new Error("AMASTER_RUNTIME_TEMPLATES_ROOT must not be a filesystem root");
   }
   return resolved;
 }
 function stateFilePath(env) {
-  return env.AMASTER_DAEMON_STATE_FILE ? expandHomePath(String(env.AMASTER_DAEMON_STATE_FILE)) : join15(runtimeHome(env), "runtime-connector-state.json");
+  return env.AMASTER_DAEMON_STATE_FILE ? expandHomePath(String(env.AMASTER_DAEMON_STATE_FILE)) : join16(runtimeHome(env), "runtime-connector-state.json");
 }
 function corruptStatePath(path) {
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/\D/g, "").slice(0, 14);
@@ -32923,7 +33078,7 @@ function readState(env) {
   const path = stateFilePath(env);
   if (!existsSync11(path)) return {};
   try {
-    const state = JSON.parse(readFileSync11(path, "utf8"));
+    const state = JSON.parse(readFileSync12(path, "utf8"));
     if (!state || typeof state !== "object" || Array.isArray(state)) {
       throw new TypeError("runtime connector state must be a JSON object");
     }
@@ -32931,7 +33086,7 @@ function readState(env) {
   } catch {
     const quarantinePath = corruptStatePath(path);
     try {
-      renameSync8(path, quarantinePath);
+      renameSync9(path, quarantinePath);
       process.stderr.write(`AMaster runtime state was invalid and quarantined at ${quarantinePath}
 `);
     } catch (error) {
@@ -32945,15 +33100,15 @@ function readState(env) {
 }
 function writeState(env, state) {
   const path = stateFilePath(env);
-  mkdirSync10(dirname9(path), { recursive: true });
+  mkdirSync11(dirname10(path), { recursive: true });
   const temporaryPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
   try {
-    writeFileSync11(temporaryPath, `${JSON.stringify(state, null, 2)}
+    writeFileSync12(temporaryPath, `${JSON.stringify(state, null, 2)}
 `, {
       flag: "wx",
       mode: 384
     });
-    renameSync8(temporaryPath, path);
+    renameSync9(temporaryPath, path);
   } finally {
     rmSync9(temporaryPath, { force: true });
   }
@@ -32968,10 +33123,10 @@ function buildConfig(env = process.env, flags = {}) {
   const home = runtimeHome(env);
   const templatesRoot = runtimeTemplatesRoot(env, home);
   const runtimeWorkspacesRoot = expandHomePath(
-    String(flags.runtimeWorkspacesRoot ?? env.AMASTER_RUNTIME_WORKSPACES_ROOT ?? join15(home, "workspaces"))
+    String(flags.runtimeWorkspacesRoot ?? env.AMASTER_RUNTIME_WORKSPACES_ROOT ?? join16(home, "workspaces"))
   );
   const browserSessionStateRoot = expandHomePath(String(
-    flags.browserSessionStateRoot ?? env.AMASTER_BROWSER_SESSION_STATE_ROOT ?? join15(home, "browser-auth")
+    flags.browserSessionStateRoot ?? env.AMASTER_BROWSER_SESSION_STATE_ROOT ?? join16(home, "browser-auth")
   ));
   const piToolArgumentGuardModeValue = String(
     flags.piToolArgumentGuardMode ?? env.AMASTER_PI_TOOL_ARGUMENT_GUARD_MODE ?? "shadow"
@@ -32997,7 +33152,7 @@ function buildConfig(env = process.env, flags = {}) {
       "Pi tool argument enforce thresholds cannot be more aggressive than 8 MiB transport, 512 KiB materialized, and 16x amplification"
     );
   }
-  mkdirSync10(runtimeWorkspacesRoot, { recursive: true });
+  mkdirSync11(runtimeWorkspacesRoot, { recursive: true });
   const workspaceBindings = splitList(
     flags.workspaceAllowlist ?? env.AMASTER_WORKSPACE_ALLOWLIST ?? env.AMASTER_WORKSPACE_BINDINGS ?? runtimeWorkspacesRoot
   ).map(expandHomePath);
@@ -33425,10 +33580,10 @@ function createBrowserCredentialChannel({ consume, onFailure }) {
 }
 
 // src/amaster-runtime-daemon/browser-credential-readiness.mjs
-import { existsSync as existsSync12, lstatSync as lstatSync9, readFileSync as readFileSync12, readdirSync as readdirSync8, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync12, lstatSync as lstatSync10, readFileSync as readFileSync13, readdirSync as readdirSync9, statSync as statSync6 } from "node:fs";
 import { createHash as createHash14 } from "node:crypto";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname10, isAbsolute as isAbsolute7, join as join16, relative as relative5, resolve as resolve10 } from "node:path";
+import { dirname as dirname11, isAbsolute as isAbsolute7, join as join17, relative as relative5, resolve as resolve11 } from "node:path";
 var CAPABILITY = "browser_credential_auth_transaction_v1";
 var CREDENTIAL_BROWSER_TCB = Object.freeze({
   package: "chrome-devtools-mcp",
@@ -33438,16 +33593,17 @@ var CREDENTIAL_BROWSER_TCB = Object.freeze({
 });
 var CREDENTIAL_BROWSER_PACKAGE_FILES = Object.freeze({
   "dist/config.js": "ed61ba70f3c2445db22fac31c432c86df2d9b3674bd36b34cce6f7a981f3926f",
-  "dist/index.js": "7530da9aaa0ee272fa6e10ff80059f42a45aee6fff8d8c7cbce05c2cb24e180c"
+  "dist/index.js": "e94fdec799848fc45942cc59868dfd12dd27597025f757eded3e1d7e3a8e0fb9"
 });
-var CREDENTIAL_AUTH_EXTENSION_SHA256 = "14088f0a7761a2a0884477ac2f300dcf615e4ba78b7753e4aec8078b344ab9b9";
+var CREDENTIAL_AUTH_EXTENSION_SHA256 = "3ad9c39fc20d35e6486cdccaee832b986108919b678b98134f1386233560277e";
+var CREDENTIAL_BROWSER_PACKAGE_VERSION = "0.1.2-beta.80";
 var IMAGE_PI_HOME = "/opt/pi-cli-runtime/.pi";
-var IMAGE_AUTH_EXTENSION_PATH = join16(IMAGE_PI_HOME, "extensions", "browser-credential-auth.mjs");
-var BROWSER_AUTH_IMAGE_NODE_PATH = join16(IMAGE_PI_HOME, "npm", "node_modules");
+var IMAGE_AUTH_EXTENSION_PATH = join17(IMAGE_PI_HOME, "extensions", "browser-credential-auth.mjs");
+var BROWSER_AUTH_IMAGE_NODE_PATH = join17(IMAGE_PI_HOME, "npm", "node_modules");
 var READINESS_CACHE_TTL_MS = 5e3;
 var readinessCache = /* @__PURE__ */ new Map();
 function inspectBrowserCredentialAuthReadiness(env = process.env, expected = {}, options = {}) {
-  const home = String(env.PI_CODING_AGENT_DIR ?? env.PI_AGENT_HOME ?? join16(homedir4(), ".pi", "agent")).trim();
+  const home = String(env.PI_CODING_AGENT_DIR ?? env.PI_AGENT_HOME ?? join17(homedir4(), ".pi", "agent")).trim();
   const packageHome = expected.packageHome ?? IMAGE_PI_HOME;
   const extensionPath = expected.authExtensionPath ?? IMAGE_AUTH_EXTENSION_PATH;
   const requireImageOwnership = options.requireImageOwnership !== false;
@@ -33456,8 +33612,8 @@ function inspectBrowserCredentialAuthReadiness(env = process.env, expected = {},
   const cached = readinessCache.get(cacheKey);
   if (!options.fresh && cached && cached.expiresAt > now) return { ...cached.readiness };
   const candidates = [
-    join16(packageHome, "npm", "node_modules", "@amaster.ai", "pi-browser-use", "package.json"),
-    join16(packageHome, "node_modules", "@amaster.ai", "pi-browser-use", "package.json")
+    join17(packageHome, "npm", "node_modules", "@amaster.ai", "pi-browser-use", "package.json"),
+    join17(packageHome, "node_modules", "@amaster.ai", "pi-browser-use", "package.json")
   ];
   const packageAttestation = candidates.map((manifestPath) => attestedPackageManifest(manifestPath, {
     browserTcb: expected.browserTcb ?? CREDENTIAL_BROWSER_TCB,
@@ -33491,34 +33647,34 @@ function browserCredentialAuthExtensionArgs(authority, env = process.env, expect
 function attestedAuthExtension(extensionPath, expectedSha256, requireImageOwnership) {
   try {
     if (typeof expectedSha256 !== "string" || !/^[a-f0-9]{64}$/u.test(expectedSha256)) return false;
-    const extensionStat = lstatSync9(extensionPath);
+    const extensionStat = lstatSync10(extensionPath);
     if (!extensionStat.isFile() || extensionStat.isSymbolicLink()) return false;
     if (requireImageOwnership && !immutableImageFile(extensionPath)) return false;
-    const source = readFileSync12(extensionPath, "utf8");
+    const source = readFileSync13(extensionPath, "utf8");
     return createHash14("sha256").update(source, "utf8").digest("hex") === expectedSha256 && source.includes("BrowserCredentialAuthBroker") && source.includes("browser_authenticate") && source.includes("AMASTER_BROWSER_CREDENTIAL_PRIVATE_CHANNEL");
   } catch {
     return false;
   }
 }
 function immutableImageFile(filePath) {
-  const fileStat = lstatSync9(filePath);
+  const fileStat = lstatSync10(filePath);
   if (!fileStat.isFile() || fileStat.isSymbolicLink() || fileStat.uid !== 0 || (fileStat.mode & 18) !== 0) return false;
-  for (let directory = dirname10(filePath); directory !== dirname10(directory); directory = dirname10(directory)) {
-    const parentStat = lstatSync9(directory);
+  for (let directory = dirname11(filePath); directory !== dirname11(directory); directory = dirname11(directory)) {
+    const parentStat = lstatSync10(directory);
     if (!parentStat.isDirectory() || parentStat.isSymbolicLink() || parentStat.uid !== 0 || (parentStat.mode & 18) !== 0) return false;
   }
   return true;
 }
 function fileSha256(path) {
-  return createHash14("sha256").update(readFileSync12(path)).digest("hex");
+  return createHash14("sha256").update(readFileSync13(path)).digest("hex");
 }
 function treeAttestation(root, requireImageOwnership) {
   const files = [];
   const visit = (directory) => {
-    for (const entry of readdirSync8(directory, { withFileTypes: true })) {
-      const path = join16(directory, entry.name);
+    for (const entry of readdirSync9(directory, { withFileTypes: true })) {
+      const path = join17(directory, entry.name);
       if (entry.isDirectory()) visit(path);
-      else if (entry.isFile() && !lstatSync9(path).isSymbolicLink() && (!requireImageOwnership || immutableImageFile(path))) files.push(path);
+      else if (entry.isFile() && !lstatSync10(path).isSymbolicLink() && (!requireImageOwnership || immutableImageFile(path))) files.push(path);
       else throw new Error("browser_credential_tcb_tree_invalid");
     }
   };
@@ -33528,33 +33684,33 @@ function treeAttestation(root, requireImageOwnership) {
   for (const path of files) {
     digest2.update(relative5(root, path).replaceAll("\\", "/"));
     digest2.update("\0");
-    digest2.update(readFileSync12(path));
+    digest2.update(readFileSync13(path));
   }
   return digest2.digest("hex");
 }
 function attestedPackageManifest(manifestPath, expected, requireImageOwnership) {
   try {
     if (requireImageOwnership && !immutableImageFile(manifestPath)) return null;
-    const manifest = JSON.parse(readFileSync12(manifestPath, "utf8"));
-    if (manifest?.name !== "@amaster.ai/pi-browser-use") return null;
-    if (!Array.isArray(manifest.mirrorxCapabilities) || !manifest.mirrorxCapabilities.includes(CAPABILITY)) {
+    const manifest = JSON.parse(readFileSync13(manifestPath, "utf8"));
+    if (manifest?.name !== "@amaster.ai/pi-browser-use" || manifest.version !== CREDENTIAL_BROWSER_PACKAGE_VERSION) return null;
+    if (!Array.isArray(manifest.mirrorxCapabilities) || manifest.mirrorxCapabilities.length !== 1 || manifest.mirrorxCapabilities[0] !== CAPABILITY) {
       return null;
     }
     if (!sameCredentialBrowserTcb(manifest.mirrorxCredentialBrowserTcb, expected.browserTcb)) return null;
     if (manifest.mirrorxCredentialAuthExtensionSha256 !== expected.authExtensionSha256) return null;
     if (typeof manifest.main !== "string" || !manifest.main.trim()) return null;
-    const packageDir = resolve10(manifestPath, "..");
+    const packageDir = resolve11(manifestPath, "..");
     if (Object.entries(expected.packageFiles).some(([relativePath, sha2563]) => {
-      const path = resolve10(packageDir, relativePath);
+      const path = resolve11(packageDir, relativePath);
       const relativePathFromPackage = relative5(packageDir, path);
       return !relativePathFromPackage || relativePathFromPackage.startsWith("..") || isAbsolute7(relativePathFromPackage) || !statSync6(path).isFile() || requireImageOwnership && !immutableImageFile(path) || fileSha256(path) !== sha2563;
     })) return null;
-    const browserPackageDir = resolve10(packageDir, "..", "..", "chrome-devtools-mcp");
-    const browserManifestPath = join16(browserPackageDir, "package.json");
+    const browserPackageDir = resolve11(packageDir, "..", "..", "chrome-devtools-mcp");
+    const browserManifestPath = join17(browserPackageDir, "package.json");
     if (requireImageOwnership && !immutableImageFile(browserManifestPath)) return null;
-    const browserPackage = JSON.parse(readFileSync12(browserManifestPath, "utf8"));
-    if (browserPackage.name !== expected.browserTcb.package || browserPackage.version !== expected.browserTcb.version || treeAttestation(join16(browserPackageDir, "build"), requireImageOwnership) !== expected.browserTcb.buildTreeSha256) return null;
-    const entrypoint = resolve10(packageDir, manifest.main);
+    const browserPackage = JSON.parse(readFileSync13(browserManifestPath, "utf8"));
+    if (browserPackage.name !== expected.browserTcb.package || browserPackage.version !== expected.browserTcb.version || treeAttestation(join17(browserPackageDir, "build"), requireImageOwnership) !== expected.browserTcb.buildTreeSha256) return null;
+    const entrypoint = resolve11(packageDir, manifest.main);
     const relativeEntrypoint = relative5(packageDir, entrypoint);
     if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || isAbsolute7(relativeEntrypoint) || !existsSync12(entrypoint) || requireImageOwnership && !immutableImageFile(entrypoint)) return null;
     return statSync6(entrypoint).isFile() ? {} : null;
@@ -33567,21 +33723,21 @@ function sameCredentialBrowserTcb(value, expected) {
 }
 
 // src/amaster-runtime-daemon/browser-credential-env-readiness.mjs
-import { lstatSync as lstatSync10, readFileSync as readFileSync13 } from "node:fs";
+import { lstatSync as lstatSync11, readFileSync as readFileSync14 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 var CACHE_TTL_MS = 5e3;
 var cache = /* @__PURE__ */ new Map();
 function inspectBrowserCredentialEnvReadiness(env = process.env) {
-  const home = String(env.PI_CODING_AGENT_DIR ?? env.PI_AGENT_HOME ?? join17(homedir5(), ".pi", "agent")).trim();
+  const home = String(env.PI_CODING_AGENT_DIR ?? env.PI_AGENT_HOME ?? join18(homedir5(), ".pi", "agent")).trim();
   const now = Date.now();
   const cached = cache.get(home);
   if (cached && cached.expiresAt > now) return { ...cached.readiness };
-  const extensionPath = join17(home, "extensions", "browser-credential-env.mjs");
+  const extensionPath = join18(home, "extensions", "browser-credential-env.mjs");
   let extension = false;
   try {
-    const stat = lstatSync10(extensionPath);
-    const source = stat.isFile() && !stat.isSymbolicLink() ? readFileSync13(extensionPath, "utf8") : "";
+    const stat = lstatSync11(extensionPath);
+    const source = stat.isFile() && !stat.isSymbolicLink() ? readFileSync14(extensionPath, "utf8") : "";
     extension = /\bname\s*:\s*["']browser_read_credential["']/u.test(source) && /\bPI_AGENT_BROWSER_CREDENTIAL_ENV_FILE\b/u.test(source);
   } catch {
     extension = false;
@@ -33592,14 +33748,14 @@ function inspectBrowserCredentialEnvReadiness(env = process.env) {
 }
 
 // src/amaster-runtime-daemon/pi-web-search-readiness.mjs
-import { lstatSync as lstatSync11, readFileSync as readFileSync14 } from "node:fs";
+import { lstatSync as lstatSync12, readFileSync as readFileSync15 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { isAbsolute as isAbsolute8, join as join18 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join19 } from "node:path";
 function readRegularJson(path) {
   try {
-    const stat = lstatSync11(path);
+    const stat = lstatSync12(path);
     if (!stat.isFile() || stat.isSymbolicLink()) return null;
-    const value = JSON.parse(readFileSync14(path, "utf8"));
+    const value = JSON.parse(readFileSync15(path, "utf8"));
     return value && typeof value === "object" && !Array.isArray(value) ? value : null;
   } catch {
     return null;
@@ -33607,23 +33763,23 @@ function readRegularJson(path) {
 }
 function isRegularFile(path) {
   try {
-    const stat = lstatSync11(path);
+    const stat = lstatSync12(path);
     return stat.isFile() && !stat.isSymbolicLink();
   } catch {
     return false;
   }
 }
 function installedPiWebAccess(env) {
-  const home = String(env["AMASTER-CLI_CODING_AGENT_DIR"] ?? env.PI_CODING_AGENT_DIR ?? env.PI_AGENT_HOME ?? join18(homedir6(), ".pi", "agent")).trim();
-  const settings = readRegularJson(join18(home, "settings.json"));
+  const home = String(env["AMASTER-CLI_CODING_AGENT_DIR"] ?? env.PI_CODING_AGENT_DIR ?? env.PI_AGENT_HOME ?? join19(homedir6(), ".pi", "agent")).trim();
+  const settings = readRegularJson(join19(home, "settings.json"));
   const packages = Array.isArray(settings?.packages) ? settings.packages : [];
   const npmConfigured = packages.some((entry) => typeof entry === "string" && /^npm:@amaster\.ai\/pi-web-access(?:@|$)/u.test(entry));
   const manifests = [
-    join18(home, "npm", "node_modules", "@amaster.ai", "pi-web-access", "package.json"),
-    join18(home, "node_modules", "@amaster.ai", "pi-web-access", "package.json")
+    join19(home, "npm", "node_modules", "@amaster.ai", "pi-web-access", "package.json"),
+    join19(home, "node_modules", "@amaster.ai", "pi-web-access", "package.json")
   ];
   const npmInstalled = npmConfigured && manifests.some((path) => readRegularJson(path)?.name === "@amaster.ai/pi-web-access");
-  const localInstalled = packages.some((entry) => typeof entry === "string" && isAbsolute8(entry) && readRegularJson(join18(entry, "package.json"))?.name === "@amaster.ai/pi-web-access" && readRegularJson(join18(entry, "package.json"))?.pi?.extensions?.includes("./dist/index.js") && isRegularFile(join18(entry, "dist", "index.js")));
+  const localInstalled = packages.some((entry) => typeof entry === "string" && isAbsolute8(entry) && readRegularJson(join19(entry, "package.json"))?.name === "@amaster.ai/pi-web-access" && readRegularJson(join19(entry, "package.json"))?.pi?.extensions?.includes("./dist/index.js") && isRegularFile(join19(entry, "dist", "index.js")));
   return { settings, installed: npmInstalled || localInstalled };
 }
 function inspectPiWebSearchReadiness(env = process.env) {
@@ -33638,8 +33794,8 @@ function inspectPiWebFetchReadiness(env = process.env) {
 }
 
 // src/amaster-runtime-daemon/browser-credential-env.mjs
-import { chmodSync as chmodSync6, mkdtempSync as mkdtempSync3, renameSync as renameSync9, rmSync as rmSync10, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join19, resolve as resolve11 } from "node:path";
+import { chmodSync as chmodSync7, mkdtempSync as mkdtempSync3, renameSync as renameSync10, rmSync as rmSync10, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join20, resolve as resolve12 } from "node:path";
 var BROWSER_CREDENTIAL_ENV_CAPABILITY = "browser_credential_env_read_v1";
 var BROWSER_CREDENTIAL_PRIVATE_CAPABILITY = "browser_credential_auth_transaction_v1";
 var BROWSER_CREDENTIAL_ENV_FILE = "PI_AGENT_BROWSER_CREDENTIAL_ENV_FILE";
@@ -33655,7 +33811,7 @@ function exactOrigin2(value) {
     return null;
   }
 }
-function fail2(code) {
+function fail3(code) {
   const error = new Error(code);
   error.code = code;
   throw error;
@@ -33666,10 +33822,10 @@ function browserCredentialPresentation(command) {
   const capabilities = new Set(Array.isArray(command?.requiredCapabilities) ? command.requiredCapabilities : []);
   const envRequested = capabilities.has(BROWSER_CREDENTIAL_ENV_CAPABILITY);
   const privateRequested = capabilities.has(BROWSER_CREDENTIAL_PRIVATE_CAPABILITY);
-  if (envRequested && privateRequested) fail2("browser_credential_capability_conflict");
+  if (envRequested && privateRequested) fail3("browser_credential_capability_conflict");
   if (envRequested) return "model_visible_env";
   if (privateRequested) return "private_channel";
-  fail2("browser_credential_capability_required");
+  fail3("browser_credential_capability_required");
 }
 function browserCredentialEnvPlan(command, presentation = browserCredentialPresentation(command)) {
   if (presentation !== "model_visible_env") return null;
@@ -33677,11 +33833,11 @@ function browserCredentialEnvPlan(command, presentation = browserCredentialPrese
   const passwordRefs = refs.filter((ref2) => ref2?.credentialRole === "password");
   const usernameRefs = refs.filter((ref2) => ref2?.credentialRole === "username");
   if (passwordRefs.length !== 1 || usernameRefs.length > 1 || passwordRefs.length + usernameRefs.length !== refs.length) {
-    fail2("browser_credential_env_ref_set_invalid");
+    fail3("browser_credential_env_ref_set_invalid");
   }
   const origin = exactOrigin2(passwordRefs[0]?.authenticationOrigin);
   if (!origin || refs.some((ref2) => ref2?.commandId !== command?.commandId || ref2?.authenticationOrigin !== origin || ref2?.targetOrigin !== origin)) {
-    fail2("browser_credential_env_origin_mismatch");
+    fail3("browser_credential_env_origin_mismatch");
   }
   const entries = [
     ...usernameRefs.map((ref2) => ({ ref: ref2, key: BROWSER_CREDENTIAL_USERNAME_KEY, controlSemantic: "username" })),
@@ -33710,13 +33866,13 @@ function browserCredentialPrivateAuthority(command, presentation = browserCreden
   try {
     parsedTarget = new URL(targetUrl);
   } catch {
-    fail2("browser_credential_authority_invalid");
+    fail3("browser_credential_authority_invalid");
   }
   const origin = parsedTarget.protocol === "https:" && !parsedTarget.username && !parsedTarget.password ? parsedTarget.origin : null;
   const passwordRefs = refs.filter((ref2) => ref2?.credentialRole === "password");
   const usernameRefs = refs.filter((ref2) => ref2?.credentialRole === "username");
   if (!origin || refs.length < 1 || refs.length > 2 || passwordRefs.length !== 1 || usernameRefs.length > 1 || !predicate || predicate.version !== 1 || predicate.type !== "snapshot_text_v1" || typeof predicate.requiredText !== "string" || predicate.requiredText !== predicate.requiredText.trim() || predicate.requiredText.length < 8 || predicate.requiredText.length > 256 || /[\u0000-\u001f\u007f]/u.test(predicate.requiredText) || refs.some((ref2) => ref2?.commandId !== command?.commandId || ref2?.bindingId !== session?.bindingId || ref2?.browserLeaseId !== session?.browserLeaseId || ref2?.targetOrigin !== origin || ref2?.authenticationOrigin !== origin)) {
-    fail2("browser_credential_authority_invalid");
+    fail3("browser_credential_authority_invalid");
   }
   return Object.freeze({
     version: 1,
@@ -33729,13 +33885,13 @@ function attachTrustedBrowserExecutorEnv(env, { authority = null, userDataDir =
   const result2 = { ...env };
   delete result2[BROWSER_CREDENTIAL_AUTHORITY_ENV];
   delete result2[BROWSER_SESSION_USER_DATA_DIR_ENV];
-  if (authority && !userDataDir) fail2("browser_credential_authority_profile_required");
+  if (authority && !userDataDir) fail3("browser_credential_authority_profile_required");
   if (userDataDir) result2[BROWSER_SESSION_USER_DATA_DIR_ENV] = userDataDir;
   if (authority) result2[BROWSER_CREDENTIAL_AUTHORITY_ENV] = JSON.stringify(authority);
   return result2;
 }
 function dotenvQuotedValue(value) {
-  if (value.includes("\0")) fail2("browser_credential_env_value_invalid");
+  if (value.includes("\0")) fail3("browser_credential_env_value_invalid");
   return `"${value.replace(/[\\"\n\r\t$`]/gu, (char) => ({
     "\\": "\\\\",
     '"': '\\"',
@@ -33747,14 +33903,14 @@ function dotenvQuotedValue(value) {
   })[char])}"`;
 }
 async function materializeBrowserCredentialEnv(plan, options) {
-  if (!plan || typeof options?.consume !== "function") fail2("browser_credential_env_plan_required");
+  if (!plan || typeof options?.consume !== "function") fail3("browser_credential_env_plan_required");
   const rawRunDir = String(options.runDir ?? "").trim();
-  if (!rawRunDir) fail2("browser_credential_env_run_dir_invalid");
-  const runDir = resolve11(rawRunDir);
-  const credentialDir = mkdtempSync3(join19(runDir, ".browser-credentials-"));
-  chmodSync6(credentialDir, 448);
-  const targetPath = join19(credentialDir, "credentials.env");
-  const temporaryPath = join19(credentialDir, ".credentials.env.tmp");
+  if (!rawRunDir) fail3("browser_credential_env_run_dir_invalid");
+  const runDir = resolve12(rawRunDir);
+  const credentialDir = mkdtempSync3(join20(runDir, ".browser-credentials-"));
+  chmodSync7(credentialDir, 448);
+  const targetPath = join20(credentialDir, "credentials.env");
+  const temporaryPath = join20(credentialDir, ".credentials.env.tmp");
   const buffers = [];
   const protectedValues = [];
   try {
@@ -33763,15 +33919,15 @@ async function materializeBrowserCredentialEnv(plan, options) {
       const consumed = await options.consume(entry.ref, entry.controlSemantic);
       const valueBuffer = Buffer.isBuffer(consumed) ? consumed : Buffer.from(String(consumed), "utf8");
       buffers.push(valueBuffer);
-      if (valueBuffer.length === 0 || valueBuffer.length > 16 * 1024) fail2("browser_credential_env_value_invalid");
+      if (valueBuffer.length === 0 || valueBuffer.length > 16 * 1024) fail3("browser_credential_env_value_invalid");
       const value = valueBuffer.toString("utf8");
       if (!protectedValues.includes(value)) protectedValues.push(value);
       lines.push(`${entry.key}=${dotenvQuotedValue(value)}`);
     }
-    writeFileSync12(temporaryPath, `${lines.join("\n")}
+    writeFileSync13(temporaryPath, `${lines.join("\n")}
 `, { encoding: "utf8", mode: 384, flag: "wx" });
-    renameSync9(temporaryPath, targetPath);
-    chmodSync6(targetPath, 384);
+    renameSync10(temporaryPath, targetPath);
+    chmodSync7(targetPath, 384);
     return {
       dirPath: credentialDir,
       filePath: targetPath,
@@ -33790,8 +33946,8 @@ async function materializeBrowserCredentialEnv(plan, options) {
 
 // src/amaster-runtime-daemon/runtime-artifact-upload.mjs
 import { createHash as createHash15 } from "node:crypto";
-import { closeSync as closeSync4, constants as constants3, fstatSync as fstatSync4, lstatSync as lstatSync12, openSync as openSync4, readFileSync as readFileSync15, realpathSync as realpathSync10 } from "node:fs";
-import { isAbsolute as isAbsolute9, relative as relative6, resolve as resolve12 } from "node:path";
+import { closeSync as closeSync4, constants as constants3, fstatSync as fstatSync4, lstatSync as lstatSync13, openSync as openSync4, readFileSync as readFileSync16, realpathSync as realpathSync10 } from "node:fs";
+import { isAbsolute as isAbsolute9, relative as relative6, resolve as resolve13 } from "node:path";
 var SHA256_PATTERN = /^[a-f0-9]{64}$/;
 function requiredString2(value, name) {
   if (typeof value !== "string" || !value.trim()) throw new Error(`Runtime Artifact ${name} is required`);
@@ -33810,10 +33966,10 @@ function sameFileSnapshot(left, right) {
   return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
 }
 function readOwnedWorkspaceFile(rootPath, sourceRelativePath, label = "Runtime workspace file", options = {}) {
-  const root = realpathSync10(resolve12(rootPath));
+  const root = realpathSync10(resolve13(rootPath));
   const relativePath = ownedRelativePath(sourceRelativePath);
-  const sourcePath = resolve12(root, relativePath);
-  const pathStat = lstatSync12(sourcePath);
+  const sourcePath = resolve13(root, relativePath);
+  const pathStat = lstatSync13(sourcePath);
   if (!pathStat.isFile() || pathStat.isSymbolicLink() || !pathWithin2(realpathSync10(sourcePath), root)) {
     throw new Error(`${label} source is not an owned regular file`);
   }
@@ -33842,10 +33998,10 @@ function readOwnedWorkspaceFile(rootPath, sourceRelativePath, label = "Runtime w
         );
       }
     }
-    const body = readFileSync15(descriptor);
+    const body = readFileSync16(descriptor);
     options.afterRead?.({ sourcePath, descriptor });
     const after = fstatSync4(descriptor);
-    const pathAfter = lstatSync12(sourcePath);
+    const pathAfter = lstatSync13(sourcePath);
     if (!sameFileSnapshot(before, after) || !sameFileSnapshot(pathAfter, after) || !pathAfter.isFile() || pathAfter.isSymbolicLink() || !pathWithin2(realpathSync10(sourcePath), root) || body.length !== after.size) {
       throw new Error(`${label} source changed during the governed read`);
     }
@@ -34169,8 +34325,8 @@ function createRuntimeArtifactIngestQueue({ ingest, onError }) {
 
 // src/amaster-runtime-daemon/workspace-guard.mjs
 import { createHash as createHash17 } from "node:crypto";
-import { existsSync as existsSync13, mkdirSync as mkdirSync11, realpathSync as realpathSync11, statSync as statSync7 } from "node:fs";
-import { basename as basename6, join as join20, isAbsolute as isAbsolute10, relative as relative7, resolve as resolve13 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync12, realpathSync as realpathSync11, statSync as statSync7 } from "node:fs";
+import { basename as basename6, join as join21, isAbsolute as isAbsolute10, relative as relative7, resolve as resolve14 } from "node:path";
 function pathWithin3(candidate, root) {
   const rel = relative7(root, candidate);
   return rel === "" || !rel.startsWith("..") && !isAbsolute10(rel);
@@ -34179,10 +34335,10 @@ function resolveWorkspaceCwd(config, command) {
   const payload = asRecord(command.payload);
   const requested = readString(payload.workspacePath);
   const fallback = config.workspaceBindings[0] ?? process.cwd();
-  const cwd = realpathSync11(resolve13(expandHomePath(requested ?? fallback)));
+  const cwd = realpathSync11(resolve14(expandHomePath(requested ?? fallback)));
   const allowlist = config.workspaceBindings.flatMap((entry) => {
     try {
-      return [realpathSync11(resolve13(expandHomePath(entry)))];
+      return [realpathSync11(resolve14(expandHomePath(entry)))];
     } catch {
       return [];
     }
@@ -34225,8 +34381,8 @@ function workspaceLabel(sourceWorkspacePath, payload) {
   return readString(payload.workspaceName) ?? readString(payload.projectName) ?? readString(context.projectName) ?? basename6(sourceWorkspacePath) ?? "workspace";
 }
 function workspacesRoot(config) {
-  const root = resolve13(expandHomePath(config.runtimeWorkspacesRoot ?? "~/.amaster-employee/workspaces"));
-  mkdirSync11(root, { recursive: true });
+  const root = resolve14(expandHomePath(config.runtimeWorkspacesRoot ?? "~/.amaster-employee/workspaces"));
+  mkdirSync12(root, { recursive: true });
   return realpathSync11(root);
 }
 function resolveExecutionWorkspace(config, command, opts = {}) {
@@ -34239,11 +34395,11 @@ function resolveExecutionWorkspace(config, command, opts = {}) {
   const workspaceKey = `${safeSegment(workspaceLabel(sourceWorkspacePath, payload), "workspace")}-${shortHash(sourceWorkspacePath)}`;
   const issueKey = `${safeSegment(issueLabel(command, payload), "issue")}-${shortHash(issueId, 8)}`;
   const runKey = `${safeSegment(runId, "run")}-${shortHash(runId, 8)}`;
-  const runDir = join20(root, workspaceKey, issueKey, runKey);
-  const cwd = join20(runDir, "workdir");
-  const executorHome = join20(runDir, "executors", safeSegment(executorKind, "executor"));
-  mkdirSync11(cwd, { recursive: true });
-  mkdirSync11(executorHome, { recursive: true });
+  const runDir = join21(root, workspaceKey, issueKey, runKey);
+  const cwd = join21(runDir, "workdir");
+  const executorHome = join21(runDir, "executors", safeSegment(executorKind, "executor"));
+  mkdirSync12(cwd, { recursive: true });
+  mkdirSync12(executorHome, { recursive: true });
   const workspace = {
     managed: true,
     cwd,
@@ -34265,8 +34421,8 @@ function resolveExecutionWorkspace(config, command, opts = {}) {
 }
 
 // src/amaster-runtime-daemon/workspace-gc.mjs
-import { existsSync as existsSync14, readdirSync as readdirSync9, statSync as statSync8 } from "node:fs";
-import { join as join21, resolve as resolve14 } from "node:path";
+import { existsSync as existsSync14, readdirSync as readdirSync10, statSync as statSync8 } from "node:fs";
+import { join as join22, resolve as resolve15 } from "node:path";
 function readIsoTime(value) {
   if (typeof value !== "string" || !value.trim()) return null;
   const time2 = new Date(value).getTime();
@@ -34283,13 +34439,13 @@ function walkWorkdirs(root) {
     if (!current) continue;
     let entries = [];
     try {
-      entries = readdirSync9(current, { withFileTypes: true });
+      entries = readdirSync10(current, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const fullPath = join21(current, entry.name);
+      const fullPath = join22(current, entry.name);
       if (entry.name === "workdir" && existsSync14(workspaceManifestPath(fullPath))) {
         workdirs.push(fullPath);
         continue;
@@ -34316,12 +34472,12 @@ function directorySizeBytes(path) {
     if (stat.isDirectory()) {
       let entries = [];
       try {
-        entries = readdirSync9(current, { withFileTypes: true });
+        entries = readdirSync10(current, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const entry of entries) {
-        stack.push(join21(current, entry.name));
+        stack.push(join22(current, entry.name));
       }
       continue;
     }
@@ -34348,7 +34504,7 @@ function summarizeWorkdir(path, manifest, nowMs) {
   };
 }
 function planManagedWorkspaceGcDryRun(input) {
-  const root = resolve14(String(input.root ?? ""));
+  const root = resolve15(String(input.root ?? ""));
   const now = input.now instanceof Date ? input.now : /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
   const ttlHours = Math.max(1, Number(input.ttlHours ?? 72));
@@ -34396,21 +34552,21 @@ function planManagedWorkspaceGcDryRun(input) {
 import { createHash as createHash18 } from "node:crypto";
 import {
   accessSync,
-  chmodSync as chmodSync7,
+  chmodSync as chmodSync8,
   constants as constants4,
   existsSync as existsSync15,
-  lstatSync as lstatSync13,
-  mkdirSync as mkdirSync12,
+  lstatSync as lstatSync14,
+  mkdirSync as mkdirSync13,
   mkdtempSync as mkdtempSync4,
-  readFileSync as readFileSync16,
-  readdirSync as readdirSync10,
-  renameSync as renameSync10,
+  readFileSync as readFileSync17,
+  readdirSync as readdirSync11,
+  renameSync as renameSync11,
   rmSync as rmSync11,
   statSync as statSync9,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync13
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync14
 } from "node:fs";
-import { dirname as dirname11, extname, isAbsolute as isAbsolute11, join as join22, parse as parse4, resolve as resolve15, sep as sep4 } from "node:path";
+import { dirname as dirname12, extname, isAbsolute as isAbsolute11, join as join23, parse as parse5, resolve as resolve16, sep as sep4 } from "node:path";
 import { fileURLToPath } from "node:url";
 var PRESET_TEMPLATE_MANIFEST_FILE = ".mirrorx-preset-templates.json";
 var MAX_PRESET_TEMPLATE_FILES = 256;
@@ -34421,7 +34577,7 @@ function sha2562(value) {
 }
 function lstatIfExists(path) {
   try {
-    return lstatSync13(path);
+    return lstatSync14(path);
   } catch (error) {
     if (error?.code === "ENOENT") return null;
     throw error;
@@ -34436,7 +34592,7 @@ function modeAllows(stat, identity, ownerBit, groupBit, otherBit) {
 function assertCatalogReadableByExecutor(targetDir, fileNames, identity) {
   if (!identity) {
     accessSync(targetDir, constants4.R_OK | constants4.X_OK);
-    for (const name of fileNames) accessSync(join22(targetDir, name), constants4.R_OK);
+    for (const name of fileNames) accessSync(join23(targetDir, name), constants4.R_OK);
     return;
   }
   let current = targetDir;
@@ -34445,7 +34601,7 @@ function assertCatalogReadableByExecutor(targetDir, fileNames, identity) {
     if (!stat.isDirectory() || !modeAllows(stat, identity, 64, 8, 1)) {
       throw new Error(`preset_template_executor_path_unreadable: ${current}`);
     }
-    const parent = dirname11(current);
+    const parent = dirname12(current);
     if (parent === current) break;
     current = parent;
   }
@@ -34454,7 +34610,7 @@ function assertCatalogReadableByExecutor(targetDir, fileNames, identity) {
     throw new Error(`preset_template_executor_catalog_unreadable: ${targetDir}`);
   }
   for (const name of fileNames) {
-    const path = join22(targetDir, name);
+    const path = join23(targetDir, name);
     const stat = statSync9(path);
     if (!stat.isFile() || !modeAllows(stat, identity, 256, 32, 4)) {
       throw new Error(`preset_template_executor_file_unreadable: ${name}`);
@@ -34466,11 +34622,11 @@ function hasAllowedTemplateExtension(name) {
   return ALLOWED_TEMPLATE_EXTENSIONS.has(extname(name).toLowerCase());
 }
 function validTemplateName(value) {
-  return typeof value === "string" && value.length > 0 && value !== "." && value !== ".." && !value.includes("\0") && !value.includes("/") && !value.includes("\\") && !isAbsolute11(value) && parse4(value).base === value && hasAllowedTemplateExtension(value);
+  return typeof value === "string" && value.length > 0 && value !== "." && value !== ".." && !value.includes("\0") && !value.includes("/") && !value.includes("\\") && !isAbsolute11(value) && parse5(value).base === value && hasAllowedTemplateExtension(value);
 }
 function readManifest(manifestPath, { strict }) {
   try {
-    const parsed = JSON.parse(readFileSync16(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync17(manifestPath, "utf8"));
     if (parsed?.schemaVersion !== 1 || !Array.isArray(parsed.files)) {
       throw new Error("preset_template_bundle_manifest_invalid");
     }
@@ -34498,12 +34654,12 @@ function readManifest(manifestPath, { strict }) {
 }
 function verifiedBundleFiles(sourceDir, manifest) {
   return manifest.files.map((entry) => {
-    const sourcePath = join22(sourceDir, entry.name);
-    const stat = lstatSync13(sourcePath);
+    const sourcePath = join23(sourceDir, entry.name);
+    const stat = lstatSync14(sourcePath);
     if (!stat.isFile() || stat.isSymbolicLink()) {
       throw new Error(`preset_template_bundle_file_unsafe: ${entry.name}`);
     }
-    const body = readFileSync16(sourcePath);
+    const body = readFileSync17(sourcePath);
     if (body.byteLength !== entry.bytes || sha2562(body) !== entry.sha256) {
       throw new Error(`preset_template_bundle_digest_mismatch: ${entry.name}`);
     }
@@ -34513,51 +34669,51 @@ function verifiedBundleFiles(sourceDir, manifest) {
 function removeRetiredPresetFiles(targetDir, previousManifest, nextNames) {
   for (const entry of previousManifest.files) {
     if (nextNames.has(entry.name)) continue;
-    const targetPath = join22(targetDir, entry.name);
+    const targetPath = join23(targetDir, entry.name);
     if (!existsSync15(targetPath)) continue;
-    const stat = lstatSync13(targetPath);
+    const stat = lstatSync14(targetPath);
     if (stat.isDirectory()) {
       throw new Error(`preset_template_target_conflict: ${entry.name}`);
     }
-    unlinkSync2(targetPath);
+    unlinkSync3(targetPath);
   }
 }
 function materializeBundledPresetTemplates(input) {
-  const sourceDir = resolve15(input.sourceDir);
-  const targetDir = resolve15(input.targetDir);
+  const sourceDir = resolve16(input.sourceDir);
+  const targetDir = resolve16(input.targetDir);
   if (sourceDir === targetDir || sourceDir.startsWith(`${targetDir}${sep4}`) || targetDir.startsWith(`${sourceDir}${sep4}`)) {
     throw new Error("preset_template_source_target_overlap");
   }
-  const manifest = readManifest(join22(sourceDir, PRESET_TEMPLATE_MANIFEST_FILE), { strict: true });
+  const manifest = readManifest(join23(sourceDir, PRESET_TEMPLATE_MANIFEST_FILE), { strict: true });
   const verifiedFiles = verifiedBundleFiles(sourceDir, manifest);
-  mkdirSync12(dirname11(targetDir), { recursive: true, mode: 493 });
+  mkdirSync13(dirname12(targetDir), { recursive: true, mode: 493 });
   const targetStat = lstatIfExists(targetDir);
   if (targetStat && (!targetStat.isDirectory() || targetStat.isSymbolicLink())) {
     throw new Error("preset_template_target_root_unsafe");
   }
-  mkdirSync12(targetDir, { recursive: true, mode: 493 });
-  const previousManifest = readManifest(join22(targetDir, PRESET_TEMPLATE_MANIFEST_FILE), { strict: false });
-  const stageDir = mkdtempSync4(join22(dirname11(targetDir), ".mirrorx-preset-templates-"));
+  mkdirSync13(targetDir, { recursive: true, mode: 493 });
+  const previousManifest = readManifest(join23(targetDir, PRESET_TEMPLATE_MANIFEST_FILE), { strict: false });
+  const stageDir = mkdtempSync4(join23(dirname12(targetDir), ".mirrorx-preset-templates-"));
   try {
     for (const file of verifiedFiles) {
-      const stagedPath = join22(stageDir, file.name);
-      writeFileSync13(stagedPath, file.body, { mode: 292 });
-      chmodSync7(stagedPath, 292);
-      renameSync10(stagedPath, join22(targetDir, file.name));
+      const stagedPath = join23(stageDir, file.name);
+      writeFileSync14(stagedPath, file.body, { mode: 292 });
+      chmodSync8(stagedPath, 292);
+      renameSync11(stagedPath, join23(targetDir, file.name));
     }
     removeRetiredPresetFiles(targetDir, previousManifest, new Set(manifest.files.map((file) => file.name)));
-    const stagedManifest = join22(stageDir, PRESET_TEMPLATE_MANIFEST_FILE);
-    writeFileSync13(stagedManifest, `${JSON.stringify({
+    const stagedManifest = join23(stageDir, PRESET_TEMPLATE_MANIFEST_FILE);
+    writeFileSync14(stagedManifest, `${JSON.stringify({
       schemaVersion: manifest.schemaVersion,
       files: manifest.files
     }, null, 2)}
 `, { mode: 292 });
-    chmodSync7(stagedManifest, 292);
-    renameSync10(stagedManifest, join22(targetDir, PRESET_TEMPLATE_MANIFEST_FILE));
+    chmodSync8(stagedManifest, 292);
+    renameSync11(stagedManifest, join23(targetDir, PRESET_TEMPLATE_MANIFEST_FILE));
   } finally {
     rmSync11(stageDir, { recursive: true, force: true });
   }
-  chmodSync7(targetDir, 493);
+  chmodSync8(targetDir, 493);
   return {
     fileCount: manifest.files.length,
     totalBytes: manifest.totalBytes,
@@ -34570,12 +34726,12 @@ function materializeRuntimePresetTemplates(input) {
     sourceDir,
     targetDir: input.targetDir
   });
-  const manifestBody = readFileSync16(
-    join22(materialized.targetDir, PRESET_TEMPLATE_MANIFEST_FILE)
+  const manifestBody = readFileSync17(
+    join23(materialized.targetDir, PRESET_TEMPLATE_MANIFEST_FILE)
   );
   const manifest = JSON.parse(manifestBody.toString("utf8"));
   for (const file of manifest.files) {
-    const body = readFileSync16(join22(materialized.targetDir, file.name));
+    const body = readFileSync17(join23(materialized.targetDir, file.name));
     if (sha2562(body) !== file.sha256) {
       throw new Error(`preset_template_materialized_digest_mismatch: ${file.name}`);
     }
@@ -34598,11 +34754,11 @@ function materializeRuntimePresetTemplates(input) {
 }
 
 // src/amaster-runtime-daemon/runtime-status-summary.mjs
-import { existsSync as existsSync16, readdirSync as readdirSync11, statSync as statSync10 } from "node:fs";
-import { dirname as dirname12, join as join23, resolve as resolve16 } from "node:path";
+import { existsSync as existsSync16, readdirSync as readdirSync12, statSync as statSync10 } from "node:fs";
+import { dirname as dirname13, join as join24, resolve as resolve17 } from "node:path";
 function runtimeStatusDirectoryEntries(path) {
   try {
-    return readdirSync11(path, { withFileTypes: true });
+    return readdirSync12(path, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -34622,7 +34778,7 @@ function runtimeStatusDirectorySizeBytes(path) {
     if (!stat || stat.isSymbolicLink()) continue;
     if (stat.isDirectory()) {
       for (const entry of runtimeStatusDirectoryEntries(current)) {
-        stack.push(join23(current, entry.name));
+        stack.push(join24(current, entry.name));
       }
       continue;
     }
@@ -34639,7 +34795,7 @@ function walkRuntimeStatusManagedWorkdirs(root) {
     if (!current) continue;
     for (const entry of runtimeStatusDirectoryEntries(current)) {
       if (!entry.isDirectory()) continue;
-      const fullPath = join23(current, entry.name);
+      const fullPath = join24(current, entry.name);
       if (entry.name === "workdir" && existsSync16(workspaceManifestPath(fullPath))) {
         workdirs.push(fullPath);
         continue;
@@ -34681,15 +34837,15 @@ function summarizeRuntimeStatusRecentRun(workdir, manifest) {
 }
 function runtimeStatusOutboxDir(config) {
   const statePath = config.AMASTER_DAEMON_STATE_FILE ?? config.daemonStateFile;
-  return join23(dirname12(stateFilePath({
+  return join24(dirname13(stateFilePath({
     AMASTER_DAEMON_STATE_FILE: statePath
   })), "result-outbox");
 }
 function runtimeStatusRunCompletionDir(config) {
   const explicit = config.AMASTER_RUN_COMPLETION_STATE_DIR ?? config.runCompletionStateDir;
-  if (typeof explicit === "string" && explicit.trim()) return resolve16(explicit);
+  if (typeof explicit === "string" && explicit.trim()) return resolve17(explicit);
   const statePath = config.AMASTER_DAEMON_STATE_FILE ?? config.daemonStateFile;
-  return join23(dirname12(stateFilePath({
+  return join24(dirname13(stateFilePath({
     AMASTER_DAEMON_STATE_FILE: statePath
   })), "run-completion-state");
 }
@@ -34699,7 +34855,7 @@ function countRuntimeStatusJsonEntries(dir) {
 }
 function summarizeRuntimeLocalState(input) {
   const config = input.config ?? {};
-  const root = resolve16(String(config.AMASTER_RUNTIME_WORKSPACES_ROOT ?? config.runtimeWorkspacesRoot ?? input.runtimeWorkspacesRoot ?? ""));
+  const root = resolve17(String(config.AMASTER_RUNTIME_WORKSPACES_ROOT ?? config.runtimeWorkspacesRoot ?? input.runtimeWorkspacesRoot ?? ""));
   const now = input.now instanceof Date ? input.now : /* @__PURE__ */ new Date();
   const workdirs = walkRuntimeStatusManagedWorkdirs(root);
   let managedWorkdirBytes = 0;
@@ -34726,9 +34882,9 @@ function summarizeRuntimeLocalState(input) {
     }
   }
   const pendingOutboxDir = runtimeStatusOutboxDir(config);
-  const invalidOutboxDir = join23(pendingOutboxDir, "invalid");
+  const invalidOutboxDir = join24(pendingOutboxDir, "invalid");
   const pendingRunCompletionDir = runtimeStatusRunCompletionDir(config);
-  const invalidRunCompletionDir = join23(pendingRunCompletionDir, "invalid");
+  const invalidRunCompletionDir = join24(pendingRunCompletionDir, "invalid");
   return {
     managedWorkspacesRoot: root,
     managedWorkdirCount: workdirs.length,
@@ -34850,7 +35006,7 @@ function summarizeAmasterRuntimeVersionDrift(input = {}) {
 }
 
 // src/amaster-runtime-daemon/pi-context-budget.mjs
-import { readFileSync as readFileSync17 } from "node:fs";
+import { readFileSync as readFileSync18 } from "node:fs";
 var CONTEXT_ERROR_CODES = /* @__PURE__ */ new Set([
   "context_effective_tool_schema_attestation_mismatch",
   "context_output_reserve_exceeds_model_limit",
@@ -34965,7 +35121,7 @@ function measureRestoredPiNativeHistory(managedMcpProfile) {
   if (!rolloutPath) {
     return { status: "fresh", tokens: 0, rolloutBytes: 0, usageTokens: 0 };
   }
-  const rollout = readFileSync17(rolloutPath);
+  const rollout = readFileSync18(rolloutPath);
   const maximumRolloutBytes = 64 * 1024 * 1024;
   if (rollout.byteLength > maximumRolloutBytes) {
     throw stableContextError(
@@ -35059,8 +35215,8 @@ function resolvePiModelContextBudget({
 }
 
 // src/amaster-runtime-daemon/pi-project-instruction-extension.mjs
-import { lstatSync as lstatSync14, readFileSync as readFileSync18 } from "node:fs";
-import { resolve as resolve17 } from "node:path";
+import { lstatSync as lstatSync15, readFileSync as readFileSync19 } from "node:fs";
+import { resolve as resolve18 } from "node:path";
 var MANAGED_PI_PROJECT_INSTRUCTION_FILENAME = "amaster-project-instructions.js";
 function requiredString4(value, name) {
   if (typeof value !== "string" || !value.trim()) {
@@ -35069,12 +35225,12 @@ function requiredString4(value, name) {
   return value.trim();
 }
 function managedPiProjectInstructionExtensionSource(input) {
-  const projectInstructionPath = resolve17(requiredString4(input.projectInstructionPath, "projectInstructionPath"));
-  const stat = lstatSync14(projectInstructionPath);
+  const projectInstructionPath = resolve18(requiredString4(input.projectInstructionPath, "projectInstructionPath"));
+  const stat = lstatSync15(projectInstructionPath);
   if (!stat.isFile() || stat.isSymbolicLink()) {
     throw new Error("pi_project_instruction_extension_invalid: unsafe projectInstructionPath");
   }
-  const projectInstructions = readFileSync18(projectInstructionPath, "utf8");
+  const projectInstructions = readFileSync19(projectInstructionPath, "utf8");
   return String.raw`const PROJECT_INSTRUCTIONS = ${JSON.stringify(projectInstructions.trim())};
 
 export default function amasterProjectInstructions(pi) {
@@ -35087,10 +35243,10 @@ export default function amasterProjectInstructions(pi) {
 }
 
 // src/amaster-runtime-daemon/workspace-status.mjs
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync5 } from "node:child_process";
 import { createHash as createHash19 } from "node:crypto";
-import { existsSync as existsSync17, readdirSync as readdirSync12, readFileSync as readFileSync19, statSync as statSync11 } from "node:fs";
-import { basename as basename7, extname as extname2, isAbsolute as isAbsolute12, join as join24, relative as relative8, resolve as resolve18 } from "node:path";
+import { existsSync as existsSync17, readdirSync as readdirSync13, readFileSync as readFileSync20, statSync as statSync11 } from "node:fs";
+import { basename as basename7, extname as extname2, isAbsolute as isAbsolute12, join as join25, relative as relative8, resolve as resolve19 } from "node:path";
 var WORKSPACE_RUNTIME_SERVICES_FILENAME = ".amaster-runtime-services.json";
 var ARTIFACT_EXTENSIONS = /* @__PURE__ */ new Map([
   [".md", "markdown"],
@@ -35159,7 +35315,7 @@ function sanitizeTrackedChange(line) {
   return isSafeRelativePath(path) ? line : null;
 }
 function sha256File(filePath) {
-  return createHash19("sha256").update(readFileSync19(filePath)).digest("hex");
+  return createHash19("sha256").update(readFileSync20(filePath)).digest("hex");
 }
 function artifactHashCacheKey(relativePath, stat) {
   return `${relativePath}\0${stat.size}\0${stat.mtimeMs}`;
@@ -35187,7 +35343,7 @@ function artifactSha256(filePath, relativePath, stat, opts = {}) {
   return hash3;
 }
 function scanArtifactCandidates(cwd, opts = {}) {
-  const root = resolve18(cwd);
+  const root = resolve19(cwd);
   const maxCandidates = opts.maxCandidates ?? MAX_CANDIDATES;
   const maxEntries = opts.maxEntries ?? MAX_SCAN_ENTRIES;
   const candidates = [];
@@ -35197,7 +35353,7 @@ function scanArtifactCandidates(cwd, opts = {}) {
     const current = stack.pop();
     let entries;
     try {
-      entries = readdirSync12(current, { withFileTypes: true });
+      entries = readdirSync13(current, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -35208,7 +35364,7 @@ function scanArtifactCandidates(cwd, opts = {}) {
       if (entry.name.startsWith(".") && entry.name !== ".amaster-runtime.json") {
         if (entry.name === ".git") continue;
       }
-      const fullPath = join24(current, entry.name);
+      const fullPath = join25(current, entry.name);
       const relativePath = normalizeRelativePath(root, fullPath);
       if (!isSafeRelativePath(relativePath)) continue;
       if (basename7(relativePath) === ".amaster-runtime.json") continue;
@@ -35226,7 +35382,7 @@ function scanArtifactCandidates(cwd, opts = {}) {
       } catch {
         continue;
       }
-      if (!statusPathWithin(resolve18(fullPath), root) || stat.size > MAX_HASH_BYTES) continue;
+      if (!statusPathWithin(resolve19(fullPath), root) || stat.size > MAX_HASH_BYTES) continue;
       candidates.push({
         relativePath,
         name: basename7(fullPath),
@@ -35286,10 +35442,10 @@ function sanitizeRuntimeService(entry) {
   };
 }
 function readRuntimeServicesSnapshot(cwd) {
-  const snapshotPath = join24(resolve18(cwd), WORKSPACE_RUNTIME_SERVICES_FILENAME);
+  const snapshotPath = join25(resolve19(cwd), WORKSPACE_RUNTIME_SERVICES_FILENAME);
   if (!existsSync17(snapshotPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync19(snapshotPath, "utf8"));
+    const parsed = JSON.parse(readFileSync20(snapshotPath, "utf8"));
     const rawServices = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.services) ? parsed.services : [];
     return rawServices.map((entry) => sanitizeRuntimeService(entry)).filter((entry) => entry !== null).slice(0, 50);
   } catch {
@@ -35300,7 +35456,7 @@ function readWorkspaceStatus(cwd, opts = {}) {
   const artifactScan = scanArtifactCandidates(cwd, opts);
   const runtimeServices = readRuntimeServicesSnapshot(cwd);
   const serviceUrls = [...new Set(runtimeServices.flatMap((service) => service.url ? [service.url] : []))];
-  const status = spawnSync4("git", ["status", "--porcelain=v1"], {
+  const status = spawnSync5("git", ["status", "--porcelain=v1"], {
     cwd,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "ignore"],
@@ -35332,7 +35488,7 @@ function readWorkspaceStatus(cwd, opts = {}) {
       trackedChanges.push(safeChange);
     }
   }
-  const aheadBehind = spawnSync4("git", ["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], {
+  const aheadBehind = spawnSync5("git", ["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], {
     cwd,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "ignore"],
@@ -35391,7 +35547,7 @@ function assertRequiredTaskAttachmentMaterialized(input, materialized) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.13-beta.0";
+var CONNECTOR_VERSION = "0.1.13-beta.2";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var SUPPORTED_TASK_CONTEXT_VERSIONS = Object.freeze([TASK_CONTEXT_MANIFEST_VERSION, TASK_CONTEXT_V2]);
 var daemonRequire = createRequire(import.meta.url);
@@ -35463,12 +35619,12 @@ function notifyDaemonLoop() {
 }
 function waitForDaemonLoop(timeoutMs, observedVersion) {
   if (daemonLoopWakeVersion !== observedVersion) return Promise.resolve();
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const finish = () => {
       clearTimeout(timer);
       if (wakeDaemonLoop === finish) wakeDaemonLoop = () => {
       };
-      resolve20();
+      resolve21();
     };
     const timer = setTimeout(finish, timeoutMs);
     wakeDaemonLoop = finish;
@@ -35490,8 +35646,8 @@ function resultOutboxPendingCount(config) {
   if (!existsSync18(dir)) return 0;
   try {
     let pending = 0;
-    for (const file of readdirSync13(dir).filter((name) => name.endsWith(".json"))) {
-      if (readValidResultOutboxEntryOrQuarantine(config, file, join25(dir, file))) {
+    for (const file of readdirSync14(dir).filter((name) => name.endsWith(".json"))) {
+      if (readValidResultOutboxEntryOrQuarantine(config, file, join26(dir, file))) {
         pending += 1;
       }
     }
@@ -35502,21 +35658,21 @@ function resultOutboxPendingCount(config) {
 }
 function runCompletionStateDir(config) {
   const explicit = readString(process.env.AMASTER_RUN_COMPLETION_STATE_DIR);
-  if (explicit) return resolve19(expandHomePath(explicit));
-  return join25(dirname13(stateFilePath(process.env)), "run-completion-state");
+  if (explicit) return resolve20(expandHomePath(explicit));
+  return join26(dirname14(stateFilePath(process.env)), "run-completion-state");
 }
 function runCompletionStateInvalidDir(config) {
-  return join25(runCompletionStateDir(config), "invalid");
+  return join26(runCompletionStateDir(config), "invalid");
 }
 function quarantineInvalidRunCompletionState(config, filePath, reason) {
   const invalidDir = runCompletionStateInvalidDir(config);
-  mkdirSync13(invalidDir, { recursive: true, mode: 448 });
-  const destination = join25(invalidDir, basename8(filePath));
+  mkdirSync14(invalidDir, { recursive: true, mode: 448 });
+  const destination = join26(invalidDir, basename8(filePath));
   try {
-    renameSync11(filePath, destination);
+    renameSync12(filePath, destination);
   } catch {
     copyFileSync2(filePath, destination);
-    unlinkSync3(filePath);
+    unlinkSync4(filePath);
   }
   process.stderr.write(`AMaster daemon quarantined invalid run completion state ${basename8(filePath)}: ${reason}
 `);
@@ -35568,8 +35724,8 @@ function resultOutboxActiveRunCommands(config) {
   if (!existsSync18(dir)) return [];
   const outboxPending = resultOutboxPendingCount(config);
   const entries = [];
-  for (const file of readdirSync13(dir).filter((name) => name.endsWith(".json")).sort()) {
-    const entry = readValidResultOutboxEntryOrQuarantine(config, file, join25(dir, file));
+  for (const file of readdirSync14(dir).filter((name) => name.endsWith(".json")).sort()) {
+    const entry = readValidResultOutboxEntryOrQuarantine(config, file, join26(dir, file));
     if (!entry) continue;
     const activeRun = asRecord(entry.activeRun);
     const commandId = readString(activeRun.commandId) ?? readString(entry.commandId);
@@ -35602,10 +35758,10 @@ function resultOutboxFailedRunCommands(config) {
   const dir = resultOutboxInvalidDir(config);
   if (!existsSync18(dir)) return [];
   const entries = [];
-  for (const file of readdirSync13(dir).filter((name) => name.endsWith(".json")).sort().slice(-100)) {
+  for (const file of readdirSync14(dir).filter((name) => name.endsWith(".json")).sort().slice(-100)) {
     let entry;
     try {
-      entry = asRecord(JSON.parse(readFileSync20(join25(dir, file), "utf8")));
+      entry = asRecord(JSON.parse(readFileSync21(join26(dir, file), "utf8")));
     } catch {
       continue;
     }
@@ -35668,11 +35824,11 @@ function piExtraArgsDiagnostics(value) {
 }
 function safeExpandPath(value) {
   const text2 = readString(value);
-  return text2 ? resolve19(expandHomePath(text2)) : null;
+  return text2 ? resolve20(expandHomePath(text2)) : null;
 }
 function safeJsonObjectFromFile(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync20(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync21(filePath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -35689,7 +35845,7 @@ function safeDirectorySummary(pathValue) {
     }
     let entryCount = 0;
     let truncated = false;
-    for (const name of readdirSync13(pathValue)) {
+    for (const name of readdirSync14(pathValue)) {
       if (name.startsWith(".")) continue;
       entryCount += 1;
       if (entryCount >= MAX_PI_CAPABILITY_SOURCE_ENTRIES) {
@@ -35713,12 +35869,12 @@ function safeSkillRootSummary(kind, source, pathValue) {
   let truncated = false;
   if (directory.available && pathValue) {
     try {
-      for (const name of readdirSync13(pathValue)) {
+      for (const name of readdirSync14(pathValue)) {
         if (name.startsWith(".")) continue;
-        const skillDir = join25(pathValue, name);
+        const skillDir = join26(pathValue, name);
         try {
           if (!statSync12(skillDir).isDirectory()) continue;
-          if (!existsSync18(join25(skillDir, "SKILL.md"))) continue;
+          if (!existsSync18(join26(skillDir, "SKILL.md"))) continue;
           skillCount += 1;
           if (skillCount >= MAX_PI_CAPABILITY_SOURCE_ENTRIES) {
             truncated = true;
@@ -35769,7 +35925,7 @@ function objectKeyCount(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? Object.keys(value).length : 0;
 }
 function defaultPiCodingAgentDir() {
-  return join25(homedir7(), ".pi", "agent");
+  return join26(homedir7(), ".pi", "agent");
 }
 function piCapabilitySourcesDiagnostics() {
   const configuredPiCodingAgentDir = safeExpandPath(process.env.PI_CODING_AGENT_DIR);
@@ -35778,14 +35934,14 @@ function piCapabilitySourcesDiagnostics() {
   const configuredPiAgentHome = safeExpandPath(process.env.PI_AGENT_HOME);
   const piAgentHome = configuredPiAgentHome ?? piCodingAgentDir;
   const piAgentHomeSource = configuredPiAgentHome ? "PI_AGENT_HOME" : piCodingAgentDirSource;
-  const userSkillsPath = piAgentHome ? join25(piAgentHome, "skills") : null;
+  const userSkillsPath = piAgentHome ? join26(piAgentHome, "skills") : null;
   const configuredMarketplaceSkillsPath = safeExpandPath(
     process.env.PI_AGENT_MARKETPLACE_SKILLS_DIR
   );
-  const marketplaceSkillsPath = configuredMarketplaceSkillsPath ?? (piAgentHome ? join25(piAgentHome, "marketplace", "skills") : null);
+  const marketplaceSkillsPath = configuredMarketplaceSkillsPath ?? (piAgentHome ? join26(piAgentHome, "marketplace", "skills") : null);
   const builtinSkillsPath = safeExpandPath(process.env.PI_AGENT_BUILTIN_SKILLS_DIR) ?? safeExpandPath(process.env.AMASTER_BUILTIN_SKILLS);
-  const mcpConfigPath = safeExpandPath(process.env.PI_AGENT_MCP_SERVERS_FILE) ?? (piAgentHome ? join25(piAgentHome, "mcp.json") : null);
-  const settingsConfigPath = piCodingAgentDir ? join25(piCodingAgentDir, "settings.json") : null;
+  const mcpConfigPath = safeExpandPath(process.env.PI_AGENT_MCP_SERVERS_FILE) ?? (piAgentHome ? join26(piAgentHome, "mcp.json") : null);
+  const settingsConfigPath = piCodingAgentDir ? join26(piCodingAgentDir, "settings.json") : null;
   const skillRoots = [
     safeSkillRootSummary("user", `${piAgentHomeSource}/skills`, userSkillsPath),
     safeSkillRootSummary(
@@ -36083,19 +36239,19 @@ function materializePiRuntimeSystemPrompt(config, promptRoot, commandId, content
   const normalizedCommandId = readString(commandId);
   if (!normalizedCommandId) throw new Error("pi_runtime_system_prompt_command_id_missing");
   const promptIdentity = createHash20("sha256").update(normalizedCommandId).digest("hex");
-  const promptDir = join25(promptRoot, "tmp");
-  mkdirSync13(promptDir, { recursive: true, mode: 448 });
-  const promptDirStat = lstatSync15(promptDir);
+  const promptDir = join26(promptRoot, "tmp");
+  mkdirSync14(promptDir, { recursive: true, mode: 448 });
+  const promptDirStat = lstatSync16(promptDir);
   if (!promptDirStat.isDirectory() || promptDirStat.isSymbolicLink()) {
     throw new Error("pi_runtime_system_prompt_directory_invalid");
   }
-  chmodSync8(promptDir, 448);
-  const promptPath = join25(promptDir, `runtime-system-${promptIdentity}.md`);
-  const temporaryPath = join25(promptDir, `.runtime-system.${process.pid}.${randomUUID2()}.tmp`);
+  chmodSync9(promptDir, 448);
+  const promptPath = join26(promptDir, `runtime-system-${promptIdentity}.md`);
+  const temporaryPath = join26(promptDir, `.runtime-system.${process.pid}.${randomUUID3()}.tmp`);
   try {
-    writeFileSync14(temporaryPath, contents, { encoding: "utf8", mode: 384, flag: "wx" });
-    renameSync11(temporaryPath, promptPath);
-    chmodSync8(promptPath, 384);
+    writeFileSync15(temporaryPath, contents, { encoding: "utf8", mode: 384, flag: "wx" });
+    renameSync12(temporaryPath, promptPath);
+    chmodSync9(promptPath, 384);
     const promptMode = statSync12(promptPath).mode & 511;
     if (promptMode !== 384) {
       throw new Error(`pi_runtime_system_prompt_permissions_failed: mode=${promptMode.toString(8)}`);
@@ -36267,7 +36423,7 @@ AMASTER_MACHINE_ID=${quoteShell(config.machineId)}
 AMASTER_WORKSPACE_ALLOWLIST=${quoteShell(config.workspaceBindings.join(","))}
 AMASTER_EXECUTORS=${quoteShell(executorEnv)}
 AMASTER_NETWORK_DOMAINS=${quoteShell(config.networkDomains.join(","))}
-AMASTER_DAEMON_STATE_FILE=${quoteShell(join25(homedir7(), ".amaster-employee", "runtime-connector-state.json"))}
+AMASTER_DAEMON_STATE_FILE=${quoteShell(join26(homedir7(), ".amaster-employee", "runtime-connector-state.json"))}
 EOF
 
 set -a
@@ -36744,58 +36900,74 @@ function browserSessionProfileIdentity(config, session) {
 }
 function ensureBrowserSessionProfile(config, session) {
   const identity = browserSessionProfileIdentity(config, session);
-  const profileRoot = resolve19(config.browserSessionStateRoot);
-  mkdirSync13(profileRoot, { recursive: true, mode: 448 });
-  if (lstatSync15(profileRoot).isSymbolicLink() || !lstatSync15(profileRoot).isDirectory()) {
+  if (config.piExecutorUid > 0) {
+    return ensureUnprivilegedBrowserSessionProfile({
+      root: config.browserSessionStateRoot,
+      identity,
+      uid: config.piExecutorUid,
+      gid: config.piExecutorGid
+    });
+  }
+  const profileRoot = resolve20(config.browserSessionStateRoot);
+  mkdirSync14(profileRoot, { recursive: true, mode: 448 });
+  if (lstatSync16(profileRoot).isSymbolicLink() || !lstatSync16(profileRoot).isDirectory()) {
     throw new Error("browser_session_profile_path_invalid");
   }
-  chmodSync8(profileRoot, 448);
-  const userDataDir = resolve19(profileRoot, identity.localOpaqueRef);
+  chmodSync9(profileRoot, 448);
+  const userDataDir = resolve20(profileRoot, identity.localOpaqueRef);
   if (!pathWithin3(userDataDir, profileRoot)) {
     throw new Error("browser_session_profile_path_invalid");
   }
-  mkdirSync13(userDataDir, { recursive: true, mode: 448 });
-  if (lstatSync15(userDataDir).isSymbolicLink() || !lstatSync15(userDataDir).isDirectory()) {
+  mkdirSync14(userDataDir, { recursive: true, mode: 448 });
+  if (lstatSync16(userDataDir).isSymbolicLink() || !lstatSync16(userDataDir).isDirectory()) {
     throw new Error("browser_session_profile_path_invalid");
   }
-  chmodSync8(userDataDir, 448);
-  const markerPath = join25(userDataDir, BROWSER_SESSION_PROFILE_OWNER_MARKER);
-  if (existsSync18(markerPath)) {
-    if (lstatSync15(markerPath).isSymbolicLink()) {
+  chmodSync9(userDataDir, 448);
+  const markerPath2 = join26(userDataDir, BROWSER_SESSION_PROFILE_OWNER_MARKER);
+  if (existsSync18(markerPath2)) {
+    if (lstatSync16(markerPath2).isSymbolicLink()) {
       throw new Error("browser_session_profile_identity_invalid");
     }
-    const existing = readJsonFile2(markerPath);
+    const existing = readJsonFile2(markerPath2);
     if (JSON.stringify(existing) !== JSON.stringify(identity)) {
       throw new Error("browser_session_profile_identity_invalid");
     }
   } else {
-    const temporaryPath = join25(
+    const temporaryPath = join26(
       userDataDir,
-      `.${BROWSER_SESSION_PROFILE_OWNER_MARKER}.${process.pid}.${createHash20("sha256").update(randomUUID2()).digest("hex")}`
+      `.${BROWSER_SESSION_PROFILE_OWNER_MARKER}.${process.pid}.${createHash20("sha256").update(randomUUID3()).digest("hex")}`
     );
-    writeFileSync14(temporaryPath, `${JSON.stringify(identity)}
+    writeFileSync15(temporaryPath, `${JSON.stringify(identity)}
 `, { mode: 384, flag: "wx" });
-    renameSync11(temporaryPath, markerPath);
+    renameSync12(temporaryPath, markerPath2);
   }
-  chmodSync8(markerPath, 384);
+  chmodSync9(markerPath2, 384);
   return { profileRoot, userDataDir, identity };
 }
 function cleanupBrowserSessionProfile(config, value) {
   const identity = browserSessionProfileIdentity(config, value);
-  const profileRoot = resolve19(config.browserSessionStateRoot);
-  const userDataDir = resolve19(profileRoot, identity.localOpaqueRef);
+  if (config.piExecutorUid > 0) {
+    return cleanupUnprivilegedBrowserSessionProfile({
+      root: config.browserSessionStateRoot,
+      identity,
+      uid: config.piExecutorUid,
+      gid: config.piExecutorGid
+    });
+  }
+  const profileRoot = resolve20(config.browserSessionStateRoot);
+  const userDataDir = resolve20(profileRoot, identity.localOpaqueRef);
   if (!pathWithin3(userDataDir, profileRoot)) {
     throw new Error("browser_session_profile_cleanup_invalid");
   }
   if (!existsSync18(userDataDir)) return { outcome: "absent", identity };
-  if (lstatSync15(userDataDir).isSymbolicLink() || !lstatSync15(userDataDir).isDirectory()) {
+  if (lstatSync16(userDataDir).isSymbolicLink() || !lstatSync16(userDataDir).isDirectory()) {
     throw new Error("browser_session_profile_cleanup_invalid");
   }
-  const markerPath = join25(userDataDir, BROWSER_SESSION_PROFILE_OWNER_MARKER);
-  if (!existsSync18(markerPath) || lstatSync15(markerPath).isSymbolicLink()) {
+  const markerPath2 = join26(userDataDir, BROWSER_SESSION_PROFILE_OWNER_MARKER);
+  if (!existsSync18(markerPath2) || lstatSync16(markerPath2).isSymbolicLink()) {
     throw new Error("browser_session_profile_cleanup_invalid");
   }
-  if (JSON.stringify(readJsonFile2(markerPath)) !== JSON.stringify(identity)) {
+  if (JSON.stringify(readJsonFile2(markerPath2)) !== JSON.stringify(identity)) {
     throw new Error("browser_session_profile_cleanup_invalid");
   }
   rmSync12(userDataDir, { recursive: true, force: false });
@@ -36803,7 +36975,7 @@ function cleanupBrowserSessionProfile(config, value) {
 }
 function readJsonFile2(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync20(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync21(filePath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
@@ -36814,8 +36986,8 @@ function syncPiExecutorProviderConfig(config, agentDir, providerConfig) {
   const { modelsSynced, settingsSynced } = syncAmasterProviderFiles(agentDir, providerConfig);
   if (!modelsSynced && !settingsSynced) return null;
   handoffPiRunPathsToChild(config, [
-    modelsSynced ? join25(agentDir, "models.json") : null,
-    settingsSynced ? join25(agentDir, "settings.json") : null
+    modelsSynced ? join26(agentDir, "models.json") : null,
+    settingsSynced ? join26(agentDir, "settings.json") : null
   ]);
   return { modelsSynced, settingsSynced };
 }
@@ -36846,7 +37018,7 @@ function safeAgentInstructionMaterializationTarget(workspace, filePath) {
   const segments = normalized.split("/").filter(Boolean);
   if (segments.length === 0 || segments.some((segment) => segment === "." || segment === "..")) return null;
   const relativePath = segments.join("/");
-  const targetPath = resolve19(workspace.cwd, relativePath);
+  const targetPath = resolve20(workspace.cwd, relativePath);
   if (!pathWithin3(targetPath, workspace.cwd)) return null;
   return { relativePath, targetPath };
 }
@@ -36932,15 +37104,15 @@ async function materializeEffectiveAgentInstructions(config, command, workspace,
     }
     const target = safeAgentInstructionMaterializationTarget(workspace, filePath);
     if (!target) throw new Error(`context_envelope_instruction_path_invalid: ${filePath}`);
-    mkdirSync13(dirname13(target.targetPath), { recursive: true });
+    mkdirSync14(dirname14(target.targetPath), { recursive: true });
     const temporaryPath = `${target.targetPath}.mirrorx-${command.commandId}.tmp`;
     try {
-      writeFileSync14(temporaryPath, content, { encoding: "utf8", mode: 384 });
-      const readBack = readFileSync20(temporaryPath, "utf8");
+      writeFileSync15(temporaryPath, content, { encoding: "utf8", mode: 384 });
+      const readBack = readFileSync21(temporaryPath, "utf8");
       if (readBack !== content) {
         throw new Error(`context_envelope_instruction_readback_mismatch: ${filePath}`);
       }
-      renameSync11(temporaryPath, target.targetPath);
+      renameSync12(temporaryPath, target.targetPath);
     } finally {
       rmSync12(temporaryPath, { force: true });
     }
@@ -36952,7 +37124,7 @@ async function materializeEffectiveAgentInstructions(config, command, workspace,
   }
   const readBackFiles = Object.fromEntries(materialized.map((entry) => [
     entry.path,
-    readFileSync20(resolve19(workspace.cwd, entry.path), "utf8")
+    readFileSync21(resolve20(workspace.cwd, entry.path), "utf8")
   ]));
   if (stableInstructionFilesHash(readBackFiles) !== readString(instructionContract.contentHash)) {
     throw new Error("context_envelope_materialized_hash_mismatch");
@@ -36976,7 +37148,7 @@ function wikiTreePathForCommand(command, workspaceBindings) {
     const candidates = [];
     if (root.endsWith("paperclipai.plugin-llm-wiki")) candidates.push(root);
     if (basename8(root) === "plugin-data" && companyId) {
-      candidates.push(join25(root, companyId, "paperclipai.plugin-llm-wiki"));
+      candidates.push(join26(root, companyId, "paperclipai.plugin-llm-wiki"));
     }
     for (const candidate of candidates) {
       try {
@@ -37215,13 +37387,13 @@ function attachPiProjectInstructionExtension(profile, input) {
       "managed Pi profile is missing"
     );
   }
-  const projectInstructionExtensionPath = join25(
+  const projectInstructionExtensionPath = join26(
     profile.profileRoot,
     "extensions",
     MANAGED_PI_PROJECT_INSTRUCTION_FILENAME
   );
-  const contract = { projectInstructionPath: resolve19(input.cwd, "AGENTS.md") };
-  writeFileSync14(projectInstructionExtensionPath, managedPiProjectInstructionExtensionSource(contract), { mode: 384 });
+  const contract = { projectInstructionPath: resolve20(input.cwd, "AGENTS.md") };
+  writeFileSync15(projectInstructionExtensionPath, managedPiProjectInstructionExtensionSource(contract), { mode: 384 });
   return projectInstructionExtensionPath;
 }
 function commandUsesPiExecutor(command) {
@@ -37264,18 +37436,18 @@ function buildExecutorEnv(config, command, workspace) {
   };
 }
 function preparePiModelCallProfile(commandId, baseEnv, options = {}) {
-  const profileRoot = mkdtempSync5(join25(tmpdir(), "amaster-pi-model-call-"));
-  const home = join25(profileRoot, "home");
-  const sessionsDir = join25(profileRoot, "sessions");
-  const tempDir = join25(profileRoot, "tmp");
+  const profileRoot = mkdtempSync5(join26(tmpdir(), "amaster-pi-model-call-"));
+  const home = join26(profileRoot, "home");
+  const sessionsDir = join26(profileRoot, "sessions");
+  const tempDir = join26(profileRoot, "tmp");
   for (const directory of [home, sessionsDir, tempDir]) {
-    mkdirSync13(directory, { recursive: true, mode: 448 });
+    mkdirSync14(directory, { recursive: true, mode: 448 });
   }
   try {
     const extensionArgs = [];
     if (options.responseContract) {
-      const extensionPath = join25(profileRoot, "model-call-output-contract.js");
-      writeFileSync14(
+      const extensionPath = join26(profileRoot, "model-call-output-contract.js");
+      writeFileSync15(
         extensionPath,
         modelCallOutputContractExtensionSource(options.responseContract.maxOutputTokens),
         { mode: 384 }
@@ -37340,7 +37512,7 @@ function resolveNativeSessionRequest(command, workspace) {
     try {
       cwdMatched = realpathSync12(requestedCwd) === realpathSync12(sourceWorkspacePath);
     } catch {
-      cwdMatched = resolve19(requestedCwd) === resolve19(sourceWorkspacePath);
+      cwdMatched = resolve20(requestedCwd) === resolve20(sourceWorkspacePath);
     }
   }
   const used = Boolean(enabled && requested && sessionId && requestedCwd && cwdMatched);
@@ -38150,7 +38322,7 @@ function sampleProcessGroupRssBytes(processGroupId) {
   if (process.platform === "win32" || processGroupId === null) return null;
   const now = Date.now();
   if (!processGroupRssSampleCache || now - processGroupRssSampleCache.sampledAtMs >= PROCESS_GROUP_RSS_SAMPLE_MIN_INTERVAL_MS) {
-    const result2 = spawnSync5("ps", ["-axo", "pgid=,rss="], {
+    const result2 = spawnSync6("ps", ["-axo", "pgid=,rss="], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -38173,7 +38345,7 @@ function realOrResolvedPath(value) {
   try {
     return realpathSync12(value);
   } catch {
-    return resolve19(value);
+    return resolve20(value);
   }
 }
 var LSOF_COMMAND = process.platform === "darwin" && existsSync18("/usr/sbin/lsof") ? "/usr/sbin/lsof" : "lsof";
@@ -38186,7 +38358,7 @@ function processCwdForPid(pid) {
     }
   }
   if (process.platform === "darwin") {
-    const result2 = spawnSync5(LSOF_COMMAND, ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], {
+    const result2 = spawnSync6(LSOF_COMMAND, ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -38202,7 +38374,7 @@ function allProcessCwdsByPid() {
   if (process.platform === "linux") {
     const procEntries = (() => {
       try {
-        return readdirSync13("/proc", { withFileTypes: true });
+        return readdirSync14("/proc", { withFileTypes: true });
       } catch {
         return [];
       }
@@ -38216,7 +38388,7 @@ function allProcessCwdsByPid() {
     return cwds;
   }
   if (process.platform === "darwin") {
-    const result2 = spawnSync5(LSOF_COMMAND, ["-nP", "-d", "cwd", "-Fp", "-Fn"], {
+    const result2 = spawnSync6(LSOF_COMMAND, ["-nP", "-d", "cwd", "-Fp", "-Fn"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -38237,7 +38409,7 @@ function allProcessCwdsByPid() {
 }
 function allProcessRows() {
   if (process.platform === "win32") return [];
-  const result2 = spawnSync5("ps", ["-axo", "pid=,pgid=,command="], {
+  const result2 = spawnSync6("ps", ["-axo", "pid=,pgid=,command="], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "ignore"]
   });
@@ -38295,13 +38467,13 @@ function walkManagedWorkdirs(root) {
     if (!current) continue;
     let entries = [];
     try {
-      entries = readdirSync13(current, { withFileTypes: true });
+      entries = readdirSync14(current, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const fullPath = join25(current, entry.name);
+      const fullPath = join26(current, entry.name);
       if (entry.name === "workdir" && existsSync18(workspaceManifestPath(fullPath))) {
         workdirs.push(fullPath);
         continue;
@@ -39310,15 +39482,15 @@ async function completeCommand(config, command, status, result2, error) {
 }
 function resultOutboxDir(config) {
   const explicit = readString(process.env.AMASTER_RESULT_OUTBOX_DIR);
-  if (explicit) return resolve19(expandHomePath(explicit));
-  return join25(dirname13(stateFilePath(process.env)), "result-outbox");
+  if (explicit) return resolve20(expandHomePath(explicit));
+  return join26(dirname14(stateFilePath(process.env)), "result-outbox");
 }
 function resultOutboxInvalidDir(config) {
-  return join25(resultOutboxDir(config), "invalid");
+  return join26(resultOutboxDir(config), "invalid");
 }
 function writeResultOutboxEntry(config, entry) {
   const dir = resultOutboxDir(config);
-  mkdirSync13(dir, { recursive: true });
+  mkdirSync14(dir, { recursive: true });
   const pendingLogEntries = takeDeferredLiveLogEntries(entry.commandId);
   const body = {
     version: 1,
@@ -39328,19 +39500,19 @@ function writeResultOutboxEntry(config, entry) {
     ...entry,
     ...pendingLogEntries.length > 0 ? { pendingLogEntries } : {}
   };
-  writeFileSync14(join25(dir, resultOutboxFileName(entry.commandId)), `${JSON.stringify(body, null, 2)}
+  writeFileSync15(join26(dir, resultOutboxFileName(entry.commandId)), `${JSON.stringify(body, null, 2)}
 `, { mode: 384 });
 }
 function moveResultOutboxEntryToInvalid(config, file, fullPath, reason, detail, original) {
   const invalidDir = resultOutboxInvalidDir(config);
-  mkdirSync13(invalidDir, { recursive: true });
-  const invalidPath = join25(invalidDir, file);
+  mkdirSync14(invalidDir, { recursive: true });
+  const invalidPath = join26(invalidDir, file);
   if (original === void 0) {
     try {
-      renameSync11(fullPath, invalidPath);
+      renameSync12(fullPath, invalidPath);
     } catch {
       copyFileSync2(fullPath, invalidPath);
-      unlinkSync3(fullPath);
+      unlinkSync4(fullPath);
     }
     return;
   }
@@ -39350,14 +39522,14 @@ function moveResultOutboxEntryToInvalid(config, file, fullPath, reason, detail,
     ...detail ? { detail: truncateText(detail, 1e3) } : {},
     original
   };
-  writeFileSync14(invalidPath, `${JSON.stringify(evidence, null, 2)}
+  writeFileSync15(invalidPath, `${JSON.stringify(evidence, null, 2)}
 `, { mode: 384 });
-  unlinkSync3(fullPath);
+  unlinkSync4(fullPath);
 }
 function readValidResultOutboxEntryOrQuarantine(config, file, fullPath) {
   let entry;
   try {
-    entry = JSON.parse(readFileSync20(fullPath, "utf8"));
+    entry = JSON.parse(readFileSync21(fullPath, "utf8"));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     moveResultOutboxEntryToInvalid(config, file, fullPath, "malformed_result_outbox_json", message);
@@ -39390,13 +39562,13 @@ function updateResultOutboxAttempt(fullPath, entry, err) {
     ...typeof err?.httpStatus === "number" ? { httpStatus: err.httpStatus } : {},
     lastError: truncateText(err instanceof Error ? err.message : String(err), 1e3)
   };
-  writeFileSync14(fullPath, `${JSON.stringify(next, null, 2)}
+  writeFileSync15(fullPath, `${JSON.stringify(next, null, 2)}
 `, { mode: 384 });
   return next;
 }
 function quarantineResultOutboxEntry(config, fullPath, file, entry, reason, err) {
   const invalidDir = resultOutboxInvalidDir(config);
-  mkdirSync13(invalidDir, { recursive: true });
+  mkdirSync14(invalidDir, { recursive: true });
   const body = {
     ...entry,
     invalidReason: reason,
@@ -39404,11 +39576,11 @@ function quarantineResultOutboxEntry(config, fullPath, file, entry, reason, err)
     ...typeof err?.httpStatus === "number" ? { httpStatus: err.httpStatus } : {},
     lastError: truncateText(err instanceof Error ? err.message : String(err), 1e3)
   };
-  const invalidPath = join25(invalidDir, file);
-  writeFileSync14(invalidPath, `${JSON.stringify(body, null, 2)}
+  const invalidPath = join26(invalidDir, file);
+  writeFileSync15(invalidPath, `${JSON.stringify(body, null, 2)}
 `, { mode: 384 });
   try {
-    unlinkSync3(fullPath);
+    unlinkSync4(fullPath);
   } catch (unlinkErr) {
     const message = unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr);
     process.stderr.write(`AMaster daemon could not remove quarantined result outbox entry ${file}: ${message}
@@ -39420,10 +39592,10 @@ function quarantineResultOutboxEntry(config, fullPath, file, entry, reason, err)
 async function flushResultOutbox(config) {
   const dir = resultOutboxDir(config);
   if (!existsSync18(dir)) return { attempted: 0, completed: 0 };
-  const files = readdirSync13(dir).filter((name) => name.endsWith(".json")).sort();
+  const files = readdirSync14(dir).filter((name) => name.endsWith(".json")).sort();
   let completed = 0;
   for (const file of files) {
-    const fullPath = join25(dir, file);
+    const fullPath = join26(dir, file);
     let entry = readValidResultOutboxEntryOrQuarantine(config, file, fullPath);
     if (!entry) continue;
     const pendingLogEntries = Array.isArray(entry.pendingLogEntries) ? entry.pendingLogEntries.filter((logEntry) => typeof asRecord(logEntry).message === "string") : [];
@@ -39438,7 +39610,7 @@ async function flushResultOutbox(config) {
         if (!isTerminalResultOutboxStatus(logHttpStatus)) {
           const logAttemptCount = readNumber(entry.logAttemptCount, 0) + 1;
           if (logAttemptCount < maxResultOutboxAttempts()) {
-            writeFileSync14(fullPath, `${JSON.stringify({ ...entry, logAttemptCount }, null, 2)}
+            writeFileSync15(fullPath, `${JSON.stringify({ ...entry, logAttemptCount }, null, 2)}
 `, { mode: 384 });
             process.stderr.write(`AMaster daemon deferred live log delivery retry failed for ${entry.commandId ?? file}: ${logMessage}
 `);
@@ -39451,12 +39623,12 @@ async function flushResultOutbox(config) {
       entry = { ...entry };
       delete entry.pendingLogEntries;
       delete entry.logAttemptCount;
-      writeFileSync14(fullPath, `${JSON.stringify(entry, null, 2)}
+      writeFileSync15(fullPath, `${JSON.stringify(entry, null, 2)}
 `, { mode: 384 });
     }
     try {
       await postJson(config, String(entry.path), entry.payload);
-      unlinkSync3(fullPath);
+      unlinkSync4(fullPath);
       clearDeliveredResultOutboxCommand(config, entry);
       completed += 1;
     } catch (err) {
@@ -39662,8 +39834,8 @@ async function materializeIssueAttachments(config, command, workspace) {
     runtimeAuth,
     issueId
   );
-  const targetDir = join25(workspace.cwd, "input-attachments");
-  mkdirSync13(targetDir, { recursive: true });
+  const targetDir = join26(workspace.cwd, "input-attachments");
+  mkdirSync14(targetDir, { recursive: true });
   const usedFilenames = /* @__PURE__ */ new Set();
   const materialized = [];
   for (const [index, rawAttachment] of attachments.entries()) {
@@ -39676,12 +39848,12 @@ async function materializeIssueAttachments(config, command, workspace) {
     let filename = safeMaterializedAttachmentFilename(attachment, index);
     filename = dedupeMaterializedFilename(filename, index, usedFilenames);
     usedFilenames.add(filename);
-    const targetPath = join25(targetDir, filename);
+    const targetPath = join26(targetDir, filename);
     const body = await runtimeApiBuffer(runtimeAuth, contentPath);
     if (attachment.initializationInput === true && (body.byteLength !== attachment.byteSize || createHash20("sha256").update(body).digest("hex") !== attachment.sha256)) {
       throw new Error("Initialization input content does not match its preparation receipt");
     }
-    writeFileSync14(targetPath, body);
+    writeFileSync15(targetPath, body);
     const attachmentId = readString(attachment.id);
     const actualSha256 = createHash20("sha256").update(body).digest("hex");
     const lineageCandidates = lineageCandidatesByAttachmentId.get(attachmentId) ?? [];
@@ -39748,9 +39920,9 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
   if (manifest.version !== 1 || !Array.isArray(manifest.entries)) {
     throw new Error("artifact_input_manifest_invalid: expected version 1 entries array");
   }
-  const targetRoot = join25(workspace.cwd, "input-artifacts");
+  const targetRoot = join26(workspace.cwd, "input-artifacts");
   rmSync12(targetRoot, { recursive: true, force: true });
-  mkdirSync13(targetRoot, { recursive: true });
+  mkdirSync14(targetRoot, { recursive: true });
   const usedPaths = /* @__PURE__ */ new Set();
   const materialized = [];
   for (const [index, rawEntry] of manifest.entries.entries()) {
@@ -39779,18 +39951,18 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
       id: attachmentId,
       originalFilename: readString(entry.originalFilename)
     }, index);
-    let relativePath = join25("input-artifacts", sourceDir, filename).split(/[\\/]+/).join("/");
+    let relativePath = join26("input-artifacts", sourceDir, filename).split(/[\\/]+/).join("/");
     if (usedPaths.has(relativePath)) {
       const ext = extname3(filename);
       const stem = ext ? filename.slice(0, -ext.length) : filename;
       filename = `${stem}-${index + 1}${ext}`;
-      relativePath = join25("input-artifacts", sourceDir, filename).split(/[\\/]+/).join("/");
+      relativePath = join26("input-artifacts", sourceDir, filename).split(/[\\/]+/).join("/");
     }
     usedPaths.add(relativePath);
-    const targetPath = join25(workspace.cwd, relativePath);
-    mkdirSync13(dirname13(targetPath), { recursive: true });
-    writeFileSync14(targetPath, body);
-    chmodSync8(targetPath, 292);
+    const targetPath = join26(workspace.cwd, relativePath);
+    mkdirSync14(dirname14(targetPath), { recursive: true });
+    writeFileSync15(targetPath, body);
+    chmodSync9(targetPath, 292);
     materialized.push({
       id: attachmentId,
       workProductId,
@@ -39809,9 +39981,9 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
     version: 1,
     entries: materialized.map(({ path: _path, relativePath, ...entry }) => ({ ...entry, path: relativePath }))
   };
-  const manifestPath = join25(targetRoot, "artifact-input-manifest.json");
-  writeFileSync14(manifestPath, JSON.stringify(localManifest, null, 2) + "\n");
-  chmodSync8(manifestPath, 292);
+  const manifestPath = join26(targetRoot, "artifact-input-manifest.json");
+  writeFileSync15(manifestPath, JSON.stringify(localManifest, null, 2) + "\n");
+  chmodSync9(manifestPath, 292);
   updateWorkspaceManifest(workspaceManifestPath(workspace), { artifactInputManifest: localManifest });
   return materialized;
 }
@@ -39822,9 +39994,9 @@ async function materializeMentionedArtifactFiles(config, command, workspace) {
   const runtimeAuth = commandRuntimeAuth(command);
   const files = Array.isArray(mention.files) ? mention.files : [];
   if (files.length === 0 || !readString(runtimeAuth.apiUrl) || !readString(runtimeAuth.apiKey)) return empty;
-  const targetDir = join25(workspace.cwd, "input-artifacts", "mentioned");
+  const targetDir = join26(workspace.cwd, "input-artifacts", "mentioned");
   rmSync12(targetDir, { recursive: true, force: true });
-  mkdirSync13(targetDir, { recursive: true });
+  mkdirSync14(targetDir, { recursive: true });
   const usedFilenames = /* @__PURE__ */ new Set();
   const materialized = [];
   const skipped = [];
@@ -39868,9 +40040,9 @@ async function materializeMentionedArtifactFiles(config, command, workspace) {
     }, index);
     filename = dedupeMaterializedFilename(filename, index, usedFilenames);
     usedFilenames.add(filename);
-    const targetPath = join25(targetDir, filename);
-    writeFileSync14(targetPath, body);
-    chmodSync8(targetPath, 292);
+    const targetPath = join26(targetDir, filename);
+    writeFileSync15(targetPath, body);
+    chmodSync9(targetPath, 292);
     materialized.push({
       id: artifactId,
       name: readString(entry.title) ?? readString(entry.originalFilename) ?? filename,
@@ -39886,7 +40058,7 @@ async function materializeMentionedArtifactFiles(config, command, workspace) {
   return { materialized, skipped };
 }
 function issueCheckpointDir(workspace) {
-  return join25(dirname13(workspace.runDir), "checkpoint");
+  return join26(dirname14(workspace.runDir), "checkpoint");
 }
 async function clearIssueCheckpoint(config, command, workspace, reason, consumedSource = null) {
   const checkpointDir = issueCheckpointDir(workspace);
@@ -39896,7 +40068,7 @@ async function clearIssueCheckpoint(config, command, workspace, reason, consumed
     if (!sourceRunId) return false;
     let manifest;
     try {
-      manifest = asRecord(JSON.parse(readFileSync20(join25(checkpointDir, "manifest.json"), "utf8")));
+      manifest = asRecord(JSON.parse(readFileSync21(join26(checkpointDir, "manifest.json"), "utf8")));
     } catch {
       return false;
     }
@@ -39915,7 +40087,7 @@ function safeCheckpointRelativePath(rawPath) {
   return normalized;
 }
 function hashFileSha256(filePath) {
-  return createHash20("sha256").update(readFileSync20(filePath)).digest("hex");
+  return createHash20("sha256").update(readFileSync21(filePath)).digest("hex");
 }
 function expectedContinuationCheckpoint(command) {
   const payload = asRecord(command.payload);
@@ -39941,7 +40113,7 @@ function expectedContinuationCheckpoint(command) {
 }
 async function materializeIssueCheckpoint(config, command, workspace) {
   const checkpointDir = issueCheckpointDir(workspace);
-  const manifestPath = join25(checkpointDir, "manifest.json");
+  const manifestPath = join26(checkpointDir, "manifest.json");
   const expectedContinuation = expectedContinuationCheckpoint(command);
   const nativeRequest = asRecord(asRecord(command.payload).nativeSession);
   let portableNativeSession;
@@ -39971,7 +40143,7 @@ async function materializeIssueCheckpoint(config, command, workspace) {
   }
   let manifest;
   try {
-    manifest = asRecord(JSON.parse(readFileSync20(manifestPath, "utf8")));
+    manifest = asRecord(JSON.parse(readFileSync21(manifestPath, "utf8")));
   } catch (err) {
     rmSync12(checkpointDir, { recursive: true, force: true });
     throw new Error(`invalid issue checkpoint manifest: ${err instanceof Error ? err.message : String(err)}`);
@@ -40002,7 +40174,7 @@ async function materializeIssueCheckpoint(config, command, workspace) {
         throw new Error("continuation_checkpoint_lineage_mismatch");
       }
     }
-    const filesRoot = files.length > 0 ? realpathSync12(join25(checkpointDir, "files")) : null;
+    const filesRoot = files.length > 0 ? realpathSync12(join26(checkpointDir, "files")) : null;
     const workspaceRoot = realpathSync12(workspace.cwd);
     const validated = [];
     let totalBytes = 0;
@@ -40010,8 +40182,8 @@ async function materializeIssueCheckpoint(config, command, workspace) {
       const file = asRecord(rawFile);
       const relativePath = safeCheckpointRelativePath(readString(file.path));
       if (!relativePath) throw new Error("issue checkpoint manifest contains an invalid file path");
-      const sourceCandidate = resolve19(filesRoot, relativePath);
-      const target = resolve19(workspaceRoot, relativePath);
+      const sourceCandidate = resolve20(filesRoot, relativePath);
+      const target = resolve20(workspaceRoot, relativePath);
       if (!pathWithin3(sourceCandidate, filesRoot) || !pathWithin3(target, workspaceRoot)) {
         throw new Error(`issue checkpoint path escapes its workspace: ${relativePath}`);
       }
@@ -40040,14 +40212,14 @@ async function materializeIssueCheckpoint(config, command, workspace) {
     }
     const materialized = [];
     for (const { relativePath, source, target, expectedSha256, expectedByteSize } of validated) {
-      mkdirSync13(dirname13(target), { recursive: true });
-      const targetParent = realpathSync12(dirname13(target));
+      mkdirSync14(dirname14(target), { recursive: true });
+      const targetParent = realpathSync12(dirname14(target));
       if (!pathWithin3(targetParent, workspaceRoot)) {
         throw new Error(`issue checkpoint target escapes its workspace: ${relativePath}`);
       }
       let existingTarget = null;
       try {
-        existingTarget = lstatSync15(target);
+        existingTarget = lstatSync16(target);
       } catch (err) {
         if (err?.code !== "ENOENT") throw err;
       }
@@ -40058,14 +40230,14 @@ async function materializeIssueCheckpoint(config, command, workspace) {
         materialized.push(relativePath);
         continue;
       }
-      const temporaryTarget = join25(targetParent, `.${basename8(target)}.checkpoint-${randomUUID2()}.tmp`);
+      const temporaryTarget = join26(targetParent, `.${basename8(target)}.checkpoint-${randomUUID3()}.tmp`);
       try {
         copyFileSync2(source, temporaryTarget);
-        const temporaryStat = lstatSync15(temporaryTarget);
+        const temporaryStat = lstatSync16(temporaryTarget);
         if (!temporaryStat.isFile() || temporaryStat.size !== expectedByteSize || hashFileSha256(temporaryTarget) !== expectedSha256) {
           throw new Error(`issue checkpoint target verification failed: ${relativePath}`);
         }
-        renameSync11(temporaryTarget, target);
+        renameSync12(temporaryTarget, target);
       } finally {
         rmSync12(temporaryTarget, { force: true });
       }
@@ -40091,13 +40263,13 @@ async function materializeIssueCheckpoint(config, command, workspace) {
 }
 async function saveIssueCheckpoint(config, command, workspace, candidates, options = {}) {
   const checkpointDir = issueCheckpointDir(workspace);
-  const commandKey = readString(command.commandId)?.replace(/[^A-Za-z0-9_-]/g, "-") ?? randomUUID2();
+  const commandKey = readString(command.commandId)?.replace(/[^A-Za-z0-9_-]/g, "-") ?? randomUUID3();
   const stagingDir = `${checkpointDir}.tmp-${commandKey}`;
   const backupDir = `${checkpointDir}.previous-${commandKey}`;
-  const filesDir = join25(stagingDir, "files");
+  const filesDir = join26(stagingDir, "files");
   rmSync12(stagingDir, { recursive: true, force: true });
   rmSync12(backupDir, { recursive: true, force: true });
-  mkdirSync13(filesDir, { recursive: true });
+  mkdirSync14(filesDir, { recursive: true });
   try {
     const files = [];
     let totalBytes = 0;
@@ -40108,13 +40280,13 @@ async function saveIssueCheckpoint(config, command, workspace, candidates, optio
       if (!normalized) {
         throw new Error(`continuation_checkpoint_file_unavailable: ${requiredPath}`);
       }
-      const sourceCandidate = resolve19(workspaceRoot, normalized);
+      const sourceCandidate = resolve20(workspaceRoot, normalized);
       if (!pathWithin3(sourceCandidate, workspaceRoot)) {
         throw new Error(`continuation_checkpoint_file_unavailable: ${requiredPath}`);
       }
       let sourceStat;
       try {
-        sourceStat = lstatSync15(sourceCandidate);
+        sourceStat = lstatSync16(sourceCandidate);
       } catch (err) {
         if (err?.code === "ENOENT") {
           throw new Error(`continuation_checkpoint_file_unavailable: ${requiredPath}`);
@@ -40146,11 +40318,11 @@ async function saveIssueCheckpoint(config, command, workspace, candidates, optio
         if (requiredPaths.length > 0 || options.taskSession) throw new Error(`continuation_checkpoint_file_size_invalid: ${relativePath}`);
         continue;
       }
-      const target = resolve19(filesDir, relativePath);
+      const target = resolve20(filesDir, relativePath);
       if (!pathWithin3(target, filesDir)) continue;
-      mkdirSync13(dirname13(target), { recursive: true });
+      mkdirSync14(dirname14(target), { recursive: true });
       copyFileSync2(ownedSource, target);
-      const storedStat = lstatSync15(target);
+      const storedStat = lstatSync16(target);
       if (!storedStat.isFile() || storedStat.size !== byteSize) {
         throw new Error(`issue checkpoint copy verification failed: ${relativePath}`);
       }
@@ -40184,15 +40356,15 @@ async function saveIssueCheckpoint(config, command, workspace, candidates, optio
       totalBytes,
       files
     };
-    writeFileSync14(join25(stagingDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    writeFileSync15(join26(stagingDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
     const replacingExistingCheckpoint = existsSync18(checkpointDir);
-    if (replacingExistingCheckpoint) renameSync11(checkpointDir, backupDir);
+    if (replacingExistingCheckpoint) renameSync12(checkpointDir, backupDir);
     try {
-      renameSync11(stagingDir, checkpointDir);
+      renameSync12(stagingDir, checkpointDir);
     } catch (err) {
       if (replacingExistingCheckpoint && existsSync18(backupDir) && !existsSync18(checkpointDir)) {
-        renameSync11(backupDir, checkpointDir);
+        renameSync12(backupDir, checkpointDir);
       }
       throw err;
     }
@@ -40519,7 +40691,7 @@ async function executeRunCommand(config, command) {
           executorCommand: invocation.command,
           executorHome: workspace.executorHome,
           runDir: workspace.runDir,
-          runtimeCacheRoot: join25(dirname13(config.daemonStateFile), "cache"),
+          runtimeCacheRoot: join26(dirname14(config.daemonStateFile), "cache"),
           cwd,
           runtimeAuth: commandRuntimeAuth(command),
           nativeSession: asRecord(asRecord(executionCommand.payload).nativeSession),
@@ -40614,7 +40786,7 @@ async function executeRunCommand(config, command) {
       const sharedPiHome = readString(process.env.PI_CODING_AGENT_DIR) ?? readString(process.env.PI_AGENT_HOME) ?? null;
       let agentDir = managedMcpProfile ? readString(managedMcpProfile.env.PI_CODING_AGENT_DIR) ?? readString(managedMcpProfile.env.PI_AGENT_HOME) ?? null : desktopDelegatedRunnerEnabled(config) ? readString(executorEnv.PI_AGENT_HOME) ?? readString(executorEnv.PI_CODING_AGENT_DIR) ?? null : readString(executorEnv.PI_CODING_AGENT_DIR) ?? readString(executorEnv.PI_AGENT_HOME) ?? null;
       piAgentDirForContextBudget = agentDir;
-      if (agentDir && sharedPiHome && resolve19(agentDir) === resolve19(sharedPiHome)) {
+      if (agentDir && sharedPiHome && resolve20(agentDir) === resolve20(sharedPiHome)) {
         agentDir = null;
       }
       try {
@@ -41029,7 +41201,7 @@ async function executeRunCommand(config, command) {
           workspace,
           workspaceStatus.artifacts.map((artifact) => ({
             rawPath: artifact.relativePath,
-            filePath: resolve19(cwd, artifact.relativePath)
+            filePath: resolve20(cwd, artifact.relativePath)
           })),
           {
             requiredPaths: checkpointPaths,
@@ -41140,7 +41312,7 @@ async function executeRunCommand(config, command) {
           workspace,
           workspaceStatus.artifacts.map((artifact) => ({
             rawPath: artifact.relativePath,
-            filePath: resolve19(cwd, artifact.relativePath)
+            filePath: resolve20(cwd, artifact.relativePath)
           }))
         ) : readString(terminalRunDisposition?.disposition) !== "continuation_scheduled" ? await saveIssueCheckpoint(config, command, workspace, [], {
           requiredPaths: taskSessionCheckpointPaths(workspaceStatus),