@integrity-labs/agt-cli 0.28.677 → 0.28.679

package/dist/{chunk-HTLUHAKN.js → chunk-CLNFPTVG.js}

@@ -12,7 +12,7 @@ import {
   parseEnvFileEntries,
   parseEnvIntegrations,
   shellQuote
-} from "./chunk-F6CUSDJ6.js";
+} from "./chunk-HLJKOJVJ.js";
 import {
   BIND_FAILURE_QUARANTINE_THRESHOLD,
   INTEGRATIONS_SECTION_END,
@@ -59,7 +59,7 @@ import {
   resolveConnectivityProbe,
   worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "./chunk-GYYEUNTD.js";
+} from "./chunk-GDT7JHV6.js";
 import {
   parsePsRows
 } from "./chunk-XWVM4KPK.js";
@@ -369,6 +369,144 @@ function formatMirrorMismatch(m) {
   return `[mcp-mirror] [parity-violation] server=${m.server} field=${m.field} location=${m.location} reason=${m.reason}`;
 }
 
+// ../../packages/core/dist/provisioning/secret-file-tmpfs.js
+import { statfsSync, accessSync, constants as fsConstants, lstatSync, readlinkSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync, chmodSync as chmodSync2, rmSync, symlinkSync } from "fs";
+import { dirname, join } from "path";
+var SECRET_FILE_MODE = 384;
+var TMPFS_MAGIC = 16914836;
+var DEFAULT_TMPFS_CANDIDATES = ["/dev/shm", "/run"];
+var TMPFS_SECRETS_SUBDIR = "augmented-secrets";
+var backingEnabled = false;
+var cachedBase;
+var baseOverride;
+function setSecretFileTmpfsBacking(enabled) {
+  backingEnabled = enabled;
+}
+function isSecretFileTmpfsBackingEnabled() {
+  return backingEnabled;
+}
+function resolveTmpfsBase(candidates = DEFAULT_TMPFS_CANDIDATES) {
+  if (baseOverride !== void 0)
+    return baseOverride;
+  if (cachedBase !== void 0)
+    return cachedBase;
+  cachedBase = null;
+  for (const cand of candidates) {
+    try {
+      if (Number(statfsSync(cand).type) !== TMPFS_MAGIC)
+        continue;
+      accessSync(cand, fsConstants.W_OK);
+      cachedBase = cand;
+      break;
+    } catch {
+    }
+  }
+  return cachedBase;
+}
+function ensureSafeSecretsRoot(base) {
+  const root = join(base, TMPFS_SECRETS_SUBDIR);
+  try {
+    mkdirSync(root, { recursive: true, mode: 448 });
+  } catch {
+    return null;
+  }
+  let st;
+  try {
+    st = lstatSync(root);
+  } catch {
+    return null;
+  }
+  if (st.isSymbolicLink() || !st.isDirectory())
+    return null;
+  const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
+  if (uid !== void 0 && st.uid !== uid)
+    return null;
+  if ((st.mode & 63) !== 0) {
+    try {
+      chmodSync2(root, 448);
+      if ((lstatSync(root).mode & 63) !== 0)
+        return null;
+    } catch {
+      return null;
+    }
+  }
+  return root;
+}
+function ensureSecretFileTmpfsBacked(persistentPath, tmpfsTarget, mode = SECRET_FILE_MODE) {
+  mkdirSync(dirname(tmpfsTarget), { recursive: true, mode: 448 });
+  let migratedContent = null;
+  try {
+    const st = lstatSync(persistentPath);
+    if (st.isSymbolicLink()) {
+      if (readlinkSync(persistentPath) === tmpfsTarget) {
+        return { backed: true, migrated: false };
+      }
+      rmSync(persistentPath, { force: true });
+    } else {
+      try {
+        migratedContent = readFileSync2(persistentPath, "utf-8");
+      } catch {
+        migratedContent = null;
+      }
+      rmSync(persistentPath, { force: true });
+    }
+  } catch {
+  }
+  if (migratedContent !== null) {
+    let targetEmpty = true;
+    try {
+      targetEmpty = readFileSync2(tmpfsTarget, "utf-8").length === 0;
+    } catch {
+      targetEmpty = true;
+    }
+    if (targetEmpty)
+      writeFileSync2(tmpfsTarget, migratedContent, { mode });
+  }
+  mkdirSync(dirname(persistentPath), { recursive: true });
+  symlinkSync(tmpfsTarget, persistentPath);
+  return { backed: true, migrated: migratedContent !== null };
+}
+function ensureSecretFileNotTmpfsBacked(persistentPath) {
+  let st;
+  try {
+    st = lstatSync(persistentPath);
+  } catch {
+    return false;
+  }
+  if (!st.isSymbolicLink())
+    return false;
+  let ramTarget = null;
+  try {
+    ramTarget = readlinkSync(persistentPath);
+  } catch {
+    ramTarget = null;
+  }
+  rmSync(persistentPath, { force: true });
+  if (ramTarget !== null) {
+    try {
+      rmSync(ramTarget, { force: true });
+    } catch {
+    }
+  }
+  return true;
+}
+function ensureAgentSecretFilesTmpfsBacked(agentDir, projectDir, agentKey) {
+  const base = resolveTmpfsBase();
+  if (base === null)
+    return false;
+  const root = ensureSafeSecretsRoot(base);
+  if (root === null)
+    return false;
+  const agentRamDir = join(root, agentKey);
+  ensureSecretFileTmpfsBacked(join(agentDir, ".env.integrations"), join(agentRamDir, "env.integrations"));
+  ensureSecretFileTmpfsBacked(join(projectDir, ".env.integrations"), join(agentRamDir, "project.env.integrations"));
+  return true;
+}
+function ensureAgentSecretFilesNotTmpfsBacked(agentDir, projectDir) {
+  ensureSecretFileNotTmpfsBacked(join(agentDir, ".env.integrations"));
+  ensureSecretFileNotTmpfsBacked(join(projectDir, ".env.integrations"));
+}
+
 // ../../packages/core/dist/provisioning/hook-env.js
 function augmentedHookPath(currentPath) {
   const extras = [
@@ -409,15 +547,15 @@ function extractCommandNotFound(stderr) {
 }
 
 // ../../packages/core/dist/provisioning/frameworks/claudecode/index.js
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, existsSync as existsSync4, chmodSync as chmodSync4, readdirSync, rmSync as rmSync2, copyFileSync, lstatSync, realpathSync, symlinkSync, readlinkSync, renameSync as renameSync4, opendirSync } from "fs";
-import { join as join3, relative, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync4, chmodSync as chmodSync5, readdirSync, rmSync as rmSync3, copyFileSync, lstatSync as lstatSync2, realpathSync, symlinkSync as symlinkSync2, readlinkSync as readlinkSync2, renameSync as renameSync4, opendirSync } from "fs";
+import { join as join4, relative, dirname as dirname4, basename } from "path";
 import { homedir as homedir3 } from "os";
 import { execFile } from "child_process";
 
 // ../../packages/core/dist/integrations/xurl-config.js
-import { chmodSync as chmodSync2, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { chmodSync as chmodSync3, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
 import { homedir } from "os";
-import { dirname, join } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 var XURL_FILE_MODE = 384;
 var XURL_AGT_APP_PREFIX = "agt-";
@@ -536,7 +674,7 @@ function buildAgtXurlApps(integrations) {
 }
 function getXurlStorePath() {
   const home = process.env["HOME"] ?? process.env["USERPROFILE"] ?? homedir();
-  return join(home, ".xurl");
+  return join2(home, ".xurl");
 }
 function writeXurlStoreForIntegrations(integrations, filePath = getXurlStorePath()) {
   const agtApps = buildAgtXurlApps(integrations);
@@ -546,7 +684,7 @@ function writeXurlStoreForIntegrations(integrations, filePath = getXurlStorePath
   if (existsSync2(filePath)) {
     let raw;
     try {
-      raw = readFileSync2(filePath, "utf-8");
+      raw = readFileSync3(filePath, "utf-8");
     } catch {
       return null;
     }
@@ -557,9 +695,9 @@ function writeXurlStoreForIntegrations(integrations, filePath = getXurlStorePath
     existing = parsed;
   }
   const merged = mergeXurlStore(existing, agtApps);
-  mkdirSync(dirname(filePath), { recursive: true });
+  mkdirSync2(dirname2(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  writeFileSync2(tmpPath, serializeXurlStore(merged), { mode: XURL_FILE_MODE });
+  writeFileSync3(tmpPath, serializeXurlStore(merged), { mode: XURL_FILE_MODE });
   try {
     renameSync2(tmpPath, filePath);
   } catch (err) {
@@ -570,16 +708,16 @@ function writeXurlStoreForIntegrations(integrations, filePath = getXurlStorePath
     throw err;
   }
   try {
-    chmodSync2(filePath, XURL_FILE_MODE);
+    chmodSync3(filePath, XURL_FILE_MODE);
   } catch {
   }
   return filePath;
 }
 
 // ../../packages/core/dist/integrations/framer-credentials.js
-import { chmodSync as chmodSync3, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync as renameSync3, rmSync, statSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
+import { chmodSync as chmodSync4, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync3, rmSync as rmSync2, statSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname as dirname3, join as join3 } from "path";
 var FRAMER_PROJECTS_CONFIG_VERSION = 2;
 var BARE_PROJECT_ID = /^[A-Za-z0-9]{20}$/u;
 var SLUGGED_PROJECT_ID = /^.+--([A-Za-z0-9]+)/u;
@@ -678,11 +816,11 @@ function mergeFramerProjectsConfig(existing, inputs, options = {}) {
 var FRAMER_FILE_MODE = 384;
 var MANAGED_SIDECAR_NAME = ".augmented-managed-projects.json";
 function sidecarPathFor(projectsPath) {
-  return join2(dirname2(projectsPath), MANAGED_SIDECAR_NAME);
+  return join3(dirname3(projectsPath), MANAGED_SIDECAR_NAME);
 }
 function readManagedIds(projectsPath) {
   try {
-    const raw = readFileSync3(sidecarPathFor(projectsPath), "utf-8");
+    const raw = readFileSync4(sidecarPathFor(projectsPath), "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed))
       return [];
@@ -701,7 +839,7 @@ function writeManagedIds(projectsPath, ids) {
       }
       return;
     }
-    writeFileSync3(target, `${JSON.stringify([...ids].sort(), null, "	")}
+    writeFileSync4(target, `${JSON.stringify([...ids].sort(), null, "	")}
 `, {
       mode: FRAMER_FILE_MODE
     });
@@ -714,18 +852,18 @@ var LOCK_MAX_ATTEMPTS = 50;
 function withStoreLock(projectsPath, fn) {
   const lockDir = `${projectsPath}.lock`;
   try {
-    mkdirSync2(dirname2(projectsPath), { recursive: true, mode: 448 });
+    mkdirSync3(dirname3(projectsPath), { recursive: true, mode: 448 });
   } catch {
   }
   let held = false;
   for (let attempt = 0; attempt < LOCK_MAX_ATTEMPTS && !held; attempt++) {
     try {
-      mkdirSync2(lockDir);
+      mkdirSync3(lockDir);
       held = true;
     } catch {
       try {
         if (Date.now() - statSync(lockDir).mtimeMs > LOCK_STALE_MS) {
-          rmSync(lockDir, { recursive: true, force: true });
+          rmSync2(lockDir, { recursive: true, force: true });
           continue;
         }
       } catch {
@@ -743,7 +881,7 @@ function withStoreLock(projectsPath, fn) {
     return { acquired: true, value: fn() };
   } finally {
     try {
-      rmSync(lockDir, { recursive: true, force: true });
+      rmSync2(lockDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -754,9 +892,9 @@ function asString2(value) {
 function getFramerProjectsPath() {
   const xdg = process.env["XDG_CONFIG_HOME"];
   if (xdg)
-    return join2(xdg, "framer", "projects.json");
+    return join3(xdg, "framer", "projects.json");
   const home = process.env["HOME"] ?? process.env["USERPROFILE"] ?? homedir2();
-  return join2(home, ".config", "framer", "projects.json");
+  return join3(home, ".config", "framer", "projects.json");
 }
 function buildFramerCredentialInputs(integrations) {
   const inputs = [];
@@ -787,7 +925,7 @@ function writeFramerStoreForIntegrations(integrations, filePath = getFramerProje
     let existing = null;
     if (existsSync3(filePath)) {
       try {
-        existing = readFileSync3(filePath, "utf-8");
+        existing = readFileSync4(filePath, "utf-8");
       } catch {
         return null;
       }
@@ -799,9 +937,9 @@ function writeFramerStoreForIntegrations(integrations, filePath = getFramerProje
     }
     if (!content)
       return null;
-    mkdirSync2(dirname2(filePath), { recursive: true, mode: 448 });
+    mkdirSync3(dirname3(filePath), { recursive: true, mode: 448 });
     const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-    writeFileSync3(tmpPath, content, { mode: FRAMER_FILE_MODE });
+    writeFileSync4(tmpPath, content, { mode: FRAMER_FILE_MODE });
     try {
       renameSync3(tmpPath, filePath);
     } catch (err) {
@@ -812,7 +950,7 @@ function writeFramerStoreForIntegrations(integrations, filePath = getFramerProje
       throw err;
     }
     try {
-      chmodSync3(filePath, FRAMER_FILE_MODE);
+      chmodSync4(filePath, FRAMER_FILE_MODE);
     } catch {
     }
     writeManagedIds(filePath, written);
@@ -1511,30 +1649,45 @@ main().catch((err) => fail(err && err.message ? err.message : String(err)));
 
 // ../../packages/core/dist/provisioning/frameworks/claudecode/index.js
 var VALID_CODE_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var SECRET_FILE_MODE = 384;
+var SECRET_FILE_MODE2 = 384;
 function writeEnvIntegrationsForAgent(codeName, args) {
   const agentDir = getAgentDir(codeName);
-  const envPath = join3(agentDir, ".env.integrations");
+  const envPath = join4(agentDir, ".env.integrations");
   let existing = null;
   try {
-    existing = readFileSync4(envPath, "utf-8");
+    existing = readFileSync5(envPath, "utf-8");
   } catch {
   }
   if (existing === null && Object.keys(args.updates).length === 0)
     return;
+  if (isSecretFileTmpfsBackingEnabled()) {
+    try {
+      ensureAgentSecretFilesTmpfsBacked(agentDir, join4(agentDir, "project"), basename(agentDir));
+    } catch (err) {
+      process.stderr.write(`[env-integrations] [tmpfs-backing-failed] agent=${codeName} error=${err.message}
+`);
+    }
+  } else {
+    try {
+      ensureAgentSecretFilesNotTmpfsBacked(agentDir, join4(agentDir, "project"));
+    } catch (err) {
+      process.stderr.write(`[env-integrations] [tmpfs-revert-failed] agent=${codeName} error=${err.message}
+`);
+    }
+  }
   const content = mergeEnvIntegrationsContent(existing, args);
-  writeFileSync4(envPath, content, { mode: SECRET_FILE_MODE });
+  writeFileSync5(envPath, content, { mode: SECRET_FILE_MODE2 });
   try {
-    chmodSync4(envPath, SECRET_FILE_MODE);
+    chmodSync5(envPath, SECRET_FILE_MODE2);
   } catch {
   }
   try {
     const projectDir = getProjectDir(codeName);
-    mkdirSync3(projectDir, { recursive: true });
-    const dest = join3(projectDir, ".env.integrations");
-    writeFileSync4(dest, content, { mode: SECRET_FILE_MODE });
+    mkdirSync4(projectDir, { recursive: true });
+    const dest = join4(projectDir, ".env.integrations");
+    writeFileSync5(dest, content, { mode: SECRET_FILE_MODE2 });
     try {
-      chmodSync4(dest, SECRET_FILE_MODE);
+      chmodSync5(dest, SECRET_FILE_MODE2);
     } catch {
     }
   } catch (err) {
@@ -1552,16 +1705,16 @@ var MIGRATABLE_FIELD_TO_ENV_VAR = {
   AGT_API_KEY: "AGT_API_KEY"
 };
 function migrateExistingLiteralSecrets(codeName) {
-  const mcpJsonPath = join3(getAgentDir(codeName), "provision", ".mcp.json");
+  const mcpJsonPath = join4(getAgentDir(codeName), "provision", ".mcp.json");
   let config;
   try {
-    config = JSON.parse(readFileSync4(mcpJsonPath, "utf-8"));
+    config = JSON.parse(readFileSync5(mcpJsonPath, "utf-8"));
   } catch {
     return;
   }
   let existingEnvKeys = /* @__PURE__ */ new Set();
   try {
-    existingEnvKeys = new Set(parseEnvFileEntries(readFileSync4(join3(getAgentDir(codeName), ".env.integrations"), "utf-8")).keys());
+    existingEnvKeys = new Set(parseEnvFileEntries(readFileSync5(join4(getAgentDir(codeName), ".env.integrations"), "utf-8")).keys());
   } catch {
   }
   const updates = {};
@@ -1649,7 +1802,7 @@ function assertValidAgentId(agentId) {
 }
 function resolveRealAgentPath(codeNamePath) {
   try {
-    if (lstatSync(codeNamePath).isSymbolicLink()) {
+    if (lstatSync2(codeNamePath).isSymbolicLink()) {
       return realpathSync(codeNamePath);
     }
   } catch {
@@ -1660,11 +1813,11 @@ function ensureIdKeyedLayout(codeName, agentId) {
   assertValidCodeName(codeName);
   assertValidAgentId(agentId);
   const home = getHomeDir();
-  const codeNamePath = join3(home, ".augmented", codeName);
-  const idPath = join3(home, ".augmented", agentId);
+  const codeNamePath = join4(home, ".augmented", codeName);
+  const idPath = join4(home, ".augmented", agentId);
   let state;
   try {
-    state = lstatSync(codeNamePath).isSymbolicLink() ? "symlink" : "realdir";
+    state = lstatSync2(codeNamePath).isSymbolicLink() ? "symlink" : "realdir";
   } catch {
     state = "absent";
   }
@@ -1672,30 +1825,30 @@ function ensureIdKeyedLayout(codeName, agentId) {
     return codeNamePath;
   }
   if (state === "symlink") {
-    const target = readlinkSync(codeNamePath);
+    const target = readlinkSync2(codeNamePath);
     if (target !== agentId) {
       throw new Error(`Codename symlink ${codeNamePath} points at "${target}", expected "${agentId}"; refusing to provision over a mismatched id-keyed layout.`);
     }
-    mkdirSync3(idPath, { recursive: true });
+    mkdirSync4(idPath, { recursive: true });
     return idPath;
   }
-  mkdirSync3(idPath, { recursive: true });
-  symlinkSync(agentId, codeNamePath);
+  mkdirSync4(idPath, { recursive: true });
+  symlinkSync2(agentId, codeNamePath);
   return idPath;
 }
 function stagedMigrationLinkPath(home, codeName) {
-  return join3(home, ".augmented", `.${codeName}.migrating`);
+  return join4(home, ".augmented", `.${codeName}.migrating`);
 }
 function cleanupStaleStagedLink(staged) {
   try {
-    if (lstatSync(staged).isSymbolicLink())
-      rmSync2(staged, { force: true });
+    if (lstatSync2(staged).isSymbolicLink())
+      rmSync3(staged, { force: true });
   } catch {
   }
 }
 function isSymlinkTo(path, target) {
   try {
-    return lstatSync(path).isSymbolicLink() && readlinkSync(path) === target;
+    return lstatSync2(path).isSymbolicLink() && readlinkSync2(path) === target;
   } catch {
     return false;
   }
@@ -1704,18 +1857,18 @@ function migrateAgentDirToIdKeyed(codeName, agentId, opts = {}) {
   assertValidCodeName(codeName);
   assertValidAgentId(agentId);
   const home = opts.home ?? getHomeDir();
-  const codeNamePath = join3(home, ".augmented", codeName);
-  const idPath = join3(home, ".augmented", agentId);
+  const codeNamePath = join4(home, ".augmented", codeName);
+  const idPath = join4(home, ".augmented", agentId);
   const staged = stagedMigrationLinkPath(home, codeName);
   let codeNameKind;
   try {
-    codeNameKind = lstatSync(codeNamePath).isSymbolicLink() ? "symlink" : "realdir";
+    codeNameKind = lstatSync2(codeNamePath).isSymbolicLink() ? "symlink" : "realdir";
   } catch {
     codeNameKind = "absent";
   }
   const idExists = existsSync4(idPath);
   if (codeNameKind === "symlink") {
-    const target = readlinkSync(codeNamePath);
+    const target = readlinkSync2(codeNamePath);
     if (target !== agentId) {
       throw new Error(`Codename symlink ${codeNamePath} points at "${target}", expected "${agentId}"; refusing to migrate.`);
     }
@@ -1726,7 +1879,7 @@ function migrateAgentDirToIdKeyed(codeName, agentId, opts = {}) {
       renameSync4(staged, codeNamePath);
     } else {
       cleanupStaleStagedLink(staged);
-      symlinkSync(agentId, codeNamePath);
+      symlinkSync2(agentId, codeNamePath);
     }
     return "recovered";
   }
@@ -1736,21 +1889,21 @@ function migrateAgentDirToIdKeyed(codeName, agentId, opts = {}) {
     return "conflict";
   }
   cleanupStaleStagedLink(staged);
-  symlinkSync(agentId, staged);
+  symlinkSync2(agentId, staged);
   renameSync4(codeNamePath, idPath);
   renameSync4(staged, codeNamePath);
   return "migrated";
 }
 function getAgentDir(codeName) {
   assertValidCodeName(codeName);
-  return resolveRealAgentPath(join3(getHomeDir(), ".augmented", codeName));
+  return resolveRealAgentPath(join4(getHomeDir(), ".augmented", codeName));
 }
 var migratedCodeNames = /* @__PURE__ */ new Set();
 function migrateLegacyClaudecodeDir(codeName, log2) {
   assertValidCodeName(codeName);
   if (migratedCodeNames.has(codeName))
     return;
-  const legacyRoot = join3(getHomeDir(), ".augmented", codeName, "claudecode");
+  const legacyRoot = join4(getHomeDir(), ".augmented", codeName, "claudecode");
   if (!existsSync4(legacyRoot)) {
     migratedCodeNames.add(codeName);
     return;
@@ -1761,20 +1914,20 @@ function migrateLegacyClaudecodeDir(codeName, log2) {
   };
   try {
     const walkAndMigrate = (srcDir, destDir) => {
-      mkdirSync3(destDir, { recursive: true });
+      mkdirSync4(destDir, { recursive: true });
       for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
-        const src = join3(srcDir, entry.name);
-        const dest = join3(destDir, entry.name);
+        const src = join4(srcDir, entry.name);
+        const dest = join4(destDir, entry.name);
         if (entry.isDirectory()) {
           walkAndMigrate(src, dest);
           continue;
         }
         if (entry.name === ".mcp.json" && existsSync4(dest)) {
           try {
-            const oldCfg = JSON.parse(readFileSync4(src, "utf-8"));
-            const newCfg = JSON.parse(readFileSync4(dest, "utf-8"));
+            const oldCfg = JSON.parse(readFileSync5(src, "utf-8"));
+            const newCfg = JSON.parse(readFileSync5(dest, "utf-8"));
             const merged = { mcpServers: { ...oldCfg.mcpServers ?? {}, ...newCfg.mcpServers ?? {} } };
-            writeFileSync4(dest, JSON.stringify(merged, null, 2));
+            writeFileSync5(dest, JSON.stringify(merged, null, 2));
             emit(`[migrate] '${codeName}' merged .mcp.json (${Object.keys(merged.mcpServers).length} servers)`);
           } catch (err) {
             throw new Error(`Failed merging .mcp.json (${src} \u2192 ${dest}): ${err.message}`);
@@ -1786,8 +1939,8 @@ function migrateLegacyClaudecodeDir(codeName, log2) {
           continue;
         }
         try {
-          const srcStat = readFileSync4(src);
-          const destStat = readFileSync4(dest);
+          const srcStat = readFileSync5(src);
+          const destStat = readFileSync5(dest);
           if (!srcStat.equals(destStat)) {
           }
         } catch (err) {
@@ -1796,7 +1949,7 @@ function migrateLegacyClaudecodeDir(codeName, log2) {
       }
     };
     walkAndMigrate(legacyRoot, newRoot);
-    rmSync2(legacyRoot, { recursive: true, force: true });
+    rmSync3(legacyRoot, { recursive: true, force: true });
     emit(`[migrate] '${codeName}': collapsed ~/.augmented/${codeName}/claudecode/ into ~/.augmented/${codeName}/`);
     migratedCodeNames.add(codeName);
   } catch (err) {
@@ -1804,25 +1957,25 @@ function migrateLegacyClaudecodeDir(codeName, log2) {
   }
 }
 function syncGitHubBrokerCredentialTooling(projectDir, enabled) {
-  const binDir = join3(projectDir, GITHUB_BROKER_BIN_DIR);
+  const binDir = join4(projectDir, GITHUB_BROKER_BIN_DIR);
   if (!enabled) {
-    rmSync2(binDir, { recursive: true, force: true });
+    rmSync3(binDir, { recursive: true, force: true });
     return {};
   }
-  const helperPath = join3(binDir, GIT_CREDENTIAL_HELPER_BASENAME);
-  const shimPath = join3(binDir, GH_SHIM_BASENAME);
-  mkdirSync3(binDir, { recursive: true });
-  writeFileSync4(helperPath, renderGitCredentialHelper(), { mode: BROKER_SCRIPT_MODE });
-  chmodSync4(helperPath, BROKER_SCRIPT_MODE);
-  writeFileSync4(shimPath, renderGhShim(), { mode: BROKER_SCRIPT_MODE });
-  chmodSync4(shimPath, BROKER_SCRIPT_MODE);
+  const helperPath = join4(binDir, GIT_CREDENTIAL_HELPER_BASENAME);
+  const shimPath = join4(binDir, GH_SHIM_BASENAME);
+  mkdirSync4(binDir, { recursive: true });
+  writeFileSync5(helperPath, renderGitCredentialHelper(), { mode: BROKER_SCRIPT_MODE });
+  chmodSync5(helperPath, BROKER_SCRIPT_MODE);
+  writeFileSync5(shimPath, renderGhShim(), { mode: BROKER_SCRIPT_MODE });
+  chmodSync5(shimPath, BROKER_SCRIPT_MODE);
   return buildGitCredentialEnv(helperPath);
 }
 function getProjectDir(codeName) {
-  return join3(getAgentDir(codeName), "project");
+  return join4(getAgentDir(codeName), "project");
 }
 function getScratchDir(codeName) {
-  return join3(getAgentDir(codeName), "scratch");
+  return join4(getAgentDir(codeName), "scratch");
 }
 function getAgentTmpDir(codeName) {
   return agentTmpDirFor(getAgentDir(codeName));
@@ -1838,11 +1991,11 @@ function sweepScratchDir(codeName, now = Date.now()) {
   }
   const cutoff = now - SCRATCH_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
   for (const entry of entries) {
-    const full = join3(scratchDir, entry);
+    const full = join4(scratchDir, entry);
     try {
       if (isFreshWithin(full, cutoff))
         continue;
-      rmSync2(full, { recursive: true, force: true });
+      rmSync3(full, { recursive: true, force: true });
       removed += 1;
     } catch {
     }
@@ -1859,7 +2012,7 @@ function isFreshWithin(path, cutoff) {
     const current = queue.pop();
     let stat;
     try {
-      stat = lstatSync(current);
+      stat = lstatSync2(current);
     } catch {
       return true;
     }
@@ -1878,7 +2031,7 @@ function isFreshWithin(path, cutoff) {
         const child = dir.readSync();
         if (child === null)
           break;
-        queue.push(join3(current, child.name));
+        queue.push(join4(current, child.name));
         budget -= 1;
       }
     } catch {
@@ -1895,18 +2048,18 @@ function isFreshWithin(path, cutoff) {
 function syncMcpToProject(codeName) {
   const agentDir = getAgentDir(codeName);
   const projectDir = getProjectDir(codeName);
-  const provisionMcpPath = join3(agentDir, "provision", ".mcp.json");
-  const projectMcpPath = join3(projectDir, ".mcp.json");
+  const provisionMcpPath = join4(agentDir, "provision", ".mcp.json");
+  const projectMcpPath = join4(projectDir, ".mcp.json");
   try {
-    const content = readFileSync4(provisionMcpPath, "utf-8");
-    mkdirSync3(projectDir, { recursive: true });
-    writeFileSync4(projectMcpPath, content, { mode: MCP_FILE_MODE });
+    const content = readFileSync5(provisionMcpPath, "utf-8");
+    mkdirSync4(projectDir, { recursive: true });
+    writeFileSync5(projectMcpPath, content, { mode: MCP_FILE_MODE });
     try {
-      chmodSync4(projectMcpPath, MCP_FILE_MODE);
+      chmodSync5(projectMcpPath, MCP_FILE_MODE);
     } catch {
     }
     try {
-      const mismatches = mcpMirrorParityErrors(JSON.parse(content), JSON.parse(readFileSync4(projectMcpPath, "utf-8")));
+      const mismatches = mcpMirrorParityErrors(JSON.parse(content), JSON.parse(readFileSync5(projectMcpPath, "utf-8")));
       for (const m of mismatches) {
         process.stderr.write(`${formatMirrorMismatch(m)} agent=${codeName}
 `);
@@ -1920,19 +2073,19 @@ function syncMcpToProject(codeName) {
 }
 var INTEGRATIONS_SUMMARY_FILE = "integrations-summary.json";
 function integrationsSummaryPath(codeName) {
-  return join3(getAgentDir(codeName), "provision", INTEGRATIONS_SUMMARY_FILE);
+  return join4(getAgentDir(codeName), "provision", INTEGRATIONS_SUMMARY_FILE);
 }
 function writeIntegrationsSummaryForAgent(codeName, summaries) {
   const target = integrationsSummaryPath(codeName);
   try {
-    mkdirSync3(dirname3(target), { recursive: true });
-    writeFileSync4(target, JSON.stringify(summaries, null, 2));
+    mkdirSync4(dirname4(target), { recursive: true });
+    writeFileSync5(target, JSON.stringify(summaries, null, 2));
   } catch {
   }
 }
 function readIntegrationsSummaryForAgent(codeName) {
   try {
-    const raw = readFileSync4(integrationsSummaryPath(codeName), "utf-8");
+    const raw = readFileSync5(integrationsSummaryPath(codeName), "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed : [];
   } catch {
@@ -1942,10 +2095,10 @@ function readIntegrationsSummaryForAgent(codeName) {
 function renderChannelMessageHandlerForAgent(codeName) {
   const agentDir = getAgentDir(codeName);
   const projectDir = getProjectDir(codeName);
-  const provisionMcpPath = join3(agentDir, "provision", ".mcp.json");
+  const provisionMcpPath = join4(agentDir, "provision", ".mcp.json");
   let mcpServerKeys;
   try {
-    const config = JSON.parse(readFileSync4(provisionMcpPath, "utf-8"));
+    const config = JSON.parse(readFileSync5(provisionMcpPath, "utf-8"));
     mcpServerKeys = Object.keys(config.mcpServers ?? {});
   } catch {
     return;
@@ -1953,10 +2106,10 @@ function renderChannelMessageHandlerForAgent(codeName) {
   const integrations = readIntegrationsSummaryForAgent(codeName);
   const content = buildChannelMessageHandlerAgent({ mcpServerKeys, integrations });
   for (const baseDir of [agentDir, projectDir]) {
-    const target = join3(baseDir, ".claude", "agents", "channel-message-handler.md");
+    const target = join4(baseDir, ".claude", "agents", "channel-message-handler.md");
     try {
-      mkdirSync3(dirname3(target), { recursive: true });
-      writeFileSync4(target, content);
+      mkdirSync4(dirname4(target), { recursive: true });
+      writeFileSync5(target, content);
     } catch {
     }
   }
@@ -1971,9 +2124,9 @@ function writeMcpJsonGuarded(codeName, path, config) {
   return true;
 }
 function readExistingMcpEnvVar(codeName, serverId, envKey) {
-  const mcpJsonPath = join3(getAgentDir(codeName), "provision", ".mcp.json");
+  const mcpJsonPath = join4(getAgentDir(codeName), "provision", ".mcp.json");
   try {
-    const raw = readFileSync4(mcpJsonPath, "utf-8");
+    const raw = readFileSync5(mcpJsonPath, "utf-8");
     const config = JSON.parse(raw);
     const server = config.mcpServers?.[serverId];
     if (!server || typeof server !== "object")
@@ -2002,10 +2155,10 @@ function resolveBrokerAgentId(codeName, fallback) {
 }
 function deployArtifactsToProject(codeName, provisionDir) {
   const projectDir = getProjectDir(codeName);
-  mkdirSync3(projectDir, { recursive: true });
+  mkdirSync4(projectDir, { recursive: true });
   try {
-    mkdirSync3(getScratchDir(codeName), { recursive: true });
-    mkdirSync3(getAgentTmpDir(codeName), { recursive: true });
+    mkdirSync4(getScratchDir(codeName), { recursive: true });
+    mkdirSync4(getAgentTmpDir(codeName), { recursive: true });
     sweepScratchDir(codeName);
   } catch (err) {
     process.stderr.write(`[scratch] [ensure-or-sweep-failed] agent=${codeName} error=${err.message}
@@ -2015,42 +2168,42 @@ function deployArtifactsToProject(codeName, provisionDir) {
   const SKILLS_START = "<!-- AGT:SKILLS_INDEX_START -->";
   const SKILLS_END = "<!-- AGT:SKILLS_INDEX_END -->";
   for (const file of artifactFiles) {
-    const src = join3(provisionDir, file);
-    const dest = join3(projectDir, file);
+    const src = join4(provisionDir, file);
+    const dest = join4(projectDir, file);
     try {
-      const srcContent = readFileSync4(src, "utf-8");
+      const srcContent = readFileSync5(src, "utf-8");
       if (file === "CLAUDE.md" && existsSync4(dest)) {
-        const destContent = readFileSync4(dest, "utf-8");
+        const destContent = readFileSync5(dest, "utf-8");
         const stripIndex = (s) => s.replace(new RegExp(`${SKILLS_START}[\\s\\S]*?${SKILLS_END}`), "").trimEnd();
         if (stripIndex(srcContent) === stripIndex(destContent))
           continue;
         const indexMatch = destContent.match(new RegExp(`${SKILLS_START}[\\s\\S]*?${SKILLS_END}`));
         if (indexMatch) {
-          writeFileSync4(dest, srcContent.trimEnd() + "\n\n" + indexMatch[0] + "\n");
+          writeFileSync5(dest, srcContent.trimEnd() + "\n\n" + indexMatch[0] + "\n");
           continue;
         }
       }
       if (file === ".mcp.json") {
-        writeFileSync4(dest, srcContent, { mode: MCP_FILE_MODE });
+        writeFileSync5(dest, srcContent, { mode: MCP_FILE_MODE });
         try {
-          chmodSync4(dest, MCP_FILE_MODE);
+          chmodSync5(dest, MCP_FILE_MODE);
         } catch {
         }
       } else {
-        writeFileSync4(dest, srcContent);
+        writeFileSync5(dest, srcContent);
       }
     } catch {
     }
   }
-  const skillsDir = join3(provisionDir, ".claude", "skills");
-  const destSkillsDir = join3(projectDir, ".claude", "skills");
+  const skillsDir = join4(provisionDir, ".claude", "skills");
+  const destSkillsDir = join4(projectDir, ".claude", "skills");
   try {
     if (existsSync4(destSkillsDir)) {
       const srcFolders = existsSync4(skillsDir) ? new Set(readdirSync(skillsDir)) : /* @__PURE__ */ new Set();
       for (const folder of readdirSync(destSkillsDir)) {
         if (folder.startsWith("knowledge-") || folder === "core-knowledge" && !srcFolders.has(folder)) {
           try {
-            rmSync2(join3(destSkillsDir, folder), { recursive: true });
+            rmSync3(join4(destSkillsDir, folder), { recursive: true });
           } catch {
           }
         }
@@ -2058,25 +2211,25 @@ function deployArtifactsToProject(codeName, provisionDir) {
     }
     if (existsSync4(skillsDir)) {
       for (const skillFolder of readdirSync(skillsDir)) {
-        const srcSkillFile = join3(skillsDir, skillFolder, "SKILL.md");
+        const srcSkillFile = join4(skillsDir, skillFolder, "SKILL.md");
         if (!existsSync4(srcSkillFile))
           continue;
-        const destFolder = join3(destSkillsDir, skillFolder);
-        const destFile = join3(destFolder, "SKILL.md");
-        const srcContent = readFileSync4(srcSkillFile, "utf-8");
+        const destFolder = join4(destSkillsDir, skillFolder);
+        const destFile = join4(destFolder, "SKILL.md");
+        const srcContent = readFileSync5(srcSkillFile, "utf-8");
         try {
-          if (existsSync4(destFile) && readFileSync4(destFile, "utf-8") === srcContent)
+          if (existsSync4(destFile) && readFileSync5(destFile, "utf-8") === srcContent)
             continue;
         } catch {
         }
-        mkdirSync3(destFolder, { recursive: true });
-        writeFileSync4(destFile, srcContent);
+        mkdirSync4(destFolder, { recursive: true });
+        writeFileSync5(destFile, srcContent);
       }
     }
   } catch {
   }
-  const agentsDir = join3(provisionDir, ".claude", "agents");
-  const destAgentsDir = join3(projectDir, ".claude", "agents");
+  const agentsDir = join4(provisionDir, ".claude", "agents");
+  const destAgentsDir = join4(projectDir, ".claude", "agents");
   try {
     if (existsSync4(agentsDir)) {
       const sourceAgentFiles = new Set(readdirSync(agentsDir).filter((f) => f.endsWith(".md")));
@@ -2087,28 +2240,28 @@ function deployArtifactsToProject(codeName, provisionDir) {
           if (sourceAgentFiles.has(destFile))
             continue;
           try {
-            rmSync2(join3(destAgentsDir, destFile));
+            rmSync3(join4(destAgentsDir, destFile));
           } catch {
           }
         }
       }
       for (const agentFile of sourceAgentFiles) {
-        const srcPath = join3(agentsDir, agentFile);
-        const destPath = join3(destAgentsDir, agentFile);
-        const srcContent = readFileSync4(srcPath, "utf-8");
+        const srcPath = join4(agentsDir, agentFile);
+        const destPath = join4(destAgentsDir, agentFile);
+        const srcContent = readFileSync5(srcPath, "utf-8");
         try {
-          if (existsSync4(destPath) && readFileSync4(destPath, "utf-8") === srcContent)
+          if (existsSync4(destPath) && readFileSync5(destPath, "utf-8") === srcContent)
             continue;
         } catch {
         }
-        mkdirSync3(destAgentsDir, { recursive: true });
-        writeFileSync4(destPath, srcContent);
+        mkdirSync4(destAgentsDir, { recursive: true });
+        writeFileSync5(destPath, srcContent);
       }
     }
   } catch {
   }
-  const workflowsDir = join3(provisionDir, ".claude", "workflows");
-  const destWorkflowsDir = join3(projectDir, ".claude", "workflows");
+  const workflowsDir = join4(provisionDir, ".claude", "workflows");
+  const destWorkflowsDir = join4(projectDir, ".claude", "workflows");
   try {
     const sourceWorkflowFiles = existsSync4(workflowsDir) ? new Set(readdirSync(workflowsDir).filter((f) => f.endsWith(".js"))) : /* @__PURE__ */ new Set();
     if (existsSync4(destWorkflowsDir)) {
@@ -2118,32 +2271,32 @@ function deployArtifactsToProject(codeName, provisionDir) {
         if (sourceWorkflowFiles.has(destFile))
           continue;
         try {
-          rmSync2(join3(destWorkflowsDir, destFile));
+          rmSync3(join4(destWorkflowsDir, destFile));
         } catch {
         }
       }
     }
     for (const workflowFile of sourceWorkflowFiles) {
-      const srcPath = join3(workflowsDir, workflowFile);
-      const destPath = join3(destWorkflowsDir, workflowFile);
-      const srcContent = readFileSync4(srcPath, "utf-8");
+      const srcPath = join4(workflowsDir, workflowFile);
+      const destPath = join4(destWorkflowsDir, workflowFile);
+      const srcContent = readFileSync5(srcPath, "utf-8");
       try {
-        if (existsSync4(destPath) && readFileSync4(destPath, "utf-8") === srcContent)
+        if (existsSync4(destPath) && readFileSync5(destPath, "utf-8") === srcContent)
           continue;
       } catch {
       }
-      mkdirSync3(destWorkflowsDir, { recursive: true });
-      writeFileSync4(destPath, srcContent);
+      mkdirSync4(destWorkflowsDir, { recursive: true });
+      writeFileSync5(destPath, srcContent);
     }
   } catch {
   }
-  const agentMcpPath = join3(getAgentDir(codeName), "provision", ".mcp.json");
-  const projectMcpPath = join3(projectDir, ".mcp.json");
+  const agentMcpPath = join4(getAgentDir(codeName), "provision", ".mcp.json");
+  const projectMcpPath = join4(projectDir, ".mcp.json");
   try {
-    const agentMcp = JSON.parse(readFileSync4(agentMcpPath, "utf-8"));
+    const agentMcp = JSON.parse(readFileSync5(agentMcpPath, "utf-8"));
     let projectMcp;
     try {
-      projectMcp = JSON.parse(readFileSync4(projectMcpPath, "utf-8"));
+      projectMcp = JSON.parse(readFileSync5(projectMcpPath, "utf-8"));
     } catch {
       projectMcp = { mcpServers: {} };
     }
@@ -2154,9 +2307,9 @@ function deployArtifactsToProject(codeName, provisionDir) {
       return !(entry && typeof entry["url"] === "string" && entry["url"].startsWith("/"));
     }));
     projectMcp["mcpServers"] = { ...stripRelativeUrls(projectServers), ...stripRelativeUrls(agentServers) };
-    writeFileSync4(projectMcpPath, JSON.stringify(projectMcp, null, 2), { mode: MCP_FILE_MODE });
+    writeFileSync5(projectMcpPath, JSON.stringify(projectMcp, null, 2), { mode: MCP_FILE_MODE });
     try {
-      chmodSync4(projectMcpPath, MCP_FILE_MODE);
+      chmodSync5(projectMcpPath, MCP_FILE_MODE);
     } catch {
     }
   } catch {
@@ -2164,37 +2317,37 @@ function deployArtifactsToProject(codeName, provisionDir) {
   const agentDir = getAgentDir(codeName);
   for (const envFile of [".env", ".env.integrations"]) {
     try {
-      const content = readFileSync4(join3(agentDir, envFile), "utf-8");
-      const envDest = join3(projectDir, envFile);
-      writeFileSync4(envDest, content, { mode: SECRET_FILE_MODE });
+      const content = readFileSync5(join4(agentDir, envFile), "utf-8");
+      const envDest = join4(projectDir, envFile);
+      writeFileSync5(envDest, content, { mode: SECRET_FILE_MODE2 });
       try {
-        chmodSync4(envDest, SECRET_FILE_MODE);
+        chmodSync5(envDest, SECRET_FILE_MODE2);
       } catch {
       }
     } catch {
     }
   }
   try {
-    const gitDir = join3(projectDir, ".git");
-    const hookSrc = join3(provisionDir, ".git-hooks", "pre-commit");
+    const gitDir = join4(projectDir, ".git");
+    const hookSrc = join4(provisionDir, ".git-hooks", "pre-commit");
     if (existsSync4(gitDir) && existsSync4(hookSrc)) {
-      const hooksDir = join3(gitDir, "hooks");
-      mkdirSync3(hooksDir, { recursive: true });
-      const hookDest = join3(hooksDir, "pre-commit");
-      const srcContent = readFileSync4(hookSrc, "utf-8");
-      const upToDate = existsSync4(hookDest) && readFileSync4(hookDest, "utf-8") === srcContent;
+      const hooksDir = join4(gitDir, "hooks");
+      mkdirSync4(hooksDir, { recursive: true });
+      const hookDest = join4(hooksDir, "pre-commit");
+      const srcContent = readFileSync5(hookSrc, "utf-8");
+      const upToDate = existsSync4(hookDest) && readFileSync5(hookDest, "utf-8") === srcContent;
       if (!upToDate)
-        writeFileSync4(hookDest, srcContent);
-      chmodSync4(hookDest, 493);
+        writeFileSync5(hookDest, srcContent);
+      chmodSync5(hookDest, 493);
     }
   } catch {
   }
 }
 function provisionStopHook(codeName) {
   const projectDir = getProjectDir(codeName);
-  const claudeDir = join3(projectDir, ".claude");
-  mkdirSync3(claudeDir, { recursive: true });
-  const hookScriptPath = join3(claudeDir, "agt-stop-hook.sh");
+  const claudeDir = join4(projectDir, ".claude");
+  mkdirSync4(claudeDir, { recursive: true });
+  const hookScriptPath = join4(claudeDir, "agt-stop-hook.sh");
   const hookScript = [
     "#!/bin/bash",
     "# Auto-generated by Augmented \u2014 captures persistent session task results.",
@@ -2225,8 +2378,8 @@ function provisionStopHook(codeName) {
     "esac",
     "exit 0"
   ].join("\n") + "\n";
-  writeFileSync4(hookScriptPath, hookScript, { mode: 493 });
-  const ghostHookPath = join3(claudeDir, "agt-ghost-reply-hook.sh");
+  writeFileSync5(hookScriptPath, hookScript, { mode: 493 });
+  const ghostHookPath = join4(claudeDir, "agt-ghost-reply-hook.sh");
   const jqNormalizeContent = '(.message.content // .content // []) | if type == "string" then [{type: "text", text: .}] elif type == "array" then . else [] end';
   const ghostHookScript = [
     "#!/bin/bash",
@@ -3098,12 +3251,12 @@ function provisionStopHook(codeName) {
     "fi",
     "exit 0"
   ].join("\n") + "\n";
-  writeFileSync4(ghostHookPath, ghostHookScript, { mode: 493 });
+  writeFileSync5(ghostHookPath, ghostHookScript, { mode: 493 });
   const backlogHookPath = provisionBacklogPullHook(codeName);
-  const settingsPath = join3(claudeDir, "settings.local.json");
+  const settingsPath = join4(claudeDir, "settings.local.json");
   let settings = {};
   try {
-    settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
   } catch {
   }
   const hooks = settings["hooks"] ?? {};
@@ -3117,21 +3270,21 @@ function provisionStopHook(codeName) {
     }
   ];
   settings["hooks"] = hooks;
-  writeFileSync4(settingsPath, JSON.stringify(settings, null, 2));
+  writeFileSync5(settingsPath, JSON.stringify(settings, null, 2));
 }
 function provisionIsolationHook(codeName, agentId) {
   const projectDir = getProjectDir(codeName);
-  const claudeDir = join3(projectDir, ".claude");
-  mkdirSync3(claudeDir, { recursive: true });
+  const claudeDir = join4(projectDir, ".claude");
+  mkdirSync4(claudeDir, { recursive: true });
   const hasAgentId = agentId !== void 0;
   if (hasAgentId)
     assertValidAgentId(agentId);
   const homeDir = getHomeDir();
-  const augmentedBase = join3(homeDir, ".augmented");
+  const augmentedBase = join4(homeDir, ".augmented");
   const ownAgentDir = getAgentDir(codeName);
-  const logFile = join3(ownAgentDir, "isolation.log");
+  const logFile = join4(ownAgentDir, "isolation.log");
   const idAllowClause = hasAgentId ? ` && [ "$AGENT_DIR" != "${agentId}" ]` : "";
-  const hookScriptPath = join3(claudeDir, "agt-isolation-hook.sh");
+  const hookScriptPath = join4(claudeDir, "agt-isolation-hook.sh");
   const hookScript = [
     "#!/bin/bash",
     "# Auto-generated by Augmented \u2014 prevents cross-agent file access.",
@@ -3184,11 +3337,11 @@ function provisionIsolationHook(codeName, agentId) {
     "",
     "exit 0"
   ].join("\n") + "\n";
-  writeFileSync4(hookScriptPath, hookScript, { mode: 493 });
-  const settingsPath = join3(claudeDir, "settings.local.json");
+  writeFileSync5(hookScriptPath, hookScript, { mode: 493 });
+  const settingsPath = join4(claudeDir, "settings.local.json");
   let settings = {};
   try {
-    settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
   } catch {
   }
   const hooks = settings["hooks"] ?? {};
@@ -3203,13 +3356,13 @@ function provisionIsolationHook(codeName, agentId) {
     }
   ];
   settings["hooks"] = hooks;
-  writeFileSync4(settingsPath, JSON.stringify(settings, null, 2));
+  writeFileSync5(settingsPath, JSON.stringify(settings, null, 2));
 }
 function provisionBacklogPullHook(codeName) {
   const projectDir = getProjectDir(codeName);
-  const claudeDir = join3(projectDir, ".claude");
-  mkdirSync3(claudeDir, { recursive: true });
-  const hookScriptPath = join3(claudeDir, "agt-backlog-pull-hook.sh");
+  const claudeDir = join4(projectDir, ".claude");
+  mkdirSync4(claudeDir, { recursive: true });
+  const hookScriptPath = join4(claudeDir, "agt-backlog-pull-hook.sh");
   const hookScript = `#!/usr/bin/env bash
 # Auto-generated by Augmented (CS-1549) \u2014 Stop hook: don't end a turn idle
 # beside a non-empty backlog. Fail-open on every path; blocks at most once per
@@ -3334,14 +3487,14 @@ If you genuinely should not pull it, say so in one line and why (it is deliberat
 jq -cn --arg r "$REASON" '{decision:"block", reason:$r}'
 exit 0
 `;
-  writeFileSync4(hookScriptPath, hookScript, { mode: 493 });
+  writeFileSync5(hookScriptPath, hookScript, { mode: 493 });
   return hookScriptPath;
 }
 function provisionAutoKanbanProgressHook(codeName) {
   const projectDir = getProjectDir(codeName);
-  const claudeDir = join3(projectDir, ".claude");
-  mkdirSync3(claudeDir, { recursive: true });
-  const hookScriptPath = join3(claudeDir, "agt-auto-kanban-progress-hook.sh");
+  const claudeDir = join4(projectDir, ".claude");
+  mkdirSync4(claudeDir, { recursive: true });
+  const hookScriptPath = join4(claudeDir, "agt-auto-kanban-progress-hook.sh");
   const hookScript = `#!/usr/bin/env bash
 # Auto-generated by Augmented (ENG-6179 / ENG-6241) \u2014 PostToolUse auto-progress.
 # Maps the agent's latest tool action onto its active in-thread kanban progress
@@ -3449,11 +3602,11 @@ BODY="$(jq -nc --arg a "$AGENT_ID" --arg s "$STEP" '{agent_id:$a, step:$s}' 2>/d
 
 exit 0
 `;
-  writeFileSync4(hookScriptPath, hookScript, { mode: 493 });
-  const settingsPath = join3(claudeDir, "settings.local.json");
+  writeFileSync5(hookScriptPath, hookScript, { mode: 493 });
+  const settingsPath = join4(claudeDir, "settings.local.json");
   let settings = {};
   try {
-    settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
   } catch {
   }
   const hooks = settings["hooks"] ?? {};
@@ -3465,13 +3618,13 @@ exit 0
     }
   ];
   settings["hooks"] = hooks;
-  writeFileSync4(settingsPath, JSON.stringify(settings, null, 2));
+  writeFileSync5(settingsPath, JSON.stringify(settings, null, 2));
 }
 function provisionChannelProgressHook(codeName) {
   const projectDir = getProjectDir(codeName);
-  const claudeDir = join3(projectDir, ".claude");
-  mkdirSync3(claudeDir, { recursive: true });
-  const hookScriptPath = join3(claudeDir, "agt-channel-progress-hook.sh");
+  const claudeDir = join4(projectDir, ".claude");
+  mkdirSync4(claudeDir, { recursive: true });
+  const hookScriptPath = join4(claudeDir, "agt-channel-progress-hook.sh");
   const hookScript = `#!/usr/bin/env bash
 # Auto-generated by Augmented (ENG-6567 Phase 2) \u2014 PostToolUse channel-progress
 # heartbeat. Writes a throttled local {step, updated_at_ms} the channel MCP reads
@@ -3538,11 +3691,11 @@ else
 fi
 exit 0
 `;
-  writeFileSync4(hookScriptPath, hookScript, { mode: 493 });
-  const settingsPath = join3(claudeDir, "settings.local.json");
+  writeFileSync5(hookScriptPath, hookScript, { mode: 493 });
+  const settingsPath = join4(claudeDir, "settings.local.json");
   let settings = {};
   try {
-    settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
   } catch {
   }
   const hooks = settings["hooks"] ?? {};
@@ -3558,14 +3711,14 @@ exit 0
   }
   hooks["PostToolUse"] = groups;
   settings["hooks"] = hooks;
-  writeFileSync4(settingsPath, JSON.stringify(settings, null, 2));
+  writeFileSync5(settingsPath, JSON.stringify(settings, null, 2));
 }
 function provisionOrientHook(codeName) {
   const projectDir = getProjectDir(codeName);
-  const claudeDir = join3(projectDir, ".claude");
-  mkdirSync3(claudeDir, { recursive: true });
+  const claudeDir = join4(projectDir, ".claude");
+  mkdirSync4(claudeDir, { recursive: true });
   const agentDir = getAgentDir(codeName);
-  const hookScriptPath = join3(claudeDir, "agt-orient-hook.sh");
+  const hookScriptPath = join4(claudeDir, "agt-orient-hook.sh");
   const hookScript = [
     "#!/bin/bash",
     "# Auto-generated by Augmented (ENG-5397) \u2014 SessionStart orientation hook.",
@@ -3715,11 +3868,11 @@ function provisionOrientHook(codeName) {
     "fi",
     "exit 0"
   ].join("\n") + "\n";
-  writeFileSync4(hookScriptPath, hookScript, { mode: 493 });
-  const settingsPath = join3(claudeDir, "settings.local.json");
+  writeFileSync5(hookScriptPath, hookScript, { mode: 493 });
+  const settingsPath = join4(claudeDir, "settings.local.json");
   let settings = {};
   try {
-    settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
   } catch {
   }
   const hooks = settings["hooks"] ?? {};
@@ -3739,15 +3892,15 @@ function provisionOrientHook(codeName) {
   }
   hooks["SessionStart"] = existingSessionStart;
   settings["hooks"] = hooks;
-  writeFileSync4(settingsPath, JSON.stringify(settings, null, 2));
+  writeFileSync5(settingsPath, JSON.stringify(settings, null, 2));
 }
 function provisionPreCompactHook(codeName) {
   const projectDir = getProjectDir(codeName);
-  const claudeDir = join3(projectDir, ".claude");
-  mkdirSync3(claudeDir, { recursive: true });
+  const claudeDir = join4(projectDir, ".claude");
+  mkdirSync4(claudeDir, { recursive: true });
   const agentDir = getAgentDir(codeName);
   const jqNormalizeContent = '(.message.content // .content // []) | if type == "string" then [{type: "text", text: .}] elif type == "array" then . else [] end';
-  const hookScriptPath = join3(claudeDir, "agt-pre-compact-hook.sh");
+  const hookScriptPath = join4(claudeDir, "agt-pre-compact-hook.sh");
   const hookScript = [
     "#!/bin/bash",
     "# Auto-generated by Augmented (ENG-7339) - PreCompact courtesy notice.",
@@ -3851,12 +4004,12 @@ function provisionPreCompactHook(codeName) {
     'if [ "$WROTE" = "1" ]; then date +%s > "$NOTICE_MARKER" 2>/dev/null || true; fi',
     "exit 0"
   ].join("\n") + "\n";
-  writeFileSync4(hookScriptPath, hookScript, { mode: 493 });
-  chmodSync4(hookScriptPath, 493);
-  const settingsPath = join3(claudeDir, "settings.local.json");
+  writeFileSync5(hookScriptPath, hookScript, { mode: 493 });
+  chmodSync5(hookScriptPath, 493);
+  const settingsPath = join4(claudeDir, "settings.local.json");
   let settings = {};
   try {
-    settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
   } catch {
   }
   const hooks = settings["hooks"] ?? {};
@@ -3876,14 +4029,14 @@ function provisionPreCompactHook(codeName) {
   }
   hooks["PreCompact"] = existingPreCompact;
   settings["hooks"] = hooks;
-  writeFileSync4(settingsPath, JSON.stringify(settings, null, 2));
+  writeFileSync5(settingsPath, JSON.stringify(settings, null, 2));
 }
 function provisionSessionStateHook(codeName) {
   const projectDir = getProjectDir(codeName);
-  const claudeDir = join3(projectDir, ".claude");
-  mkdirSync3(claudeDir, { recursive: true });
+  const claudeDir = join4(projectDir, ".claude");
+  mkdirSync4(claudeDir, { recursive: true });
   const agentDir = getAgentDir(codeName);
-  const hookScriptPath = join3(claudeDir, "agt-session-state-hook.sh");
+  const hookScriptPath = join4(claudeDir, "agt-session-state-hook.sh");
   const hookScript = `#!/usr/bin/env bash
 # Auto-generated by Augmented (ENG-6233 / ENG-6268) \u2014 SessionStart session-state
 # recorder. Writes the model + session origin (which only the agent's own
@@ -3960,11 +4113,11 @@ fi
 
 exit 0
 `;
-  writeFileSync4(hookScriptPath, hookScript, { mode: 493 });
-  const settingsPath = join3(claudeDir, "settings.local.json");
+  writeFileSync5(hookScriptPath, hookScript, { mode: 493 });
+  const settingsPath = join4(claudeDir, "settings.local.json");
   let settings = {};
   try {
-    settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
   } catch {
   }
   const hooks = settings["hooks"] ?? {};
@@ -3980,13 +4133,13 @@ exit 0
   }
   hooks["SessionStart"] = existingSessionStart;
   settings["hooks"] = hooks;
-  writeFileSync4(settingsPath, JSON.stringify(settings, null, 2));
+  writeFileSync5(settingsPath, JSON.stringify(settings, null, 2));
 }
 function modifyJsonConfig(filePath, fn) {
   let originalContent;
   let config;
   try {
-    originalContent = readFileSync4(filePath, "utf-8");
+    originalContent = readFileSync5(filePath, "utf-8");
     config = JSON.parse(originalContent);
   } catch {
     return;
@@ -3997,7 +4150,7 @@ function modifyJsonConfig(filePath, fn) {
   const newContent = JSON.stringify(config, null, 2);
   if (newContent === originalContent)
     return;
-  writeFileSync4(filePath, newContent);
+  writeFileSync5(filePath, newContent);
 }
 var SECRETS_DENY_PERMISSIONS = [
   // Read blocks
@@ -4095,7 +4248,7 @@ function buildSettingsJson(input) {
   const projectDir = getProjectDir(agent.code_name);
   const agentDir = getAgentDir(agent.code_name);
   const homeDir = getHomeDir();
-  const codenameAliasDir = join3(homeDir, ".augmented", agent.code_name);
+  const codenameAliasDir = join4(homeDir, ".augmented", agent.code_name);
   settings["allowedDirectories"] = [
     .../* @__PURE__ */ new Set([
       projectDir,
@@ -4104,7 +4257,7 @@ function buildSettingsJson(input) {
       // Agent's config dir (.env, schedules, registration)
       codenameAliasDir,
       // Codename symlink alias (== agentDir for legacy agents)
-      join3(homeDir, ".augmented", "_mcp"),
+      join4(homeDir, ".augmented", "_mcp"),
       // Shared MCP binaries
       "/tmp"
       // Temp files
@@ -4222,10 +4375,10 @@ ${integrationsBlock}`;
 function renderAugmentedWorkerForAgent(codeName) {
   const agentDir = getAgentDir(codeName);
   const projectDir = getProjectDir(codeName);
-  const provisionMcpPath = join3(agentDir, "provision", ".mcp.json");
+  const provisionMcpPath = join4(agentDir, "provision", ".mcp.json");
   let mcpServerKeys;
   try {
-    const config = JSON.parse(readFileSync4(provisionMcpPath, "utf-8"));
+    const config = JSON.parse(readFileSync5(provisionMcpPath, "utf-8"));
     mcpServerKeys = Object.keys(config.mcpServers ?? {});
   } catch {
     return;
@@ -4233,10 +4386,10 @@ function renderAugmentedWorkerForAgent(codeName) {
   const integrations = readIntegrationsSummaryForAgent(codeName);
   const content = buildAugmentedWorkerAgent({ mcpServerKeys, integrations });
   for (const baseDir of [agentDir, projectDir]) {
-    const target = join3(baseDir, ".claude", "agents", "augmented-worker.md");
+    const target = join4(baseDir, ".claude", "agents", "augmented-worker.md");
     try {
-      mkdirSync3(dirname3(target), { recursive: true });
-      writeFileSync4(target, content);
+      mkdirSync4(dirname4(target), { recursive: true });
+      writeFileSync5(target, content);
     } catch {
     }
   }
@@ -4262,8 +4415,8 @@ function buildPostizMcpEntry(integration) {
 }
 function buildMcpJson(input) {
   const mcpServers = {};
-  const turnInitiatorFile = join3(getAgentDir(input.agent.code_name), ".current-turn-initiator.json");
-  const localMcpPath = join3(getHomeDir(), ".augmented", "_mcp", "index.js");
+  const turnInitiatorFile = join4(getAgentDir(input.agent.code_name), ".current-turn-initiator.json");
+  const localMcpPath = join4(getHomeDir(), ".augmented", "_mcp", "index.js");
   mcpServers["augmented"] = {
     command: "node",
     args: [localMcpPath],
@@ -4315,7 +4468,7 @@ function buildMcpJson(input) {
   const xeroIntegration = input.integrations?.find((i) => i.definition_id === "xero");
   if (xeroIntegration) {
     const brokerMode = Boolean(xeroIntegration.id);
-    const localXeroMcpPath = join3(getHomeDir(), ".augmented", "_mcp", "xero.js");
+    const localXeroMcpPath = join4(getHomeDir(), ".augmented", "_mcp", "xero.js");
     mcpServers["xero"] = {
       command: "node",
       args: [localXeroMcpPath],
@@ -4355,7 +4508,7 @@ function buildMcpJson(input) {
         // getProjectDir (the ADR-0049 seam), not the MCP child's inherited
         // cwd, so the path stays correct if Claude Code ever spawns the
         // server from somewhere else.
-        XERO_EXPORT_DIR: join3(getProjectDir(input.agent.code_name), "xero-exports"),
+        XERO_EXPORT_DIR: join4(getProjectDir(input.agent.code_name), "xero-exports"),
         PATH: process.env["PATH"] ?? "",
         HOME: process.env["HOME"] ?? ""
       }
@@ -4366,8 +4519,8 @@ function buildMcpJson(input) {
     mcpServers["postiz"] = buildPostizMcpEntry(postizIntegration);
   }
   const remoteOAuthProxyPaths = {
-    proxyPath: join3(getHomeDir(), ".augmented", "_mcp", "remote-oauth-proxy.js"),
-    tokenFile: join3(getProjectDir(input.agent.code_name), ".env.integrations")
+    proxyPath: join4(getHomeDir(), ".augmented", "_mcp", "remote-oauth-proxy.js"),
+    tokenFile: join4(getProjectDir(input.agent.code_name), ".env.integrations")
   };
   for (const integration of input.integrations ?? []) {
     const connectionKey = integration.connection_key;
@@ -4433,7 +4586,7 @@ function buildMcpJson(input) {
   }
   const hasAdminDebug = input.integrations?.some((i) => i.definition_id === "augmented-admin") ?? false;
   if (hasAdminDebug) {
-    const localAdminMcpPath = join3(getHomeDir(), ".augmented", "_mcp", "augmented-admin.js");
+    const localAdminMcpPath = join4(getHomeDir(), ".augmented", "_mcp", "augmented-admin.js");
     mcpServers["augmented-admin"] = {
       command: "node",
       args: [localAdminMcpPath],
@@ -4447,7 +4600,7 @@ function buildMcpJson(input) {
   }
   const hasSupport = input.integrations?.some((i) => i.definition_id === "augmented-support") ?? false;
   if (hasSupport) {
-    const localSupportMcpPath = join3(getHomeDir(), ".augmented", "_mcp", "augmented-support.js");
+    const localSupportMcpPath = join4(getHomeDir(), ".augmented", "_mcp", "augmented-support.js");
     mcpServers["augmented-support"] = {
       command: "node",
       args: [localSupportMcpPath],
@@ -4461,7 +4614,7 @@ function buildMcpJson(input) {
   }
   const hasHelpKb = input.integrations?.some((i) => i.definition_id === "augmented-help-kb") ?? false;
   if (hasHelpKb) {
-    const localHelpKbMcpPath = join3(getHomeDir(), ".augmented", "_mcp", "augmented-help-kb.js");
+    const localHelpKbMcpPath = join4(getHomeDir(), ".augmented", "_mcp", "augmented-help-kb.js");
     mcpServers["augmented-help-kb"] = {
       command: "node",
       args: [localHelpKbMcpPath],
@@ -4475,7 +4628,7 @@ function buildMcpJson(input) {
   }
   const origamiIntegration = input.integrations?.find((i) => i.definition_id === "origami");
   if (origamiIntegration?.stdioMcp === true && origamiIntegration.id) {
-    const localOrigamiMcpPath = join3(getHomeDir(), ".augmented", "_mcp", "origami.js");
+    const localOrigamiMcpPath = join4(getHomeDir(), ".augmented", "_mcp", "origami.js");
     mcpServers["origami"] = {
       command: "node",
       args: [localOrigamiMcpPath],
@@ -4719,27 +4872,27 @@ ${sections}`
   },
   async getRegisteredAgents(_profile) {
     const homeDir = getHomeDir();
-    const augDir = join3(homeDir, ".augmented");
+    const augDir = join4(homeDir, ".augmented");
     const agents = /* @__PURE__ */ new Set();
     try {
       const entries = readdirSync(augDir);
       for (const entry of entries) {
         if (entry.startsWith("_") || entry.startsWith("."))
           continue;
-        const agentRoot = join3(augDir, entry);
+        const agentRoot = join4(augDir, entry);
         let st;
         try {
-          st = lstatSync(agentRoot);
+          st = lstatSync2(agentRoot);
         } catch {
           continue;
         }
         if (st.isSymbolicLink() || !st.isDirectory())
           continue;
-        if (!existsSync4(join3(agentRoot, "registration.json")))
+        if (!existsSync4(join4(agentRoot, "registration.json")))
           continue;
         let codeName = entry;
         try {
-          const reg = JSON.parse(readFileSync4(join3(agentRoot, "registration.json"), "utf8"));
+          const reg = JSON.parse(readFileSync5(join4(agentRoot, "registration.json"), "utf8"));
           if (reg && typeof reg.code_name === "string" && reg.code_name) {
             codeName = reg.code_name;
           }
@@ -4758,9 +4911,9 @@ ${sections}`
       }
       const agentDir = getAgentDir(codeName);
       const projectDir = getProjectDir(codeName);
-      mkdirSync3(agentDir, { recursive: true });
-      mkdirSync3(projectDir, { recursive: true });
-      writeFileSync4(join3(agentDir, "registration.json"), JSON.stringify({
+      mkdirSync4(agentDir, { recursive: true });
+      mkdirSync4(projectDir, { recursive: true });
+      writeFileSync5(join4(agentDir, "registration.json"), JSON.stringify({
         code_name: codeName,
         agent_id: agentId ?? null,
         team_dir: teamDir,
@@ -4779,7 +4932,7 @@ ${sections}`
   async deregisterAgent(codeName) {
     try {
       const agentDir = getAgentDir(codeName);
-      const regFile = join3(agentDir, "registration.json");
+      const regFile = join4(agentDir, "registration.json");
       if (existsSync4(regFile)) {
         const { unlinkSync: unlinkSync5 } = await import("fs");
         unlinkSync5(regFile);
@@ -4791,7 +4944,7 @@ ${sections}`
   },
   writeAuthProfiles(codeName, profiles) {
     const agentDir = getAgentDir(codeName);
-    mkdirSync3(agentDir, { recursive: true });
+    mkdirSync4(agentDir, { recursive: true });
     const envLines = ["# Augmented auth profiles \u2014 auto-generated, do not edit"];
     for (const p of profiles) {
       if (!p.api_key)
@@ -4805,9 +4958,9 @@ ${sections}`
       }
     }
     if (envLines.length > 1) {
-      const envPath = join3(agentDir, ".env");
-      writeFileSync4(envPath, envLines.join("\n") + "\n");
-      chmodSync4(envPath, SECRET_FILE_MODE);
+      const envPath = join4(agentDir, ".env");
+      writeFileSync5(envPath, envLines.join("\n") + "\n");
+      chmodSync5(envPath, SECRET_FILE_MODE2);
     }
   },
   // Claude Code has no gateway process — methods intentionally omitted
@@ -4840,7 +4993,7 @@ ${sections}`
     const senderPolicyInternalOnly = options?.senderPolicy?.internal_only === true;
     const senderPolicyEnv = senderPolicyTeamId ? { AGT_TEAM_ID: senderPolicyTeamId } : {};
     const agentDir = getAgentDir(codeName);
-    mkdirSync3(agentDir, { recursive: true });
+    mkdirSync4(agentDir, { recursive: true });
     const persistChannelSecrets = options?.channelSecretDelivery !== "spawn-env";
     const channelSecretUpdates = (updates, fullKeySet) => {
       if (persistChannelSecrets)
@@ -4854,7 +5007,7 @@ ${sections}`
       if (!botToken)
         return;
       const allowedChats = config["allowed_chats"];
-      const localTelegramChannel = join3(getHomeDir(), ".augmented", "_mcp", "telegram-channel.js");
+      const localTelegramChannel = join4(getHomeDir(), ".augmented", "_mcp", "telegram-channel.js");
       const resolvedAgtHostForTelegram = process.env["AGT_HOST"]?.trim() || "https://api.augmented.team";
       const resolvedAgtApiKeyForTelegram = process.env["AGT_API_KEY"]?.trim();
       writeEnvIntegrationsForAgent(codeName, {
@@ -4869,7 +5022,7 @@ ${sections}`
         ...options?.agentId ? { AGT_AGENT_ID: options.agentId } : {},
         ...tzEnv,
         // ENG-6582 (D16): stamp the verified turn initiator for broker MCPs.
-        AGT_TURN_INITIATOR_FILE: join3(getAgentDir(codeName), ".current-turn-initiator.json")
+        AGT_TURN_INITIATOR_FILE: join4(getAgentDir(codeName), ".current-turn-initiator.json")
       };
       if (allowedChats && allowedChats.length > 0) {
         telegramEnv.TELEGRAM_ALLOWED_CHATS = allowedChats.join(",");
@@ -4929,11 +5082,11 @@ ${sections}`
         args: [localTelegramChannel],
         env: telegramEnv
       };
-      const provisionMcpPath = join3(agentDir, "provision", ".mcp.json");
-      mkdirSync3(dirname3(provisionMcpPath), { recursive: true });
+      const provisionMcpPath = join4(agentDir, "provision", ".mcp.json");
+      mkdirSync4(dirname4(provisionMcpPath), { recursive: true });
       let mcpConfig2 = { mcpServers: {} };
       try {
-        mcpConfig2 = JSON.parse(readFileSync4(provisionMcpPath, "utf-8"));
+        mcpConfig2 = JSON.parse(readFileSync5(provisionMcpPath, "utf-8"));
         if (!mcpConfig2.mcpServers)
           mcpConfig2.mcpServers = {};
       } catch {
@@ -4946,13 +5099,13 @@ ${sections}`
       return;
     }
     if (isPersistent && (channelId === "discord" || channelId === "slack")) {
-      const channelDir = join3(getHomeDir(), ".claude", "channels", channelId);
+      const channelDir = join4(getHomeDir(), ".claude", "channels", channelId);
       if (channelId === "discord")
-        mkdirSync3(channelDir, { recursive: true });
+        mkdirSync4(channelDir, { recursive: true });
       if (channelId === "discord") {
         const botToken = config["bot_token"];
         if (botToken) {
-          writeFileSync4(join3(channelDir, ".env"), `DISCORD_BOT_TOKEN=${botToken}
+          writeFileSync5(join4(channelDir, ".env"), `DISCORD_BOT_TOKEN=${botToken}
 `);
         }
       } else if (channelId === "slack") {
@@ -5018,7 +5171,7 @@ ${sections}`
               ...appToken ? { SLACK_APP_TOKEN: appToken } : {}
             }, ["SLACK_BOT_TOKEN", "SLACK_APP_TOKEN"])
           });
-          const localSlackChannel = join3(getHomeDir(), ".augmented", "_mcp", "slack-channel.js");
+          const localSlackChannel = join4(getHomeDir(), ".augmented", "_mcp", "slack-channel.js");
           const slackAvatarEnvUrl = resolveAvatarEnvUrl(options?.agentAvatarUrl).url;
           const slackEntry = {
             command: existsSync4(localSlackChannel) ? "node" : "npx",
@@ -5104,14 +5257,14 @@ ${sections}`
               ...pingAllowedUsers.length > 0 ? { SLACK_PING_ALLOWED_USERS: pingAllowedUsers.join(",") } : {},
               // ENG-6563 (D16): stamp the verified turn initiator so broker MCPs
               // can forward it when the agent files an approval mid-turn.
-              AGT_TURN_INITIATOR_FILE: join3(agentDir, ".current-turn-initiator.json")
+              AGT_TURN_INITIATOR_FILE: join4(agentDir, ".current-turn-initiator.json")
             }
           };
-          const provisionMcpPath = join3(agentDir, "provision", ".mcp.json");
-          mkdirSync3(dirname3(provisionMcpPath), { recursive: true });
+          const provisionMcpPath = join4(agentDir, "provision", ".mcp.json");
+          mkdirSync4(dirname4(provisionMcpPath), { recursive: true });
           let mcpConfig2 = { mcpServers: {} };
           try {
-            mcpConfig2 = JSON.parse(readFileSync4(provisionMcpPath, "utf-8"));
+            mcpConfig2 = JSON.parse(readFileSync5(provisionMcpPath, "utf-8"));
             if (!mcpConfig2.mcpServers)
               mcpConfig2.mcpServers = {};
           } catch {
@@ -5121,10 +5274,10 @@ ${sections}`
             return;
           }
           syncMcpToProject(codeName);
-          const staleChannelsPath = join3(getProjectDir(codeName), ".mcp-channels.json");
+          const staleChannelsPath = join4(getProjectDir(codeName), ".mcp-channels.json");
           if (existsSync4(staleChannelsPath)) {
             try {
-              rmSync2(staleChannelsPath, { force: true });
+              rmSync3(staleChannelsPath, { force: true });
             } catch {
             }
           }
@@ -5132,11 +5285,11 @@ ${sections}`
       }
       return;
     }
-    const mcpJsonPath = join3(agentDir, "provision", ".mcp.json");
-    mkdirSync3(dirname3(mcpJsonPath), { recursive: true });
+    const mcpJsonPath = join4(agentDir, "provision", ".mcp.json");
+    mkdirSync4(dirname4(mcpJsonPath), { recursive: true });
     let mcpConfig;
     try {
-      mcpConfig = JSON.parse(readFileSync4(mcpJsonPath, "utf-8"));
+      mcpConfig = JSON.parse(readFileSync5(mcpJsonPath, "utf-8"));
     } catch {
       mcpConfig = { mcpServers: {} };
     }
@@ -5155,7 +5308,7 @@ ${sections}`
       const appToken = config["app_token"];
       if (!botToken)
         return;
-      const localSlackChannel = join3(getHomeDir(), ".augmented", "_mcp", "slack-channel.js");
+      const localSlackChannel = join4(getHomeDir(), ".augmented", "_mcp", "slack-channel.js");
       const slackThreadAutoFollow = config["thread_auto_follow"];
       const slackAutoFollowEnv = slackThreadAutoFollow && slackThreadAutoFollow !== "off" ? { SLACK_THREAD_AUTO_FOLLOW: slackThreadAutoFollow } : {};
       const slackChannelResponseMode = config["channel_response_mode"];
@@ -5248,7 +5401,7 @@ ${sections}`
             ...slackAgtAuthEnv,
             ...tzEnv,
             // ENG-6563 (D16): stamp the verified turn initiator for broker MCPs.
-            AGT_TURN_INITIATOR_FILE: join3(getAgentDir(codeName), ".current-turn-initiator.json"),
+            AGT_TURN_INITIATOR_FILE: join4(getAgentDir(codeName), ".current-turn-initiator.json"),
             // ENG-6155: avatar URL → bot Slack profile photo (see persistent
             // branch above). Mirrored here so oneshot-mode agents get it too.
             // ENG-6245: slackAvatarEnvUrl is null for data-URI / oversized values.
@@ -5273,7 +5426,7 @@ ${sections}`
             ...slackAgtAuthEnv,
             ...tzEnv,
             // ENG-6563 (D16): stamp the verified turn initiator for broker MCPs.
-            AGT_TURN_INITIATOR_FILE: join3(getAgentDir(codeName), ".current-turn-initiator.json"),
+            AGT_TURN_INITIATOR_FILE: join4(getAgentDir(codeName), ".current-turn-initiator.json"),
             // ENG-6155: avatar URL → bot Slack profile photo (see persistent
             // branch above). Mirrored here so oneshot-mode agents get it too.
             // ENG-6245: slackAvatarEnvUrl is null for data-URI / oversized values.
@@ -5286,12 +5439,12 @@ ${sections}`
       const clientSecret = config["client_secret"];
       if (!appId || !clientSecret)
         return;
-      const localTeamsChannel = join3(getHomeDir(), ".augmented", "_mcp", "teams-channel.js");
+      const localTeamsChannel = join4(getHomeDir(), ".augmented", "_mcp", "teams-channel.js");
       const agentDirMs = getAgentDir(codeName);
       try {
-        mkdirSync3(join3(agentDirMs, "msteams-pending-inbound", ".markers"), { recursive: true });
-        mkdirSync3(join3(agentDirMs, "msteams-pending-interactions"), { recursive: true });
-        mkdirSync3(join3(agentDirMs, "msteams-recovery-outbox"), { recursive: true });
+        mkdirSync4(join4(agentDirMs, "msteams-pending-inbound", ".markers"), { recursive: true });
+        mkdirSync4(join4(agentDirMs, "msteams-pending-interactions"), { recursive: true });
+        mkdirSync4(join4(agentDirMs, "msteams-recovery-outbox"), { recursive: true });
       } catch {
       }
       const tenantId = config["tenant_id"] ?? "common";
@@ -5369,7 +5522,7 @@ ${sections}`
     }
     if (channelId === "whatsapp") {
       const provider = config["provider"] ?? "kapso";
-      const localWhatsappChannel = join3(getHomeDir(), ".augmented", "_mcp", "whatsapp-channel.js");
+      const localWhatsappChannel = join4(getHomeDir(), ".augmented", "_mcp", "whatsapp-channel.js");
       if (provider === "baileys") {
         mcpServers["whatsapp"] = {
           command: "node",
@@ -5388,7 +5541,7 @@ ${sections}`
       const phoneNumberId = config["phone_number_id"];
       if (projectApiKey && phoneNumberId) {
         try {
-          mkdirSync3(join3(getAgentDir(codeName), "whatsapp-pending-inbound"), { recursive: true });
+          mkdirSync4(join4(getAgentDir(codeName), "whatsapp-pending-inbound"), { recursive: true });
         } catch {
         }
         writeEnvIntegrationsForAgent(codeName, {
@@ -5416,11 +5569,11 @@ ${sections}`
     }
   },
   hasChannelCredentials(codeName, channelId) {
-    const provisionMcpPath = join3(getAgentDir(codeName), "provision", ".mcp.json");
+    const provisionMcpPath = join4(getAgentDir(codeName), "provision", ".mcp.json");
     if (!existsSync4(provisionMcpPath))
       return false;
     try {
-      const parsed = JSON.parse(readFileSync4(provisionMcpPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync5(provisionMcpPath, "utf-8"));
       return Boolean(parsed.mcpServers?.[channelId]);
     } catch {
       return false;
@@ -5428,7 +5581,7 @@ ${sections}`
   },
   removeChannelCredentials(codeName, channelId) {
     const agentDir = getAgentDir(codeName);
-    const mcpJsonPath = join3(agentDir, "provision", ".mcp.json");
+    const mcpJsonPath = join4(agentDir, "provision", ".mcp.json");
     modifyJsonConfig(mcpJsonPath, (config) => {
       const mcpServers = config["mcpServers"];
       if (!mcpServers || !(channelId in mcpServers))
@@ -5440,7 +5593,7 @@ ${sections}`
   },
   async updateAgentModel(codeName, model) {
     const agentDir = getAgentDir(codeName);
-    const settingsPath = join3(agentDir, "provision", "settings.json");
+    const settingsPath = join4(agentDir, "provision", "settings.json");
     let changed = false;
     modifyJsonConfig(settingsPath, (config) => {
       config["model"] = model;
@@ -5458,20 +5611,20 @@ ${sections}`
   seedProfileConfig(codeName) {
     const agentDir = getAgentDir(codeName);
     const projectDir = getProjectDir(codeName);
-    mkdirSync3(join3(agentDir, "provision"), { recursive: true });
-    mkdirSync3(projectDir, { recursive: true });
+    mkdirSync4(join4(agentDir, "provision"), { recursive: true });
+    mkdirSync4(projectDir, { recursive: true });
   },
   syncScheduledTasks(codeName, tasks) {
     const agentDir = getAgentDir(codeName);
-    const schedulesPath = join3(agentDir, "schedules.json");
+    const schedulesPath = join4(agentDir, "schedules.json");
     const mapped = mapScheduledTasks(tasks);
-    mkdirSync3(agentDir, { recursive: true });
-    writeFileSync4(schedulesPath, JSON.stringify({ schedules: mapped }, null, 2));
+    mkdirSync4(agentDir, { recursive: true });
+    writeFileSync5(schedulesPath, JSON.stringify({ schedules: mapped }, null, 2));
     return Promise.resolve();
   },
   writeIntegrations(codeName, integrations, agentId, options) {
     const agentDir = getAgentDir(codeName);
-    mkdirSync3(agentDir, { recursive: true });
+    mkdirSync4(agentDir, { recursive: true });
     const summariesForSidecar = integrations.map((i) => {
       const def = INTEGRATION_REGISTRY.find((d) => d.id === i.definition_id);
       return {
@@ -5588,7 +5741,7 @@ ${sections}`
         xeroEnv.AGT_AGENT_ID = agentId;
         xeroEnv.AGT_INTEGRATION_ID = xeroIntegration.id;
       }
-      const localXeroMcpPath = join3(getHomeDir(), ".augmented", "_mcp", "xero.js");
+      const localXeroMcpPath = join4(getHomeDir(), ".augmented", "_mcp", "xero.js");
       this.writeMcpServer(codeName, "xero", {
         command: "node",
         args: [localXeroMcpPath],
@@ -5600,8 +5753,8 @@ ${sections}`
       this.writeMcpServer(codeName, "postiz", buildPostizMcpEntry(postizIntegration));
     }
     const remoteOAuthProxyPaths = {
-      proxyPath: join3(getHomeDir(), ".augmented", "_mcp", "remote-oauth-proxy.js"),
-      tokenFile: join3(getProjectDir(codeName), ".env.integrations")
+      proxyPath: join4(getHomeDir(), ".augmented", "_mcp", "remote-oauth-proxy.js"),
+      tokenFile: join4(getProjectDir(codeName), ".env.integrations")
     };
     for (const integration of integrations) {
       const connectionKey = integration.connection_key;
@@ -5642,7 +5795,7 @@ ${sections}`
             // ENG-6586 (D16): keep incremental cloud-broker wiring in sync with
             // buildMcpJson so agents that add cloud-broker post-provision still
             // forward the per-turn initiator.
-            AGT_TURN_INITIATOR_FILE: join3(getAgentDir(codeName), ".current-turn-initiator.json"),
+            AGT_TURN_INITIATOR_FILE: join4(getAgentDir(codeName), ".current-turn-initiator.json"),
             PATH: process.env["PATH"] ?? "",
             HOME: process.env["HOME"] ?? ""
           }
@@ -5666,7 +5819,7 @@ ${sections}`
             // ENG-6563 (D16): keep incremental xero-broker wiring in sync with
             // buildMcpJson so agents that add xero-broker post-provision still
             // forward the per-turn initiator.
-            AGT_TURN_INITIATOR_FILE: join3(getAgentDir(codeName), ".current-turn-initiator.json"),
+            AGT_TURN_INITIATOR_FILE: join4(getAgentDir(codeName), ".current-turn-initiator.json"),
             PATH: process.env["PATH"] ?? "",
             HOME: process.env["HOME"] ?? ""
           }
@@ -5675,7 +5828,7 @@ ${sections}`
     }
     const hasAdminDebug = integrations.some((i) => i.definition_id === "augmented-admin");
     if (hasAdminDebug) {
-      const localAdminMcpPath = join3(getHomeDir(), ".augmented", "_mcp", "augmented-admin.js");
+      const localAdminMcpPath = join4(getHomeDir(), ".augmented", "_mcp", "augmented-admin.js");
       this.writeMcpServer(codeName, "augmented-admin", {
         command: "node",
         args: [localAdminMcpPath],
@@ -5689,7 +5842,7 @@ ${sections}`
     }
     const hasSupport = integrations.some((i) => i.definition_id === "augmented-support");
     if (hasSupport) {
-      const localSupportMcpPath = join3(getHomeDir(), ".augmented", "_mcp", "augmented-support.js");
+      const localSupportMcpPath = join4(getHomeDir(), ".augmented", "_mcp", "augmented-support.js");
       this.writeMcpServer(codeName, "augmented-support", {
         command: "node",
         args: [localSupportMcpPath],
@@ -5703,7 +5856,7 @@ ${sections}`
     }
     const hasHelpKb = integrations.some((i) => i.definition_id === "augmented-help-kb");
     if (hasHelpKb) {
-      const localHelpKbMcpPath = join3(getHomeDir(), ".augmented", "_mcp", "augmented-help-kb.js");
+      const localHelpKbMcpPath = join4(getHomeDir(), ".augmented", "_mcp", "augmented-help-kb.js");
       this.writeMcpServer(codeName, "augmented-help-kb", {
         command: "node",
         args: [localHelpKbMcpPath],
@@ -5719,7 +5872,7 @@ ${sections}`
     const origamiStdioAgentId = resolveBrokerAgentId(codeName) ?? agentId;
     const origamiStdioExpected = Boolean(origamiStdio?.stdioMcp === true && origamiStdio.id);
     if (origamiStdioExpected && origamiStdioAgentId) {
-      const localOrigamiMcpPath = join3(getHomeDir(), ".augmented", "_mcp", "origami.js");
+      const localOrigamiMcpPath = join4(getHomeDir(), ".augmented", "_mcp", "origami.js");
       this.writeMcpServer(codeName, "origami", {
         command: "node",
         args: [localOrigamiMcpPath],
@@ -5836,9 +5989,9 @@ ${sections}`
       }
     }
     const projectDir = getProjectDir(codeName);
-    const claudeMdPath = join3(projectDir, "CLAUDE.md");
+    const claudeMdPath = join4(projectDir, "CLAUDE.md");
     try {
-      const existing = readFileSync4(claudeMdPath, "utf-8");
+      const existing = readFileSync5(claudeMdPath, "utf-8");
       const renderSection = options?.renderClaudeMdSection === true;
       const newSection = renderSection ? buildIntegrationsSection(summariesForSidecar) : "";
       const sentinelStart = INTEGRATIONS_SECTION_START.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -5855,15 +6008,15 @@ ${sections}`
         updated = existing;
       }
       if (updated !== existing)
-        writeFileSync4(claudeMdPath, updated);
+        writeFileSync5(claudeMdPath, updated);
       const agentDir2 = getAgentDir(codeName);
-      const envSrc = join3(agentDir2, ".env.integrations");
+      const envSrc = join4(agentDir2, ".env.integrations");
       try {
-        const envContent = readFileSync4(envSrc, "utf-8");
-        const envDest = join3(projectDir, ".env.integrations");
-        writeFileSync4(envDest, envContent, { mode: SECRET_FILE_MODE });
+        const envContent = readFileSync5(envSrc, "utf-8");
+        const envDest = join4(projectDir, ".env.integrations");
+        writeFileSync5(envDest, envContent, { mode: SECRET_FILE_MODE2 });
         try {
-          chmodSync4(envDest, SECRET_FILE_MODE);
+          chmodSync5(envDest, SECRET_FILE_MODE2);
         } catch {
         }
       } catch {
@@ -5875,11 +6028,11 @@ ${sections}`
   },
   writeMcpServer(codeName, serverId, config) {
     const agentDir = getAgentDir(codeName);
-    const mcpJsonPath = join3(agentDir, "provision", ".mcp.json");
-    mkdirSync3(join3(agentDir, "provision"), { recursive: true });
+    const mcpJsonPath = join4(agentDir, "provision", ".mcp.json");
+    mkdirSync4(join4(agentDir, "provision"), { recursive: true });
     let mcpConfig;
     try {
-      mcpConfig = JSON.parse(readFileSync4(mcpJsonPath, "utf-8"));
+      mcpConfig = JSON.parse(readFileSync5(mcpJsonPath, "utf-8"));
     } catch {
       mcpConfig = { mcpServers: {} };
     }
@@ -5923,7 +6076,7 @@ ${sections}`
     }
   },
   getMcpPath(codeName) {
-    return join3(getAgentDir(codeName), "provision", ".mcp.json");
+    return join4(getAgentDir(codeName), "provision", ".mcp.json");
   },
   /**
    * ENG-7994: the declared servers from `provision/.mcp.json`. Mirrors what the
@@ -5934,7 +6087,7 @@ ${sections}`
   readMcpServers(codeName) {
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync4(join3(getAgentDir(codeName), "provision", ".mcp.json"), "utf-8"));
+      parsed = JSON.parse(readFileSync5(join4(getAgentDir(codeName), "provision", ".mcp.json"), "utf-8"));
     } catch {
       return {};
     }
@@ -5947,10 +6100,10 @@ ${sections}`
   },
   removeMcpServer(codeName, serverId) {
     const agentDir = getAgentDir(codeName);
-    const mcpJsonPath = join3(agentDir, "provision", ".mcp.json");
+    const mcpJsonPath = join4(agentDir, "provision", ".mcp.json");
     let mcpConfig;
     try {
-      mcpConfig = JSON.parse(readFileSync4(mcpJsonPath, "utf-8"));
+      mcpConfig = JSON.parse(readFileSync5(mcpJsonPath, "utf-8"));
     } catch {
       return;
     }
@@ -5969,27 +6122,27 @@ ${sections}`
     const READ_WRITE_MODE = 420;
     const agentDir = getAgentDir(codeName);
     const projectDir = getProjectDir(codeName);
-    for (const baseDir of [join3(agentDir, "skills"), join3(projectDir, ".claude", "skills")]) {
-      const skillDir = join3(baseDir, skillId);
-      mkdirSync3(skillDir, { recursive: true });
+    for (const baseDir of [join4(agentDir, "skills"), join4(projectDir, ".claude", "skills")]) {
+      const skillDir = join4(baseDir, skillId);
+      mkdirSync4(skillDir, { recursive: true });
       for (const file of files) {
         assertSafeRelativePath(file.relativePath);
-        const filePath = join3(skillDir, file.relativePath);
+        const filePath = join4(skillDir, file.relativePath);
         const rel = relative(skillDir, filePath);
         if (rel.startsWith("..") || rel === "") {
           throw new Error(`Path traversal detected: ${file.relativePath} resolves outside ${skillDir}`);
         }
-        mkdirSync3(join3(filePath, ".."), { recursive: true });
+        mkdirSync4(join4(filePath, ".."), { recursive: true });
         if (isPluginManaged && existsSync4(filePath)) {
           try {
-            chmodSync4(filePath, READ_WRITE_MODE);
+            chmodSync5(filePath, READ_WRITE_MODE);
           } catch {
           }
         }
-        writeFileSync4(filePath, file.content);
+        writeFileSync5(filePath, file.content);
         if (isPluginManaged) {
           try {
-            chmodSync4(filePath, READ_ONLY_MODE);
+            chmodSync5(filePath, READ_ONLY_MODE);
           } catch {
           }
         }
@@ -5998,11 +6151,11 @@ ${sections}`
   },
   installPlugin(codeName, pluginId, pluginPath, pluginConfig) {
     const agentDir = getAgentDir(codeName);
-    const pluginsJsonPath = join3(agentDir, "plugins.json");
-    mkdirSync3(agentDir, { recursive: true });
+    const pluginsJsonPath = join4(agentDir, "plugins.json");
+    mkdirSync4(agentDir, { recursive: true });
     let pluginsConfig;
     try {
-      pluginsConfig = JSON.parse(readFileSync4(pluginsJsonPath, "utf-8"));
+      pluginsConfig = JSON.parse(readFileSync5(pluginsJsonPath, "utf-8"));
     } catch {
       pluginsConfig = { plugins: {} };
     }
@@ -6015,7 +6168,7 @@ ${sections}`
       installed_at: (/* @__PURE__ */ new Date()).toISOString(),
       ...pluginConfig ? { config: pluginConfig } : {}
     };
-    writeFileSync4(pluginsJsonPath, JSON.stringify(pluginsConfig, null, 2));
+    writeFileSync5(pluginsJsonPath, JSON.stringify(pluginsConfig, null, 2));
   },
   /**
    * Full plugin provisioning: install scripts, register hooks, apply permissions,
@@ -6031,11 +6184,11 @@ ${sections}`
     assertValidCodeName(codeName);
     assertValidCodeName(plugin.slug);
     const projectDir = getProjectDir(codeName);
-    const claudeDir = join3(projectDir, ".claude");
-    mkdirSync3(claudeDir, { recursive: true });
+    const claudeDir = join4(projectDir, ".claude");
+    mkdirSync4(claudeDir, { recursive: true });
     const sourceSpec = options?.scriptSource ?? `augmented-plugin:${plugin.slug}`;
     this.installPlugin(codeName, plugin.slug, sourceSpec, contextValues);
-    const installedDir = join3(projectDir, ".claude", "plugins", plugin.slug);
+    const installedDir = join4(projectDir, ".claude", "plugins", plugin.slug);
     for (const skill of plugin.skills) {
       const skillId = skill.id;
       assertValidCodeName(skillId);
@@ -6047,10 +6200,10 @@ ${sections}`
     }
     const scriptsConfig = plugin.scripts;
     if (scriptsConfig?.hooks) {
-      const settingsPath = join3(claudeDir, "settings.local.json");
+      const settingsPath = join4(claudeDir, "settings.local.json");
       let settings = {};
       try {
-        settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+        settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
       } catch {
       }
       const existingHooks = settings["hooks"] ?? {};
@@ -6084,13 +6237,13 @@ ${sections}`
         }
       }
       settings["hooks"] = existingHooks;
-      writeFileSync4(settingsPath, JSON.stringify(settings, null, 2));
+      writeFileSync5(settingsPath, JSON.stringify(settings, null, 2));
     }
     if (plugin.allowed_tools.length > 0) {
-      const settingsPath = join3(claudeDir, "settings.local.json");
+      const settingsPath = join4(claudeDir, "settings.local.json");
       let settings = {};
       try {
-        settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+        settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
       } catch {
       }
       const existingPerms = settings["permissions"] ?? {};
@@ -6102,20 +6255,20 @@ ${sections}`
       }
       existingPerms["allow"] = allowList;
       settings["permissions"] = existingPerms;
-      writeFileSync4(settingsPath, JSON.stringify(settings, null, 2));
+      writeFileSync5(settingsPath, JSON.stringify(settings, null, 2));
     }
     if (contextValues && Object.keys(contextValues).length > 0) {
-      const configDir = join3(projectDir, `.${plugin.slug}`);
-      mkdirSync3(configDir, { recursive: true });
-      writeFileSync4(join3(configDir, "config.json"), JSON.stringify(contextValues, null, 2));
+      const configDir = join4(projectDir, `.${plugin.slug}`);
+      mkdirSync4(configDir, { recursive: true });
+      writeFileSync5(join4(configDir, "config.json"), JSON.stringify(contextValues, null, 2));
     }
   },
   executePluginHook(ctx) {
     assertValidCodeName(ctx.codeName);
-    const agentRootDir = join3(getHomeDir(), ".augmented", ctx.codeName);
+    const agentRootDir = join4(getHomeDir(), ".augmented", ctx.codeName);
     const projectDir = getProjectDir(ctx.codeName);
-    mkdirSync3(agentRootDir, { recursive: true });
-    mkdirSync3(projectDir, { recursive: true });
+    mkdirSync4(agentRootDir, { recursive: true });
+    mkdirSync4(projectDir, { recursive: true });
     const startedAt = Date.now();
     return new Promise((resolve) => {
       const child = execFile("bash", ["-c", ctx.script], {
@@ -6151,7 +6304,7 @@ ${sections}`
   },
   writeTokenFile(codeName, integrations) {
     const agentDir = getAgentDir(codeName);
-    mkdirSync3(agentDir, { recursive: true });
+    mkdirSync4(agentDir, { recursive: true });
     const tokens = {};
     for (const integration of integrations) {
       if (integration.auth_type !== "oauth2" && integration.auth_type !== "github_app")
@@ -6168,9 +6321,9 @@ ${sections}`
     }
     if (Object.keys(tokens).length === 0)
       return;
-    const tokenPath = join3(agentDir, ".tokens.json");
-    writeFileSync4(tokenPath, JSON.stringify(tokens, null, 2));
-    chmodSync4(tokenPath, SECRET_FILE_MODE);
+    const tokenPath = join4(agentDir, ".tokens.json");
+    writeFileSync5(tokenPath, JSON.stringify(tokens, null, 2));
+    chmodSync5(tokenPath, SECRET_FILE_MODE2);
   }
 };
 registerFramework(claudeCodeAdapter);
@@ -6192,14 +6345,14 @@ function jsonOutput(data) {
 }
 
 // src/lib/config.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
 import { homedir as homedir4 } from "os";
-var AUGMENTED_DIR = join4(homedir4(), ".augmented");
-var CONFIG_PATH = join4(AUGMENTED_DIR, "config.json");
+var AUGMENTED_DIR = join5(homedir4(), ".augmented");
+var CONFIG_PATH = join5(AUGMENTED_DIR, "config.json");
 function ensureAugmentedDir() {
   if (!existsSync5(AUGMENTED_DIR)) {
-    mkdirSync4(AUGMENTED_DIR, { recursive: true });
+    mkdirSync5(AUGMENTED_DIR, { recursive: true });
   }
 }
 function reloadFromShellProfile() {
@@ -6209,10 +6362,10 @@ function loadFromShellProfile(force = false) {
   if (!force && process.env["AGT_HOST"] && process.env["AGT_API_KEY"]) return;
   const shell = process.env["SHELL"] ?? "";
   const home = homedir4();
-  const candidates = shell.includes("zsh") ? [join4(home, ".zshrc"), join4(home, ".zprofile")] : shell.includes("fish") ? [join4(home, ".config", "fish", "config.fish")] : [join4(home, ".bashrc"), join4(home, ".bash_profile")];
+  const candidates = shell.includes("zsh") ? [join5(home, ".zshrc"), join5(home, ".zprofile")] : shell.includes("fish") ? [join5(home, ".config", "fish", "config.fish")] : [join5(home, ".bashrc"), join5(home, ".bash_profile")];
   for (const profile of candidates) {
     try {
-      const content = readFileSync5(profile, "utf-8");
+      const content = readFileSync6(profile, "utf-8");
       for (const key of ["AGT_HOST", "AGT_API_KEY", "AGT_TEAM"]) {
         if (!force && process.env[key]) continue;
         const match = content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).map(
@@ -6237,7 +6390,7 @@ function getApiKey() {
 }
 function getConfig() {
   try {
-    const raw = readFileSync5(CONFIG_PATH, "utf-8");
+    const raw = readFileSync6(CONFIG_PATH, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -6245,7 +6398,7 @@ function getConfig() {
 }
 function saveConfig(config) {
   ensureAugmentedDir();
-  writeFileSync5(CONFIG_PATH, JSON.stringify(config, null, 2));
+  writeFileSync6(CONFIG_PATH, JSON.stringify(config, null, 2));
 }
 function getActiveTeam() {
   const envTeam = process.env["AGT_TEAM"];
@@ -6292,7 +6445,7 @@ function exchangeFailureKind(err) {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.677" : "dev";
+var agtCliVersion = true ? "0.28.679" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -6542,13 +6695,13 @@ async function getHostId() {
 }
 
 // src/lib/atomic-write.ts
-import { closeSync, fsyncSync, openSync, writeSync, renameSync as renameSync5, mkdirSync as mkdirSync5 } from "fs";
-import { dirname as dirname4 } from "path";
+import { closeSync, fsyncSync, openSync, writeSync, renameSync as renameSync5, mkdirSync as mkdirSync6 } from "fs";
+import { dirname as dirname5 } from "path";
 function atomicWriteFileSync(path, data) {
-  const dirPath = dirname4(path);
+  const dirPath = dirname5(path);
   const tmpPath = `${path}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 8)}`;
   try {
-    mkdirSync5(dirPath, { recursive: true });
+    mkdirSync6(dirPath, { recursive: true });
   } catch {
   }
   const fd = openSync(tmpPath, "w", 420);
@@ -6574,15 +6727,15 @@ function atomicWriteFileSync(path, data) {
 }
 
 // src/lib/feature-flags-host.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { join as join6 } from "path";
 function defaultFlagsCachePath(configDir) {
-  return join5(configDir, "flags-cache.json");
+  return join6(configDir, "flags-cache.json");
 }
 function readFlagsCache(path) {
   try {
     if (!existsSync6(path)) return null;
-    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path, "utf8"));
     if (!parsed || typeof parsed !== "object") return null;
     const obj = parsed;
     const flags = obj["flags"];
@@ -7047,16 +7200,16 @@ function buildArgvMatchersForEntry(key, entry) {
     const tail = "(?![A-Za-z0-9_-])";
     if (/^@?[a-z0-9]([a-z0-9._-]*\/)?[a-z0-9._-]+$/i.test(stripped)) {
       patterns.push(new RegExp(`${escapeRe(stripped)}${tail}`));
-      const basename = stripped.split("/").pop();
-      if (basename && basename !== stripped) {
-        patterns.push(new RegExp(`${escapeRe(basename)}${tail}`));
+      const basename2 = stripped.split("/").pop();
+      if (basename2 && basename2 !== stripped) {
+        patterns.push(new RegExp(`${escapeRe(basename2)}${tail}`));
       }
       break;
     }
     if (stripped.includes("/")) {
-      const basename = stripped.split("/").pop();
-      if (basename) {
-        patterns.push(new RegExp(`${escapeRe(basename)}${tail}`));
+      const basename2 = stripped.split("/").pop();
+      if (basename2) {
+        patterns.push(new RegExp(`${escapeRe(basename2)}${tail}`));
         break;
       }
     }
@@ -8208,8 +8361,8 @@ function verdictForUnavailableMcpConfig(cause, ctx) {
 }
 
 // src/lib/connectivity-probe-context.ts
-import { delimiter as pathDelimiter, join as join6 } from "path";
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { delimiter as pathDelimiter, join as join7 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
 
 // src/lib/mcp-stdio-probe.ts
 import { spawn } from "child_process";
@@ -8720,7 +8873,7 @@ function resolveHttpServerEntry(entry, env) {
 function readMcpHttpServerConfig(projectDir, serverKey, env) {
   let servers;
   try {
-    const raw = readFileSync7(join6(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync8(join7(projectDir, ".mcp.json"), "utf-8");
     servers = JSON.parse(raw).mcpServers ?? {};
   } catch {
     return { ok: false, cause: "file-unreadable" };
@@ -8732,7 +8885,7 @@ function readMcpHttpServerConfig(projectDir, serverKey, env) {
 }
 function resolveDeclaredServerKey(projectDir, definitionId, derivedKey) {
   try {
-    const raw = readFileSync7(join6(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync8(join7(projectDir, ".mcp.json"), "utf-8");
     const servers = JSON.parse(raw).mcpServers ?? {};
     const declared = Object.keys(servers);
     if (derivedKey !== definitionId && derivedKey !== sanitizeServerKey(definitionId)) {
@@ -8774,7 +8927,7 @@ function resolveStdioServerEntry(entry, env) {
 function readMcpStdioServerConfig(projectDir, serverKey, env) {
   let servers;
   try {
-    const raw = readFileSync7(join6(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync8(join7(projectDir, ".mcp.json"), "utf-8");
     servers = JSON.parse(raw).mcpServers ?? {};
   } catch {
     return { ok: false, cause: "file-unreadable" };
@@ -8800,9 +8953,9 @@ function deriveMcpServerKey(input) {
 function buildProbeEnv(projectDir, agentId) {
   const probeEnv = { ...process.env };
   try {
-    const envIntPath = join6(projectDir, ".env.integrations");
+    const envIntPath = join7(projectDir, ".env.integrations");
     if (existsSync7(envIntPath)) {
-      Object.assign(probeEnv, parseEnvIntegrations(readFileSync7(envIntPath, "utf-8")));
+      Object.assign(probeEnv, parseEnvIntegrations(readFileSync8(envIntPath, "utf-8")));
     }
   } catch {
   }
@@ -8810,7 +8963,7 @@ function buildProbeEnv(projectDir, agentId) {
     probeEnv.AGT_AGENT_ID = agentId.trim();
   }
   try {
-    const agentBinDir = join6(projectDir, ".claude", "agt-bin");
+    const agentBinDir = join7(projectDir, ".claude", "agt-bin");
     if (existsSync7(agentBinDir)) {
       probeEnv.PATH = probeEnv.PATH ? `${agentBinDir}${pathDelimiter}${probeEnv.PATH}` : agentBinDir;
     }
@@ -8947,9 +9100,9 @@ function buildConnectivityProbeDeps(projectDir, probeEnv) {
 
 // src/lib/session-tool-bind-probe-host.ts
 import { execFileSync as syncExecFile } from "child_process";
-import { readFileSync as readFileSync8 } from "fs";
-import { join as join7 } from "path";
-import { dirname as dirname5 } from "path";
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join8 } from "path";
+import { dirname as dirname6 } from "path";
 function deliveryFields(i) {
   const keys = ["source_type", "provider", "mcp_command", "mcp_url", "cli_binary", "cli_package"];
   const out = {};
@@ -8962,7 +9115,7 @@ async function gatherSessionToolBindProbe(agent, integrations, projectDir, opts)
   if (integrations.length === 0) return null;
   let mcpRaw = null;
   try {
-    mcpRaw = readFileSync8(join7(projectDir, ".mcp.json"), "utf-8");
+    mcpRaw = readFileSync9(join8(projectDir, ".mcp.json"), "utf-8");
   } catch {
     mcpRaw = null;
   }
@@ -9055,7 +9208,7 @@ var SLACK_MCP_SERVER_KEY = "slack";
 function readSlackTransportDownKeys(projectDir) {
   const none = /* @__PURE__ */ new Set();
   try {
-    const raw = readFileSync8(join7(dirname5(projectDir), SLACK_SOCKET_STATE_FILENAME), "utf-8");
+    const raw = readFileSync9(join8(dirname6(projectDir), SLACK_SOCKET_STATE_FILENAME), "utf-8");
     const state = parseSlackSocketState(raw, Date.now());
     return isSlackInboundTransportDown(state, SLACK_TRANSPORT_DOWN_AFTER_MS) ? /* @__PURE__ */ new Set([SLACK_MCP_SERVER_KEY]) : none;
   } catch {
@@ -9172,34 +9325,34 @@ function decidePin(opts) {
 // src/commands/manager.ts
 import chalk3 from "chalk";
 import { existsSync as existsSync9, realpathSync as realpathSync2 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { homedir as homedir5, userInfo } from "os";
 import { spawn as spawn3 } from "child_process";
 
 // src/lib/watchdog.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, unlinkSync as unlinkSync4, existsSync as existsSync8, mkdirSync as mkdirSync6, openSync as openSync2, closeSync as closeSync2, chmodSync as chmodSync5 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, unlinkSync as unlinkSync4, existsSync as existsSync8, mkdirSync as mkdirSync7, openSync as openSync2, closeSync as closeSync2, chmodSync as chmodSync6 } from "fs";
+import { join as join9 } from "path";
 import { spawn as spawn2, execFileSync as execFileSync3 } from "child_process";
-var DEFAULT_CONFIG_DIR = join8(process.env["HOME"] ?? "/tmp", ".augmented");
+var DEFAULT_CONFIG_DIR = join9(process.env["HOME"] ?? "/tmp", ".augmented");
 function getManagerPaths(configDir) {
   return {
-    pidFile: join8(configDir, "manager.pid"),
-    stateFile: join8(configDir, "manager-state.json"),
-    logFile: join8(configDir, "manager.log")
+    pidFile: join9(configDir, "manager.pid"),
+    stateFile: join9(configDir, "manager-state.json"),
+    logFile: join9(configDir, "manager.log")
   };
 }
 function ensureDir(configDir) {
   if (!existsSync8(configDir)) {
-    mkdirSync6(configDir, { recursive: true });
+    mkdirSync7(configDir, { recursive: true });
   }
 }
 function writePidFile(configDir, pid) {
   ensureDir(configDir);
-  writeFileSync6(getManagerPaths(configDir).pidFile, String(pid), { mode: 384 });
+  writeFileSync7(getManagerPaths(configDir).pidFile, String(pid), { mode: 384 });
 }
 function readPidFile(configDir) {
   try {
-    const raw = readFileSync9(getManagerPaths(configDir).pidFile, "utf-8").trim();
+    const raw = readFileSync10(getManagerPaths(configDir).pidFile, "utf-8").trim();
     const pid = parseInt(raw, 10);
     return isNaN(pid) ? null : pid;
   } catch {
@@ -9245,7 +9398,7 @@ function defaultPgrep() {
 }
 function readStateFile(configDir) {
   try {
-    const raw = readFileSync9(getManagerPaths(configDir).stateFile, "utf-8");
+    const raw = readFileSync10(getManagerPaths(configDir).stateFile, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -9279,7 +9432,7 @@ function startWatchdog(opts) {
     const { logFile } = getManagerPaths(configDir);
     const logFd = openSync2(logFile, "a", 384);
     try {
-      chmodSync5(logFile, 384);
+      chmodSync6(logFile, 384);
     } catch {
     }
     const intervalSec = String(Math.max(Math.floor(opts.intervalMs / 1e3), 5));
@@ -9441,7 +9594,7 @@ function managerStartCommand(opts) {
     process.exitCode = 1;
     return;
   }
-  const configDir = opts.configDir ?? join9(homedir5(), ".augmented");
+  const configDir = opts.configDir ?? join10(homedir5(), ".augmented");
   if (opts.supervise) {
     if (json) {
       jsonOutput({ ok: false, error: "--supervise is not supported with --json" });
@@ -9537,7 +9690,7 @@ function runSupervisorLoop(intervalSec, configDir) {
 }
 async function managerStopCommand(opts = {}) {
   const json = isJsonMode();
-  const configDir = opts.configDir ?? join9(homedir5(), ".augmented");
+  const configDir = opts.configDir ?? join10(homedir5(), ".augmented");
   try {
     const result = await stopWatchdog(configDir);
     if (!result.stopped && !result.pid) {
@@ -9565,7 +9718,7 @@ async function managerStopCommand(opts = {}) {
 }
 function managerStatusCommand(opts = {}) {
   const json = isJsonMode();
-  const configDir = opts.configDir ?? join9(homedir5(), ".augmented");
+  const configDir = opts.configDir ?? join10(homedir5(), ".augmented");
   const status = getManagerStatus(configDir);
   if (!status) {
     if (json) {
@@ -9657,7 +9810,7 @@ async function managerInstallCommand(opts = {}) {
     process.exitCode = 1;
     return;
   }
-  const configDir = opts.configDir ?? join9(homedir5(), ".augmented");
+  const configDir = opts.configDir ?? join10(homedir5(), ".augmented");
   const rawAgtBin = process.argv[1];
   if (!rawAgtBin) {
     const msg = "Could not resolve the agt binary path from argv. Re-run via the installed `agt` command.";
@@ -9670,7 +9823,7 @@ async function managerInstallCommand(opts = {}) {
   if (process.platform === "darwin") {
     const home = homedir5();
     const protectedRoots = ["Documents", "Downloads", "Desktop", "Movies", "Music", "Pictures"];
-    const offending = protectedRoots.map((r) => join9(home, r)).find((p) => agtBin === p || agtBin.startsWith(`${p}/`));
+    const offending = protectedRoots.map((r) => join10(home, r)).find((p) => agtBin === p || agtBin.startsWith(`${p}/`));
     if (offending) {
       const msg = `agt binary at ${agtBin} sits inside a macOS TCC-protected folder (${offending}). launchd-spawned processes cannot read files there and the manager would EPERM on startup. Either install agt globally (\`npm install -g @integrity-labs/agt-cli\`) or copy the dist outside protected folders before running this command.`;
       if (json) jsonOutput({ ok: false, error: msg });
@@ -9739,7 +9892,7 @@ async function managerInstallSystemUnitCommand(opts = {}) {
     return;
   }
   const user = opts.user ?? "root";
-  const configDir = opts.configDir ?? (user === "root" ? "/root/.augmented" : join9("/home", user, ".augmented"));
+  const configDir = opts.configDir ?? (user === "root" ? "/root/.augmented" : join10("/home", user, ".augmented"));
   const rawAgtBin = process.argv[1];
   if (!rawAgtBin) {
     const msg = "Could not resolve the agt binary path from argv. Re-run via the installed `agt` command.";
@@ -9951,6 +10104,7 @@ function withEvidence(outcome, evidence) {
 export {
   LITERAL_SECRET_PATTERNS,
   safeWriteJsonAtomic,
+  setSecretFileTmpfsBacking,
   extractCommandNotFound,
   migrateAgentDirToIdKeyed,
   provisionStopHook,
@@ -10033,4 +10187,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-HTLUHAKN.js.map
+//# sourceMappingURL=chunk-CLNFPTVG.js.map