@integrity-labs/agt-cli 0.26.0 → 0.26.2-eng5706.0

package/dist/lib/manager-worker.js

@@ -13,7 +13,7 @@ import {
   provisionOrientHook,
   provisionStopHook,
   requireHost
-} from "../chunk-XG4X7BNT.js";
+} from "../chunk-WERKUMWY.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -32,11 +32,9 @@ import {
   isAgentPromptReady,
   isSessionHealthy,
   isStaleForToday,
-  parsePsRows,
   peekCurrentSession,
   prepareForRespawn,
   readPaneLogTail,
-  reapOrphanChannelMcps,
   resetRestartCount,
   resolveClaudeBinary,
   sanitizeMcpJson,
@@ -46,7 +44,7 @@ import {
   stopAllSessionsAndWait,
   stopPersistentSession,
   takeZombieDetection
-} from "../chunk-LULDCIUS.js";
+} from "../chunk-QSDDP7JN.js";
 import {
   KANBAN_CHECK_COMMAND,
   appendDmFooter,
@@ -69,7 +67,11 @@ import {
   resolveConnectivityProbe,
   resolveDmTarget,
   wrapScheduledTaskPrompt
-} from "../chunk-YMIDZT5T.js";
+} from "../chunk-U3HCB23E.js";
+import {
+  parsePsRows,
+  reapOrphanChannelMcps
+} from "../chunk-XWVM4KPK.js";
 
 // src/lib/manager-worker.ts
 import { createHash as createHash3 } from "crypto";
@@ -2191,6 +2193,67 @@ function withScheduleLinkFooter(opts) {
   return appendScheduleLinkFooter(opts.body, url, opts.medium);
 }
 
+// src/lib/manager/agent-state.ts
+var agentState = {
+  // ---------------------------------------------------------------------------
+  // agentId-keyed
+  // ---------------------------------------------------------------------------
+  knownVersions: /* @__PURE__ */ new Map(),
+  knownStatuses: /* @__PURE__ */ new Map(),
+  knownChannels: /* @__PURE__ */ new Map(),
+  writtenHashes: /* @__PURE__ */ new Map(),
+  knownSecretsHashes: /* @__PURE__ */ new Map(),
+  knownModels: /* @__PURE__ */ new Map(),
+  knownTasksHashes: /* @__PURE__ */ new Map(),
+  knownIntegrationHashes: /* @__PURE__ */ new Map(),
+  knownManagedMcpHashes: /* @__PURE__ */ new Map(),
+  knownManagedMcpStructure: /* @__PURE__ */ new Map(),
+  // ---------------------------------------------------------------------------
+  // codeName-keyed
+  // ---------------------------------------------------------------------------
+  agentDisplayNames: /* @__PURE__ */ new Map(),
+  codeNameToAgentId: /* @__PURE__ */ new Map(),
+  /**
+   * Set of code_names with a live persistent session managed by this worker.
+   * Borderline ownership: written from pollCycle and the persistent-session
+   * lifecycle, read from the kanban-inject gate. Lives in agentState to keep
+   * the kanban subsystem from importing from lifecycle in PR-C/E.
+   */
+  persistentSessionAgents: /* @__PURE__ */ new Set(),
+  // ---------------------------------------------------------------------------
+  // compound-keyed (`agentId:<suffix>`)
+  // ---------------------------------------------------------------------------
+  knownChannelConfigHashes: /* @__PURE__ */ new Map(),
+  knownSkillHashes: /* @__PURE__ */ new Map()
+};
+function clearAgentState(agentId, codeName) {
+  agentState.knownVersions.delete(agentId);
+  agentState.knownStatuses.delete(agentId);
+  agentState.knownChannels.delete(agentId);
+  agentState.writtenHashes.delete(agentId);
+  agentState.knownSecretsHashes.delete(agentId);
+  agentState.knownModels.delete(agentId);
+  agentState.knownTasksHashes.delete(agentId);
+  agentState.knownIntegrationHashes.delete(agentId);
+  agentState.knownManagedMcpHashes.delete(agentId);
+  agentState.knownManagedMcpStructure.delete(agentId);
+  agentState.agentDisplayNames.delete(codeName);
+  agentState.codeNameToAgentId.delete(codeName);
+  let channelCacheMutated = false;
+  for (const key of agentState.knownChannelConfigHashes.keys()) {
+    if (key.startsWith(`${agentId}:`)) {
+      agentState.knownChannelConfigHashes.delete(key);
+      channelCacheMutated = true;
+    }
+  }
+  for (const key of agentState.knownSkillHashes.keys()) {
+    if (key.startsWith(`${agentId}:`)) {
+      agentState.knownSkillHashes.delete(key);
+    }
+  }
+  return channelCacheMutated;
+}
+
 // src/lib/restart-flags.ts
 import { existsSync as existsSync3, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync4, renameSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
@@ -2846,9 +2909,6 @@ function shouldSkipRevokedCleanup(previousKnownStatus) {
 function hasRevokedResiduals(state5) {
   return state5.gatewayRunning || state5.portAllocated || state5.provisionDirExists;
 }
-var knownVersions = /* @__PURE__ */ new Map();
-var knownStatuses = /* @__PURE__ */ new Map();
-var knownChannels = /* @__PURE__ */ new Map();
 var pendingSessionRestarts = /* @__PURE__ */ new Map();
 var restartBreaker = new RestartBreaker();
 var reportedTrips = /* @__PURE__ */ new Map();
@@ -2863,7 +2923,7 @@ function recordRestartForBreaker(codeName, reason) {
 }
 async function reportCircuitTripped(codeName, trip) {
   if (reportedTrips.get(codeName) === trip.trippedAt) return;
-  const agentId = codeNameToAgentId.get(codeName);
+  const agentId = agentState.codeNameToAgentId.get(codeName);
   if (!agentId) throw new Error(`no agent_id known yet for '${codeName}' \u2014 will retry next poll`);
   await api.post("/host/circuit-breaker/trip", {
     agent_id: agentId,
@@ -2904,8 +2964,6 @@ function cancelPendingSessionRestart(codeName) {
   pendingSessionRestarts.delete(codeName);
   log(`[hot-reload] Cancelled pending restart timer for '${codeName}' (another teardown path is handling it)`);
 }
-var writtenHashes = /* @__PURE__ */ new Map();
-var knownSecretsHashes = /* @__PURE__ */ new Map();
 var runningMcpHashes = /* @__PURE__ */ new Map();
 var runningMcpServerKeys = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
@@ -2962,7 +3020,14 @@ async function runAgentConnectivityProbes(agent, integrations, projectDir) {
       auth_type: i.auth_type,
       source_type: i.source_type ?? null,
       credentials: i.credentials,
-      last_connectivity_check_at: i.last_connectivity_check_at ?? null
+      last_connectivity_check_at: i.last_connectivity_check_at ?? null,
+      // ENG-5665: for managed (Composio) + mcp_server toolkits the connectivity
+      // probe is an MCP `tools/list` against the agent's wired server. Derive the
+      // .mcp.json server key the same way the managed-toolkit writer does
+      // (definition_id === toolkit_id, sanitised: non-alnum → '_', lowercased —
+      // e.g. 'composio_outlook'). The executor looks this up in .mcp.json; an
+      // unresolvable key degrades to transient_error, never a false 'down'.
+      mcp_server_key: i.source_type === "managed" || i.source_type === "mcp_server" ? i.definition_id.replace(/[^a-z0-9]/gi, "_").toLowerCase() : void 0
     })),
     { probeDeps, intervalMs: intervalSec * 1e3 }
   );
@@ -3038,13 +3103,6 @@ function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
     }
   }
 }
-var knownChannelConfigHashes = /* @__PURE__ */ new Map();
-var knownModels = /* @__PURE__ */ new Map();
-var knownTasksHashes = /* @__PURE__ */ new Map();
-var knownIntegrationHashes = /* @__PURE__ */ new Map();
-var knownManagedMcpHashes = /* @__PURE__ */ new Map();
-var knownManagedMcpStructure = /* @__PURE__ */ new Map();
-var knownSkillHashes = /* @__PURE__ */ new Map();
 var managedToolkitIdByAgentAndServerId = /* @__PURE__ */ new Map();
 function managedToolkitMapKey(agentId, serverId) {
   return `${agentId}\0${serverId}`;
@@ -3063,8 +3121,6 @@ var STALE_TASK_THRESHOLD_MS = (() => {
 var alertSlackWebhook = null;
 var alertedJobs = /* @__PURE__ */ new Set();
 var taskDisplayInfo = /* @__PURE__ */ new Map();
-var agentDisplayNames = /* @__PURE__ */ new Map();
-var codeNameToAgentId = /* @__PURE__ */ new Map();
 var agentChannelTokens = /* @__PURE__ */ new Map();
 var activeChannels = /* @__PURE__ */ new Map();
 var gatewaysStartedThisCycle = /* @__PURE__ */ new Set();
@@ -3086,18 +3142,7 @@ function resolveAgentFramework(codeName) {
 }
 var gatewayPool = null;
 function clearAgentCaches(agentId, codeName) {
-  knownVersions.delete(agentId);
-  knownStatuses.delete(agentId);
-  knownChannels.delete(agentId);
-  writtenHashes.delete(agentId);
-  knownSecretsHashes.delete(agentId);
-  knownModels.delete(agentId);
-  knownTasksHashes.delete(agentId);
-  knownIntegrationHashes.delete(agentId);
-  knownManagedMcpHashes.delete(agentId);
-  knownManagedMcpStructure.delete(agentId);
-  agentDisplayNames.delete(codeName);
-  codeNameToAgentId.delete(codeName);
+  const channelCacheMutated = clearAgentState(agentId, codeName);
   agentFrameworkCache.delete(codeName);
   kanbanBoardCache.delete(codeName);
   lastHarvestAt.delete(codeName);
@@ -3107,26 +3152,16 @@ function clearAgentCaches(agentId, codeName) {
   memoryFileHashes.delete(agentId);
   lastDownloadHash.delete(agentId);
   lastLocalFileHash.delete(agentId);
-  let channelCacheMutated = false;
-  for (const key of knownChannelConfigHashes.keys()) {
-    if (key.startsWith(`${agentId}:`)) {
-      knownChannelConfigHashes.delete(key);
-      channelCacheMutated = true;
-    }
-  }
-  if (channelCacheMutated) saveChannelHashCache2();
-  for (const key of knownSkillHashes.keys()) {
-    if (key.startsWith(`${agentId}:`)) knownSkillHashes.delete(key);
-  }
   for (const key of taskDisplayInfo.keys()) {
     if (key.startsWith(`${codeName}:`)) taskDisplayInfo.delete(key);
   }
+  if (channelCacheMutated) saveChannelHashCache2();
 }
 var cachedFrameworkVersion = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.26.0" : "dev";
+var agtCliVersion = true ? "0.26.2-eng5706.0" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -3640,10 +3675,10 @@ function channelHashCacheDir() {
   return config?.configDir ?? join6(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
-  loadChannelHashCache(knownChannelConfigHashes, channelHashCacheDir());
+  loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
 }
 function saveChannelHashCache2() {
-  saveChannelHashCache(knownChannelConfigHashes, channelHashCacheDir());
+  saveChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
 }
 function send(msg) {
   if (msg.type === "state-update") {
@@ -3974,40 +4009,40 @@ async function stopAllGateways() {
   }
 }
 async function healthCheckGateways(agentStates) {
-  for (const agentState of agentStates) {
-    if (agentState.status !== "active" || !agentState.gatewayPort) continue;
-    const adapter = resolveAgentFramework(agentState.codeName);
+  for (const agent of agentStates) {
+    if (agent.status !== "active" || !agent.gatewayPort) continue;
+    const adapter = resolveAgentFramework(agent.codeName);
     if (!adapter.isGatewayRunning || !adapter.startGateway) continue;
-    if (gatewaysStartedThisCycle.has(agentState.codeName)) continue;
-    const status = await adapter.isGatewayRunning(agentState.codeName);
-    if (!status.running && agentState.gatewayRunning) {
-      const displayName = agentDisplayNames.get(agentState.codeName) ?? agentState.codeName;
-      log(`Gateway for '${agentState.codeName}' crashed, restarting...`);
+    if (gatewaysStartedThisCycle.has(agent.codeName)) continue;
+    const status = await adapter.isGatewayRunning(agent.codeName);
+    if (!status.running && agent.gatewayRunning) {
+      const displayName = agentState.agentDisplayNames.get(agent.codeName) ?? agent.codeName;
+      log(`Gateway for '${agent.codeName}' crashed, restarting...`);
       sendSlackWebhookMessage(
-        `:red_circle: *Host Down* \u2014 *${displayName}* (\`${agentState.codeName}\`)
+        `:red_circle: *Host Down* \u2014 *${displayName}* (\`${agent.codeName}\`)
 OpenClaw gateway crashed. Attempting automatic restart...`
       ).catch(() => {
       });
       try {
-        const result = await adapter.startGateway(agentState.codeName, agentState.gatewayPort);
-        agentState.gatewayPid = result.pid;
-        agentState.gatewayRunning = true;
-        log(`Gateway restarted for '${agentState.codeName}' (PID ${result.pid})`);
+        const result = await adapter.startGateway(agent.codeName, agent.gatewayPort);
+        agent.gatewayPid = result.pid;
+        agent.gatewayRunning = true;
+        log(`Gateway restarted for '${agent.codeName}' (PID ${result.pid})`);
         await new Promise((resolve) => setTimeout(resolve, 2e3));
         if (gatewayPool) {
-          const token = readGatewayToken(agentState.codeName);
-          gatewayPool.addAgent(agentState.codeName, agentState.gatewayPort, token);
+          const token = readGatewayToken(agent.codeName);
+          gatewayPool.addAgent(agent.codeName, agent.gatewayPort, token);
         }
         sendSlackWebhookMessage(
-          `:large_green_circle: *Host Recovered* \u2014 *${displayName}* (\`${agentState.codeName}\`)
+          `:large_green_circle: *Host Recovered* \u2014 *${displayName}* (\`${agent.codeName}\`)
 Gateway restarted successfully (PID ${result.pid}).`
         ).catch(() => {
         });
       } catch (err) {
-        agentState.gatewayRunning = false;
-        log(`Failed to restart gateway for '${agentState.codeName}': ${err.message}`);
+        agent.gatewayRunning = false;
+        log(`Failed to restart gateway for '${agent.codeName}': ${err.message}`);
         sendSlackWebhookMessage(
-          `:x: *Host Restart Failed* \u2014 *${displayName}* (\`${agentState.codeName}\`)
+          `:x: *Host Restart Failed* \u2014 *${displayName}* (\`${agent.codeName}\`)
 Automatic restart failed: ${err.message}`
         ).catch(() => {
         });
@@ -4025,7 +4060,7 @@ async function pollCycle() {
       resolveFramework: (codeName) => agentFrameworkCache.get(codeName) ?? null,
       stopSession: (codeName) => {
         stopPersistentSessionAndForgetMcpBaseline(codeName, "channel-set-change");
-        persistentSessionAgents.delete(codeName);
+        agentState.persistentSessionAgents.delete(codeName);
         claudeAuthTupleBySession.delete(codeName);
       },
       getTelegramTokens: (codeName) => {
@@ -4085,8 +4120,8 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-3ITHPO4P.js");
-      const diagCodeNames = [...persistentSessionAgents];
+      const { collectDiagnostics } = await import("../persistent-session-K4X76LLB.js");
+      const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
       try {
@@ -4118,7 +4153,7 @@ async function pollCycle() {
         const errId = createHash3("sha256").update(errText).digest("hex").slice(0, 12);
         log(`Claude auth detection failed (error_id=${errId})`);
       }
-      await api.post("/host/heartbeat", {
+      const hbResp = await api.post("/host/heartbeat", {
         host_id: hostId,
         framework_version: cachedFrameworkVersion ?? void 0,
         agt_version: agtCliVersion,
@@ -4136,6 +4171,16 @@ async function pollCycle() {
         // behind a fresh heartbeat.
         realtime_socket_connected: isRealtimeSocketConnected()
       });
+      try {
+        const { maybeUpdateClaudeCode } = await import("../claude-code-updater-7BGQ6JCV.js");
+        await maybeUpdateClaudeCode({
+          desiredVersion: hbResp?.desired_claude_code_version ?? "latest",
+          currentVersion: cachedFrameworkVersion,
+          log
+        });
+      } catch (err) {
+        log(`Claude Code updater error: ${err.message}`);
+      }
     } catch (err) {
       log(`Heartbeat failed: ${err.message}`);
     }
@@ -4143,10 +4188,10 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-7XWORQLO.js");
+      } = await import("../responsiveness-probe-QBV43SJ7.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
-        const probeCodeNames = [...persistentSessionAgents];
+        const probeCodeNames = [...agentState.persistentSessionAgents];
         if (probeCodeNames.length > 0) {
           const probes = collectResponsivenessProbes(probeCodeNames);
           if (probes.length > 0) {
@@ -4164,8 +4209,8 @@ async function pollCycle() {
       const { scrapeMcpFailedBannerCount } = await import("../pane-mcp-banner-scraper-JA437JIB.js");
       const observations = [];
       const pendingCacheCommits = [];
-      for (const codeName of persistentSessionAgents) {
-        const agentId = codeNameToAgentId.get(codeName);
+      for (const codeName of agentState.persistentSessionAgents) {
+        const agentId = agentState.codeNameToAgentId.get(codeName);
         if (!agentId) continue;
         const tail = readPaneLogTail(codeName, 40);
         if (!tail) continue;
@@ -4185,7 +4230,7 @@ async function pollCycle() {
             (resp?.results ?? []).filter((r) => r.ok).map((r) => r.agent_id)
           );
           for (const { codeName, count } of pendingCacheCommits) {
-            const agentId = codeNameToAgentId.get(codeName);
+            const agentId = agentState.codeNameToAgentId.get(codeName);
             if (agentId && accepted.has(agentId)) {
               lastMcpFailedBannerCount.set(codeName, count);
             }
@@ -4416,9 +4461,9 @@ async function getOrCacheRegisteredAgents(adapter, profile) {
 }
 async function processAgent(agent, agentStates) {
   if (!config) return;
-  const previousKnownStatus = knownStatuses.get(agent.agent_id);
-  agentDisplayNames.set(agent.code_name, agent.display_name);
-  codeNameToAgentId.set(agent.code_name, agent.agent_id);
+  const previousKnownStatus = agentState.knownStatuses.get(agent.agent_id);
+  agentState.agentDisplayNames.set(agent.code_name, agent.display_name);
+  agentState.codeNameToAgentId.set(agent.code_name, agent.agent_id);
   maybeReportCurrentTrip(agent.code_name);
   if (agent.framework) {
     agentFrameworkCache.set(agent.code_name, agent.framework);
@@ -4468,7 +4513,7 @@ async function processAgent(agent, agentStates) {
       gatewayRunning: false,
       acpSessions: []
     });
-    knownStatuses.set(agent.agent_id, agent.status);
+    agentState.knownStatuses.set(agent.agent_id, agent.status);
     return;
   }
   if (agent.status === "revoked") {
@@ -4515,7 +4560,7 @@ async function processAgent(agent, agentStates) {
     freePort(agent.code_name);
     await cleanupAgentFiles(agent.code_name, agentDir);
     clearAgentCaches(agent.agent_id, agent.code_name);
-    knownStatuses.set(agent.agent_id, agent.status);
+    agentState.knownStatuses.set(agent.agent_id, agent.status);
     agentStates.push({
       agentId: agent.agent_id,
       codeName: agent.code_name,
@@ -4534,25 +4579,25 @@ async function processAgent(agent, agentStates) {
     });
     return;
   }
-  const previousStatus = knownStatuses.get(agent.agent_id);
+  const previousStatus = agentState.knownStatuses.get(agent.agent_id);
   if (previousStatus && previousStatus !== agent.status) {
     log(`Agent '${agent.code_name}' status changed: ${previousStatus} \u2192 ${agent.status}`);
-    knownVersions.delete(agent.agent_id);
+    agentState.knownVersions.delete(agent.agent_id);
     if (previousStatus === "paused" && agent.status === "active" && restartBreaker.isTripped(agent.code_name)) {
       restartBreaker.clear(agent.code_name);
       reportedTrips.delete(agent.code_name);
       log(`[circuit-breaker] Cleared trip for '${agent.code_name}' on operator resume (paused \u2192 active)`);
     }
     let channelCacheMutated = false;
-    for (const key of knownChannelConfigHashes.keys()) {
+    for (const key of agentState.knownChannelConfigHashes.keys()) {
       if (key.startsWith(`${agent.agent_id}:`)) {
-        knownChannelConfigHashes.delete(key);
+        agentState.knownChannelConfigHashes.delete(key);
         channelCacheMutated = true;
       }
     }
     if (channelCacheMutated) saveChannelHashCache2();
   }
-  knownStatuses.set(agent.agent_id, agent.status);
+  agentState.knownStatuses.set(agent.agent_id, agent.status);
   let refreshData;
   try {
     refreshData = await api.post("/host/refresh", {
@@ -4615,10 +4660,10 @@ async function processAgent(agent, agentStates) {
   }
   const charterVersion = refreshData.charter.version;
   const toolsVersion = refreshData.tools.version;
-  const known = knownVersions.get(agent.agent_id);
+  const known = agentState.knownVersions.get(agent.agent_id);
   let lastProvisionAt = state4.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
   const currentChannelIds = launchableChannelIds(refreshData.channel_configs);
-  const previousChannelIds = knownChannels.get(agent.agent_id);
+  const previousChannelIds = agentState.knownChannels.get(agent.agent_id);
   const channelsChanged = !previousChannelIds || currentChannelIds.size !== previousChannelIds.size || [...currentChannelIds].some((ch) => !previousChannelIds.has(ch)) || [...previousChannelIds].some((ch) => !currentChannelIds.has(ch));
   let channelConfigConverged = true;
   if (previousChannelIds && channelsChanged && frameworkAdapter.removeChannelCredentials) {
@@ -4716,14 +4761,14 @@ async function processAgent(agent, agentStates) {
       } catch {
       }
       lastProvisionAt = (/* @__PURE__ */ new Date()).toISOString();
-      knownVersions.set(agent.agent_id, { charterVersion, toolsVersion });
+      agentState.knownVersions.set(agent.agent_id, { charterVersion, toolsVersion });
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
         const h = hashFile(join6(agentDir, file));
         if (h) hashes.set(file, h);
       }
-      writtenHashes.set(agent.agent_id, hashes);
+      agentState.writtenHashes.set(agent.agent_id, hashes);
       const resolvedModelsForRegistration = resolveModelChain(refreshData);
       const primaryModel2 = resolvedModelsForRegistration.primary ?? refreshData.agent.primary_model;
       const registeredAgents = await getOrCacheRegisteredAgents(frameworkAdapter, agent.code_name);
@@ -4745,7 +4790,7 @@ async function processAgent(agent, agentStates) {
   const resolvedForModel = resolveModelChain(refreshData);
   const primaryModel = resolvedForModel.primary ?? refreshData.agent.primary_model;
   if (primaryModel && frameworkAdapter.updateAgentModel) {
-    const previousModel = knownModels.get(agent.agent_id);
+    const previousModel = agentState.knownModels.get(agent.agent_id);
     if (previousModel !== primaryModel) {
       try {
         const updated = await frameworkAdapter.updateAgentModel(agent.code_name, primaryModel);
@@ -4781,10 +4826,10 @@ async function processAgent(agent, agentStates) {
         scheduleSessionRestart(agent.code_name, delay, "model change", "model-change");
       }
     }
-    knownModels.set(agent.agent_id, primaryModel);
+    agentState.knownModels.set(agent.agent_id, primaryModel);
   }
   let lastDriftCheckAt = now;
-  const written = writtenHashes.get(agent.agent_id);
+  const written = agentState.writtenHashes.get(agent.agent_id);
   if (written && existsSync4(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
@@ -4881,14 +4926,14 @@ async function processAgent(agent, agentStates) {
             log(`hasChannelCredentials failed for '${agent.code_name}/${channelId}': ${err.message} \u2014 forcing credential rewrite`);
             onDiskPresent = false;
           }
-          if (knownChannelConfigHashes.get(cacheKey) === configHash && onDiskPresent) {
+          if (agentState.knownChannelConfigHashes.get(cacheKey) === configHash && onDiskPresent) {
             continue;
           }
-          const prevHash = knownChannelConfigHashes.get(cacheKey);
+          const prevHash = agentState.knownChannelConfigHashes.get(cacheKey);
           const reason = !prevHash ? "first-write" : !onDiskPresent ? "on-disk-missing" : "content-changed";
           if (!onDiskPresent && prevHash) {
             log(`Cached hash for '${agent.code_name}/${channelId}' but on-disk entry missing \u2014 re-writing credentials`);
-            knownChannelConfigHashes.delete(cacheKey);
+            agentState.knownChannelConfigHashes.delete(cacheKey);
           }
           try {
             const sessionMode2 = refreshData.agent.session_mode;
@@ -4910,7 +4955,7 @@ async function processAgent(agent, agentStates) {
                 agentTimezone
               }
             );
-            knownChannelConfigHashes.set(cacheKey, configHash);
+            agentState.knownChannelConfigHashes.set(cacheKey, configHash);
             saveChannelHashCache2();
             log(`Channel credentials written for '${agent.code_name}/${channelId}' (reason=${reason}, hash=${configHash.slice(0, 8)}${prevHash ? `, prev=${prevHash.slice(0, 8)}` : ""})`);
           } catch (err) {
@@ -4928,7 +4973,7 @@ async function processAgent(agent, agentStates) {
     }
   }
   if (channelConfigConverged) {
-    knownChannels.set(agent.agent_id, currentChannelIds);
+    agentState.knownChannels.set(agent.agent_id, currentChannelIds);
   } else {
     log(`[channels] Credential sync did not converge for '${agent.code_name}' \u2014 leaving diff live for next tick retry`);
   }
@@ -5002,7 +5047,7 @@ async function processAgent(agent, agentStates) {
     }
   }
   let lastSecretsProvisionAt = state4.agents.find((a) => a.agentId === agent.agent_id)?.lastSecretsProvisionAt ?? null;
-  let secretsHash = knownSecretsHashes.get(agent.agent_id) ?? null;
+  let secretsHash = agentState.knownSecretsHashes.get(agent.agent_id) ?? null;
   try {
     const secretsData = await api.post("/host/secrets", { agent_id: agent.agent_id });
     const newHash = secretsData.secrets_hash;
@@ -5013,10 +5058,10 @@ async function processAgent(agent, agentStates) {
       log(`Secrets updated for '${agent.code_name}'`);
     }
     if (newHash) {
-      knownSecretsHashes.set(agent.agent_id, newHash);
+      agentState.knownSecretsHashes.set(agent.agent_id, newHash);
       secretsHash = newHash;
     } else {
-      knownSecretsHashes.delete(agent.agent_id);
+      agentState.knownSecretsHashes.delete(agent.agent_id);
       secretsHash = null;
     }
   } catch (err) {
@@ -5063,7 +5108,7 @@ async function processAgent(agent, agentStates) {
     }
     if (integrations.length > 0) {
       const intHash = computeIntegrationsHash(integrations);
-      const prevIntHash = knownIntegrationHashes.get(agent.agent_id);
+      const prevIntHash = agentState.knownIntegrationHashes.get(agent.agent_id);
       if (intHash !== prevIntHash) {
         const projectDir = join6(homedir4(), ".augmented", agent.code_name, "project");
         const envIntPath = join6(projectDir, ".env.integrations");
@@ -5108,7 +5153,7 @@ async function processAgent(agent, agentStates) {
           }
         }
         if (rotationHandled) {
-          knownIntegrationHashes.set(agent.agent_id, intHash);
+          agentState.knownIntegrationHashes.set(agent.agent_id, intHash);
         }
         needsGatewayRestart = true;
       }
@@ -5138,9 +5183,9 @@ async function processAgent(agent, agentStates) {
           return `${e.serverId}|${e.url}|${headersHash}`;
         }).join("\n");
         const mcpHash = createHash3("sha256").update(hashBasis).digest("hex").slice(0, 16);
-        const prevMcpHash = knownManagedMcpHashes.get(agent.agent_id);
+        const prevMcpHash = agentState.knownManagedMcpHashes.get(agent.agent_id);
         const structureHash = managedMcpStructureHash(desiredEntries);
-        const prevStructureHash = knownManagedMcpStructure.get(agent.agent_id);
+        const prevStructureHash = agentState.knownManagedMcpStructure.get(agent.agent_id);
         if (mcpHash !== prevMcpHash) {
           for (const e of desiredEntries) {
             frameworkAdapter.writeMcpServer(agent.code_name, e.serverId, { url: e.url, headers: e.headers });
@@ -5177,8 +5222,8 @@ async function processAgent(agent, agentStates) {
               }
             }
           }
-          knownManagedMcpHashes.set(agent.agent_id, mcpHash);
-          knownManagedMcpStructure.set(agent.agent_id, structureHash);
+          agentState.knownManagedMcpHashes.set(agent.agent_id, mcpHash);
+          agentState.knownManagedMcpStructure.set(agent.agent_id, structureHash);
           if (prevStructureHash !== void 0 && structureHash !== prevStructureHash && fwForMcp === "claude-code" && isSessionHealthy(agent.code_name)) {
             const mcpNames = agentToolkits.map((tk) => tk.toolkit_name).join(", ") || "none (all removed)";
             log(`[hot-reload] MCP servers changed for '${agent.code_name}': ${mcpNames} \u2014 restarting session`);
@@ -5304,9 +5349,9 @@ async function processAgent(agent, agentStates) {
           const bundle = buildIntegrationBundle(renderedScopes);
           const contentHash = createHash4("sha256").update(bundleFingerprint(bundle.files)).digest("hex").slice(0, 12);
           const hashKey = `plugin-skill:${agent.agent_id}:${integrationSkillId}`;
-          if (knownSkillHashes.get(hashKey) === contentHash) continue;
+          if (agentState.knownSkillHashes.get(hashKey) === contentHash) continue;
           frameworkAdapter.installSkillFiles(agent.code_name, integrationSkillId, bundle.files);
-          knownSkillHashes.set(hashKey, contentHash);
+          agentState.knownSkillHashes.set(hashKey, contentHash);
           for (const s of scopes) installedIntegrationSkills.push(s.skill_name);
           log(`Installed integration skill bundle '${integrationSkillId}' for '${agent.code_name}' (${scopes.length} scope(s))`);
         } catch (err) {
@@ -5373,7 +5418,7 @@ async function processAgent(agent, agentStates) {
           try {
             const scriptHash = createHash4("sha256").update(hook.script).digest("hex").slice(0, 12);
             const hookKey = `${agent.agent_id}:${frameworkAdapter.id}:plugin-hook:${slug}:on_install`;
-            if (knownSkillHashes.get(hookKey) === scriptHash) continue;
+            if (agentState.knownSkillHashes.get(hookKey) === scriptHash) continue;
             const result = await frameworkAdapter.executePluginHook({
               codeName: agent.code_name,
               pluginSlug: slug,
@@ -5381,7 +5426,7 @@ async function processAgent(agent, agentStates) {
               script: hook.script
             });
             if (result.exitCode === 0) {
-              knownSkillHashes.set(hookKey, scriptHash);
+              agentState.knownSkillHashes.set(hookKey, scriptHash);
               log(`Integration hook on_install '${slug}' succeeded for '${agent.code_name}' (${result.durationMs}ms)`);
             } else if (result.timedOut) {
               log(`Integration hook on_install '${slug}' TIMED OUT for '${agent.code_name}' after ${result.durationMs}ms`);
@@ -5589,7 +5634,7 @@ async function processAgent(agent, agentStates) {
     const resolvedModels = resolveModelChain(refreshData);
     const modelsHash = createHash3("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
     const combinedHash = `${stableTasksHash}:${boardHash}:${modelsHash}`;
-    const prevTasksHash = knownTasksHashes.get(agent.agent_id);
+    const prevTasksHash = agentState.knownTasksHashes.get(agent.agent_id);
     if (combinedHash !== prevTasksHash) {
       const enrichedTasks = tasks.map((t) => {
         if (BOARD_INJECT_TEMPLATES.has(t.template_id) && boardItems.length > 0) {
@@ -5626,7 +5671,7 @@ async function processAgent(agent, agentStates) {
             models: resolvedModels
           }
         );
-        knownTasksHashes.set(agent.agent_id, combinedHash);
+        agentState.knownTasksHashes.set(agent.agent_id, combinedHash);
         log(`Scheduled tasks synced for '${agent.code_name}' (${enrichedTasks.length} task(s))`);
       } catch (err) {
         log(`Failed to sync scheduled tasks for '${agent.code_name}': ${err.message}`);
@@ -5695,7 +5740,7 @@ async function processAgent(agent, agentStates) {
     cleanupStaleSessions(agent.code_name);
   }
   {
-    const agentId = codeNameToAgentId.get(agent.code_name);
+    const agentId = agentState.codeNameToAgentId.get(agent.code_name);
     if (agentId) {
       try {
         const boardData = await api.post("/host/my-kanban", { agent_id: agentId });
@@ -5711,16 +5756,11 @@ async function processAgent(agent, agentStates) {
           );
           log(`[${agent.code_name}] Board diff: ${previousDoneIds.size} prev done \u2192 ${freshDoneIds.size} now, ${newlyDone.length} newly done`);
           if (newlyDone.length > 0) {
-            const displayName = agentDisplayNames.get(agent.code_name) ?? agent.code_name;
+            const displayName = agentState.agentDisplayNames.get(agent.code_name) ?? agent.code_name;
             for (const item of newlyDone) {
               log(`Newly done: '${item.title}' notify_channel=${item.notify_channel ?? "none"} notify_to=${item.notify_to ?? "none"}`);
               if (item.notify_channel && item.notify_to) {
-                const isFailed = item.status === "failed";
-                const resultLine = item.result ? `
-${isFailed ? "Reason" : "Result"}: ${item.result}` : "";
-                const emoji = isFailed ? "\u274C" : "\u2705";
-                const message = `${emoji} ${isFailed ? "Task Failed" : "Task Complete"} \u2014 ${displayName}
-${item.title}${resultLine}`;
+                const message = await buildDoneCardNotification(agentId, agent.code_name, displayName, item);
                 sendTaskNotification(agent.code_name, item.notify_channel, item.notify_to, message).catch((err) => {
                   log(`sendTaskNotification failed for '${agent.code_name}': ${err.message}`);
                 });
@@ -5734,7 +5774,7 @@ ${item.title}${resultLine}`;
           return age > STALE_TASK_THRESHOLD_MS && !alertedStaleItems.has(`${agent.code_name}:${b.id}`);
         });
         if (staleItems.length > 0) {
-          const displayName = agentDisplayNames.get(agent.code_name) ?? agent.code_name;
+          const displayName = agentState.agentDisplayNames.get(agent.code_name) ?? agent.code_name;
           for (const item of staleItems) {
             const age = Math.round((Date.now() - new Date(item.updated_at).getTime()) / 6e4);
             const stuckKey = `${agent.code_name}:${item.id}`;
@@ -5807,9 +5847,9 @@ In progress for ${age} minutes \u2014 auto-failed`).catch(() => {
       const h = hashFile(join6(agentDir, file));
       if (h) hashes.set(file, h);
     }
-    writtenHashes.set(agent.agent_id, hashes);
+    agentState.writtenHashes.set(agent.agent_id, hashes);
   } else {
-    writtenHashes.delete(agent.agent_id);
+    agentState.writtenHashes.delete(agent.agent_id);
   }
   agentStates.push({
     agentId: agent.agent_id,
@@ -5970,7 +6010,7 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
   const resolvedModels = resolveModelChain(refreshData);
   const modelsHash = createHash3("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
   const combinedHash = `${stableTasksHash}:${boardHash}:${modelsHash}`;
-  const prevHash = knownTasksHashes.get(agent.agent_id);
+  const prevHash = agentState.knownTasksHashes.get(agent.agent_id);
   if (combinedHash !== prevHash) {
     const taskInputs = tasks.map((t) => ({
       id: t.id,
@@ -5991,7 +6031,7 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
     }));
     const state6 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
     claudeSchedulerStates.set(codeName, state6);
-    knownTasksHashes.set(agent.agent_id, combinedHash);
+    agentState.knownTasksHashes.set(agent.agent_id, combinedHash);
     log(`[claude-scheduler] Tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
   }
   if (!claudeSchedulerStates.has(codeName)) {
@@ -6414,7 +6454,6 @@ async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput,
     log(`[claude-scheduler] Failed to post result for '${codeName}': ${err.message}`);
   }
 }
-var persistentSessionAgents = /* @__PURE__ */ new Set();
 var lastMcpFailedBannerCount = /* @__PURE__ */ new Map();
 var persistentSessionStuckTracker = new PersistentSessionStuckTracker();
 var claudeAuthTupleBySession = /* @__PURE__ */ new Map();
@@ -6478,7 +6517,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
     log(`[persistent-session] Failed to resolve auth for '${codeName}': ${msg} \u2014 refusing to spawn`);
     if (isSessionHealthy(codeName)) {
       stopPersistentSessionAndForgetMcpBaseline(codeName);
-      persistentSessionAgents.delete(codeName);
+      agentState.persistentSessionAgents.delete(codeName);
       claudeAuthTupleBySession.delete(codeName);
     }
     return {
@@ -6515,7 +6554,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   if (recordedAuthTuple && recordedAuthTuple !== currentAuthTuple && isSessionHealthy(codeName)) {
     log(`[persistent-session] Auth config changed for '${codeName}' (${recordedAuthTuple} \u2192 ${currentAuthTuple}) \u2014 restarting session`);
     stopPersistentSessionAndForgetMcpBaseline(codeName, "auth-tuple-change");
-    persistentSessionAgents.delete(codeName);
+    agentState.persistentSessionAgents.delete(codeName);
     restartTrigger = "auth-tuple";
   }
   if (isStaleForToday(codeName, /* @__PURE__ */ new Date(), agentTimezone) && isSessionHealthy(codeName)) {
@@ -6527,7 +6566,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
           `[persistent-session] Day rollover for '${codeName}' (yesterday=${current.date}) \u2014 agent idle, restarting to mint fresh session`
         );
         stopPersistentSessionAndForgetMcpBaseline(codeName, "day-rollover");
-        persistentSessionAgents.delete(codeName);
+        agentState.persistentSessionAgents.delete(codeName);
         restartTrigger = "day-rollover";
       } else {
         log(
@@ -6547,7 +6586,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
     };
   }
   if (!isSessionHealthy(codeName)) {
-    if (persistentSessionAgents.has(codeName)) {
+    if (agentState.persistentSessionAgents.has(codeName)) {
       const ctx = getLastFailureContext(codeName);
       const recovery = prepareForRespawn(codeName);
       const tailSummary = !ctx.tail ? "" : KNOWN_SAFE_TAIL_SIGNATURES.has(ctx.signature) ? `; last pane output (${PANE_TAIL_PREVIEW_LINES} of ~20 lines):
@@ -6621,7 +6660,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash3("sha256").
       agentTimezone,
       log
     });
-    persistentSessionAgents.add(codeName);
+    agentState.persistentSessionAgents.add(codeName);
     claudeAuthTupleBySession.set(codeName, currentAuthTuple);
     return {
       decision: "spawn",
@@ -6635,7 +6674,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash3("sha256").
     claudeAuthTupleBySession.set(codeName, currentAuthTuple);
   }
   const stableTasksHash = createHash3("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
-  const prevHash = knownTasksHashes.get(agent.agent_id);
+  const prevHash = agentState.knownTasksHashes.get(agent.agent_id);
   if (stableTasksHash !== prevHash) {
     const taskInputs = tasks.map((t) => ({
       id: t.id,
@@ -6656,7 +6695,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash3("sha256").
     }));
     const schedulerState = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
     claudeSchedulerStates.set(codeName, schedulerState);
-    knownTasksHashes.set(agent.agent_id, stableTasksHash);
+    agentState.knownTasksHashes.set(agent.agent_id, stableTasksHash);
     log(`[persistent-session] Tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
   } else if (!claudeSchedulerStates.has(codeName)) {
     claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
@@ -6828,10 +6867,10 @@ function ensureRealtimeDriftStarted(agentStates) {
       token: exchange.token,
       agentIds: activeAgentIds,
       onDrift: (doc) => {
-        const agentState = agentStates.find((a) => a.agentId === doc.agent_id);
-        if (agentState) {
-          knownVersions.delete(doc.agent_id);
-          log(`[realtime] Drift invalidated for '${agentState.codeName}' \u2014 will re-provision next cycle`);
+        const agent = agentStates.find((a) => a.agentId === doc.agent_id);
+        if (agent) {
+          agentState.knownVersions.delete(doc.agent_id);
+          log(`[realtime] Drift invalidated for '${agent.codeName}' \u2014 will re-provision next cycle`);
         }
       },
       log
@@ -6883,7 +6922,7 @@ function ensureRealtimeConfigStarted(agentStates) {
       token: exchange.token,
       agentIds: activeAgentIds,
       onConfigChange: (agent) => {
-        knownStatuses.delete(agent.agent_id);
+        agentState.knownStatuses.delete(agent.agent_id);
       },
       log
     });
@@ -6983,9 +7022,9 @@ function ensureRealtimeIntegrationContextStarted(agentStates) {
       onContextChange: (payload) => {
         const agent = agentStates.find((a) => a.agentId === payload.agent_id);
         if (agent) {
-          for (const key of knownSkillHashes.keys()) {
+          for (const key of agentState.knownSkillHashes.keys()) {
             if (key.startsWith(`plugin-skill:${agent.agentId}:`)) {
-              knownSkillHashes.delete(key);
+              agentState.knownSkillHashes.delete(key);
             }
           }
         }
@@ -7242,6 +7281,7 @@ var lastHarvestAt = /* @__PURE__ */ new Map();
 var HARVEST_INTERVAL_MS = 3 * 60 * 1e3;
 var kanbanBoardCache = /* @__PURE__ */ new Map();
 var notifyBoardCache = /* @__PURE__ */ new Map();
+var NOTIFY_RESULT_MAX_CHARS = 3500;
 async function harvestCronResults(codeName, tasks, gatewayPort) {
   const token = readGatewayToken(codeName);
   const gwArgs = ["--url", `ws://127.0.0.1:${gatewayPort}`, ...token ? ["--token", token] : []];
@@ -7275,7 +7315,7 @@ async function harvestCronResults(codeName, tasks, gatewayPort) {
     }
     const latestRun = runs.filter((r) => r.action === "finished").sort((a, b) => b.ts - a.ts)[0];
     if (latestRun) {
-      const agentId = codeNameToAgentId.get(codeName);
+      const agentId = agentState.codeNameToAgentId.get(codeName);
       const summary = latestRun.summary ?? "";
       const isKeyError = summary.includes("Key limit exceeded") || summary.includes("key limit") || summary.includes("rate limit") || summary.includes("insufficient_quota") || summary.includes("billing") || summary.includes("402");
       if (agentId) {
@@ -7322,7 +7362,7 @@ async function harvestCronResults(codeName, tasks, gatewayPort) {
       const planItems = parsePlanItems(summary);
       if (planItems.length > 0) {
         try {
-          const agentId = codeNameToAgentId.get(codeName);
+          const agentId = agentState.codeNameToAgentId.get(codeName);
           if (agentId) {
             await api.post("/host/kanban", {
               agent_id: agentId,
@@ -7341,7 +7381,7 @@ async function harvestCronResults(codeName, tasks, gatewayPort) {
       const kanbanUpdates = parseKanbanUpdates(summary);
       if (kanbanUpdates.length > 0) {
         try {
-          const agentId = codeNameToAgentId.get(codeName);
+          const agentId = agentState.codeNameToAgentId.get(codeName);
           if (agentId) {
             await api.post("/host/kanban", {
               agent_id: agentId,
@@ -8071,7 +8111,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-7PHOEAUN.js");
+  } = await import("../claude-pair-runtime-2NNAUBP3.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));
@@ -8190,6 +8230,24 @@ async function maybePostScheduledTaskRatingPrompt(agentId, taskId, channelId, me
     log(`[rating-prompt] Failed to post rating prompt for ${agentId}/${taskId}: ${err.message}`);
   }
 }
+async function buildDoneCardNotification(agentId, codeName, displayName, item) {
+  const isFailed = item.status === "failed";
+  let resultBody = item.result ?? "";
+  try {
+    const full = await api.post("/host/kanban-item", {
+      agent_id: agentId,
+      item_id: item.id
+    });
+    if (full.item?.result) resultBody = full.item.result;
+  } catch (err) {
+    log(`[notify] full-result fetch failed for card ${item.id} on '${codeName}': ${err.message} \u2014 using truncated board result`);
+  }
+  const resultLine = resultBody ? `
+${isFailed ? "Reason" : "Result"}: ${resultBody.slice(0, NOTIFY_RESULT_MAX_CHARS)}` : "";
+  const emoji = isFailed ? "\u274C" : "\u2705";
+  return `${emoji} ${isFailed ? "Task Failed" : "Task Complete"} \u2014 ${displayName}
+${item.title}${resultLine}`;
+}
 async function sendTaskNotification(agentCodeName, channel, to, text) {
   const tokens = agentChannelTokens.get(agentCodeName);
   if (channel === "slack") {
@@ -8841,6 +8899,7 @@ export {
   ChildProcessError,
   __resetScheduledDeliveryDedupeForTest,
   applyRestartAcks,
+  buildDoneCardNotification,
   claudeCodeUpgradeMarkerPath,
   claudeCodeUpgradeThrottled,
   deliverScheduledCardResult,