@integrity-labs/agt-cli 0.28.263 → 0.28.265

package/dist/lib/manager-worker.js

@@ -37,7 +37,7 @@ import {
   requireHost,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-77QMM7RI.js";
+} from "../chunk-PDE3XSVC.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -122,16 +122,16 @@ import {
   takeZombieDetection,
   transcriptActivityAgeSeconds,
   writeEgressAllowlist
-} from "../chunk-E45AAMBQ.js";
+} from "../chunk-MWKR6B3T.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
 
 // src/lib/manager-worker.ts
 import { createHash as createHash11 } from "crypto";
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, existsSync as existsSync8, rmSync as rmSync4, readdirSync as readdirSync5, statSync as statSync4, copyFileSync } from "fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, existsSync as existsSync9, rmSync as rmSync4, readdirSync as readdirSync5, statSync as statSync4, copyFileSync } from "fs";
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join16, dirname as dirname5 } from "path";
+import { join as join17, dirname as dirname6 } from "path";
 import { homedir as homedir9 } from "os";
 import { fileURLToPath } from "url";
 
@@ -3432,7 +3432,7 @@ function clearAgentState(agentId, codeName) {
 function sanitizeGlobalSkillId(codeName) {
   return codeName.trim().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
-function planGlobalSkillSync(globalSkills, prevIds, hashOf, knownHash) {
+function planGlobalSkillSync(globalSkills, prevIds, hashOf, knownHash, options) {
   const currentIds = /* @__PURE__ */ new Set();
   const installs = [];
   for (const gs of globalSkills ?? []) {
@@ -3446,14 +3446,44 @@ function planGlobalSkillSync(globalSkills, prevIds, hashOf, knownHash) {
     if (knownHash(skillId) === hash) continue;
     installs.push({ skillId, content, hash });
   }
-  const removes = [...prevIds].filter((id) => !currentIds.has(id));
+  const desiredResolved = options?.desiredResolved ?? true;
+  const removes = desiredResolved ? [...prevIds].filter((id) => !currentIds.has(id)) : [];
   return { installs, removes, currentIds };
 }
 
+// src/lib/manager/managed-skill-manifest.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
+var MANIFEST_VERSION = 1;
+function managedSkillManifestPath(agentRootDir) {
+  return join11(agentRootDir, "managed-skills.json");
+}
+function readManagedSkillManifest(path) {
+  try {
+    if (!existsSync4(path)) return /* @__PURE__ */ new Set();
+    const parsed = JSON.parse(readFileSync11(path, "utf-8"));
+    const ids = Array.isArray(parsed?.globalSkillIds) ? parsed.globalSkillIds : [];
+    return new Set(ids.filter((id) => typeof id === "string" && id.length > 0));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function writeManagedSkillManifest(path, ids) {
+  try {
+    mkdirSync4(dirname4(path), { recursive: true });
+    const body = {
+      version: MANIFEST_VERSION,
+      globalSkillIds: [...ids].sort()
+    };
+    writeFileSync5(path, JSON.stringify(body, null, 2));
+  } catch {
+  }
+}
+
 // src/lib/manager/runtime.ts
 import { createHash as createHash6 } from "crypto";
-import { readFileSync as readFileSync11, appendFileSync, mkdirSync as mkdirSync4, chmodSync, existsSync as existsSync4 } from "fs";
-import { join as join11, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync12, appendFileSync, mkdirSync as mkdirSync5, chmodSync, existsSync as existsSync5 } from "fs";
+import { join as join12, dirname as dirname5 } from "path";
 import { homedir as homedir5 } from "os";
 function redactForDiskLog(value) {
   try {
@@ -3474,9 +3504,9 @@ function log(msg) {
 `;
   if (!managerLogPath) {
     try {
-      managerLogPath = join11(homedir5(), ".augmented", "manager.log");
-      mkdirSync4(dirname4(managerLogPath), { recursive: true });
-      if (existsSync4(managerLogPath)) {
+      managerLogPath = join12(homedir5(), ".augmented", "manager.log");
+      mkdirSync5(dirname5(managerLogPath), { recursive: true });
+      if (existsSync5(managerLogPath)) {
         chmodSync(managerLogPath, 384);
       }
     } catch {
@@ -3504,7 +3534,7 @@ function sha256(content) {
 }
 function hashFile(filePath) {
   try {
-    const content = readFileSync11(filePath, "utf-8");
+    const content = readFileSync12(filePath, "utf-8");
     return sha256(content);
   } catch {
     return null;
@@ -3662,8 +3692,8 @@ function resolveModelChain(refreshData) {
 }
 
 // src/lib/manager/claude-auth.ts
-import { existsSync as existsSync5, rmSync as rmSync2 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync6, rmSync as rmSync2 } from "fs";
+import { join as join13 } from "path";
 import { homedir as homedir6 } from "os";
 async function applyClaudeAuthToEnv(childEnv, label) {
   const apiKey = getApiKey();
@@ -3676,10 +3706,10 @@ async function applyClaudeAuthToEnv(childEnv, label) {
       throw new Error("claude_auth_mode=api_key but /host/exchange returned no decrypted key");
     }
     childEnv.ANTHROPIC_API_KEY = exchange.anthropicApiKey;
-    const claudeDir = join12(homedir6(), ".claude");
+    const claudeDir = join13(homedir6(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join12(claudeDir, filename);
-      if (existsSync5(p)) {
+      const p = join13(claudeDir, filename);
+      if (existsSync6(p)) {
         try {
           rmSync2(p, { force: true });
           log(`[${label}] Removed ${p} (api_key mode \u2014 preventing OAuth fallback)`);
@@ -3693,8 +3723,8 @@ async function applyClaudeAuthToEnv(childEnv, label) {
 }
 
 // src/lib/manager/kanban/parsers.ts
-import { existsSync as existsSync6, readFileSync as readFileSync12 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync13 } from "fs";
+import { join as join14 } from "path";
 var STANDUP_TEMPLATES = /* @__PURE__ */ new Set(["daily-standup", "end-of-day-summary"]);
 var TASK_UPDATE_TEMPLATES = /* @__PURE__ */ new Set(["hourly-status", "task-update"]);
 var PLAN_TEMPLATES = /* @__PURE__ */ new Set(["morning-plan"]);
@@ -3818,12 +3848,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join13(process.cwd(), "skills", skillId, "SKILL.md"),
-      join13(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join14(process.cwd(), "skills", skillId, "SKILL.md"),
+      join14(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
-      if (existsSync6(candidate)) {
-        const content = readFileSync12(candidate, "utf-8");
+      if (existsSync7(candidate)) {
+        const content = readFileSync13(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -4956,9 +4986,9 @@ async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput,
 // src/lib/manager/scheduler/execution.ts
 import { createHash as createHash10 } from "crypto";
 import { homedir as homedir7 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function claudePidFilePath() {
-  return join14(homedir7(), ".augmented", "manager-claude-pids.json");
+  return join15(homedir7(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -5158,24 +5188,24 @@ function partitionActionableByPoison(actionable, states, config2) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync13, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync14, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { randomUUID } from "crypto";
 function restartFlagsDir() {
-  return join15(homedir8(), ".augmented", "restart-flags");
+  return join16(homedir8(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join15(restartFlagsDir(), `${codeName}.flag`);
+  return join16(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
-  if (!existsSync7(dir)) return [];
+  if (!existsSync8(dir)) return [];
   const out = [];
   for (const entry of readdirSync4(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync13(join15(dir, entry), "utf8");
+      const raw = readFileSync14(join16(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -5193,7 +5223,7 @@ function readRestartFlags() {
 }
 function deleteRestartFlag(codeName) {
   const path = flagPath(codeName);
-  if (existsSync7(path)) {
+  if (existsSync8(path)) {
     rmSync3(path, { force: true });
   }
 }
@@ -6354,7 +6384,7 @@ var runningMcpServerKeys = /* @__PURE__ */ new Map();
 var runningChannelSecretHashes = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync14(join16(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync15(join17(projectDir, ".mcp.json"), "utf-8");
     return createHash11("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
@@ -6362,7 +6392,7 @@ function projectMcpHash(_codeName, projectDir) {
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync14(join16(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync15(join17(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -6456,7 +6486,7 @@ async function runAgentSessionToolBindProbes(agent, integrations, projectDir, op
   if (result && result.rebindCandidates.length > 0 && hostFlagStore().getBoolean("session-tool-rebind")) {
     let mcpJsonForRebind = null;
     try {
-      mcpJsonForRebind = JSON.parse(readFileSync14(join16(projectDir, ".mcp.json"), "utf-8"));
+      mcpJsonForRebind = JSON.parse(readFileSync15(join17(projectDir, ".mcp.json"), "utf-8"));
     } catch {
       mcpJsonForRebind = null;
     }
@@ -6584,7 +6614,7 @@ function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
 function projectChannelSecretHash(projectDir) {
   try {
     const entries = parseEnvIntegrations(
-      readFileSync14(join16(projectDir, ".env.integrations"), "utf-8")
+      readFileSync15(join17(projectDir, ".env.integrations"), "utf-8")
     );
     return channelSecretValueHash(entries, CHANNEL_SECRET_ENV_KEYS);
   } catch {
@@ -6669,7 +6699,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.263" : "dev";
+var agtCliVersion = true ? "0.28.265" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -6682,7 +6712,7 @@ function resolveBrewPath(execFileSync2) {
     "/usr/local/bin/brew"
   ];
   for (const path of fallbacks) {
-    if (existsSync8(path)) return path;
+    if (existsSync9(path)) return path;
   }
   return null;
 }
@@ -6692,7 +6722,7 @@ function claudeBinaryInstalled(execFileSync2) {
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude"
   ];
-  if (canonical.some((path) => existsSync8(path))) return true;
+  if (canonical.some((path) => existsSync9(path))) return true;
   try {
     execFileSync2("which", ["claude"], { timeout: 5e3 });
     return true;
@@ -6764,7 +6794,7 @@ async function ensureToolkitCli(toolkitSlug) {
         toolkitCliEnsured.add(toolkitSlug);
         return;
       }
-      brewBinDir = dirname5(brewPath);
+      brewBinDir = dirname6(brewPath);
       const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
       log(`[toolkit-install] ${toolkitSlug}: installing via brew (${pkg})\u2026`);
       if (isRoot) {
@@ -6845,8 +6875,8 @@ function claudeManagedSettingsPath() {
 function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
   try {
     let settings = {};
-    if (existsSync8(path)) {
-      const raw = readFileSync14(path, "utf-8").trim();
+    if (existsSync9(path)) {
+      const raw = readFileSync15(path, "utf-8").trim();
       if (raw) {
         let parsed;
         try {
@@ -6862,8 +6892,8 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
     }
     if (settings.channelsEnabled === true) return "ok";
     settings.channelsEnabled = true;
-    mkdirSync6(dirname5(path), { recursive: true });
-    writeFileSync6(path, `${JSON.stringify(settings, null, 2)}
+    mkdirSync7(dirname6(path), { recursive: true });
+    writeFileSync7(path, `${JSON.stringify(settings, null, 2)}
 `);
     log(`[managed-settings] set channelsEnabled:true in ${path} (ENG-5786 \u2014 unblocks Claude Code channels)`);
     return "ok";
@@ -6904,11 +6934,11 @@ async function ensureFrameworkBinary(frameworkId) {
       log(`Claude Code install failed: ${err.message}`);
       return;
     }
-    const brewBinDir = dirname5(brewPath);
+    const brewBinDir = dirname6(brewPath);
     if (!process.env.PATH?.split(":").includes(brewBinDir)) {
       process.env.PATH = `${brewBinDir}:${process.env.PATH ?? ""}`;
     }
-    if (existsSync8("/home/linuxbrew/.linuxbrew/bin/claude")) {
+    if (existsSync9("/home/linuxbrew/.linuxbrew/bin/claude")) {
       log("Claude Code installed successfully");
     } else {
       log("Claude Code install completed but binary not found at expected path \u2014 check brew logs");
@@ -6964,7 +6994,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join16(homedir9(), ".augmented", ".last-self-update-applied");
+  return join17(homedir9(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var restartAfterUpgrade = false;
@@ -6988,7 +7018,7 @@ async function checkAndUpdateCli(opts) {
     const isNpmGlobal = !isBrewFormula && resolvedPath.includes("node_modules");
     if (!isBrewFormula && !isNpmGlobal) return "noop";
     const { readFileSync: readF, writeFileSync: writeF } = await import("fs");
-    const markerPath = join16(homedir9(), ".augmented", ".last-update-check");
+    const markerPath = join17(homedir9(), ".augmented", ".last-update-check");
     if (!force) {
       try {
         const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
@@ -7266,14 +7296,14 @@ async function checkClaudeAuth() {
 }
 var evalEmptyMcpConfigPath = null;
 function ensureEvalEmptyMcpConfig() {
-  if (evalEmptyMcpConfigPath && existsSync8(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
-  const dir = join16(homedir9(), ".augmented");
+  if (evalEmptyMcpConfigPath && existsSync9(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
+  const dir = join17(homedir9(), ".augmented");
   try {
-    mkdirSync6(dir, { recursive: true });
+    mkdirSync7(dir, { recursive: true });
   } catch {
   }
-  const p = join16(dir, ".eval-empty-mcp.json");
-  writeFileSync6(p, JSON.stringify({ mcpServers: {} }));
+  const p = join17(dir, ".eval-empty-mcp.json");
+  writeFileSync7(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
 }
@@ -7364,10 +7394,10 @@ function resolveConversationEvalBackend() {
   return conversationEvalBackend;
 }
 function getStateFile() {
-  return join16(config?.configDir ?? join16(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join17(config?.configDir ?? join17(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join16(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join17(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -7378,7 +7408,7 @@ function saveChannelHashCache2() {
 var _channelQuarantineStore = null;
 function channelQuarantineStore() {
   if (!_channelQuarantineStore) {
-    const dir = config?.configDir ?? join16(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join17(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
   }
   return _channelQuarantineStore;
@@ -7386,7 +7416,7 @@ function channelQuarantineStore() {
 var _hostFlagStore = null;
 function hostFlagStore() {
   if (!_hostFlagStore) {
-    const dir = config?.configDir ?? join16(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join17(process.env["HOME"] ?? "/tmp", ".augmented");
     _hostFlagStore = new HostFlagStore({ cachePath: defaultFlagsCachePath(dir), log });
   }
   return _hostFlagStore;
@@ -7453,13 +7483,13 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
-  const { readdirSync: readdirSync6, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync7 } = await import("fs");
-  const skillsDir = join16(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join16(configDir, codeName, "project", "CLAUDE.md");
+  const { readdirSync: readdirSync6, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync8 } = await import("fs");
+  const skillsDir = join17(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join17(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
   for (const dir of readdirSync6(skillsDir).sort()) {
-    const skillFile = join16(skillsDir, dir, "SKILL.md");
+    const skillFile = join17(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -7501,7 +7531,7 @@ ${SKILLS_INDEX_END}`;
     next = current.trimEnd() + "\n\n" + section + "\n";
   }
   if (next !== current) {
-    writeFileSync7(claudeMdPath, next, "utf-8");
+    writeFileSync8(claudeMdPath, next, "utf-8");
     log2(`Refreshed skills index in CLAUDE.md for '${codeName}' (${entries.length} skills)`);
   }
 }
@@ -7519,7 +7549,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-OP4TXILO.js");
+      const { collectDiagnostics } = await import("../persistent-session-K5RJ4BVF.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames)
@@ -7617,7 +7647,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-OP4TXILO.js");
+      const { collectDiagnostics } = await import("../persistent-session-K5RJ4BVF.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -7765,7 +7795,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-K2RGVZCR.js");
+      } = await import("../responsiveness-probe-2PHY7QKJ.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -7797,7 +7827,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-K2RGVZCR.js");
+        } = await import("../responsiveness-probe-2PHY7QKJ.js");
         const { getProjectDir: wedgeProjectDir } = await import("../claude-scheduler-FATCLHDM.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -7886,13 +7916,13 @@ async function pollCycle() {
             );
             if (hostFlagStore().getBoolean("wedge-transient-notice")) {
               try {
-                const paneTail = readFileSync14(paneLogPath(codeName), "utf8").slice(-65536);
+                const paneTail = readFileSync15(paneLogPath(codeName), "utf8").slice(-65536);
                 const transient = detectTransientApiErrorInLog(paneTail);
                 if (transient) {
-                  const wedgeHome = join16(homedir9(), ".augmented", codeName);
-                  if (existsSync8(wedgeHome)) {
+                  const wedgeHome = join17(homedir9(), ".augmented", codeName);
+                  if (existsSync9(wedgeHome)) {
                     atomicWriteFileSync(
-                      join16(wedgeHome, "watchdog-give-up.json"),
+                      join17(wedgeHome, "watchdog-give-up.json"),
                       JSON.stringify({
                         gave_up_at: wedgeNow.toISOString(),
                         reason: "transient_overload"
@@ -8123,7 +8153,7 @@ async function pollCycle() {
         } catch {
         }
         killAgentChannelProcesses(prev.codeName, { log });
-        const agentDir = join16(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join17(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -8210,10 +8240,10 @@ async function pollCycle() {
         // pending-inbound marker. Best-effort: a write failure is logged by
         // the watchdog, never fails the poll cycle.
         signalGiveUp: (codeName) => {
-          const dir = join16(homedir9(), ".augmented", codeName);
-          if (!existsSync8(dir)) return;
+          const dir = join17(homedir9(), ".augmented", codeName);
+          if (!existsSync9(dir)) return;
           atomicWriteFileSync(
-            join16(dir, "watchdog-give-up.json"),
+            join17(dir, "watchdog-give-up.json"),
             JSON.stringify({ gave_up_at: (/* @__PURE__ */ new Date()).toISOString() })
           );
         }
@@ -8343,7 +8373,7 @@ async function processAgent(agent, agentStates) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join16(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join17(adapter.getAgentDir(agent.code_name), "provision");
   if (agent.status === "draft" || agent.status === "paused") {
     if (previousKnownStatus !== agent.status) {
       log(`Agent '${agent.code_name}' is ${agent.status}, skipping provisioning`);
@@ -8389,7 +8419,7 @@ async function processAgent(agent, agentStates) {
       const residuals = {
         gatewayRunning: false,
         portAllocated: false,
-        provisionDirExists: existsSync8(agentDir)
+        provisionDirExists: existsSync9(agentDir)
       };
       if (!hasRevokedResiduals(residuals)) {
         agentStates.push({
@@ -8527,7 +8557,7 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? DEFAULT_FRAMEWORK;
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join16(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join17(frameworkAdapter.getAgentDir(agent.code_name), "provision");
   cacheAgentDeliveryMetadata(agent.code_name, refreshData);
   agentRestartTimezoneInputs.set(agent.code_name, {
     agentTimezone: typeof refreshData.agent.timezone === "string" ? refreshData.agent.timezone : null,
@@ -8572,9 +8602,9 @@ async function processAgent(agent, agentStates) {
   try {
     const artifacts = generateArtifacts(agent, refreshData, frameworkAdapter);
     const changedFiles = [];
-    mkdirSync6(agentDir, { recursive: true });
+    mkdirSync7(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join16(agentDir, artifact.relativePath);
+      const filePath = join17(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -8593,8 +8623,8 @@ async function processAgent(agent, agentStates) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join16(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync14(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join17(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync15(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -8612,7 +8642,7 @@ async function processAgent(agent, agentStates) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync14(filePath, "utf-8");
+          existingRaw = readFileSync15(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -8634,26 +8664,26 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync8(join16(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync9(join17(agentDir, "CHARTER.md"));
       const verb = isFirst ? "Provisioning" : "Updating";
       const fileNames = changedFiles.map((f) => f.relativePath).join(", ");
       log(`${verb} '${agent.code_name}': ${fileNames}`);
       for (const file of changedFiles) {
-        const filePath = join16(agentDir, file.relativePath);
-        mkdirSync6(dirname5(filePath), { recursive: true });
+        const filePath = join17(agentDir, file.relativePath);
+        mkdirSync7(dirname6(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
         } else {
-          writeFileSync6(filePath, file.content);
+          writeFileSync7(filePath, file.content);
         }
       }
       try {
-        const provSkillsDir = join16(agentDir, ".claude", "skills");
-        if (existsSync8(provSkillsDir)) {
+        const provSkillsDir = join17(agentDir, ".claude", "skills");
+        if (existsSync9(provSkillsDir)) {
           for (const folder of readdirSync5(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync4(join16(provSkillsDir, folder), { recursive: true });
+                rmSync4(join17(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -8666,7 +8696,7 @@ async function processAgent(agent, agentStates) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join16(agentDir, file));
+        const h = hashFile(join17(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -8684,14 +8714,14 @@ async function processAgent(agent, agentStates) {
     }
     if (Array.isArray(refreshData.workflows)) {
       try {
-        const provWorkflowsDir = join16(agentDir, ".claude", "workflows");
-        if (existsSync8(provWorkflowsDir)) {
+        const provWorkflowsDir = join17(agentDir, ".claude", "workflows");
+        if (existsSync9(provWorkflowsDir)) {
           const expected = new Set(refreshData.workflows.map((w) => `${w.name}.js`));
           for (const file of readdirSync5(provWorkflowsDir)) {
             if (!file.endsWith(".js")) continue;
             if (expected.has(file)) continue;
             try {
-              rmSync4(join16(provWorkflowsDir, file));
+              rmSync4(join17(provWorkflowsDir, file));
             } catch {
             }
           }
@@ -8748,10 +8778,10 @@ async function processAgent(agent, agentStates) {
   }
   let lastDriftCheckAt = now;
   const written = agentState.writtenHashes.get(agent.agent_id);
-  if (written && existsSync8(agentDir)) {
+  if (written && existsSync9(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join16(agentDir, file));
+      const localHash = hashFile(join17(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -8762,7 +8792,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join16(agentDir, file));
+          localHashes[file] = hashFile(join17(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -8949,15 +8979,15 @@ async function processAgent(agent, agentStates) {
     const addedChannels = [...restartDecision.added];
     const writeDmNoticeMarkers = isChannelAddRestart ? () => {
       try {
-        const agentAugmentedDir = join16(homedir9(), ".augmented", agent.code_name);
-        mkdirSync6(agentAugmentedDir, { recursive: true });
+        const agentAugmentedDir = join17(homedir9(), ".augmented", agent.code_name);
+        mkdirSync7(agentAugmentedDir, { recursive: true });
         const markerJson = JSON.stringify({
           version: 1,
           at: (/* @__PURE__ */ new Date()).toISOString(),
           added: addedChannels
         });
         for (const file of ["slack-channel-add-restart.json", "telegram-channel-add-restart.json"]) {
-          atomicWriteFileSync(join16(agentAugmentedDir, file), markerJson);
+          atomicWriteFileSync(join17(agentAugmentedDir, file), markerJson);
         }
       } catch (err) {
         log(`[hot-reload] channel-add DM-notice marker write failed for '${agent.code_name}' (non-fatal): ${err.message}`);
@@ -9110,24 +9140,24 @@ async function processAgent(agent, agentStates) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK) === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join16(homedir9(), ".augmented", agent.code_name, "project");
-      mkdirSync6(agentProvisionDir, { recursive: true });
-      mkdirSync6(projectDir, { recursive: true });
-      const provisionMcpPath = join16(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join16(projectDir, ".mcp.json");
+      const projectDir = join17(homedir9(), ".augmented", agent.code_name, "project");
+      mkdirSync7(agentProvisionDir, { recursive: true });
+      mkdirSync7(projectDir, { recursive: true });
+      const provisionMcpPath = join17(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join17(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync14(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync15(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join16(homedir9(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join17(homedir9(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
         return typeof tz === "string" && tz.trim() !== "" ? tz.trim() : void 0;
       })();
-      if (existsSync8(localDirectChatChannel)) {
+      if (existsSync9(localDirectChatChannel)) {
         const directChatEnv = {
           AGT_HOST: requireHost(),
           // ENG-5901 Track D: templated — the manager exports the real
@@ -9147,7 +9177,7 @@ async function processAgent(agent, agentStates) {
           // ~/.augmented/<codeName>/.current-turn-initiator.json. Note getAgentDir
           // returns the agent root (NOT the /provision subdir `agentDir` points at),
           // so it byte-matches the broker readers' path.
-          AGT_TURN_INITIATOR_FILE: join16(
+          AGT_TURN_INITIATOR_FILE: join17(
             frameworkAdapter.getAgentDir(agent.code_name),
             ".current-turn-initiator.json"
           )
@@ -9167,8 +9197,8 @@ async function processAgent(agent, agentStates) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join16(projectDir, ".mcp-channels.json");
-      if (existsSync8(staleChannelsPath)) {
+      const staleChannelsPath = join17(projectDir, ".mcp-channels.json");
+      if (existsSync9(staleChannelsPath)) {
         try {
           rmSync4(staleChannelsPath, { force: true });
         } catch {
@@ -9235,7 +9265,7 @@ async function processAgent(agent, agentStates) {
     }
     if (hostFlagStore().getBoolean("connectivity-probe")) {
       try {
-        const probeProjectDir = join16(homedir9(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join17(homedir9(), ".augmented", agent.code_name, "project");
         await runAgentConnectivityProbes(agent, integrations, probeProjectDir);
       } catch (err) {
         log(`Connectivity probe failed for '${agent.code_name}': ${err.message}`);
@@ -9246,7 +9276,7 @@ async function processAgent(agent, agentStates) {
       const forceDue = attemptsLeft > 0;
       let probeRan = false;
       try {
-        const probeProjectDir = join16(homedir9(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join17(homedir9(), ".augmented", agent.code_name, "project");
         probeRan = await runAgentSessionToolBindProbes(agent, integrations, probeProjectDir, { forceDue });
       } catch (err) {
         log(`Session-tool-bind probe failed for '${agent.code_name}': ${err.message}`);
@@ -9259,9 +9289,9 @@ async function processAgent(agent, agentStates) {
     }
     if (frameworkAdapter.removeMcpServer && frameworkAdapter.getMcpPath) {
       const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
-      if (mcpPath && existsSync8(mcpPath)) {
+      if (mcpPath && existsSync9(mcpPath)) {
         try {
-          const cfg = JSON.parse(readFileSync14(mcpPath, "utf-8"));
+          const cfg = JSON.parse(readFileSync15(mcpPath, "utf-8"));
           const expectedRemoteKeys = new Set(
             integrations.map((i) => i.definition_id)
           );
@@ -9286,11 +9316,11 @@ async function processAgent(agent, agentStates) {
         recordConfigChurnEvent(agent.agent_id, agent.code_name, FLAP_CHANNEL_INTEGRATIONS, intMembership);
       }
       if (intHash !== prevIntHash) {
-        const projectDir = join16(homedir9(), ".augmented", agent.code_name, "project");
-        const envIntPath = join16(projectDir, ".env.integrations");
+        const projectDir = join17(homedir9(), ".augmented", agent.code_name, "project");
+        const envIntPath = join17(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
-          preWriteEnv = readFileSync14(envIntPath, "utf-8");
+          preWriteEnv = readFileSync15(envIntPath, "utf-8");
         } catch {
           preWriteEnv = void 0;
         }
@@ -9302,9 +9332,9 @@ async function processAgent(agent, agentStates) {
         let rotationHandled = true;
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join16(projectDir, ".mcp.json");
-            const postWriteEnv = readFileSync14(envIntPath, "utf-8");
-            const mcpContent = readFileSync14(projectMcpPath, "utf-8");
+            const projectMcpPath = join17(projectDir, ".mcp.json");
+            const postWriteEnv = readFileSync15(envIntPath, "utf-8");
+            const mcpContent = readFileSync15(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
             const mcpJsonForReap = JSON.parse(mcpContent);
             const affectedServerKeys = findMcpServersUsingVars(mcpJsonForReap, changedVars);
@@ -9387,8 +9417,8 @@ async function processAgent(agent, agentStates) {
             const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
             if (mcpPath) {
               try {
-                const { readFileSync: readFileSync15 } = await import("fs");
-                const mcpConfig = JSON.parse(readFileSync15(mcpPath, "utf-8"));
+                const { readFileSync: readFileSync16 } = await import("fs");
+                const mcpConfig = JSON.parse(readFileSync16(mcpPath, "utf-8"));
                 if (mcpConfig.mcpServers) {
                   for (const key of Object.keys(mcpConfig.mcpServers)) {
                     if (isManagedMcpServerKey(key) && !expectedServerIds.has(key)) {
@@ -9528,14 +9558,14 @@ async function processAgent(agent, agentStates) {
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join16(homedir10(), ".augmented", agent.code_name, "skills"),
+          join17(homedir10(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join16(homedir10(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join17(homedir10(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join16(agentDir, ".claude", "skills")
+          join17(agentDir, ".claude", "skills")
         ];
-        const existingDirs = candidateSkillDirs.filter((d) => existsSync8(d));
+        const existingDirs = candidateSkillDirs.filter((d) => existsSync9(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
         for (const dir of existingDirs) {
           try {
@@ -9549,8 +9579,8 @@ async function processAgent(agent, agentStates) {
         }
         const removeSkillFolder = (entry, reason) => {
           for (const dir of existingDirs) {
-            const p = join16(dir, entry);
-            if (existsSync8(p)) {
+            const p = join17(dir, entry);
+            if (existsSync9(p)) {
               rmSync5(p, { recursive: true, force: true });
             }
           }
@@ -9565,11 +9595,22 @@ async function processAgent(agent, agentStates) {
         log(`Integration skill cleanup failed for '${agent.code_name}': ${err.message}`);
       }
       try {
+        const globalSkillsPayload = refreshAny.global_skills;
+        const sharedSkillsPayload = refreshAny.shared_skills;
+        const desiredResolved = globalSkillsPayload !== void 0 || sharedSkillsPayload !== void 0;
+        const manifestPath = managedSkillManifestPath(
+          join17(homedir9(), ".augmented", agent.code_name)
+        );
+        const prevIds = /* @__PURE__ */ new Set([
+          ...agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
+          ...readManagedSkillManifest(manifestPath)
+        ]);
         const plan = planGlobalSkillSync(
-          [...refreshAny.global_skills ?? [], ...refreshAny.shared_skills ?? []],
-          agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
+          [...globalSkillsPayload ?? [], ...sharedSkillsPayload ?? []],
+          prevIds,
           (content) => createHash12("sha256").update(content).digest("hex").slice(0, 12),
-          (skillId) => agentState.knownSkillHashes.get(`global-skill:${agent.agent_id}:${skillId}`)
+          (skillId) => agentState.knownSkillHashes.get(`global-skill:${agent.agent_id}:${skillId}`),
+          { desiredResolved }
         );
         for (const { skillId, content, hash } of plan.installs) {
           frameworkAdapter.installSkillFiles(agent.code_name, skillId, [{ relativePath: "SKILL.md", content }]);
@@ -9577,23 +9618,30 @@ async function processAgent(agent, agentStates) {
           log(`Installed global skill '${skillId}' for '${agent.code_name}'`);
         }
         if (plan.removes.length) {
-          const { rmSync: rmSync5 } = await import("fs");
-          const { homedir: homedir10 } = await import("os");
           const globalSkillDirs = [
-            join16(homedir10(), ".augmented", agent.code_name, "skills"),
-            join16(homedir10(), ".augmented", agent.code_name, "project", ".claude", "skills"),
-            join16(agentDir, ".claude", "skills")
+            join17(homedir9(), ".augmented", agent.code_name, "skills"),
+            join17(homedir9(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+            join17(agentDir, ".claude", "skills")
           ];
           for (const id of plan.removes) {
+            let prunedAny = false;
             for (const dir of globalSkillDirs) {
-              const p = join16(dir, id);
-              if (existsSync8(p)) rmSync5(p, { recursive: true, force: true });
+              const p = join17(dir, id);
+              if (existsSync9(p) && existsSync9(join17(p, "SKILL.md"))) {
+                rmSync4(p, { recursive: true, force: true });
+                prunedAny = true;
+              }
             }
             agentState.knownSkillHashes.delete(`global-skill:${agent.agent_id}:${id}`);
-            log(`Removed unpublished global skill '${id}' for '${agent.code_name}'`);
+            if (prunedAny) {
+              log(`Pruned unassigned skill '${id}' for '${agent.code_name}' (ENG-7492)`);
+            }
           }
         }
         agentState.knownGlobalSkillIds.set(agent.agent_id, plan.currentIds);
+        if (desiredResolved) {
+          writeManagedSkillManifest(manifestPath, plan.currentIds);
+        }
       } catch (err) {
         log(`Global skill install failed for '${agent.code_name}': ${err.message}`);
       }
@@ -9761,8 +9809,8 @@ async function processAgent(agent, agentStates) {
       const sess = getSessionState(agent.code_name);
       let mcpJsonParsed = null;
       try {
-        const mcpPath = join16(getProjectDir(agent.code_name), ".mcp.json");
-        mcpJsonParsed = JSON.parse(readFileSync14(mcpPath, "utf-8"));
+        const mcpPath = join17(getProjectDir(agent.code_name), ".mcp.json");
+        mcpJsonParsed = JSON.parse(readFileSync15(mcpPath, "utf-8"));
       } catch {
       }
       reapMissingMcpSessions({
@@ -10032,10 +10080,10 @@ In progress for ${age} minutes \u2014 auto-failed`).catch(() => {
     }
   }
   const trackedFiles = frameworkAdapter.driftTrackedFiles();
-  if (trackedFiles.length > 0 && existsSync8(agentDir)) {
+  if (trackedFiles.length > 0 && existsSync9(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join16(agentDir, file));
+      const h = hashFile(join17(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -10050,7 +10098,7 @@ In progress for ${age} minutes \u2014 auto-failed`).catch(() => {
         refreshData.agent.onboarding_state
       );
       const obStep = obState.step;
-      const markerPath = join16(homedir9(), ".augmented", agent.code_name, "onboarding-drive.json");
+      const markerPath = join17(homedir9(), ".augmented", agent.code_name, "onboarding-drive.json");
       const marker = readOnboardingDriveMarker(markerPath);
       const decision = decideOnboardingDrive(obStep, marker, Date.now(), obState.generation ?? 0);
       if (decision.clearMarker) {
@@ -10113,8 +10161,8 @@ var egressAllowlistEqual = (a, b) => a.length === b.length && a.every((d, i) =>
 async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const codeName = agent.code_name;
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join16(projectDir, ".mcp.json");
-  const claudeMdPath = join16(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join17(projectDir, ".mcp.json");
+  const claudeMdPath = join17(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -10623,7 +10671,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
     void api.post("/host/restart-ack", { host_id: hostId, agent_id: agentId, restart_requested_at: requestedAt }).catch((err) => log(`[restart-lane] ack failed for '${codeName}': ${err.message}`));
     void (async () => {
       try {
-        const { collectDiagnostics } = await import("../persistent-session-OP4TXILO.js");
+        const { collectDiagnostics } = await import("../persistent-session-K5RJ4BVF.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName])
@@ -10673,7 +10721,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-OP4TXILO.js");
+      const { collectDiagnostics } = await import("../persistent-session-K5RJ4BVF.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName])
@@ -10915,8 +10963,8 @@ async function processDirectChatMessage(agent, msg) {
     if (useDoorbell) {
       try {
         const doorbell = directChatDoorbellPath(agent.agentId, homedir9());
-        mkdirSync6(dirname5(doorbell), { recursive: true });
-        writeFileSync6(doorbell, String(Date.now()));
+        mkdirSync7(dirname6(doorbell), { recursive: true });
+        writeFileSync7(doorbell, String(Date.now()));
         log(`[direct-chat] Doorbell rung for '${agent.codeName}' (msg=${msg.id}) \u2014 in-session MCP will pull via the cursor`);
         return;
       } catch (err) {
@@ -10984,8 +11032,8 @@ ${formatRunMarker(run_id)}` : KANBAN_CHECK_COMMAND;
   if (run_id) openInjectedRunByCode.set(codeName, run_id);
   try {
     const doorbell = directChatDoorbellPath(agentId, homedir9());
-    mkdirSync6(dirname5(doorbell), { recursive: true });
-    writeFileSync6(doorbell, String(Date.now()));
+    mkdirSync7(dirname6(doorbell), { recursive: true });
+    writeFileSync7(doorbell, String(Date.now()));
   } catch (err) {
     log(`[kanban] doorbell ring failed for '${codeName}': ${err.message} (notice still queued)`);
   }
@@ -11064,7 +11112,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-X5NJYZSK.js");
+  } = await import("../claude-pair-runtime-YZ2PGUW3.js");
   for (const pairId of pendingResp.cancelled_pair_ids ?? []) {
     log(`[claude-pair] sweeping orphan tmux session for pair ${pairId.slice(0, 8)}`);
     const killed = await killPairSession(pairTmuxSession(pairId));
@@ -11307,8 +11355,8 @@ function parseMemoryFile(raw, fallbackName) {
   };
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join16(configDir, agent.code_name, "project");
-  const memoryDir = join16(projectDir, "memory");
+  const projectDir = join17(configDir, agent.code_name, "project");
+  const memoryDir = join17(projectDir, "memory");
   const isFreshSync = pendingFreshMemorySync.has(agent.agent_id);
   if (isFreshSync) {
     log2(`[memory-sync] Fresh-sync requested for '${agent.code_name}' \u2014 pulling DB first`);
@@ -11319,14 +11367,14 @@ async function syncMemories(agent, configDir, log2) {
     }
     pendingFreshMemorySync.delete(agent.agent_id);
   }
-  if (existsSync8(memoryDir)) {
+  if (existsSync9(memoryDir)) {
     const prevHashes = memoryFileHashes.get(agent.agent_id) ?? /* @__PURE__ */ new Map();
     const currentHashes = /* @__PURE__ */ new Map();
     const changedMemories = [];
     for (const file of readdirSync5(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync14(join16(memoryDir, file), "utf-8");
+        const raw = readFileSync15(join17(memoryDir, file), "utf-8");
         const fileHash = createHash11("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
@@ -11351,7 +11399,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync14(join16(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync15(join17(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -11364,7 +11412,7 @@ async function syncMemories(agent, configDir, log2) {
   }
 }
 async function downloadMemories(agent, memoryDir, log2, { force }) {
-  const localFiles = existsSync8(memoryDir) ? readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
+  const localFiles = existsSync9(memoryDir) ? readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
   const localListHash = createHash11("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
   const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
   const prevDownload = lastDownloadHash.get(agent.agent_id);
@@ -11379,14 +11427,14 @@ async function downloadMemories(agent, memoryDir, log2, { force }) {
     lastDownloadHash.set(agent.agent_id, responseHash);
     lastLocalFileHash.set(agent.agent_id, localListHash);
     if (dbMemories.memories?.length) {
-      mkdirSync6(memoryDir, { recursive: true });
+      mkdirSync7(memoryDir, { recursive: true });
       let written = 0;
       let overwritten = 0;
       for (let i = 0; i < dbMemories.memories.length; i++) {
         const mem = dbMemories.memories[i];
         const rawSlug = mem.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 60);
         const slug = rawSlug || `memory-${i}`;
-        const filePath = join16(memoryDir, `${slug}.md`);
+        const filePath = join17(memoryDir, `${slug}.md`);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -11395,17 +11443,17 @@ description: ${JSON.stringify(mem.content.slice(0, 200))}
 
 ${mem.content}
 `;
-        if (existsSync8(filePath)) {
+        if (existsSync9(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync14(filePath, "utf-8");
+            existing = readFileSync15(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) continue;
-          writeFileSync6(filePath, desired);
+          writeFileSync7(filePath, desired);
           overwritten++;
         } else {
-          writeFileSync6(filePath, desired);
+          writeFileSync7(filePath, desired);
           written++;
         }
       }
@@ -11422,7 +11470,7 @@ ${mem.content}
   }
 }
 async function cleanupAgentFiles(codeName, agentDir) {
-  if (existsSync8(agentDir)) {
+  if (existsSync9(agentDir)) {
     try {
       rmSync4(agentDir, { recursive: true, force: true });
       log(`Removed provision directory for '${codeName}'`);
@@ -11655,8 +11703,8 @@ function startManager(opts) {
   config = opts;
   try {
     const stateFile = getStateFile();
-    if (existsSync8(stateFile)) {
-      const raw = readFileSync14(stateFile, "utf-8");
+    if (existsSync9(stateFile)) {
+      const raw = readFileSync15(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
         state6.agents = parsed.agents;
@@ -11683,7 +11731,7 @@ function startManager(opts) {
     log(`[startup] state rehydration failed (continuing with empty state): ${err.message}`);
   }
   log(
-    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join16(homedir9(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join17(homedir9(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -11704,7 +11752,7 @@ async function reapOrphanedClaudePids() {
   const looksLikeClaude = (pid) => {
     if (process.platform !== "linux") return true;
     try {
-      const comm = readFileSync14(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
+      const comm = readFileSync15(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
       return comm.includes("claude");
     } catch {
       return false;
@@ -11801,18 +11849,18 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join16(homedir9(), ".augmented", "_mcp");
-  mkdirSync6(targetDir, { recursive: true });
-  const moduleDir = dirname5(fileURLToPath(import.meta.url));
+  const targetDir = join17(homedir9(), ".augmented", "_mcp");
+  mkdirSync7(targetDir, { recursive: true });
+  const moduleDir = dirname6(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join16(dir, "dist", "mcp");
-    if (existsSync8(join16(candidate, "index.js"))) {
+    const candidate = join17(dir, "dist", "mcp");
+    if (existsSync9(join17(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
-    const parent = dirname5(dir);
+    const parent = dirname6(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -11823,8 +11871,8 @@ function deployMcpAssets() {
   const changedBasenames = [];
   const fileHash = (p) => {
     try {
-      if (!existsSync8(p)) return null;
-      return createHash11("sha256").update(readFileSync14(p)).digest("hex");
+      if (!existsSync9(p)) return null;
+      return createHash11("sha256").update(readFileSync15(p)).digest("hex");
     } catch {
       return null;
     }
@@ -11877,9 +11925,9 @@ function deployMcpAssets() {
     // never needs restarting to pick up a key rotation either.
     "origami.js"
   ]) {
-    const src = join16(mcpSourceDir, file);
-    const dst = join16(targetDir, file);
-    if (!existsSync8(src)) continue;
+    const src = join17(mcpSourceDir, file);
+    const dst = join17(targetDir, file);
+    if (!existsSync9(src)) continue;
     const before = fileHash(dst);
     try {
       copyFileSync(src, dst);
@@ -11896,23 +11944,23 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join16(targetDir, "index.js");
+  const localMcpPath = join17(targetDir, "index.js");
   try {
-    const agentsDir = join16(homedir9(), ".augmented", "agents");
-    if (existsSync8(agentsDir)) {
+    const agentsDir = join17(homedir9(), ".augmented", "agents");
+    if (existsSync9(agentsDir)) {
       for (const entry of readdirSync5(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join16(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join17(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync14(mcpJsonPath, "utf-8");
+            const raw = readFileSync15(mcpJsonPath, "utf-8");
             if (!raw.includes("@integrity-labs/augmented-mcp")) continue;
             const mcpConfig = JSON.parse(raw);
             const augServer = mcpConfig.mcpServers?.["augmented"];
             if (!augServer) continue;
             augServer.command = "node";
             augServer.args = [localMcpPath];
-            writeFileSync6(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+            writeFileSync7(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
             log(`[manager] Patched ${entry.name}/${subdir}/.mcp.json: npx \u2192 node`);
           } catch {
           }