@integrity-labs/agt-cli 0.28.322 → 0.28.324

package/dist/lib/manager-worker.js

@@ -43,7 +43,7 @@ import {
   requireHost,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-FG7ELAP4.js";
+} from "../chunk-KHSPRKK2.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -132,16 +132,16 @@ import {
   takeZombieDetection,
   transcriptActivityAgeSeconds,
   writeEgressAllowlist
-} from "../chunk-LJT3U3GQ.js";
+} from "../chunk-BSTFCC62.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
 
 // src/lib/manager-worker.ts
 import { createHash as createHash12 } from "crypto";
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, existsSync as existsSync11, rmSync as rmSync4, readdirSync as readdirSync5, statSync as statSync4, copyFileSync } from "fs";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8, existsSync as existsSync12, rmSync as rmSync4, readdirSync as readdirSync5, statSync as statSync4, copyFileSync } from "fs";
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join20, dirname as dirname6 } from "path";
+import { join as join21, dirname as dirname6 } from "path";
 import { homedir as homedir11 } from "os";
 import { fileURLToPath } from "url";
 
@@ -4122,10 +4122,14 @@ function isHybridActionable(item) {
 function kanbanActionableSignature(allowed) {
   return allowed.map((i) => `${i.id}:${i.status}`).sort().join("|");
 }
-function shouldNudgeUnchangedBoard(signature, state7, now, fullCadenceMs) {
+function nudgeIntervalForCount(nudgeCount, fullCadenceMs, maxCadenceMs) {
+  const exponent = Math.max(0, Math.min(nudgeCount - 1, 8));
+  return Math.min(fullCadenceMs * 3 ** exponent, Math.max(maxCadenceMs, fullCadenceMs));
+}
+function shouldNudgeUnchangedBoard(signature, state7, now, fullCadenceMs, maxCadenceMs = fullCadenceMs) {
   if (!state7) return true;
   if (state7.signature !== signature) return true;
-  return now - state7.nudgedAt >= fullCadenceMs;
+  return now - state7.nudgedAt >= nudgeIntervalForCount(state7.nudgeCount ?? 1, fullCadenceMs, maxCadenceMs);
 }
 function isSlashCommand(command) {
   return command.trimStart().startsWith("/");
@@ -4373,6 +4377,49 @@ function formatBoardForPrompt(items, template) {
   return lines.join("\n");
 }
 
+// src/lib/manager/kanban/nudge-state-cache.ts
+import { existsSync as existsSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "fs";
+import { join as join16 } from "path";
+var CACHE_FILENAME2 = "kanban-nudge-state.json";
+var KANBAN_NUDGE_STATE_VERSION = 1;
+function getKanbanNudgeStateFile(configDir) {
+  return join16(configDir, CACHE_FILENAME2);
+}
+function loadKanbanNudgeState(target, configDir) {
+  const path = getKanbanNudgeStateFile(configDir);
+  if (!existsSync9(path)) return;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync15(path, "utf-8"));
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
+  const obj = parsed;
+  if (obj.version !== KANBAN_NUDGE_STATE_VERSION) return;
+  const entries = obj.agents;
+  if (!entries || typeof entries !== "object" || Array.isArray(entries)) return;
+  for (const [codeName, value] of Object.entries(entries)) {
+    if (!value || typeof value !== "object") continue;
+    const v = value;
+    if (typeof v.signature !== "string" || typeof v.nudgedAt !== "number" || !Number.isFinite(v.nudgedAt)) continue;
+    target.set(codeName, {
+      signature: v.signature,
+      nudgedAt: v.nudgedAt,
+      nudgeCount: typeof v.nudgeCount === "number" && Number.isFinite(v.nudgeCount) && v.nudgeCount >= 1 ? Math.floor(v.nudgeCount) : 1
+    });
+  }
+}
+function saveKanbanNudgeState(source, configDir) {
+  const path = getKanbanNudgeStateFile(configDir);
+  const agents = {};
+  for (const [codeName, state7] of source) agents[codeName] = state7;
+  try {
+    writeFileSync6(path, JSON.stringify({ version: KANBAN_NUDGE_STATE_VERSION, agents }, null, 2));
+  } catch {
+  }
+}
+
 // src/lib/manager/kanban/notify.ts
 import { createHash as createHash7 } from "crypto";
 async function enqueueKanbanNotice(opts) {
@@ -4594,6 +4641,9 @@ async function maybeSendTelegramFollowUpHint(agentCodeName, botToken, chatId) {
 }
 
 // src/lib/manager/delivery/state.ts
+function toPreferredChannel(raw) {
+  return raw === "slack" || raw === "telegram" ? raw : null;
+}
 var agentInfoForDelivery = /* @__PURE__ */ new Map();
 function cacheAgentDeliveryMetadata(codeName, refreshData) {
   const agentRow = refreshData["agent"] ?? {};
@@ -4625,7 +4675,8 @@ function cacheAgentDeliveryMetadata(codeName, refreshData) {
       person_id: reportsToPersonId,
       display_name: agentRow["reports_to_name"] ?? "Reports-To",
       slack_user_id: agentRow["reports_to_slack_user_id"] ?? null,
-      telegram_chat_id: agentRow["reports_to_telegram_chat_id"] ?? null
+      telegram_chat_id: agentRow["reports_to_telegram_chat_id"] ?? null,
+      preferred_channel: toPreferredChannel(agentRow["reports_to_approval_notify_channel"])
     });
   }
   const people = refreshData["people"] ?? [];
@@ -4637,7 +4688,8 @@ function cacheAgentDeliveryMetadata(codeName, refreshData) {
       person_id: personId,
       display_name: p["display_name"] ?? "person",
       slack_user_id: contactPrefs["slack_user_id"] ?? null,
-      telegram_chat_id: contactPrefs["telegram_chat_id"] ?? null
+      telegram_chat_id: contactPrefs["telegram_chat_id"] ?? null,
+      preferred_channel: toPreferredChannel(contactPrefs["approval_notify_channel"])
     });
   }
   agentInfoForDelivery.set(codeName, {
@@ -4904,9 +4956,9 @@ function closeScheduledRunsForCode(codeName, outcome, reason) {
 
 // src/lib/manager/scheduler/kanban-route.ts
 import { createHash as createHash9 } from "crypto";
-import { writeFileSync as writeFileSync6, renameSync } from "fs";
+import { writeFileSync as writeFileSync7, renameSync } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 
 // src/lib/manager/delivery/scheduled-output.ts
 async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, body, taskId) {
@@ -5210,10 +5262,10 @@ function resolveScheduledSlackTarget(task) {
 }
 function stampScheduledTurnMarker(codeName, taskId, target) {
   try {
-    const file = join16(homedir7(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+    const file = join17(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");
+    writeFileSync7(tmp, JSON.stringify(marker), "utf8");
     renameSync(tmp, file);
   } catch (err) {
     log(`[scheduled-kanban] scheduled-turn marker write failed for '${codeName}': ${err.message}`);
@@ -5397,9 +5449,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 join17 } from "path";
+import { join as join18 } from "path";
 function claudePidFilePath() {
-  return join17(homedir8(), ".augmented", "manager-claude-pids.json");
+  return join18(homedir8(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -5463,9 +5515,9 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
 import { spawn, execSync } from "child_process";
 import { createServer } from "net";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync16 } from "fs";
 import { homedir as homedir9, userInfo } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 var OPENCODE_BIN = process.env["AGT_OPENCODE_BIN"]?.trim() || "opencode";
 var sessions = /* @__PURE__ */ new Map();
 var bridges = /* @__PURE__ */ new Map();
@@ -5473,7 +5525,7 @@ function opencodeTmuxSession(codeName) {
   return `agt-oc-${codeName}`;
 }
 function opencodePaneLogPath(codeName) {
-  return join18(homedir9(), ".augmented", codeName, "opencode-serve.log");
+  return join19(homedir9(), ".augmented", codeName, "opencode-serve.log");
 }
 function baseUrlFor(port) {
   return `http://127.0.0.1:${port}`;
@@ -5540,7 +5592,7 @@ async function startOpencodeSession(config2) {
 }
 async function spawnServe(config2, session) {
   const { codeName, projectDir, log: log2 } = config2;
-  if (!existsSync9(join18(projectDir, "opencode.json"))) {
+  if (!existsSync10(join19(projectDir, "opencode.json"))) {
     log2(`[opencode-session] warning: no opencode.json in ${projectDir} for '${codeName}' (provisioning may not have run)`);
   }
   const tmuxSession = opencodeTmuxSession(codeName);
@@ -5550,7 +5602,7 @@ async function spawnServe(config2, session) {
     execSync(`tmux kill-session -t ${tmuxSession} 2>/dev/null`, { stdio: "ignore" });
   } catch {
   }
-  mkdirSync6(join18(homedir9(), ".augmented", codeName), { recursive: true });
+  mkdirSync6(join19(homedir9(), ".augmented", codeName), { recursive: true });
   const serveEnv = {
     ...process.env,
     ...stripUndefined(config2.serveEnv ?? {}),
@@ -5601,9 +5653,9 @@ function setupPaneLog(tmuxSession, codeName, log2) {
 }
 function readOpencodePaneLogTail(codeName, lines = 40) {
   const logPath = opencodePaneLogPath(codeName);
-  if (!existsSync9(logPath)) return null;
+  if (!existsSync10(logPath)) return null;
   try {
-    const all = readFileSync15(logPath, "utf8").split("\n");
+    const all = readFileSync16(logPath, "utf8").split("\n");
     return all.slice(-lines).join("\n");
   } catch {
     return null;
@@ -6696,24 +6748,24 @@ function partitionActionableByPoison(actionable, states, config2) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync4, readFileSync as readFileSync16, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, readdirSync as readdirSync4, readFileSync as readFileSync17, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 import { randomUUID } from "crypto";
 function restartFlagsDir() {
-  return join19(homedir10(), ".augmented", "restart-flags");
+  return join20(homedir10(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join19(restartFlagsDir(), `${codeName}.flag`);
+  return join20(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
-  if (!existsSync10(dir)) return [];
+  if (!existsSync11(dir)) return [];
   const out = [];
   for (const entry of readdirSync4(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync16(join19(dir, entry), "utf8");
+      const raw = readFileSync17(join20(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -6731,7 +6783,7 @@ function readRestartFlags() {
 }
 function deleteRestartFlag(codeName) {
   const path = flagPath(codeName);
-  if (existsSync10(path)) {
+  if (existsSync11(path)) {
     rmSync3(path, { force: true });
   }
 }
@@ -7965,7 +8017,7 @@ var runningChannelSecretHashes = /* @__PURE__ */ new Map();
 var sessionLaunchManagedStructure = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync17(join20(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync18(join21(projectDir, ".mcp.json"), "utf-8");
     return createHash12("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
@@ -7973,7 +8025,7 @@ function projectMcpHash(_codeName, projectDir) {
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync17(join20(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync18(join21(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -7991,7 +8043,7 @@ function seedSessionLaunchBaselines(codeName, projectDir) {
   else runningMcpServerKeys.delete(codeName);
   let launchStructure = null;
   try {
-    const raw = readFileSync17(join20(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync18(join21(projectDir, ".mcp.json"), "utf-8");
     launchStructure = managedMcpStructureHashFromFile(
       JSON.parse(raw),
       isManagedMcpServerKey
@@ -8091,7 +8143,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(readFileSync17(join20(projectDir, ".mcp.json"), "utf-8"));
+      mcpJsonForRebind = JSON.parse(readFileSync18(join21(projectDir, ".mcp.json"), "utf-8"));
     } catch {
       mcpJsonForRebind = null;
     }
@@ -8220,7 +8272,7 @@ function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
 function projectChannelSecretHash(projectDir) {
   try {
     const entries = parseEnvIntegrations(
-      readFileSync17(join20(projectDir, ".env.integrations"), "utf-8")
+      readFileSync18(join21(projectDir, ".env.integrations"), "utf-8")
     );
     return channelSecretValueHash(entries, CHANNEL_SECRET_ENV_KEYS);
   } catch {
@@ -8285,6 +8337,7 @@ function clearAgentCaches(agentId, codeName) {
   stopOpencodeSlackIngest(codeName, log);
   agentFrameworkCache.delete(codeName);
   kanbanBoardCache.delete(codeName);
+  clearKanbanNudgeState(codeName);
   notifyBoardCache.delete(codeName);
   notifiedWaitingHumanIds.delete(codeName);
   lastHarvestAt.delete(codeName);
@@ -8309,7 +8362,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.322" : "dev";
+var agtCliVersion = true ? "0.28.324" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -8322,7 +8375,7 @@ function resolveBrewPath(execFileSync2) {
     "/usr/local/bin/brew"
   ];
   for (const path of fallbacks) {
-    if (existsSync11(path)) return path;
+    if (existsSync12(path)) return path;
   }
   return null;
 }
@@ -8332,7 +8385,7 @@ function claudeBinaryInstalled(execFileSync2) {
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude"
   ];
-  if (canonical.some((path) => existsSync11(path))) return true;
+  if (canonical.some((path) => existsSync12(path))) return true;
   try {
     execFileSync2("which", ["claude"], { timeout: 5e3 });
     return true;
@@ -8487,8 +8540,8 @@ function claudeManagedSettingsPath() {
 function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
   try {
     let settings = {};
-    if (existsSync11(path)) {
-      const raw = readFileSync17(path, "utf-8").trim();
+    if (existsSync12(path)) {
+      const raw = readFileSync18(path, "utf-8").trim();
       if (raw) {
         let parsed;
         try {
@@ -8505,7 +8558,7 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
     if (settings.channelsEnabled === true) return "ok";
     settings.channelsEnabled = true;
     mkdirSync8(dirname6(path), { recursive: true });
-    writeFileSync8(path, `${JSON.stringify(settings, null, 2)}
+    writeFileSync9(path, `${JSON.stringify(settings, null, 2)}
 `);
     log(`[managed-settings] set channelsEnabled:true in ${path} (ENG-5786 \u2014 unblocks Claude Code channels)`);
     return "ok";
@@ -8550,7 +8603,7 @@ async function ensureFrameworkBinary(frameworkId) {
     if (!process.env.PATH?.split(":").includes(brewBinDir)) {
       process.env.PATH = `${brewBinDir}:${process.env.PATH ?? ""}`;
     }
-    if (existsSync11("/home/linuxbrew/.linuxbrew/bin/claude")) {
+    if (existsSync12("/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");
@@ -8606,7 +8659,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join20(homedir11(), ".augmented", ".last-self-update-applied");
+  return join21(homedir11(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var restartAfterUpgrade = false;
@@ -8630,7 +8683,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 = join20(homedir11(), ".augmented", ".last-update-check");
+    const markerPath = join21(homedir11(), ".augmented", ".last-update-check");
     if (!force) {
       try {
         const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
@@ -8908,14 +8961,14 @@ async function checkClaudeAuth() {
 }
 var evalEmptyMcpConfigPath = null;
 function ensureEvalEmptyMcpConfig() {
-  if (evalEmptyMcpConfigPath && existsSync11(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
-  const dir = join20(homedir11(), ".augmented");
+  if (evalEmptyMcpConfigPath && existsSync12(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
+  const dir = join21(homedir11(), ".augmented");
   try {
     mkdirSync8(dir, { recursive: true });
   } catch {
   }
-  const p = join20(dir, ".eval-empty-mcp.json");
-  writeFileSync8(p, JSON.stringify({ mcpServers: {} }));
+  const p = join21(dir, ".eval-empty-mcp.json");
+  writeFileSync9(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
 }
@@ -9006,10 +9059,10 @@ function resolveConversationEvalBackend() {
   return conversationEvalBackend;
 }
 function getStateFile() {
-  return join20(config?.configDir ?? join20(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join21(config?.configDir ?? join21(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join20(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join21(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -9061,7 +9114,7 @@ function removeDeliveryBaselineEntries(agentId) {
 var _channelQuarantineStore = null;
 function channelQuarantineStore() {
   if (!_channelQuarantineStore) {
-    const dir = config?.configDir ?? join20(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join21(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
   }
   return _channelQuarantineStore;
@@ -9069,7 +9122,7 @@ function channelQuarantineStore() {
 var _hostFlagStore = null;
 function hostFlagStore() {
   if (!_hostFlagStore) {
-    const dir = config?.configDir ?? join20(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join21(process.env["HOME"] ?? "/tmp", ".augmented");
     _hostFlagStore = new HostFlagStore({ cachePath: defaultFlagsCachePath(dir), log });
   }
   return _hostFlagStore;
@@ -9136,13 +9189,13 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
-  const { readdirSync: readdirSync6, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync9 } = await import("fs");
-  const skillsDir = join20(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join20(configDir, codeName, "project", "CLAUDE.md");
+  const { readdirSync: readdirSync6, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync10 } = await import("fs");
+  const skillsDir = join21(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join21(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
   for (const dir of readdirSync6(skillsDir).sort()) {
-    const skillFile = join20(skillsDir, dir, "SKILL.md");
+    const skillFile = join21(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -9184,7 +9237,7 @@ ${SKILLS_INDEX_END}`;
     next = current.trimEnd() + "\n\n" + section + "\n";
   }
   if (next !== current) {
-    writeFileSync9(claudeMdPath, next, "utf-8");
+    writeFileSync10(claudeMdPath, next, "utf-8");
     log2(`Refreshed skills index in CLAUDE.md for '${codeName}' (${entries.length} skills)`);
   }
 }
@@ -9205,7 +9258,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-L6S6HABH.js");
+      const { collectDiagnostics } = await import("../persistent-session-BICDYHOC.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames)
@@ -9304,7 +9357,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-L6S6HABH.js");
+      const { collectDiagnostics } = await import("../persistent-session-BICDYHOC.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -9453,7 +9506,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-X2WATO46.js");
+      } = await import("../responsiveness-probe-FEAFPNUF.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -9485,7 +9538,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-X2WATO46.js");
+        } = await import("../responsiveness-probe-FEAFPNUF.js");
         const { getProjectDir: wedgeProjectDir } = await import("../claude-scheduler-FATCLHDM.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -9574,13 +9627,13 @@ async function pollCycle() {
             );
             if (hostFlagStore().getBoolean("wedge-transient-notice")) {
               try {
-                const paneTail = readFileSync17(paneLogPath(codeName), "utf8").slice(-65536);
+                const paneTail = readFileSync18(paneLogPath(codeName), "utf8").slice(-65536);
                 const transient = detectTransientApiErrorInLog(paneTail);
                 if (transient) {
-                  const wedgeHome = join20(homedir11(), ".augmented", codeName);
-                  if (existsSync11(wedgeHome)) {
+                  const wedgeHome = join21(homedir11(), ".augmented", codeName);
+                  if (existsSync12(wedgeHome)) {
                     atomicWriteFileSync(
-                      join20(wedgeHome, "watchdog-give-up.json"),
+                      join21(wedgeHome, "watchdog-give-up.json"),
                       JSON.stringify({
                         gave_up_at: wedgeNow.toISOString(),
                         reason: "transient_overload"
@@ -9829,7 +9882,7 @@ async function pollCycle() {
         } catch {
         }
         killAgentChannelProcesses(prev.codeName, { log });
-        const agentDir = join20(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join21(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -9916,10 +9969,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 = join20(homedir11(), ".augmented", codeName);
-          if (!existsSync11(dir)) return;
+          const dir = join21(homedir11(), ".augmented", codeName);
+          if (!existsSync12(dir)) return;
           atomicWriteFileSync(
-            join20(dir, "watchdog-give-up.json"),
+            join21(dir, "watchdog-give-up.json"),
             JSON.stringify({ gave_up_at: (/* @__PURE__ */ new Date()).toISOString() })
           );
         }
@@ -10049,7 +10102,7 @@ async function processAgent(agent, agentStates) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join20(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join21(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`);
@@ -10095,7 +10148,7 @@ async function processAgent(agent, agentStates) {
       const residuals = {
         gatewayRunning: false,
         portAllocated: false,
-        provisionDirExists: existsSync11(agentDir)
+        provisionDirExists: existsSync12(agentDir)
       };
       if (!hasRevokedResiduals(residuals)) {
         agentStates.push({
@@ -10233,7 +10286,7 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? DEFAULT_FRAMEWORK;
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join20(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join21(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,
@@ -10280,7 +10333,7 @@ async function processAgent(agent, agentStates) {
     const changedFiles = [];
     mkdirSync8(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join20(agentDir, artifact.relativePath);
+      const filePath = join21(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -10299,8 +10352,8 @@ async function processAgent(agent, agentStates) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join20(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync17(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join21(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync18(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -10318,7 +10371,7 @@ async function processAgent(agent, agentStates) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync17(filePath, "utf-8");
+          existingRaw = readFileSync18(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -10340,26 +10393,26 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync11(join20(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync12(join21(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 = join20(agentDir, file.relativePath);
+        const filePath = join21(agentDir, file.relativePath);
         mkdirSync8(dirname6(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
         } else {
-          writeFileSync8(filePath, file.content);
+          writeFileSync9(filePath, file.content);
         }
       }
       try {
-        const provSkillsDir = join20(agentDir, ".claude", "skills");
-        if (existsSync11(provSkillsDir)) {
+        const provSkillsDir = join21(agentDir, ".claude", "skills");
+        if (existsSync12(provSkillsDir)) {
           for (const folder of readdirSync5(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync4(join20(provSkillsDir, folder), { recursive: true });
+                rmSync4(join21(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -10372,7 +10425,7 @@ async function processAgent(agent, agentStates) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join20(agentDir, file));
+        const h = hashFile(join21(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -10390,14 +10443,14 @@ async function processAgent(agent, agentStates) {
     }
     if (Array.isArray(refreshData.workflows)) {
       try {
-        const provWorkflowsDir = join20(agentDir, ".claude", "workflows");
-        if (existsSync11(provWorkflowsDir)) {
+        const provWorkflowsDir = join21(agentDir, ".claude", "workflows");
+        if (existsSync12(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(join20(provWorkflowsDir, file));
+              rmSync4(join21(provWorkflowsDir, file));
             } catch {
             }
           }
@@ -10454,10 +10507,10 @@ async function processAgent(agent, agentStates) {
   }
   let lastDriftCheckAt = now;
   const written = agentState.writtenHashes.get(agent.agent_id);
-  if (written && existsSync11(agentDir)) {
+  if (written && existsSync12(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join20(agentDir, file));
+      const localHash = hashFile(join21(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -10468,7 +10521,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join20(agentDir, file));
+          localHashes[file] = hashFile(join21(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -10655,7 +10708,7 @@ async function processAgent(agent, agentStates) {
     const addedChannels = [...restartDecision.added];
     const writeDmNoticeMarkers = isChannelAddRestart ? () => {
       try {
-        const agentAugmentedDir = join20(homedir11(), ".augmented", agent.code_name);
+        const agentAugmentedDir = join21(homedir11(), ".augmented", agent.code_name);
         mkdirSync8(agentAugmentedDir, { recursive: true });
         const markerJson = JSON.stringify({
           version: 1,
@@ -10663,7 +10716,7 @@ async function processAgent(agent, agentStates) {
           added: addedChannels
         });
         for (const file of ["slack-channel-add-restart.json", "telegram-channel-add-restart.json"]) {
-          atomicWriteFileSync(join20(agentAugmentedDir, file), markerJson);
+          atomicWriteFileSync(join21(agentAugmentedDir, file), markerJson);
         }
       } catch (err) {
         log(`[hot-reload] channel-add DM-notice marker write failed for '${agent.code_name}' (non-fatal): ${err.message}`);
@@ -10852,24 +10905,24 @@ async function processAgent(agent, agentStates) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK) === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join20(homedir11(), ".augmented", agent.code_name, "project");
+      const projectDir = join21(homedir11(), ".augmented", agent.code_name, "project");
       mkdirSync8(agentProvisionDir, { recursive: true });
       mkdirSync8(projectDir, { recursive: true });
-      const provisionMcpPath = join20(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join20(projectDir, ".mcp.json");
+      const provisionMcpPath = join21(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join21(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync17(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync18(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join20(homedir11(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join21(homedir11(), ".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 (existsSync11(localDirectChatChannel)) {
+      if (existsSync12(localDirectChatChannel)) {
         const directChatEnv = {
           AGT_HOST: requireHost(),
           // ENG-5901 Track D: templated — the manager exports the real
@@ -10889,7 +10942,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: join20(
+          AGT_TURN_INITIATOR_FILE: join21(
             frameworkAdapter.getAgentDir(agent.code_name),
             ".current-turn-initiator.json"
           )
@@ -10909,8 +10962,8 @@ async function processAgent(agent, agentStates) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join20(projectDir, ".mcp-channels.json");
-      if (existsSync11(staleChannelsPath)) {
+      const staleChannelsPath = join21(projectDir, ".mcp-channels.json");
+      if (existsSync12(staleChannelsPath)) {
         try {
           rmSync4(staleChannelsPath, { force: true });
         } catch {
@@ -10999,7 +11052,7 @@ async function processAgent(agent, agentStates) {
     }
     if (hostFlagStore().getBoolean("connectivity-probe")) {
       try {
-        const probeProjectDir = join20(homedir11(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join21(homedir11(), ".augmented", agent.code_name, "project");
         await runAgentConnectivityProbes(agent, integrations, probeProjectDir);
       } catch (err) {
         log(`Connectivity probe failed for '${agent.code_name}': ${err.message}`);
@@ -11010,7 +11063,7 @@ async function processAgent(agent, agentStates) {
       const forceDue = attemptsLeft > 0;
       let probeRan = false;
       try {
-        const probeProjectDir = join20(homedir11(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join21(homedir11(), ".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}`);
@@ -11023,9 +11076,9 @@ async function processAgent(agent, agentStates) {
     }
     if (frameworkAdapter.removeMcpServer && frameworkAdapter.getMcpPath) {
       const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
-      if (mcpPath && existsSync11(mcpPath)) {
+      if (mcpPath && existsSync12(mcpPath)) {
         try {
-          const cfg = JSON.parse(readFileSync17(mcpPath, "utf-8"));
+          const cfg = JSON.parse(readFileSync18(mcpPath, "utf-8"));
           const expectedRemoteKeys = new Set(
             integrations.map((i) => i.definition_id)
           );
@@ -11050,11 +11103,11 @@ async function processAgent(agent, agentStates) {
         recordConfigChurnEvent(agent.agent_id, agent.code_name, FLAP_CHANNEL_INTEGRATIONS, intMembership);
       }
       if (intHash !== prevIntHash) {
-        const projectDir = join20(homedir11(), ".augmented", agent.code_name, "project");
-        const envIntPath = join20(projectDir, ".env.integrations");
+        const projectDir = join21(homedir11(), ".augmented", agent.code_name, "project");
+        const envIntPath = join21(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
-          preWriteEnv = readFileSync17(envIntPath, "utf-8");
+          preWriteEnv = readFileSync18(envIntPath, "utf-8");
         } catch {
           preWriteEnv = void 0;
         }
@@ -11066,9 +11119,9 @@ async function processAgent(agent, agentStates) {
         let rotationHandled = true;
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join20(projectDir, ".mcp.json");
-            const postWriteEnv = readFileSync17(envIntPath, "utf-8");
-            const mcpContent = readFileSync17(projectMcpPath, "utf-8");
+            const projectMcpPath = join21(projectDir, ".mcp.json");
+            const postWriteEnv = readFileSync18(envIntPath, "utf-8");
+            const mcpContent = readFileSync18(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
             const mcpJsonForReap = JSON.parse(mcpContent);
             const affectedServerKeys = findMcpServersUsingVars(mcpJsonForReap, changedVars);
@@ -11170,8 +11223,8 @@ async function processAgent(agent, agentStates) {
             const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
             if (mcpPath) {
               try {
-                const { readFileSync: readFileSync18 } = await import("fs");
-                const mcpConfig = JSON.parse(readFileSync18(mcpPath, "utf-8"));
+                const { readFileSync: readFileSync19 } = await import("fs");
+                const mcpConfig = JSON.parse(readFileSync19(mcpPath, "utf-8"));
                 if (mcpConfig.mcpServers) {
                   for (const key of Object.keys(mcpConfig.mcpServers)) {
                     if (isManagedMcpServerKey(key) && !expectedServerIds.has(key)) {
@@ -11318,14 +11371,14 @@ async function processAgent(agent, agentStates) {
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join20(homedir12(), ".augmented", agent.code_name, "skills"),
+          join21(homedir12(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join20(homedir12(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join21(homedir12(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join20(agentDir, ".claude", "skills")
+          join21(agentDir, ".claude", "skills")
         ];
-        const existingDirs = candidateSkillDirs.filter((d) => existsSync11(d));
+        const existingDirs = candidateSkillDirs.filter((d) => existsSync12(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
         for (const dir of existingDirs) {
           try {
@@ -11339,8 +11392,8 @@ async function processAgent(agent, agentStates) {
         }
         const removeSkillFolder = (entry, reason) => {
           for (const dir of existingDirs) {
-            const p = join20(dir, entry);
-            if (existsSync11(p)) {
+            const p = join21(dir, entry);
+            if (existsSync12(p)) {
               rmSync5(p, { recursive: true, force: true });
             }
           }
@@ -11359,7 +11412,7 @@ async function processAgent(agent, agentStates) {
         const sharedSkillsPayload = refreshAny.shared_skills;
         const desiredResolved = globalSkillsPayload !== void 0 || sharedSkillsPayload !== void 0;
         const manifestPath = managedSkillManifestPath(
-          join20(homedir11(), ".augmented", agent.code_name)
+          join21(homedir11(), ".augmented", agent.code_name)
         );
         const prevIds = /* @__PURE__ */ new Set([
           ...agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
@@ -11379,15 +11432,15 @@ async function processAgent(agent, agentStates) {
         }
         if (plan.removes.length) {
           const globalSkillDirs = [
-            join20(homedir11(), ".augmented", agent.code_name, "skills"),
-            join20(homedir11(), ".augmented", agent.code_name, "project", ".claude", "skills"),
-            join20(agentDir, ".claude", "skills")
+            join21(homedir11(), ".augmented", agent.code_name, "skills"),
+            join21(homedir11(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+            join21(agentDir, ".claude", "skills")
           ];
           for (const id of plan.removes) {
             let prunedAny = false;
             for (const dir of globalSkillDirs) {
-              const p = join20(dir, id);
-              if (existsSync11(p) && existsSync11(join20(p, "SKILL.md"))) {
+              const p = join21(dir, id);
+              if (existsSync12(p) && existsSync12(join21(p, "SKILL.md"))) {
                 rmSync4(p, { recursive: true, force: true });
                 prunedAny = true;
               }
@@ -11534,11 +11587,13 @@ async function processAgent(agent, agentStates) {
           "completed",
           "kanban inject suppressed \u2014 suspected poison card(s) (ENG-6171)"
         );
-      } else if (openInjectedRunByCode.has(agent.code_name)) {
-        const openRunId = openInjectedRunByCode.get(agent.code_name);
-        openInjectedRunByCode.delete(agent.code_name);
-        kanbanNudgeStateByCode.delete(agent.code_name);
-        void cancelKanbanNoticeOnDrain(agent.code_name, agent.agent_id, openRunId);
+      } else {
+        clearKanbanNudgeState(agent.code_name);
+        if (openInjectedRunByCode.has(agent.code_name)) {
+          const openRunId = openInjectedRunByCode.get(agent.code_name);
+          openInjectedRunByCode.delete(agent.code_name);
+          void cancelKanbanNoticeOnDrain(agent.code_name, agent.agent_id, openRunId);
+        }
       }
     }
   }
@@ -11590,8 +11645,8 @@ async function processAgent(agent, agentStates) {
       const sess = getSessionState(agent.code_name);
       let mcpJsonParsed = null;
       try {
-        const mcpPath = join20(getProjectDir(agent.code_name), ".mcp.json");
-        mcpJsonParsed = JSON.parse(readFileSync17(mcpPath, "utf-8"));
+        const mcpPath = join21(getProjectDir(agent.code_name), ".mcp.json");
+        mcpJsonParsed = JSON.parse(readFileSync18(mcpPath, "utf-8"));
       } catch {
       }
       reapMissingMcpSessions({
@@ -11916,10 +11971,10 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
     }
   }
   const trackedFiles = frameworkAdapter.driftTrackedFiles();
-  if (trackedFiles.length > 0 && existsSync11(agentDir)) {
+  if (trackedFiles.length > 0 && existsSync12(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join20(agentDir, file));
+      const h = hashFile(join21(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -11934,7 +11989,7 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
         refreshData.agent.onboarding_state
       );
       const obStep = obState.step;
-      const markerPath = join20(homedir11(), ".augmented", agent.code_name, "onboarding-drive.json");
+      const markerPath = join21(homedir11(), ".augmented", agent.code_name, "onboarding-drive.json");
       const marker = readOnboardingDriveMarker(markerPath);
       const decision = decideOnboardingDrive(obStep, marker, Date.now(), obState.generation ?? 0);
       if (decision.clearMarker) {
@@ -12002,7 +12057,7 @@ async function ensureOpencodeRuntime(agent, refreshData, agentTimezone) {
     return { decision: "healthy", spawnAttempted: false, sessionHealthyAfter: true };
   }
   stopOpencodeSlackIngest(codeName, log);
-  const opencodeProjectDir = join20(getFramework("opencode").getAgentDir(codeName), "project");
+  const opencodeProjectDir = join21(getFramework("opencode").getAgentDir(codeName), "project");
   const openRouterRaw = refreshData.openrouter ?? null;
   const serveEnv = {
     AGT_HOST: requireHost(),
@@ -12042,8 +12097,8 @@ async function ensureOpencodeRuntime(agent, refreshData, agentTimezone) {
 async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const codeName = agent.code_name;
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join20(projectDir, ".mcp.json");
-  const claudeMdPath = join20(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join21(projectDir, ".mcp.json");
+  const claudeMdPath = join21(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -12581,7 +12636,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-L6S6HABH.js");
+        const { collectDiagnostics } = await import("../persistent-session-BICDYHOC.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName])
@@ -12631,7 +12686,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-L6S6HABH.js");
+      const { collectDiagnostics } = await import("../persistent-session-BICDYHOC.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName])
@@ -12918,7 +12973,7 @@ async function processDirectChatMessage(agent, msg) {
       try {
         const doorbell = directChatDoorbellPath(agent.agentId, homedir11());
         mkdirSync8(dirname6(doorbell), { recursive: true });
-        writeFileSync8(doorbell, String(Date.now()));
+        writeFileSync9(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) {
@@ -12950,6 +13005,21 @@ ${escapeXml(msg.content)}
 }
 var lastKanbanInjectAt = /* @__PURE__ */ new Map();
 var kanbanNudgeStateByCode = /* @__PURE__ */ new Map();
+function loadKanbanNudgeStateFromDisk() {
+  loadKanbanNudgeState(kanbanNudgeStateByCode, channelHashCacheDir());
+}
+function setKanbanNudgeState(codeName, state7) {
+  kanbanNudgeStateByCode.set(codeName, state7);
+  saveKanbanNudgeState(kanbanNudgeStateByCode, channelHashCacheDir());
+}
+function clearKanbanNudgeState(codeName) {
+  if (!kanbanNudgeStateByCode.delete(codeName)) return;
+  saveKanbanNudgeState(kanbanNudgeStateByCode, channelHashCacheDir());
+}
+function nextKanbanNudgeCount(codeName, signature) {
+  const prev = kanbanNudgeStateByCode.get(codeName);
+  return prev && prev.signature === signature ? (prev.nudgeCount ?? 1) + 1 : 1;
+}
 var openInjectedRunByCode = /* @__PURE__ */ new Map();
 function closeInjectedRunIfOpen(codeName, outcome, outcomeMessage) {
   const runId = openInjectedRunByCode.get(codeName);
@@ -12982,6 +13052,12 @@ var KANBAN_HYBRID_FULL_CADENCE_MS = (() => {
   if (Number.isFinite(parsed) && parsed > 0) return Math.max(parsed * 1e3, KANBAN_HYBRID_DEBOUNCE_MS);
   return Math.max(5 * 6e4, KANBAN_HYBRID_DEBOUNCE_MS);
 })();
+var KANBAN_HYBRID_MAX_CADENCE_MS = (() => {
+  const raw = process.env["AGT_KANBAN_HYBRID_MAX_CADENCE_SECONDS"];
+  const parsed = raw ? parseInt(raw, 10) : NaN;
+  if (Number.isFinite(parsed) && parsed > 0) return Math.max(parsed * 1e3, KANBAN_HYBRID_FULL_CADENCE_MS);
+  return Math.max(60 * 6e4, KANBAN_HYBRID_FULL_CADENCE_MS);
+})();
 async function injectKanbanCheckViaDirectChat(codeName, agentId, actionableCount) {
   if (isKanbanHybridDryRun()) {
     log(
@@ -13007,7 +13083,7 @@ ${formatRunMarker(run_id)}` : KANBAN_CHECK_COMMAND;
   try {
     const doorbell = directChatDoorbellPath(agentId, homedir11());
     mkdirSync8(dirname6(doorbell), { recursive: true });
-    writeFileSync8(doorbell, String(Date.now()));
+    writeFileSync9(doorbell, String(Date.now()));
   } catch (err) {
     log(`[kanban] doorbell ring failed for '${codeName}': ${err.message} (notice still queued)`);
   }
@@ -13021,7 +13097,8 @@ async function maybeInjectKanbanCheck(codeName, agentId, actionableCount, signat
     signature,
     kanbanNudgeStateByCode.get(codeName),
     Date.now(),
-    KANBAN_HYBRID_FULL_CADENCE_MS
+    KANBAN_HYBRID_FULL_CADENCE_MS,
+    KANBAN_HYBRID_MAX_CADENCE_MS
   )) {
     return;
   }
@@ -13033,7 +13110,11 @@ async function maybeInjectKanbanCheck(codeName, agentId, actionableCount, signat
   if (hostFlagStore().getBoolean("kanban-doorbell")) {
     const ok = await injectKanbanCheckViaDirectChat(codeName, agentId, actionableCount);
     if (ok) {
-      kanbanNudgeStateByCode.set(codeName, { signature, nudgedAt: Date.now() });
+      setKanbanNudgeState(codeName, {
+        signature,
+        nudgedAt: Date.now(),
+        nudgeCount: nextKanbanNudgeCount(codeName, signature)
+      });
       return;
     }
     log(`[manager-worker] kanban direct-chat enqueue failed for '${codeName}' \u2014 falling back to send-keys`);
@@ -13067,7 +13148,11 @@ ${formatRunMarker(run_id)}` : KANBAN_CHECK_COMMAND;
   }
   if (delivered) {
     if (run_id) openInjectedRunByCode.set(codeName, run_id);
-    kanbanNudgeStateByCode.set(codeName, { signature, nudgedAt: Date.now() });
+    setKanbanNudgeState(codeName, {
+      signature,
+      nudgedAt: Date.now(),
+      nudgeCount: nextKanbanNudgeCount(codeName, signature)
+    });
     log(
       `[manager-worker] Injected kanban check for '${codeName}' (${actionableCount} actionable items)${run_id ? ` run_id=${run_id}` : ""}`
     );
@@ -13099,7 +13184,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-ZL2U2NZJ.js");
+  } = await import("../claude-pair-runtime-BOFTEAQC.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));
@@ -13342,8 +13427,8 @@ function parseMemoryFile(raw, fallbackName) {
   };
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join20(configDir, agent.code_name, "project");
-  const memoryDir = join20(projectDir, "memory");
+  const projectDir = join21(configDir, agent.code_name, "project");
+  const memoryDir = join21(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`);
@@ -13354,14 +13439,14 @@ async function syncMemories(agent, configDir, log2) {
     }
     pendingFreshMemorySync.delete(agent.agent_id);
   }
-  if (existsSync11(memoryDir)) {
+  if (existsSync12(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 = readFileSync17(join20(memoryDir, file), "utf-8");
+        const raw = readFileSync18(join21(memoryDir, file), "utf-8");
         const fileHash = createHash12("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
@@ -13386,7 +13471,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync17(join20(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync18(join21(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -13399,7 +13484,7 @@ async function syncMemories(agent, configDir, log2) {
   }
 }
 async function downloadMemories(agent, memoryDir, log2, { force }) {
-  const localFiles = existsSync11(memoryDir) ? readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
+  const localFiles = existsSync12(memoryDir) ? readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
   const localListHash = createHash12("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
   const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
   const prevDownload = lastDownloadHash.get(agent.agent_id);
@@ -13421,7 +13506,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 = join20(memoryDir, `${slug}.md`);
+        const filePath = join21(memoryDir, `${slug}.md`);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -13430,17 +13515,17 @@ description: ${JSON.stringify(mem.content.slice(0, 200))}
 
 ${mem.content}
 `;
-        if (existsSync11(filePath)) {
+        if (existsSync12(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync17(filePath, "utf-8");
+            existing = readFileSync18(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) continue;
-          writeFileSync8(filePath, desired);
+          writeFileSync9(filePath, desired);
           overwritten++;
         } else {
-          writeFileSync8(filePath, desired);
+          writeFileSync9(filePath, desired);
           written++;
         }
       }
@@ -13457,7 +13542,7 @@ ${mem.content}
   }
 }
 async function cleanupAgentFiles(codeName, agentDir) {
-  if (existsSync11(agentDir)) {
+  if (existsSync12(agentDir)) {
     try {
       rmSync4(agentDir, { recursive: true, force: true });
       log(`Removed provision directory for '${codeName}'`);
@@ -13567,6 +13652,7 @@ function startPolling() {
   void startCaffeinate();
   loadChannelHashCache2();
   loadSenderPolicyBaseline2();
+  loadKanbanNudgeStateFromDisk();
   hostFlagStore().init();
   log(`Starting poll loop (interval=${config.intervalMs}ms, configDir=${config.configDir})`);
   void killAllAgtTmuxSessions().catch(() => {
@@ -13692,8 +13778,8 @@ function startManager(opts) {
   config = opts;
   try {
     const stateFile = getStateFile();
-    if (existsSync11(stateFile)) {
-      const raw = readFileSync17(stateFile, "utf-8");
+    if (existsSync12(stateFile)) {
+      const raw = readFileSync18(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
         state6.agents = parsed.agents;
@@ -13720,7 +13806,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=${join20(homedir11(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join21(homedir11(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -13741,7 +13827,7 @@ async function reapOrphanedClaudePids() {
   const looksLikeClaude = (pid) => {
     if (process.platform !== "linux") return true;
     try {
-      const comm = readFileSync17(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
+      const comm = readFileSync18(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
       return comm.includes("claude");
     } catch {
       return false;
@@ -13838,14 +13924,14 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join20(homedir11(), ".augmented", "_mcp");
+  const targetDir = join21(homedir11(), ".augmented", "_mcp");
   mkdirSync8(targetDir, { recursive: true });
   const moduleDir = dirname6(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join20(dir, "dist", "mcp");
-    if (existsSync11(join20(candidate, "index.js"))) {
+    const candidate = join21(dir, "dist", "mcp");
+    if (existsSync12(join21(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
@@ -13860,8 +13946,8 @@ function deployMcpAssets() {
   const changedBasenames = [];
   const fileHash = (p) => {
     try {
-      if (!existsSync11(p)) return null;
-      return createHash12("sha256").update(readFileSync17(p)).digest("hex");
+      if (!existsSync12(p)) return null;
+      return createHash12("sha256").update(readFileSync18(p)).digest("hex");
     } catch {
       return null;
     }
@@ -13925,9 +14011,9 @@ function deployMcpAssets() {
     // needs restarting to pick up a token rotation.
     "xero.js"
   ]) {
-    const src = join20(mcpSourceDir, file);
-    const dst = join20(targetDir, file);
-    if (!existsSync11(src)) continue;
+    const src = join21(mcpSourceDir, file);
+    const dst = join21(targetDir, file);
+    if (!existsSync12(src)) continue;
     const before = fileHash(dst);
     try {
       copyFileSync(src, dst);
@@ -13944,23 +14030,23 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join20(targetDir, "index.js");
+  const localMcpPath = join21(targetDir, "index.js");
   try {
-    const agentsDir = join20(homedir11(), ".augmented", "agents");
-    if (existsSync11(agentsDir)) {
+    const agentsDir = join21(homedir11(), ".augmented", "agents");
+    if (existsSync12(agentsDir)) {
       for (const entry of readdirSync5(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join20(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join21(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync17(mcpJsonPath, "utf-8");
+            const raw = readFileSync18(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];
-            writeFileSync8(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+            writeFileSync9(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
             log(`[manager] Patched ${entry.name}/${subdir}/.mcp.json: npx \u2192 node`);
           } catch {
           }