@integrity-labs/agt-cli 0.28.313 → 0.28.314

package/dist/lib/manager-worker.js

@@ -39,7 +39,7 @@ import {
   requireHost,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-57W744KO.js";
+} from "../chunk-R5AKZYDG.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -134,9 +134,9 @@ import {
 
 // src/lib/manager-worker.ts
 import { createHash as createHash11 } from "crypto";
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7, existsSync as existsSync9, rmSync as rmSync4, readdirSync as readdirSync5, statSync as statSync4, copyFileSync } from "fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7, existsSync as existsSync10, rmSync as rmSync4, readdirSync as readdirSync5, statSync as statSync4, copyFileSync } from "fs";
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join18, dirname as dirname6 } from "path";
+import { join as join19, dirname as dirname6 } from "path";
 import { homedir as homedir10 } from "os";
 import { fileURLToPath } from "url";
 
@@ -331,31 +331,34 @@ function resolveChannelLaunchFlags(channelConfigs, quarantinedChannels) {
 function decideSenderPolicyRestart(input) {
   const {
     previousHash,
+    currentPolicyRestrictive,
     currentHash,
     sessionMode,
     framework,
     sessionHealthy,
     channelSetRestartAlreadyScheduled
   } = input;
-  if (previousHash === void 0) {
-    return { restart: false, firstPoll: true, changed: false };
-  }
-  if (previousHash === currentHash) {
+  const firstPoll = previousHash === void 0;
+  if (!firstPoll && previousHash === currentHash) {
     return { restart: false, firstPoll: false, changed: false };
   }
+  if (firstPoll && !currentPolicyRestrictive) {
+    return { restart: false, firstPoll: true, changed: false };
+  }
+  const changed = !firstPoll;
   if (sessionMode !== "persistent") {
-    return { restart: false, firstPoll: false, changed: true };
+    return { restart: false, firstPoll, changed };
   }
   if (framework !== "claude-code") {
-    return { restart: false, firstPoll: false, changed: true };
+    return { restart: false, firstPoll, changed };
   }
   if (!sessionHealthy) {
-    return { restart: false, firstPoll: false, changed: true };
+    return { restart: false, firstPoll, changed };
   }
   if (channelSetRestartAlreadyScheduled) {
-    return { restart: false, firstPoll: false, changed: true };
+    return { restart: false, firstPoll, changed };
   }
-  return { restart: true, firstPoll: false, changed: true };
+  return { restart: true, firstPoll, changed };
 }
 
 // src/lib/sender-policy-normalize.ts
@@ -400,6 +403,13 @@ function normalizeSenderPolicyForHash(policy) {
 function computeSenderPolicyRestartHash(policy) {
   return createHash3("sha256").update(canonicalJson({ senderPolicy: normalizeSenderPolicyForHash(policy) })).digest("hex");
 }
+function isSenderPolicyRestrictive(policy) {
+  if (policy === null || policy === void 0) return false;
+  if (typeof policy !== "object") return true;
+  const p = policy;
+  if (p.internal_only === true) return true;
+  return p.mode !== "all";
+}
 
 // src/lib/msteams-behaviour-restart.ts
 function extractMsTeamsBehaviourSubset(config2) {
@@ -654,7 +664,17 @@ var PROVISIONING_RELOAD_REASONS = /* @__PURE__ */ new Set([
   "bind-remediation",
   // ENG-7576: the dashboard integration-add stop itself - the first restart of
   // the very burst this class exists for, previously uncounted entirely.
-  "integration-change"
+  "integration-change",
+  // ENG-7771: a sender_policy delivery restart is a deliberate config-delivery
+  // reload (operator changed the policy, or the fail-closed first-poll verify
+  // after a manager restart with no persisted baseline), not a crash. On the
+  // tight crash tally, a host whose sender-policy-baseline.json write keeps
+  // failing (disk full, permissions) would convert the fail-closed restart
+  // into repeated crash tallies across a multi-deploy day and trip the
+  // breaker - taking the agent DOWN, which is strictly worse than the stale
+  // policy the restart exists to fix. The looser provisioning tally still
+  // trips + pages on sustained thrash.
+  "sender-policy-change"
 ]);
 function isProvisioningReloadReason(reason) {
   return PROVISIONING_RELOAD_REASONS.has(reason);
@@ -1402,7 +1422,10 @@ var GATEABLE_RESTART_REASONS = /* @__PURE__ */ new Set([
 function isGateableRestartReason(reason) {
   return reason != null && GATEABLE_RESTART_REASONS.has(reason);
 }
-var WINDOW_EXEMPT_RESTART_REASONS = /* @__PURE__ */ new Set(["channel-set-change"]);
+var WINDOW_EXEMPT_RESTART_REASONS = /* @__PURE__ */ new Set([
+  "channel-set-change",
+  "sender-policy-change"
+]);
 function isWindowExemptRestartReason(reason) {
   return reason != null && WINDOW_EXEMPT_RESTART_REASONS.has(reason);
 }
@@ -3193,6 +3216,63 @@ function saveChannelHashCache(source, configDir) {
   }
 }
 
+// src/lib/sender-policy-baseline.ts
+import { existsSync as existsSync4, readFileSync as readFileSync11 } from "fs";
+import { join as join11 } from "path";
+var BASELINE_FILENAME = "sender-policy-baseline.json";
+var SENDER_POLICY_BASELINE_VERSION = 1;
+function getSenderPolicyBaselineFile(configDir) {
+  return join11(configDir, BASELINE_FILENAME);
+}
+function loadSenderPolicyBaseline(target, configDir, log2) {
+  const path = getSenderPolicyBaselineFile(configDir);
+  if (!existsSync4(path)) return;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync11(path, "utf-8"));
+  } catch (err) {
+    log2?.(
+      `[sender-policy] discarding corrupt ${BASELINE_FILENAME} (${err.message}) - restrictive-policy agents will take one fail-closed restart`
+    );
+    return;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    log2?.(
+      `[sender-policy] discarding malformed ${BASELINE_FILENAME} (not an object) - restrictive-policy agents will take one fail-closed restart`
+    );
+    return;
+  }
+  const obj = parsed;
+  if (obj.version !== SENDER_POLICY_BASELINE_VERSION) {
+    log2?.(
+      `[sender-policy] discarding ${BASELINE_FILENAME} with version ${String(obj.version)} (expected ${SENDER_POLICY_BASELINE_VERSION}) - hash semantics changed; restrictive-policy agents will take one fail-closed restart`
+    );
+    return;
+  }
+  const entries = obj.senderPolicy;
+  if (!entries || typeof entries !== "object" || Array.isArray(entries)) return;
+  for (const [agentId, hash] of Object.entries(entries)) {
+    if (typeof hash === "string" && hash.length > 0) target.set(agentId, hash);
+  }
+}
+function saveSenderPolicyBaseline(source, configDir, log2) {
+  const path = getSenderPolicyBaselineFile(configDir);
+  const senderPolicy = {};
+  for (const [agentId, hash] of source) senderPolicy[agentId] = hash;
+  const payload = JSON.stringify(
+    { version: SENDER_POLICY_BASELINE_VERSION, senderPolicy },
+    null,
+    2
+  );
+  try {
+    atomicWriteFileSync(path, payload);
+  } catch (err) {
+    log2?.(
+      `[sender-policy] failed to persist ${BASELINE_FILENAME} (non-fatal): ${err.message}`
+    );
+  }
+}
+
 // src/lib/channel-sweep.ts
 import { execFileSync } from "child_process";
 var CHANNEL_BASENAMES = [
@@ -3632,16 +3712,16 @@ function planGlobalSkillSync(globalSkills, prevIds, hashOf, knownHash, options)
 }
 
 // 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";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname4, join as join12 } from "path";
 var MANIFEST_VERSION = 1;
 function managedSkillManifestPath(agentRootDir) {
-  return join11(agentRootDir, "managed-skills.json");
+  return join12(agentRootDir, "managed-skills.json");
 }
 function readManagedSkillManifest(path) {
   try {
-    if (!existsSync4(path)) return /* @__PURE__ */ new Set();
-    const parsed = JSON.parse(readFileSync11(path, "utf-8"));
+    if (!existsSync5(path)) return /* @__PURE__ */ new Set();
+    const parsed = JSON.parse(readFileSync12(path, "utf-8"));
     const ids = Array.isArray(parsed?.globalSkillIds) ? parsed.globalSkillIds : [];
     return new Set(ids.filter((id) => typeof id === "string" && id.length > 0));
   } catch {
@@ -3662,8 +3742,8 @@ function writeManagedSkillManifest(path, ids) {
 
 // src/lib/manager/runtime.ts
 import { createHash as createHash6 } from "crypto";
-import { readFileSync as readFileSync12, appendFileSync, mkdirSync as mkdirSync5, chmodSync, existsSync as existsSync5 } from "fs";
-import { join as join12, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync13, appendFileSync, mkdirSync as mkdirSync5, chmodSync, existsSync as existsSync6 } from "fs";
+import { join as join13, dirname as dirname5 } from "path";
 import { homedir as homedir5 } from "os";
 function redactForDiskLog(value) {
   try {
@@ -3684,9 +3764,9 @@ function log(msg) {
 `;
   if (!managerLogPath) {
     try {
-      managerLogPath = join12(homedir5(), ".augmented", "manager.log");
+      managerLogPath = join13(homedir5(), ".augmented", "manager.log");
       mkdirSync5(dirname5(managerLogPath), { recursive: true });
-      if (existsSync5(managerLogPath)) {
+      if (existsSync6(managerLogPath)) {
         chmodSync(managerLogPath, 384);
       }
     } catch {
@@ -3714,7 +3794,7 @@ function sha256(content) {
 }
 function hashFile(filePath) {
   try {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     return sha256(content);
   } catch {
     return null;
@@ -3872,8 +3952,8 @@ function resolveModelChain(refreshData) {
 }
 
 // src/lib/manager/claude-auth.ts
-import { existsSync as existsSync6, rmSync as rmSync2 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync7, rmSync as rmSync2 } from "fs";
+import { join as join14 } from "path";
 import { homedir as homedir6 } from "os";
 async function applyClaudeAuthToEnv(childEnv, label) {
   const apiKey = getApiKey();
@@ -3886,10 +3966,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 = join13(homedir6(), ".claude");
+    const claudeDir = join14(homedir6(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join13(claudeDir, filename);
-      if (existsSync6(p)) {
+      const p = join14(claudeDir, filename);
+      if (existsSync7(p)) {
         try {
           rmSync2(p, { force: true });
           log(`[${label}] Removed ${p} (api_key mode \u2014 preventing OAuth fallback)`);
@@ -3903,8 +3983,8 @@ async function applyClaudeAuthToEnv(childEnv, label) {
 }
 
 // src/lib/manager/kanban/parsers.ts
-import { existsSync as existsSync7, readFileSync as readFileSync13 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync14 } from "fs";
+import { join as join15 } 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"]);
@@ -4036,12 +4116,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join14(process.cwd(), "skills", skillId, "SKILL.md"),
-      join14(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join15(process.cwd(), "skills", skillId, "SKILL.md"),
+      join15(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
-      if (existsSync7(candidate)) {
-        const content = readFileSync13(candidate, "utf-8");
+      if (existsSync8(candidate)) {
+        const content = readFileSync14(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -4714,7 +4794,7 @@ function closeScheduledRunsForCode(codeName, outcome, reason) {
 import { createHash as createHash9 } from "crypto";
 import { writeFileSync as writeFileSync6, renameSync } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/lib/manager/delivery/scheduled-output.ts
 async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, body, taskId) {
@@ -5018,7 +5098,7 @@ function resolveScheduledSlackTarget(task) {
 }
 function stampScheduledTurnMarker(codeName, taskId, target) {
   try {
-    const file = join15(homedir7(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+    const file = join16(homedir7(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
     const marker = { ts: Date.now(), task_id: taskId, ...target ? { target } : {} };
     const tmp = `${file}.tmp`;
     writeFileSync6(tmp, JSON.stringify(marker), "utf8");
@@ -5205,9 +5285,9 @@ async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput,
 // src/lib/manager/scheduler/execution.ts
 import { createHash as createHash10 } from "crypto";
 import { homedir as homedir8 } from "os";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 function claudePidFilePath() {
-  return join16(homedir8(), ".augmented", "manager-claude-pids.json");
+  return join17(homedir8(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -5407,24 +5487,24 @@ function partitionActionableByPoison(actionable, states, config2) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync14, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync15, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { randomUUID } from "crypto";
 function restartFlagsDir() {
-  return join17(homedir9(), ".augmented", "restart-flags");
+  return join18(homedir9(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join17(restartFlagsDir(), `${codeName}.flag`);
+  return join18(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
-  if (!existsSync8(dir)) return [];
+  if (!existsSync9(dir)) return [];
   const out = [];
   for (const entry of readdirSync4(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync14(join17(dir, entry), "utf8");
+      const raw = readFileSync15(join18(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -5442,7 +5522,7 @@ function readRestartFlags() {
 }
 function deleteRestartFlag(codeName) {
   const path = flagPath(codeName);
-  if (existsSync8(path)) {
+  if (existsSync9(path)) {
     rmSync3(path, { force: true });
   }
 }
@@ -6472,6 +6552,15 @@ function scheduleSessionRestart(codeName, delayMs, reason, breakerReason = "hot-
     }
     stopPersistentSession(codeName, log);
     markRestartStopped(codeName, log);
+    {
+      const baselineAgentId = agentState.codeNameToAgentId.get(codeName);
+      if (baselineAgentId) {
+        persistSenderPolicyBaselineEntry(
+          baselineAgentId,
+          agentState.knownSenderPolicyHashes.get(baselineAgentId)
+        );
+      }
+    }
     runningMcpHashes.delete(codeName);
     sessionLaunchManagedStructure.delete(codeName);
     recordRestartForBreaker(codeName, breakerReason);
@@ -6655,7 +6744,7 @@ var runningChannelSecretHashes = /* @__PURE__ */ new Map();
 var sessionLaunchManagedStructure = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync15(join18(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync16(join19(projectDir, ".mcp.json"), "utf-8");
     return createHash11("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
@@ -6663,7 +6752,7 @@ function projectMcpHash(_codeName, projectDir) {
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync15(join18(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync16(join19(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -6681,7 +6770,7 @@ function seedSessionLaunchBaselines(codeName, projectDir) {
   else runningMcpServerKeys.delete(codeName);
   let launchStructure = null;
   try {
-    const raw = readFileSync15(join18(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync16(join19(projectDir, ".mcp.json"), "utf-8");
     launchStructure = managedMcpStructureHashFromFile(
       JSON.parse(raw),
       isManagedMcpServerKey
@@ -6781,7 +6870,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(readFileSync15(join18(projectDir, ".mcp.json"), "utf-8"));
+      mcpJsonForRebind = JSON.parse(readFileSync16(join19(projectDir, ".mcp.json"), "utf-8"));
     } catch {
       mcpJsonForRebind = null;
     }
@@ -6910,7 +6999,7 @@ function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
 function projectChannelSecretHash(projectDir) {
   try {
     const entries = parseEnvIntegrations(
-      readFileSync15(join18(projectDir, ".env.integrations"), "utf-8")
+      readFileSync16(join19(projectDir, ".env.integrations"), "utf-8")
     );
     return channelSecretValueHash(entries, CHANNEL_SECRET_ENV_KEYS);
   } catch {
@@ -6990,6 +7079,7 @@ function clearAgentCaches(agentId, codeName) {
   mcpFlapDampener.forget(codeName);
   deferLogThrottle.delete(codeName);
   if (channelCacheMutated) saveChannelHashCache2();
+  removeSenderPolicyBaselineEntry(agentId);
 }
 var cachedFrameworkVersion = null;
 var cachedMaintenanceWindow = null;
@@ -6997,7 +7087,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.313" : "dev";
+var agtCliVersion = true ? "0.28.314" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -7010,7 +7100,7 @@ function resolveBrewPath(execFileSync2) {
     "/usr/local/bin/brew"
   ];
   for (const path of fallbacks) {
-    if (existsSync9(path)) return path;
+    if (existsSync10(path)) return path;
   }
   return null;
 }
@@ -7020,7 +7110,7 @@ function claudeBinaryInstalled(execFileSync2) {
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude"
   ];
-  if (canonical.some((path) => existsSync9(path))) return true;
+  if (canonical.some((path) => existsSync10(path))) return true;
   try {
     execFileSync2("which", ["claude"], { timeout: 5e3 });
     return true;
@@ -7175,8 +7265,8 @@ function claudeManagedSettingsPath() {
 function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
   try {
     let settings = {};
-    if (existsSync9(path)) {
-      const raw = readFileSync15(path, "utf-8").trim();
+    if (existsSync10(path)) {
+      const raw = readFileSync16(path, "utf-8").trim();
       if (raw) {
         let parsed;
         try {
@@ -7238,7 +7328,7 @@ async function ensureFrameworkBinary(frameworkId) {
     if (!process.env.PATH?.split(":").includes(brewBinDir)) {
       process.env.PATH = `${brewBinDir}:${process.env.PATH ?? ""}`;
     }
-    if (existsSync9("/home/linuxbrew/.linuxbrew/bin/claude")) {
+    if (existsSync10("/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");
@@ -7294,7 +7384,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join18(homedir10(), ".augmented", ".last-self-update-applied");
+  return join19(homedir10(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var restartAfterUpgrade = false;
@@ -7318,7 +7408,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 = join18(homedir10(), ".augmented", ".last-update-check");
+    const markerPath = join19(homedir10(), ".augmented", ".last-update-check");
     if (!force) {
       try {
         const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
@@ -7596,13 +7686,13 @@ async function checkClaudeAuth() {
 }
 var evalEmptyMcpConfigPath = null;
 function ensureEvalEmptyMcpConfig() {
-  if (evalEmptyMcpConfigPath && existsSync9(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
-  const dir = join18(homedir10(), ".augmented");
+  if (evalEmptyMcpConfigPath && existsSync10(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
+  const dir = join19(homedir10(), ".augmented");
   try {
     mkdirSync7(dir, { recursive: true });
   } catch {
   }
-  const p = join18(dir, ".eval-empty-mcp.json");
+  const p = join19(dir, ".eval-empty-mcp.json");
   writeFileSync8(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
@@ -7694,10 +7784,10 @@ function resolveConversationEvalBackend() {
   return conversationEvalBackend;
 }
 function getStateFile() {
-  return join18(config?.configDir ?? join18(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join19(config?.configDir ?? join19(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join18(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join19(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -7705,10 +7795,27 @@ function loadChannelHashCache2() {
 function saveChannelHashCache2() {
   saveChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
 }
+var persistedSenderPolicyBaseline = /* @__PURE__ */ new Map();
+function loadSenderPolicyBaseline2() {
+  loadSenderPolicyBaseline(persistedSenderPolicyBaseline, channelHashCacheDir(), log);
+  for (const [agentId, hash] of persistedSenderPolicyBaseline) {
+    agentState.knownSenderPolicyHashes.set(agentId, hash);
+  }
+}
+function persistSenderPolicyBaselineEntry(agentId, hash) {
+  if (hash === void 0) return;
+  if (persistedSenderPolicyBaseline.get(agentId) === hash) return;
+  persistedSenderPolicyBaseline.set(agentId, hash);
+  saveSenderPolicyBaseline(persistedSenderPolicyBaseline, channelHashCacheDir(), log);
+}
+function removeSenderPolicyBaselineEntry(agentId) {
+  if (!persistedSenderPolicyBaseline.delete(agentId)) return;
+  saveSenderPolicyBaseline(persistedSenderPolicyBaseline, channelHashCacheDir(), log);
+}
 var _channelQuarantineStore = null;
 function channelQuarantineStore() {
   if (!_channelQuarantineStore) {
-    const dir = config?.configDir ?? join18(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join19(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
   }
   return _channelQuarantineStore;
@@ -7716,7 +7823,7 @@ function channelQuarantineStore() {
 var _hostFlagStore = null;
 function hostFlagStore() {
   if (!_hostFlagStore) {
-    const dir = config?.configDir ?? join18(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join19(process.env["HOME"] ?? "/tmp", ".augmented");
     _hostFlagStore = new HostFlagStore({ cachePath: defaultFlagsCachePath(dir), log });
   }
   return _hostFlagStore;
@@ -7784,12 +7891,12 @@ function parseSkillFrontmatter(content) {
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
   const { readdirSync: readdirSync6, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync9 } = await import("fs");
-  const skillsDir = join18(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join18(configDir, codeName, "project", "CLAUDE.md");
+  const skillsDir = join19(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join19(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
   for (const dir of readdirSync6(skillsDir).sort()) {
-    const skillFile = join18(skillsDir, dir, "SKILL.md");
+    const skillFile = join19(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -8219,13 +8326,13 @@ async function pollCycle() {
             );
             if (hostFlagStore().getBoolean("wedge-transient-notice")) {
               try {
-                const paneTail = readFileSync15(paneLogPath(codeName), "utf8").slice(-65536);
+                const paneTail = readFileSync16(paneLogPath(codeName), "utf8").slice(-65536);
                 const transient = detectTransientApiErrorInLog(paneTail);
                 if (transient) {
-                  const wedgeHome = join18(homedir10(), ".augmented", codeName);
-                  if (existsSync9(wedgeHome)) {
+                  const wedgeHome = join19(homedir10(), ".augmented", codeName);
+                  if (existsSync10(wedgeHome)) {
                     atomicWriteFileSync(
-                      join18(wedgeHome, "watchdog-give-up.json"),
+                      join19(wedgeHome, "watchdog-give-up.json"),
                       JSON.stringify({
                         gave_up_at: wedgeNow.toISOString(),
                         reason: "transient_overload"
@@ -8474,7 +8581,7 @@ async function pollCycle() {
         } catch {
         }
         killAgentChannelProcesses(prev.codeName, { log });
-        const agentDir = join18(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join19(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -8561,10 +8668,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 = join18(homedir10(), ".augmented", codeName);
-          if (!existsSync9(dir)) return;
+          const dir = join19(homedir10(), ".augmented", codeName);
+          if (!existsSync10(dir)) return;
           atomicWriteFileSync(
-            join18(dir, "watchdog-give-up.json"),
+            join19(dir, "watchdog-give-up.json"),
             JSON.stringify({ gave_up_at: (/* @__PURE__ */ new Date()).toISOString() })
           );
         }
@@ -8694,7 +8801,7 @@ async function processAgent(agent, agentStates) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join18(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join19(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`);
@@ -8740,7 +8847,7 @@ async function processAgent(agent, agentStates) {
       const residuals = {
         gatewayRunning: false,
         portAllocated: false,
-        provisionDirExists: existsSync9(agentDir)
+        provisionDirExists: existsSync10(agentDir)
       };
       if (!hasRevokedResiduals(residuals)) {
         agentStates.push({
@@ -8878,7 +8985,7 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? DEFAULT_FRAMEWORK;
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join18(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join19(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,
@@ -8925,7 +9032,7 @@ async function processAgent(agent, agentStates) {
     const changedFiles = [];
     mkdirSync7(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join18(agentDir, artifact.relativePath);
+      const filePath = join19(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -8944,8 +9051,8 @@ async function processAgent(agent, agentStates) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join18(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync15(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join19(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync16(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -8963,7 +9070,7 @@ async function processAgent(agent, agentStates) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync15(filePath, "utf-8");
+          existingRaw = readFileSync16(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -8985,12 +9092,12 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync9(join18(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync10(join19(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 = join18(agentDir, file.relativePath);
+        const filePath = join19(agentDir, file.relativePath);
         mkdirSync7(dirname6(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
@@ -8999,12 +9106,12 @@ async function processAgent(agent, agentStates) {
         }
       }
       try {
-        const provSkillsDir = join18(agentDir, ".claude", "skills");
-        if (existsSync9(provSkillsDir)) {
+        const provSkillsDir = join19(agentDir, ".claude", "skills");
+        if (existsSync10(provSkillsDir)) {
           for (const folder of readdirSync5(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync4(join18(provSkillsDir, folder), { recursive: true });
+                rmSync4(join19(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -9017,7 +9124,7 @@ async function processAgent(agent, agentStates) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join18(agentDir, file));
+        const h = hashFile(join19(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -9035,14 +9142,14 @@ async function processAgent(agent, agentStates) {
     }
     if (Array.isArray(refreshData.workflows)) {
       try {
-        const provWorkflowsDir = join18(agentDir, ".claude", "workflows");
-        if (existsSync9(provWorkflowsDir)) {
+        const provWorkflowsDir = join19(agentDir, ".claude", "workflows");
+        if (existsSync10(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(join18(provWorkflowsDir, file));
+              rmSync4(join19(provWorkflowsDir, file));
             } catch {
             }
           }
@@ -9099,10 +9206,10 @@ async function processAgent(agent, agentStates) {
   }
   let lastDriftCheckAt = now;
   const written = agentState.writtenHashes.get(agent.agent_id);
-  if (written && existsSync9(agentDir)) {
+  if (written && existsSync10(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join18(agentDir, file));
+      const localHash = hashFile(join19(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -9113,7 +9220,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join18(agentDir, file));
+          localHashes[file] = hashFile(join19(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -9300,7 +9407,7 @@ async function processAgent(agent, agentStates) {
     const addedChannels = [...restartDecision.added];
     const writeDmNoticeMarkers = isChannelAddRestart ? () => {
       try {
-        const agentAugmentedDir = join18(homedir10(), ".augmented", agent.code_name);
+        const agentAugmentedDir = join19(homedir10(), ".augmented", agent.code_name);
         mkdirSync7(agentAugmentedDir, { recursive: true });
         const markerJson = JSON.stringify({
           version: 1,
@@ -9308,7 +9415,7 @@ async function processAgent(agent, agentStates) {
           added: addedChannels
         });
         for (const file of ["slack-channel-add-restart.json", "telegram-channel-add-restart.json"]) {
-          atomicWriteFileSync(join18(agentAugmentedDir, file), markerJson);
+          atomicWriteFileSync(join19(agentAugmentedDir, file), markerJson);
         }
       } catch (err) {
         log(`[hot-reload] channel-add DM-notice marker write failed for '${agent.code_name}' (non-fatal): ${err.message}`);
@@ -9326,20 +9433,26 @@ async function processAgent(agent, agentStates) {
     const hasSenderPolicyChannel = currentChannelIds.has("slack") || currentChannelIds.has("msteams");
     const senderPolicyForRestartHash = refreshData.sender_policy ?? null;
     const senderPolicyHash = computeSenderPolicyRestartHash(senderPolicyForRestartHash);
+    const senderPolicyRestrictive = isSenderPolicyRestrictive(senderPolicyForRestartHash);
     const prevSenderPolicyHash = agentState.knownSenderPolicyHashes.get(agent.agent_id);
+    const spSessionMode = refreshData.agent.session_mode;
+    const spFramework = agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK;
+    const spSessionHealthy = isSessionHealthy(agent.code_name);
     const senderPolicyDecision = hasSenderPolicyChannel ? decideSenderPolicyRestart({
       previousHash: prevSenderPolicyHash,
+      currentPolicyRestrictive: senderPolicyRestrictive,
       currentHash: senderPolicyHash,
-      sessionMode: refreshData.agent.session_mode,
-      framework: agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK,
-      sessionHealthy: isSessionHealthy(agent.code_name),
+      sessionMode: spSessionMode,
+      framework: spFramework,
+      sessionHealthy: spSessionHealthy,
       channelSetRestartAlreadyScheduled: channelSetRestartScheduled
     }) : { restart: false, firstPoll: prevSenderPolicyHash === void 0, changed: false };
     if (senderPolicyDecision.restart) {
+      const isVerifyRestart = senderPolicyDecision.firstPoll;
       log(
-        `[hot-reload] sender_policy changed for '${agent.code_name}' (${prevSenderPolicyHash?.slice(0, 8) ?? "first"} \u2192 ${senderPolicyHash.slice(0, 8)}) \u2014 restarting session`
+        isVerifyRestart ? `[hot-reload] sender_policy delivery baseline unknown for '${agent.code_name}' with a restrictive policy (\u2192 ${senderPolicyHash.slice(0, 8)}) \u2014 restarting session to guarantee enforcement (fail closed, ENG-7771)` : `[hot-reload] sender_policy changed for '${agent.code_name}' (${prevSenderPolicyHash?.slice(0, 8) ?? "first"} \u2192 ${senderPolicyHash.slice(0, 8)}) \u2014 restarting session`
       );
-      const notice = "Your sender_policy has been updated. Restarting session shortly so the channel MCP servers pick up the new gate.";
+      const notice = isVerifyRestart ? "Your manager was updated and needs to restart your session to make sure your configured sender policy is enforced by the channel MCP servers." : "Your sender_policy has been updated. Restarting session shortly so the channel MCP servers pick up the new gate.";
       const delivered = await injectMessage(
         agent.code_name,
         "system",
@@ -9356,11 +9469,22 @@ async function processAgent(agent, agentStates) {
       scheduleSessionRestart(
         agent.code_name,
         delay,
-        "sender_policy change",
+        isVerifyRestart ? "sender policy verify (unknown baseline)" : "sender_policy change",
         "sender-policy-change"
       );
     }
     agentState.knownSenderPolicyHashes.set(agent.agent_id, senderPolicyHash);
+    const hasLiveSenderPolicyConsumer = hasSenderPolicyChannel && spSessionHealthy && spSessionMode === "persistent" && spFramework === "claude-code";
+    if (!hasLiveSenderPolicyConsumer) {
+      persistSenderPolicyBaselineEntry(agent.agent_id, senderPolicyHash);
+    } else if (senderPolicyDecision.firstPoll && !senderPolicyRestrictive) {
+      if (persistedSenderPolicyBaseline.get(agent.agent_id) !== senderPolicyHash) {
+        log(
+          `[sender-policy] baseline established without restart for '${agent.code_name}' (policy is non-restrictive); a policy loosened while the baseline was unknown requires an agent restart to take effect (ENG-7771)`
+        );
+      }
+      persistSenderPolicyBaselineEntry(agent.agent_id, senderPolicyHash);
+    }
     let msteamsBehaviourRestartScheduled = false;
     if (currentChannelIds.has("msteams")) {
       const msteamsEntry = refreshData.channel_configs?.["msteams"];
@@ -9371,6 +9495,12 @@ async function processAgent(agent, agentStates) {
       const prevBehaviourHash = agentState.knownMsTeamsBehaviourHashes.get(agent.agent_id);
       const behaviourDecision = decideSenderPolicyRestart({
         previousHash: prevBehaviourHash,
+        // ENG-7771 scoped the persisted-baseline + first-poll fail-safe to
+        // sender_policy only; the behaviour baselines keep the legacy
+        // "first poll never restarts" semantics until the follow-up that
+        // migrates them onto the sidecar (their maps share the same
+        // wipe-on-manager-restart pathology).
+        currentPolicyRestrictive: false,
         currentHash: behaviourHash,
         sessionMode: refreshData.agent.session_mode,
         framework: agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK,
@@ -9418,6 +9548,9 @@ async function processAgent(agent, agentStates) {
       const prevSlackBehaviourHash = agentState.knownSlackBehaviourHashes.get(agent.agent_id);
       const slackBehaviourDecision = decideSenderPolicyRestart({
         previousHash: prevSlackBehaviourHash,
+        // See the msteams call above — behaviour baselines are out of
+        // ENG-7771's scope; legacy first-poll semantics until the follow-up.
+        currentPolicyRestrictive: false,
         currentHash: slackBehaviourHash,
         sessionMode: refreshData.agent.session_mode,
         framework: agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK,
@@ -9461,24 +9594,24 @@ async function processAgent(agent, agentStates) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK) === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join18(homedir10(), ".augmented", agent.code_name, "project");
+      const projectDir = join19(homedir10(), ".augmented", agent.code_name, "project");
       mkdirSync7(agentProvisionDir, { recursive: true });
       mkdirSync7(projectDir, { recursive: true });
-      const provisionMcpPath = join18(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join18(projectDir, ".mcp.json");
+      const provisionMcpPath = join19(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join19(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync15(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync16(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join18(homedir10(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join19(homedir10(), ".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 (existsSync9(localDirectChatChannel)) {
+      if (existsSync10(localDirectChatChannel)) {
         const directChatEnv = {
           AGT_HOST: requireHost(),
           // ENG-5901 Track D: templated — the manager exports the real
@@ -9498,7 +9631,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: join18(
+          AGT_TURN_INITIATOR_FILE: join19(
             frameworkAdapter.getAgentDir(agent.code_name),
             ".current-turn-initiator.json"
           )
@@ -9518,8 +9651,8 @@ async function processAgent(agent, agentStates) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join18(projectDir, ".mcp-channels.json");
-      if (existsSync9(staleChannelsPath)) {
+      const staleChannelsPath = join19(projectDir, ".mcp-channels.json");
+      if (existsSync10(staleChannelsPath)) {
         try {
           rmSync4(staleChannelsPath, { force: true });
         } catch {
@@ -9590,7 +9723,7 @@ async function processAgent(agent, agentStates) {
     }
     if (hostFlagStore().getBoolean("connectivity-probe")) {
       try {
-        const probeProjectDir = join18(homedir10(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join19(homedir10(), ".augmented", agent.code_name, "project");
         await runAgentConnectivityProbes(agent, integrations, probeProjectDir);
       } catch (err) {
         log(`Connectivity probe failed for '${agent.code_name}': ${err.message}`);
@@ -9601,7 +9734,7 @@ async function processAgent(agent, agentStates) {
       const forceDue = attemptsLeft > 0;
       let probeRan = false;
       try {
-        const probeProjectDir = join18(homedir10(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join19(homedir10(), ".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}`);
@@ -9614,9 +9747,9 @@ async function processAgent(agent, agentStates) {
     }
     if (frameworkAdapter.removeMcpServer && frameworkAdapter.getMcpPath) {
       const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
-      if (mcpPath && existsSync9(mcpPath)) {
+      if (mcpPath && existsSync10(mcpPath)) {
         try {
-          const cfg = JSON.parse(readFileSync15(mcpPath, "utf-8"));
+          const cfg = JSON.parse(readFileSync16(mcpPath, "utf-8"));
           const expectedRemoteKeys = new Set(
             integrations.map((i) => i.definition_id)
           );
@@ -9641,11 +9774,11 @@ async function processAgent(agent, agentStates) {
         recordConfigChurnEvent(agent.agent_id, agent.code_name, FLAP_CHANNEL_INTEGRATIONS, intMembership);
       }
       if (intHash !== prevIntHash) {
-        const projectDir = join18(homedir10(), ".augmented", agent.code_name, "project");
-        const envIntPath = join18(projectDir, ".env.integrations");
+        const projectDir = join19(homedir10(), ".augmented", agent.code_name, "project");
+        const envIntPath = join19(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
-          preWriteEnv = readFileSync15(envIntPath, "utf-8");
+          preWriteEnv = readFileSync16(envIntPath, "utf-8");
         } catch {
           preWriteEnv = void 0;
         }
@@ -9657,9 +9790,9 @@ async function processAgent(agent, agentStates) {
         let rotationHandled = true;
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join18(projectDir, ".mcp.json");
-            const postWriteEnv = readFileSync15(envIntPath, "utf-8");
-            const mcpContent = readFileSync15(projectMcpPath, "utf-8");
+            const projectMcpPath = join19(projectDir, ".mcp.json");
+            const postWriteEnv = readFileSync16(envIntPath, "utf-8");
+            const mcpContent = readFileSync16(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
             const mcpJsonForReap = JSON.parse(mcpContent);
             const affectedServerKeys = findMcpServersUsingVars(mcpJsonForReap, changedVars);
@@ -9760,8 +9893,8 @@ async function processAgent(agent, agentStates) {
             const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
             if (mcpPath) {
               try {
-                const { readFileSync: readFileSync16 } = await import("fs");
-                const mcpConfig = JSON.parse(readFileSync16(mcpPath, "utf-8"));
+                const { readFileSync: readFileSync17 } = await import("fs");
+                const mcpConfig = JSON.parse(readFileSync17(mcpPath, "utf-8"));
                 if (mcpConfig.mcpServers) {
                   for (const key of Object.keys(mcpConfig.mcpServers)) {
                     if (isManagedMcpServerKey(key) && !expectedServerIds.has(key)) {
@@ -9908,14 +10041,14 @@ async function processAgent(agent, agentStates) {
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join18(homedir11(), ".augmented", agent.code_name, "skills"),
+          join19(homedir11(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join18(homedir11(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join19(homedir11(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join18(agentDir, ".claude", "skills")
+          join19(agentDir, ".claude", "skills")
         ];
-        const existingDirs = candidateSkillDirs.filter((d) => existsSync9(d));
+        const existingDirs = candidateSkillDirs.filter((d) => existsSync10(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
         for (const dir of existingDirs) {
           try {
@@ -9929,8 +10062,8 @@ async function processAgent(agent, agentStates) {
         }
         const removeSkillFolder = (entry, reason) => {
           for (const dir of existingDirs) {
-            const p = join18(dir, entry);
-            if (existsSync9(p)) {
+            const p = join19(dir, entry);
+            if (existsSync10(p)) {
               rmSync5(p, { recursive: true, force: true });
             }
           }
@@ -9949,7 +10082,7 @@ async function processAgent(agent, agentStates) {
         const sharedSkillsPayload = refreshAny.shared_skills;
         const desiredResolved = globalSkillsPayload !== void 0 || sharedSkillsPayload !== void 0;
         const manifestPath = managedSkillManifestPath(
-          join18(homedir10(), ".augmented", agent.code_name)
+          join19(homedir10(), ".augmented", agent.code_name)
         );
         const prevIds = /* @__PURE__ */ new Set([
           ...agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
@@ -9969,15 +10102,15 @@ async function processAgent(agent, agentStates) {
         }
         if (plan.removes.length) {
           const globalSkillDirs = [
-            join18(homedir10(), ".augmented", agent.code_name, "skills"),
-            join18(homedir10(), ".augmented", agent.code_name, "project", ".claude", "skills"),
-            join18(agentDir, ".claude", "skills")
+            join19(homedir10(), ".augmented", agent.code_name, "skills"),
+            join19(homedir10(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+            join19(agentDir, ".claude", "skills")
           ];
           for (const id of plan.removes) {
             let prunedAny = false;
             for (const dir of globalSkillDirs) {
-              const p = join18(dir, id);
-              if (existsSync9(p) && existsSync9(join18(p, "SKILL.md"))) {
+              const p = join19(dir, id);
+              if (existsSync10(p) && existsSync10(join19(p, "SKILL.md"))) {
                 rmSync4(p, { recursive: true, force: true });
                 prunedAny = true;
               }
@@ -10180,8 +10313,8 @@ async function processAgent(agent, agentStates) {
       const sess = getSessionState(agent.code_name);
       let mcpJsonParsed = null;
       try {
-        const mcpPath = join18(getProjectDir(agent.code_name), ".mcp.json");
-        mcpJsonParsed = JSON.parse(readFileSync15(mcpPath, "utf-8"));
+        const mcpPath = join19(getProjectDir(agent.code_name), ".mcp.json");
+        mcpJsonParsed = JSON.parse(readFileSync16(mcpPath, "utf-8"));
       } catch {
       }
       reapMissingMcpSessions({
@@ -10506,10 +10639,10 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
     }
   }
   const trackedFiles = frameworkAdapter.driftTrackedFiles();
-  if (trackedFiles.length > 0 && existsSync9(agentDir)) {
+  if (trackedFiles.length > 0 && existsSync10(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join18(agentDir, file));
+      const h = hashFile(join19(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -10524,7 +10657,7 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
         refreshData.agent.onboarding_state
       );
       const obStep = obState.step;
-      const markerPath = join18(homedir10(), ".augmented", agent.code_name, "onboarding-drive.json");
+      const markerPath = join19(homedir10(), ".augmented", agent.code_name, "onboarding-drive.json");
       const marker = readOnboardingDriveMarker(markerPath);
       const decision = decideOnboardingDrive(obStep, marker, Date.now(), obState.generation ?? 0);
       if (decision.clearMarker) {
@@ -10588,8 +10721,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 = join18(projectDir, ".mcp.json");
-  const claudeMdPath = join18(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join19(projectDir, ".mcp.json");
+  const claudeMdPath = join19(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -11837,8 +11970,8 @@ function parseMemoryFile(raw, fallbackName) {
   };
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join18(configDir, agent.code_name, "project");
-  const memoryDir = join18(projectDir, "memory");
+  const projectDir = join19(configDir, agent.code_name, "project");
+  const memoryDir = join19(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`);
@@ -11849,14 +11982,14 @@ async function syncMemories(agent, configDir, log2) {
     }
     pendingFreshMemorySync.delete(agent.agent_id);
   }
-  if (existsSync9(memoryDir)) {
+  if (existsSync10(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 = readFileSync15(join18(memoryDir, file), "utf-8");
+        const raw = readFileSync16(join19(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;
@@ -11881,7 +12014,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync15(join18(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync16(join19(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -11894,7 +12027,7 @@ async function syncMemories(agent, configDir, log2) {
   }
 }
 async function downloadMemories(agent, memoryDir, log2, { force }) {
-  const localFiles = existsSync9(memoryDir) ? readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
+  const localFiles = existsSync10(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);
@@ -11916,7 +12049,7 @@ async function downloadMemories(agent, memoryDir, log2, { force }) {
         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 = join18(memoryDir, `${slug}.md`);
+        const filePath = join19(memoryDir, `${slug}.md`);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -11925,10 +12058,10 @@ description: ${JSON.stringify(mem.content.slice(0, 200))}
 
 ${mem.content}
 `;
-        if (existsSync9(filePath)) {
+        if (existsSync10(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync15(filePath, "utf-8");
+            existing = readFileSync16(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) continue;
@@ -11952,7 +12085,7 @@ ${mem.content}
   }
 }
 async function cleanupAgentFiles(codeName, agentDir) {
-  if (existsSync9(agentDir)) {
+  if (existsSync10(agentDir)) {
     try {
       rmSync4(agentDir, { recursive: true, force: true });
       log(`Removed provision directory for '${codeName}'`);
@@ -12061,6 +12194,7 @@ function startPolling() {
   livenessTimer.unref();
   void startCaffeinate();
   loadChannelHashCache2();
+  loadSenderPolicyBaseline2();
   hostFlagStore().init();
   log(`Starting poll loop (interval=${config.intervalMs}ms, configDir=${config.configDir})`);
   void killAllAgtTmuxSessions().catch(() => {
@@ -12185,8 +12319,8 @@ function startManager(opts) {
   config = opts;
   try {
     const stateFile = getStateFile();
-    if (existsSync9(stateFile)) {
-      const raw = readFileSync15(stateFile, "utf-8");
+    if (existsSync10(stateFile)) {
+      const raw = readFileSync16(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
         state6.agents = parsed.agents;
@@ -12213,7 +12347,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=${join18(homedir10(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join19(homedir10(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -12234,7 +12368,7 @@ async function reapOrphanedClaudePids() {
   const looksLikeClaude = (pid) => {
     if (process.platform !== "linux") return true;
     try {
-      const comm = readFileSync15(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
+      const comm = readFileSync16(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
       return comm.includes("claude");
     } catch {
       return false;
@@ -12331,14 +12465,14 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join18(homedir10(), ".augmented", "_mcp");
+  const targetDir = join19(homedir10(), ".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 = join18(dir, "dist", "mcp");
-    if (existsSync9(join18(candidate, "index.js"))) {
+    const candidate = join19(dir, "dist", "mcp");
+    if (existsSync10(join19(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
@@ -12353,8 +12487,8 @@ function deployMcpAssets() {
   const changedBasenames = [];
   const fileHash = (p) => {
     try {
-      if (!existsSync9(p)) return null;
-      return createHash11("sha256").update(readFileSync15(p)).digest("hex");
+      if (!existsSync10(p)) return null;
+      return createHash11("sha256").update(readFileSync16(p)).digest("hex");
     } catch {
       return null;
     }
@@ -12418,9 +12552,9 @@ function deployMcpAssets() {
     // needs restarting to pick up a token rotation.
     "xero.js"
   ]) {
-    const src = join18(mcpSourceDir, file);
-    const dst = join18(targetDir, file);
-    if (!existsSync9(src)) continue;
+    const src = join19(mcpSourceDir, file);
+    const dst = join19(targetDir, file);
+    if (!existsSync10(src)) continue;
     const before = fileHash(dst);
     try {
       copyFileSync(src, dst);
@@ -12437,16 +12571,16 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join18(targetDir, "index.js");
+  const localMcpPath = join19(targetDir, "index.js");
   try {
-    const agentsDir = join18(homedir10(), ".augmented", "agents");
-    if (existsSync9(agentsDir)) {
+    const agentsDir = join19(homedir10(), ".augmented", "agents");
+    if (existsSync10(agentsDir)) {
       for (const entry of readdirSync5(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join18(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join19(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync15(mcpJsonPath, "utf-8");
+            const raw = readFileSync16(mcpJsonPath, "utf-8");
             if (!raw.includes("@integrity-labs/augmented-mcp")) continue;
             const mcpConfig = JSON.parse(raw);
             const augServer = mcpConfig.mcpServers?.["augmented"];