@integrity-labs/agt-cli 0.28.28 → 0.28.29

package/dist/lib/manager-worker.js

@@ -22,7 +22,7 @@ import {
   provisionStopHook,
   requireHost,
   safeWriteJsonAtomic
-} from "../chunk-GW2FVIMZ.js";
+} from "../chunk-FIB2OQLF.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -64,7 +64,7 @@ import {
   takeWatchdogGiveUpCount,
   takeZombieDetection,
   transcriptActivityAgeSeconds
-} from "../chunk-IHPN6AX7.js";
+} from "../chunk-SR6RHUAV.js";
 import {
   FLAGS_SCHEMA_VERSION,
   KANBAN_CHECK_COMMAND,
@@ -97,7 +97,7 @@ import {
   sumTranscriptUsageInWindow,
   worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "../chunk-SN2G4B2Z.js";
+} from "../chunk-VIIPFWE4.js";
 import {
   parsePsRows,
   reapOrphanChannelMcps
@@ -3416,63 +3416,6 @@ function killAgentChannelProcesses(codeName, opts) {
   return pids;
 }
 
-// src/lib/delivery-schedule-link.ts
-function envSuffixFor(codeName) {
-  return codeName.replace(/[^A-Za-z0-9]+/g, "_").toUpperCase();
-}
-function scheduleLinkFooterEnabled(codeName, env = process.env) {
-  if (codeName) {
-    const perAgent = env[`AGT_SCHEDULE_LINK_FOOTER_DISABLED__${envSuffixFor(codeName)}`];
-    if (perAgent === "1") return false;
-  }
-  if (env["AGT_SCHEDULE_LINK_FOOTER_DISABLED"] === "1") return false;
-  return true;
-}
-function getConsoleUrl(env = process.env) {
-  const canonical = env["AGT_CONSOLE_URL"]?.trim();
-  if (canonical) return canonical.replace(/\/+$/, "");
-  const fallback = env["NEXT_PUBLIC_APP_URL"]?.trim();
-  if (fallback) return fallback.replace(/\/+$/, "");
-  return null;
-}
-function buildScheduleEditLink(consoleUrl, agentId, taskId) {
-  const base = consoleUrl.replace(/\/+$/, "");
-  return `${base}/agents/${encodeURIComponent(agentId)}/schedules/${encodeURIComponent(taskId)}`;
-}
-function formatScheduleLinkFooter(url, medium) {
-  if (medium === "slack") return `<${url}|Edit schedule>`;
-  if (medium === "telegram") return `Edit schedule: ${url}`;
-  return url;
-}
-function appendScheduleLinkFooter(body, url, medium) {
-  const footer = formatScheduleLinkFooter(url, medium);
-  const trimmed = body.replace(/\s+$/, "");
-  if (trimmed.endsWith(footer)) return trimmed;
-  return `${trimmed}
-
-${footer}`;
-}
-var warnedNullConsoleUrl = false;
-function withScheduleLinkFooter(opts) {
-  if (!opts.taskId) return opts.body;
-  if (!scheduleLinkFooterEnabled(opts.codeName, opts.env)) return opts.body;
-  const consoleUrl = getConsoleUrl(opts.env);
-  if (!consoleUrl) {
-    if (!warnedNullConsoleUrl && opts.log) {
-      warnedNullConsoleUrl = true;
-      try {
-        opts.log(
-          "[schedule-link] AGT_CONSOLE_URL unset and NEXT_PUBLIC_APP_URL unset \u2014 schedule-edit deep-link footer disabled. Run `agt setup` again or export AGT_CONSOLE_URL (e.g. https://app.augmented.team) to restore it."
-        );
-      } catch {
-      }
-    }
-    return opts.body;
-  }
-  const url = buildScheduleEditLink(consoleUrl, opts.agentId, opts.taskId);
-  return appendScheduleLinkFooter(opts.body, url, opts.medium);
-}
-
 // src/lib/manager/agent-state.ts
 var agentState = {
   // ---------------------------------------------------------------------------
@@ -4065,11 +4008,11 @@ function setAlertSlackWebhook(value) {
 
 // src/lib/delivery-hint.ts
 var DEFAULT_PROBABILITY = 0.1;
-function envSuffixFor2(codeName) {
+function envSuffixFor(codeName) {
   return codeName.replace(/[^A-Za-z0-9]+/g, "_").toUpperCase();
 }
 function hintProbability(codeName, env = process.env) {
-  const suffix = codeName ? `__${envSuffixFor2(codeName)}` : "";
+  const suffix = codeName ? `__${envSuffixFor(codeName)}` : "";
   if (suffix && env[`AGT_DELIVERY_HINT_DISABLED${suffix}`] === "1") return 0;
   const perAgent = suffix ? env[`AGT_DELIVERY_HINT_PROBABILITY${suffix}`] : void 0;
   if (perAgent != null) return clampProbability(perAgent);
@@ -4236,139 +4179,505 @@ async function maybeSendTelegramFollowUpHint(agentCodeName, botToken, chatId) {
   }
 }
 
-// src/lib/wedge-detection.ts
-var DEFAULTS = {
-  inboundWaitSeconds: 120,
-  // ENG-6264: DISABLED by default (0). A session that's actively producing
-  // tokens is never force-respawned — a working agent must not be killed just
-  // because a message has been queued behind its turn, no matter how long.
-  // ENG-6238 made this an absolute backstop (1200s) to still catch a
-  // producing-but-never-draining runaway loop, but that re-introduced the exact
-  // failure we set out to kill: cutting off real work on a long turn. Runaway
-  // token burn is owned by the cost guardrail (ENG-5556); a producing-but-silent
-  // loop still trips the synthetic-probe alarm. So the backstop is now opt-in:
-  // set AGT_WEDGE_INBOUND_HARD_WAIT_SECONDS to a positive value to re-enable it
-  // (floored at inboundWaitSeconds). 0 = the frozen/hung wedge (transcript
-  // static) is still caught by the soft path; only the *producing* path is spared.
-  inboundHardWaitSeconds: 0,
-  paneStaleSeconds: 120,
-  transcriptStaleSeconds: 60,
-  minCycles: 3
-};
-function parseMode(raw) {
-  const v = (raw ?? "").trim().toLowerCase();
-  return v === "shadow" || v === "enforce" ? v : "off";
-}
-function parsePositiveInt(raw, fallback, floor) {
-  const n = raw ? Number.parseInt(raw, 10) : NaN;
-  return Number.isInteger(n) && n >= floor ? n : fallback;
-}
-function resolveWedgeConfig(env = process.env) {
-  const inboundWaitSeconds = parsePositiveInt(
-    env.AGT_WEDGE_INBOUND_WAIT_SECONDS,
-    DEFAULTS.inboundWaitSeconds,
-    30
-  );
-  const inboundHardWaitRaw = parsePositiveInt(
-    env.AGT_WEDGE_INBOUND_HARD_WAIT_SECONDS,
-    DEFAULTS.inboundHardWaitSeconds,
-    0
-  );
-  const inboundHardWaitSeconds = inboundHardWaitRaw <= 0 ? 0 : Math.max(inboundWaitSeconds, inboundHardWaitRaw);
-  return {
-    mode: parseMode(env.AGT_WEDGE_RESTART_MODE),
-    inboundWaitSeconds,
-    inboundHardWaitSeconds,
-    paneStaleSeconds: parsePositiveInt(env.AGT_WEDGE_PANE_STALE_SECONDS, DEFAULTS.paneStaleSeconds, 30),
-    transcriptStaleSeconds: parsePositiveInt(
-      env.AGT_WEDGE_TRANSCRIPT_STALE_SECONDS,
-      DEFAULTS.transcriptStaleSeconds,
-      15
-    ),
-    minCycles: parsePositiveInt(env.AGT_WEDGE_MIN_CYCLES, DEFAULTS.minCycles, 2)
-  };
-}
-function isSessionProducing(signals, config2) {
-  const subagentAge = signals.subagentActivityAgeSeconds;
-  if (subagentAge !== null && subagentAge < config2.transcriptStaleSeconds) return true;
-  const transcriptAge = signals.transcriptActivityAgeSeconds;
-  if (transcriptAge !== null) return transcriptAge < config2.transcriptStaleSeconds;
-  const paneAge = signals.paneActivityAgeSeconds;
-  return paneAge !== null && paneAge < config2.paneStaleSeconds;
-}
-function wedgeExemptionReason(signals, config2) {
-  if (signals.subagentActivityAgeSeconds === null) return null;
-  if (isWedgeCandidateCycle(signals, config2)) return null;
-  const withoutSubagent = { ...signals, subagentActivityAgeSeconds: null };
-  return isWedgeCandidateCycle(withoutSubagent, config2) ? "background-task-in-flight" : null;
-}
-function isWedgeCandidateCycle(signals, config2) {
-  const inboundAge = signals.pendingInboundOldestAgeSeconds;
-  if (inboundAge === null) return false;
-  if (inboundAge < config2.inboundWaitSeconds) return false;
-  if (isSessionProducing(signals, config2)) {
-    if (config2.inboundHardWaitSeconds <= 0) return false;
-    return inboundAge >= config2.inboundHardWaitSeconds;
+// src/lib/manager/delivery/state.ts
+var agentInfoForDelivery = /* @__PURE__ */ new Map();
+function cacheAgentDeliveryMetadata(codeName, refreshData) {
+  const agentRow = refreshData["agent"] ?? {};
+  const displayName = agentRow["display_name"] ?? codeName;
+  const ownerTeamName = agentRow["owner_team_name"] ?? null;
+  const framework = agentRow["framework"] ?? "openclaw";
+  const reportsToPersonId = agentRow["reports_to"] ?? null;
+  const reportsToType = agentRow["reports_to_type"] ?? null;
+  const channelConfigs = refreshData["channel_configs"] ?? {};
+  const dmCapable = [];
+  const slackBotToken = channelConfigs["slack"]?.config?.["bot_token"];
+  if (typeof slackBotToken === "string" && slackBotToken.length > 0) {
+    dmCapable.push("slack");
   }
-  return true;
-}
-function decideWedgeRestart(input, config2) {
-  if (!isWedgeCandidateCycle(input, config2)) return "none";
-  return input.consecutiveWedgeCycles >= config2.minCycles ? "wedged" : "none";
-}
-
-// src/lib/wedge-poison-card.ts
-var DEFAULTS2 = {
-  threshold: 3,
-  cooldownSeconds: 1800
-  // 30 min — matches the kanban stale-auto-fail window
-};
-function parsePositiveInt2(raw, fallback, floor) {
-  const n = raw ? Number.parseInt(raw, 10) : NaN;
-  return Number.isInteger(n) && n >= floor ? n : fallback;
-}
-function resolvePoisonCardConfig(env = process.env) {
-  return {
-    threshold: parsePositiveInt2(env.AGT_WEDGE_POISON_CARD_THRESHOLD, DEFAULTS2.threshold, 2),
-    cooldownMs: parsePositiveInt2(
-      env.AGT_WEDGE_POISON_CARD_COOLDOWN_SECONDS,
-      DEFAULTS2.cooldownSeconds,
-      300
-    ) * 1e3
+  const telegramBotToken = channelConfigs["telegram"]?.config?.["bot_token"];
+  if (typeof telegramBotToken === "string" && telegramBotToken.length > 0) {
+    dmCapable.push("telegram");
+  }
+  const resolverAgent = {
+    agent_id: agentRow["agent_id"] ?? "",
+    framework,
+    dm_capable_mediums: dmCapable,
+    reports_to_person_id: reportsToType === "person" ? reportsToPersonId : null,
+    reports_to_type: reportsToType
   };
-}
-function recordWedgeForCards(states, inProgressCardIds, nowMs, config2) {
-  if (inProgressCardIds.length === 0) {
-    return { next: new Map(states), newlyPoisoned: [] };
+  const peopleByPersonId = /* @__PURE__ */ new Map();
+  if (reportsToPersonId && reportsToType === "person") {
+    peopleByPersonId.set(reportsToPersonId, {
+      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
+    });
   }
-  const next = /* @__PURE__ */ new Map();
-  const newlyPoisoned = [];
-  for (const id of inProgressCardIds) {
-    if (next.has(id)) continue;
-    const count = (states.get(id)?.count ?? 0) + 1;
-    next.set(id, { count, lastWedgeAtMs: nowMs });
-    if (count === config2.threshold) newlyPoisoned.push(id);
+  const people = refreshData["people"] ?? [];
+  for (const p of people) {
+    const personId = p["person_id"];
+    if (!personId) continue;
+    const contactPrefs = p["contact_preferences"] ?? {};
+    peopleByPersonId.set(personId, {
+      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
+    });
   }
-  return { next, newlyPoisoned };
+  agentInfoForDelivery.set(codeName, {
+    agentDisplayName: displayName,
+    ownerTeamName,
+    resolverAgent,
+    peopleByPersonId
+  });
 }
-function pruneCardStates(states, liveInProgressCardIds, nowMs, config2) {
-  const live = liveInProgressCardIds instanceof Set ? liveInProgressCardIds : new Set(liveInProgressCardIds);
-  const next = /* @__PURE__ */ new Map();
-  for (const [id, state7] of states) {
-    if (!live.has(id)) continue;
-    if (nowMs - state7.lastWedgeAtMs > config2.cooldownMs) continue;
-    next.set(id, state7);
+
+// src/lib/manager/delivery/notifications.ts
+var NOTIFY_RESULT_MAX_CHARS = 3500;
+async function reportDeliveryStatus(agentId, taskId, payload) {
+  if (!taskId) return;
+  try {
+    await api.post("/host/schedules/delivery-status", {
+      agent_id: agentId,
+      task_id: taskId,
+      status: payload.status,
+      medium: payload.medium ?? null,
+      error_code: payload.error_code ?? null
+    });
+  } catch (err) {
+    log(`[delivery] Failed to report delivery status for ${agentId}/${taskId}: ${err.message}`);
   }
-  return next;
 }
-function isCardPoisoned(states, cardId, config2) {
-  return (states.get(cardId)?.count ?? 0) >= config2.threshold;
+async function maybePostScheduledTaskRatingPrompt(agentId, taskId, channelId, messageTs) {
+  try {
+    await api.post("/host/scheduled-task/rating-prompt", {
+      agent_id: agentId,
+      task_id: taskId,
+      channel: channelId,
+      message_ts: messageTs
+    });
+  } catch (err) {
+    log(`[rating-prompt] Failed to post rating prompt for ${agentId}/${taskId}: ${err.message}`);
+  }
 }
-function partitionActionableByPoison(actionable, states, config2) {
-  const allowed = [];
-  const suppressed = [];
-  for (const item of actionable) {
-    if (isCardPoisoned(states, item.id, config2)) suppressed.push(item);
+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") {
+    const botToken = tokens?.slack;
+    const channelId = to.replace(/^channel:/, "");
+    if (!botToken) {
+      log(`No Slack bot token for '${agentCodeName}' \u2014 targeted notification dropped`);
+      return { ok: false, error_code: "SLACK_NO_TOKEN" };
+    }
+    const sent = await sendSlackChannelMessage(agentCodeName, channelId, text);
+    return sent ? { ok: true } : { ok: false, error_code: "SLACK_SEND_FAILED" };
+  }
+  if (channel === "telegram") {
+    const botToken = tokens?.telegram;
+    const chatId = to.replace(/^chat:/, "");
+    if (!botToken) {
+      log(`No Telegram bot token for '${agentCodeName}' \u2014 notification dropped`);
+      return { ok: false, error_code: "TELEGRAM_NO_TOKEN" };
+    }
+    const allowedChats = tokens?.telegramAllowedChats;
+    if (allowedChats && allowedChats.length > 0 && !allowedChats.includes(chatId)) {
+      log(`Telegram chat ${chatId} not in allowed_chat_ids for '${agentCodeName}'`);
+      return { ok: false, error_code: "TELEGRAM_CHAT_NOT_ALLOWED" };
+    }
+    try {
+      const result = await telegramApiCall(botToken, "sendMessage", { chat_id: chatId, text });
+      if (!result.ok) {
+        log(`Telegram sendMessage failed for '${agentCodeName}': ${result.description}`);
+        return { ok: false, error_code: `TELEGRAM_SEND_FAILED:${result.description ?? "unknown"}` };
+      }
+      log(`Telegram notification sent for '${agentCodeName}' to chat ${chatId}`);
+      return { ok: true };
+    } catch (err) {
+      log(`Telegram API error for '${agentCodeName}': ${err.message}`);
+      return { ok: false, error_code: "TELEGRAM_EXCEPTION" };
+    }
+  }
+  log(`Unknown notify_channel '${channel}' for '${agentCodeName}'`);
+  return { ok: false, error_code: `UNKNOWN_CHANNEL:${channel}` };
+}
+
+// src/lib/delivery-schedule-link.ts
+function envSuffixFor2(codeName) {
+  return codeName.replace(/[^A-Za-z0-9]+/g, "_").toUpperCase();
+}
+function scheduleLinkFooterEnabled(codeName, env = process.env) {
+  if (codeName) {
+    const perAgent = env[`AGT_SCHEDULE_LINK_FOOTER_DISABLED__${envSuffixFor2(codeName)}`];
+    if (perAgent === "1") return false;
+  }
+  if (env["AGT_SCHEDULE_LINK_FOOTER_DISABLED"] === "1") return false;
+  return true;
+}
+function getConsoleUrl(env = process.env) {
+  const canonical = env["AGT_CONSOLE_URL"]?.trim();
+  if (canonical) return canonical.replace(/\/+$/, "");
+  const fallback = env["NEXT_PUBLIC_APP_URL"]?.trim();
+  if (fallback) return fallback.replace(/\/+$/, "");
+  return null;
+}
+function buildScheduleEditLink(consoleUrl, agentId, taskId) {
+  const base = consoleUrl.replace(/\/+$/, "");
+  return `${base}/agents/${encodeURIComponent(agentId)}/schedules/${encodeURIComponent(taskId)}`;
+}
+function formatScheduleLinkFooter(url, medium) {
+  if (medium === "slack") return `<${url}|Edit schedule>`;
+  if (medium === "telegram") return `Edit schedule: ${url}`;
+  return url;
+}
+function appendScheduleLinkFooter(body, url, medium) {
+  const footer = formatScheduleLinkFooter(url, medium);
+  const trimmed = body.replace(/\s+$/, "");
+  if (trimmed.endsWith(footer)) return trimmed;
+  return `${trimmed}
+
+${footer}`;
+}
+var warnedNullConsoleUrl = false;
+function withScheduleLinkFooter(opts) {
+  if (!opts.taskId) return opts.body;
+  if (!scheduleLinkFooterEnabled(opts.codeName, opts.env)) return opts.body;
+  const consoleUrl = getConsoleUrl(opts.env);
+  if (!consoleUrl) {
+    if (!warnedNullConsoleUrl && opts.log) {
+      warnedNullConsoleUrl = true;
+      try {
+        opts.log(
+          "[schedule-link] AGT_CONSOLE_URL unset and NEXT_PUBLIC_APP_URL unset \u2014 schedule-edit deep-link footer disabled. Run `agt setup` again or export AGT_CONSOLE_URL (e.g. https://app.augmented.team) to restore it."
+        );
+      } catch {
+      }
+    }
+    return opts.body;
+  }
+  const url = buildScheduleEditLink(consoleUrl, opts.agentId, opts.taskId);
+  return appendScheduleLinkFooter(opts.body, url, opts.medium);
+}
+
+// src/lib/manager/delivery/scheduled-output.ts
+async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, body, taskId) {
+  const withLink = (b, medium) => withScheduleLinkFooter({ body: b, medium, codeName: agentCodeName, agentId, taskId, log });
+  if (typeof rawTarget === "string") {
+    if (rawTarget.startsWith("channel:")) {
+      const result = await sendTaskNotification(agentCodeName, "slack", rawTarget, withLink(body, "slack"));
+      await reportDeliveryStatus(agentId, taskId, {
+        status: result.ok ? "ok" : "failed",
+        medium: "slack",
+        error_code: result.ok ? null : result.error_code ?? "SLACK_SEND_FAILED"
+      });
+      return;
+    }
+    if (rawTarget.startsWith("chat:")) {
+      const result = await sendTaskNotification(agentCodeName, "telegram", rawTarget, withLink(body, "telegram"));
+      await reportDeliveryStatus(agentId, taskId, {
+        status: result.ok ? "ok" : "failed",
+        medium: "telegram",
+        error_code: result.ok ? null : result.error_code ?? "TELEGRAM_SEND_FAILED"
+      });
+      return;
+    }
+    log(`[delivery] Unrecognised legacy delivery_to string for '${agentCodeName}': ${rawTarget.slice(0, 60)}`);
+    await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "LEGACY_DELIVERY_TO_UNRECOGNISED" });
+    return;
+  }
+  const parsed = parseDeliveryTarget(rawTarget);
+  if (isParseError(parsed)) {
+    log(`[delivery] Malformed delivery_to for '${agentCodeName}': ${parsed.code} \u2014 ${parsed.detail}`);
+    await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: parsed.code });
+    return;
+  }
+  if (parsed.kind === "channel") {
+    if (parsed.provider === "slack") {
+      const channelId = parsed.channel_id ?? "";
+      const threadTs = parsed.thread_ts;
+      let sent = await postSlackChannelMessage(agentCodeName, channelId, withLink(body, "slack"), threadTs);
+      let deliveredInThread = Boolean(threadTs);
+      if (!sent.ok && threadTs && (sent.error === "thread_not_found" || sent.error === "message_not_found")) {
+        log(`[delivery] Originating thread ${threadTs} gone in ${channelId} for '${agentCodeName}' \u2014 falling back to top-level post`);
+        sent = await postSlackChannelMessage(agentCodeName, channelId, withLink(body, "slack"));
+        deliveredInThread = false;
+      }
+      await reportDeliveryStatus(agentId, taskId, {
+        status: sent.ok ? "ok" : "failed",
+        medium: "slack",
+        // Preserve Slack's concrete failure code (channel_not_found,
+        // not_in_channel, auth errors, …) in the observability row rather
+        // than collapsing everything to the generic constant.
+        error_code: sent.ok ? null : sent.error ? `SLACK_SEND_FAILED:${sent.error}` : "SLACK_SEND_FAILED"
+      });
+      if (sent.ok) {
+        if (!deliveredInThread) {
+          await maybePostSlackThreadHint(agentCodeName, channelId, sent.ts);
+        }
+        if (sent.ts && taskId) {
+          await maybePostScheduledTaskRatingPrompt(agentId, taskId, channelId, sent.ts);
+        }
+      }
+      return;
+    }
+    const chatId = parsed.chat_id ?? "";
+    const toStr = `chat:${chatId}`;
+    const result = await sendTaskNotification(agentCodeName, "telegram", toStr, withLink(body, "telegram"));
+    await reportDeliveryStatus(agentId, taskId, {
+      status: result.ok ? "ok" : "failed",
+      medium: "telegram",
+      error_code: result.ok ? null : result.error_code ?? "TELEGRAM_SEND_FAILED"
+    });
+    if (result.ok) {
+      const botToken = agentChannelTokens.get(agentCodeName)?.telegram;
+      if (botToken) await maybeSendTelegramFollowUpHint(agentCodeName, botToken, chatId);
+    }
+    return;
+  }
+  const agentRow = agentInfoForDelivery.get(agentCodeName);
+  if (!agentRow) {
+    log(`[delivery] No agent metadata cached for '${agentCodeName}' \u2014 dropping DM`);
+    await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "AGENT_METADATA_UNAVAILABLE" });
+    return;
+  }
+  const resolved = resolveDmTarget(parsed, agentRow.resolverAgent, agentRow.peopleByPersonId);
+  if (isResolveError(resolved)) {
+    log(`[delivery] Cannot resolve DM target for '${agentCodeName}': ${resolved.code} \u2014 ${resolved.detail}`);
+    await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: resolved.code });
+    return;
+  }
+  const attributionBody = appendDmFooter(
+    body,
+    agentRow.ownerTeamName,
+    agentRow.agentDisplayName
+  );
+  const footeredBody = resolved.kind === "dm" ? withLink(attributionBody, resolved.medium === "slack" ? "slack" : "telegram") : attributionBody;
+  if (resolved.kind === "dm" && resolved.medium === "slack") {
+    const tokens = agentChannelTokens.get(agentCodeName);
+    const botToken = tokens?.slack;
+    if (!botToken) {
+      await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "SLACK_MISSING_SCOPE", medium: "slack" });
+      log(`[delivery] No Slack bot token for '${agentCodeName}' \u2014 DM dropped`);
+      return;
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutHandle = setTimeout(() => controller.abort(), 5e3);
+      let openJson;
+      try {
+        const openResp = await fetch("https://slack.com/api/conversations.open", {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${botToken}`,
+            "Content-Type": "application/json; charset=utf-8"
+          },
+          body: JSON.stringify({ users: resolved.slack_user_id }),
+          signal: controller.signal
+        });
+        openJson = await openResp.json();
+      } finally {
+        clearTimeout(timeoutHandle);
+      }
+      if (!openJson.ok || !openJson.channel?.id) {
+        const errCode = openJson.error === "missing_scope" ? "SLACK_MISSING_SCOPE" : `SLACK_OPEN_FAILED:${openJson.error ?? "unknown"}`;
+        log(`[delivery] conversations.open failed for '${agentCodeName}': ${openJson.error}`);
+        await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: errCode, medium: "slack" });
+        return;
+      }
+      const sent = await postSlackChannelMessage(agentCodeName, openJson.channel.id, footeredBody);
+      await reportDeliveryStatus(agentId, taskId, {
+        status: sent.ok ? "ok" : "failed",
+        medium: "slack",
+        error_code: sent.ok ? null : "SLACK_SEND_FAILED"
+      });
+      if (sent.ok) await maybePostSlackThreadHint(agentCodeName, openJson.channel.id, sent.ts);
+    } catch (err) {
+      const isAbort = err.name === "AbortError";
+      const errCode = isAbort ? "SLACK_OPEN_TIMEOUT" : "SLACK_EXCEPTION";
+      log(`[delivery] Slack DM ${isAbort ? "timeout" : "failure"} for '${agentCodeName}': ${err.message}`);
+      await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: errCode, medium: "slack" });
+    }
+    return;
+  }
+  if (resolved.kind === "dm" && resolved.medium === "telegram") {
+    const tokens = agentChannelTokens.get(agentCodeName);
+    const botToken = tokens?.telegram;
+    if (!botToken) {
+      log(`[delivery] No Telegram bot token for '${agentCodeName}' \u2014 DM dropped`);
+      await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "TELEGRAM_NO_TOKEN", medium: "telegram" });
+      return;
+    }
+    try {
+      const result = await telegramApiCall(botToken, "sendMessage", {
+        chat_id: resolved.telegram_chat_id,
+        text: footeredBody
+      });
+      if (!result.ok) {
+        log(`[delivery] Telegram DM failed for '${agentCodeName}': ${result.description}`);
+        await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: `TELEGRAM_SEND_FAILED:${result.description ?? "unknown"}`, medium: "telegram" });
+        return;
+      }
+      await reportDeliveryStatus(agentId, taskId, { status: "ok", medium: "telegram" });
+      await maybeSendTelegramFollowUpHint(agentCodeName, botToken, resolved.telegram_chat_id);
+    } catch (err) {
+      log(`[delivery] Telegram DM exception for '${agentCodeName}': ${err.message}`);
+      await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "TELEGRAM_EXCEPTION", medium: "telegram" });
+    }
+  }
+}
+
+// src/lib/wedge-detection.ts
+var DEFAULTS = {
+  inboundWaitSeconds: 120,
+  // ENG-6264: DISABLED by default (0). A session that's actively producing
+  // tokens is never force-respawned — a working agent must not be killed just
+  // because a message has been queued behind its turn, no matter how long.
+  // ENG-6238 made this an absolute backstop (1200s) to still catch a
+  // producing-but-never-draining runaway loop, but that re-introduced the exact
+  // failure we set out to kill: cutting off real work on a long turn. Runaway
+  // token burn is owned by the cost guardrail (ENG-5556); a producing-but-silent
+  // loop still trips the synthetic-probe alarm. So the backstop is now opt-in:
+  // set AGT_WEDGE_INBOUND_HARD_WAIT_SECONDS to a positive value to re-enable it
+  // (floored at inboundWaitSeconds). 0 = the frozen/hung wedge (transcript
+  // static) is still caught by the soft path; only the *producing* path is spared.
+  inboundHardWaitSeconds: 0,
+  paneStaleSeconds: 120,
+  transcriptStaleSeconds: 60,
+  minCycles: 3
+};
+function parseMode(raw) {
+  const v = (raw ?? "").trim().toLowerCase();
+  return v === "shadow" || v === "enforce" ? v : "off";
+}
+function parsePositiveInt(raw, fallback, floor) {
+  const n = raw ? Number.parseInt(raw, 10) : NaN;
+  return Number.isInteger(n) && n >= floor ? n : fallback;
+}
+function resolveWedgeConfig(env = process.env) {
+  const inboundWaitSeconds = parsePositiveInt(
+    env.AGT_WEDGE_INBOUND_WAIT_SECONDS,
+    DEFAULTS.inboundWaitSeconds,
+    30
+  );
+  const inboundHardWaitRaw = parsePositiveInt(
+    env.AGT_WEDGE_INBOUND_HARD_WAIT_SECONDS,
+    DEFAULTS.inboundHardWaitSeconds,
+    0
+  );
+  const inboundHardWaitSeconds = inboundHardWaitRaw <= 0 ? 0 : Math.max(inboundWaitSeconds, inboundHardWaitRaw);
+  return {
+    mode: parseMode(env.AGT_WEDGE_RESTART_MODE),
+    inboundWaitSeconds,
+    inboundHardWaitSeconds,
+    paneStaleSeconds: parsePositiveInt(env.AGT_WEDGE_PANE_STALE_SECONDS, DEFAULTS.paneStaleSeconds, 30),
+    transcriptStaleSeconds: parsePositiveInt(
+      env.AGT_WEDGE_TRANSCRIPT_STALE_SECONDS,
+      DEFAULTS.transcriptStaleSeconds,
+      15
+    ),
+    minCycles: parsePositiveInt(env.AGT_WEDGE_MIN_CYCLES, DEFAULTS.minCycles, 2)
+  };
+}
+function isSessionProducing(signals, config2) {
+  const subagentAge = signals.subagentActivityAgeSeconds;
+  if (subagentAge !== null && subagentAge < config2.transcriptStaleSeconds) return true;
+  const transcriptAge = signals.transcriptActivityAgeSeconds;
+  if (transcriptAge !== null) return transcriptAge < config2.transcriptStaleSeconds;
+  const paneAge = signals.paneActivityAgeSeconds;
+  return paneAge !== null && paneAge < config2.paneStaleSeconds;
+}
+function wedgeExemptionReason(signals, config2) {
+  if (signals.subagentActivityAgeSeconds === null) return null;
+  if (isWedgeCandidateCycle(signals, config2)) return null;
+  const withoutSubagent = { ...signals, subagentActivityAgeSeconds: null };
+  return isWedgeCandidateCycle(withoutSubagent, config2) ? "background-task-in-flight" : null;
+}
+function isWedgeCandidateCycle(signals, config2) {
+  const inboundAge = signals.pendingInboundOldestAgeSeconds;
+  if (inboundAge === null) return false;
+  if (inboundAge < config2.inboundWaitSeconds) return false;
+  if (isSessionProducing(signals, config2)) {
+    if (config2.inboundHardWaitSeconds <= 0) return false;
+    return inboundAge >= config2.inboundHardWaitSeconds;
+  }
+  return true;
+}
+function decideWedgeRestart(input, config2) {
+  if (!isWedgeCandidateCycle(input, config2)) return "none";
+  return input.consecutiveWedgeCycles >= config2.minCycles ? "wedged" : "none";
+}
+
+// src/lib/wedge-poison-card.ts
+var DEFAULTS2 = {
+  threshold: 3,
+  cooldownSeconds: 1800
+  // 30 min — matches the kanban stale-auto-fail window
+};
+function parsePositiveInt2(raw, fallback, floor) {
+  const n = raw ? Number.parseInt(raw, 10) : NaN;
+  return Number.isInteger(n) && n >= floor ? n : fallback;
+}
+function resolvePoisonCardConfig(env = process.env) {
+  return {
+    threshold: parsePositiveInt2(env.AGT_WEDGE_POISON_CARD_THRESHOLD, DEFAULTS2.threshold, 2),
+    cooldownMs: parsePositiveInt2(
+      env.AGT_WEDGE_POISON_CARD_COOLDOWN_SECONDS,
+      DEFAULTS2.cooldownSeconds,
+      300
+    ) * 1e3
+  };
+}
+function recordWedgeForCards(states, inProgressCardIds, nowMs, config2) {
+  if (inProgressCardIds.length === 0) {
+    return { next: new Map(states), newlyPoisoned: [] };
+  }
+  const next = /* @__PURE__ */ new Map();
+  const newlyPoisoned = [];
+  for (const id of inProgressCardIds) {
+    if (next.has(id)) continue;
+    const count = (states.get(id)?.count ?? 0) + 1;
+    next.set(id, { count, lastWedgeAtMs: nowMs });
+    if (count === config2.threshold) newlyPoisoned.push(id);
+  }
+  return { next, newlyPoisoned };
+}
+function pruneCardStates(states, liveInProgressCardIds, nowMs, config2) {
+  const live = liveInProgressCardIds instanceof Set ? liveInProgressCardIds : new Set(liveInProgressCardIds);
+  const next = /* @__PURE__ */ new Map();
+  for (const [id, state7] of states) {
+    if (!live.has(id)) continue;
+    if (nowMs - state7.lastWedgeAtMs > config2.cooldownMs) continue;
+    next.set(id, state7);
+  }
+  return next;
+}
+function isCardPoisoned(states, cardId, config2) {
+  return (states.get(cardId)?.count ?? 0) >= config2.threshold;
+}
+function partitionActionableByPoison(actionable, states, config2) {
+  const allowed = [];
+  const suppressed = [];
+  for (const item of actionable) {
+    if (isCardPoisoned(states, item.id, config2)) suppressed.push(item);
     else allowed.push(item);
   }
   return { allowed, suppressed };
@@ -5763,7 +6072,7 @@ var cachedMaintenanceWindow = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.28" : "dev";
+var agtCliVersion = true ? "0.28.29" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -6891,7 +7200,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-34CY65FC.js");
+      const { collectDiagnostics } = await import("../persistent-session-JHBXSNVW.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -6985,7 +7294,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-KKWPOZSX.js");
+      } = await import("../responsiveness-probe-SKVWT5CO.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -7017,7 +7326,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-KKWPOZSX.js");
+        } = await import("../responsiveness-probe-SKVWT5CO.js");
         const { getProjectDir: wedgeProjectDir } = await import("../claude-scheduler-FATCLHDM.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -10774,7 +11083,6 @@ 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] : []];
@@ -10873,339 +11181,107 @@ async function harvestCronResults(codeName, tasks, gatewayPort) {
       const summary = latest.summary ?? "";
       const kanbanUpdates = parseKanbanUpdates(summary);
       if (kanbanUpdates.length > 0) {
-        try {
-          const agentId = agentState.codeNameToAgentId.get(codeName);
-          if (agentId) {
-            await api.post("/host/kanban", {
-              agent_id: agentId,
-              update: kanbanUpdates
-            });
-            log(`Updated ${kanbanUpdates.length} kanban items for '${codeName}'`);
-          }
-        } catch (err) {
-          log(`Failed to update kanban for '${codeName}': ${err.message}`);
-        }
-      }
-    }
-  }
-}
-var LATE_THRESHOLD_MS = 5 * 60 * 1e3;
-async function monitorCronHealth(agentStates) {
-  const alerts = [];
-  const now = Date.now();
-  for (const agent of agentStates) {
-    if (!agent.gatewayRunning || !agent.gatewayPort) continue;
-    const token = readGatewayToken(agent.codeName);
-    const gwArgs = ["--url", `ws://127.0.0.1:${agent.gatewayPort}`, ...token ? ["--token", token] : []];
-    let jobs = [];
-    try {
-      const cliBin = resolveAgentFramework(agent.codeName).cliBinary ?? "openclaw";
-      const { stdout } = await execFilePromise(cliBin, ["--profile", agent.codeName, "cron", "list", "--json", ...gwArgs]);
-      const parsed = JSON.parse(stdout);
-      jobs = parsed.jobs ?? [];
-    } catch {
-      continue;
-    }
-    for (const job of jobs) {
-      if (!job.enabled || !job.name.startsWith("aug:")) continue;
-      const alertKey = `${agent.codeName}:${job.id}`;
-      const displayInfo = taskDisplayInfo.get(`${agent.codeName}:${job.name}`);
-      const taskName = displayInfo?.taskName ?? job.name;
-      const schedule = displayInfo?.schedule ?? "";
-      const agentDisplayName = displayInfo?.agentDisplayName ?? agent.codeName;
-      if (job.state?.nextRunAtMs && job.state.nextRunAtMs + LATE_THRESHOLD_MS < now) {
-        if (!alertedJobs.has(`late:${alertKey}`)) {
-          const minsLate = Math.round((now - job.state.nextRunAtMs) / 6e4);
-          alerts.push({
-            type: "late_standup",
-            agentCodeName: agent.codeName,
-            agentDisplayName,
-            jobName: job.name,
-            taskName,
-            schedule,
-            jobId: job.id,
-            detail: `Job is ${minsLate}m late (expected at ${new Date(job.state.nextRunAtMs).toISOString()})`
-          });
-          alertedJobs.add(`late:${alertKey}`);
-        }
-      } else {
-        alertedJobs.delete(`late:${alertKey}`);
-      }
-      if (job.state?.lastRunStatus === "error" || job.state?.consecutiveErrors && job.state.consecutiveErrors > 0) {
-        if (!alertedJobs.has(`fail:${alertKey}`)) {
-          alerts.push({
-            type: "cron_failure",
-            agentCodeName: agent.codeName,
-            agentDisplayName,
-            jobName: job.name,
-            taskName,
-            schedule,
-            jobId: job.id,
-            detail: `Last run failed (${job.state.consecutiveErrors ?? 1} consecutive error(s))`
-          });
-          alertedJobs.add(`fail:${alertKey}`);
-        }
-      } else {
-        alertedJobs.delete(`fail:${alertKey}`);
-      }
-    }
-  }
-  if (alerts.length === 0) return;
-  for (const alert of alerts) {
-    log(`ALERT [${alert.type}] ${alert.agentCodeName}/${alert.jobName}: ${alert.detail}`);
-  }
-  if (getAlertSlackWebhook()) {
-    await sendSlackAlert(alerts);
-  }
-  try {
-    await api.post("/host/cron-alerts", { alerts });
-  } catch {
-  }
-}
-async function sendSlackAlert(alerts) {
-  const blocks = alerts.map((a) => {
-    const emoji = a.type === "late_standup" ? ":warning:" : ":x:";
-    const label = a.type === "late_standup" ? "Late" : "Failed";
-    const scheduleInfo = a.schedule ? ` (${a.schedule})` : "";
-    return `${emoji} *${label}* \u2014 *${a.agentDisplayName}* / ${a.taskName}${scheduleInfo}
-${a.detail}`;
-  });
-  await sendSlackWebhookMessage(`:rotating_light: *Cron Health Alert*
-
-${blocks.join("\n\n")}`);
-}
-async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, body, taskId) {
-  const withLink = (b, medium) => withScheduleLinkFooter({ body: b, medium, codeName: agentCodeName, agentId, taskId, log });
-  if (typeof rawTarget === "string") {
-    if (rawTarget.startsWith("channel:")) {
-      const result = await sendTaskNotification(agentCodeName, "slack", rawTarget, withLink(body, "slack"));
-      await reportDeliveryStatus(agentId, taskId, {
-        status: result.ok ? "ok" : "failed",
-        medium: "slack",
-        error_code: result.ok ? null : result.error_code ?? "SLACK_SEND_FAILED"
-      });
-      return;
-    }
-    if (rawTarget.startsWith("chat:")) {
-      const result = await sendTaskNotification(agentCodeName, "telegram", rawTarget, withLink(body, "telegram"));
-      await reportDeliveryStatus(agentId, taskId, {
-        status: result.ok ? "ok" : "failed",
-        medium: "telegram",
-        error_code: result.ok ? null : result.error_code ?? "TELEGRAM_SEND_FAILED"
-      });
-      return;
-    }
-    log(`[delivery] Unrecognised legacy delivery_to string for '${agentCodeName}': ${rawTarget.slice(0, 60)}`);
-    await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "LEGACY_DELIVERY_TO_UNRECOGNISED" });
-    return;
-  }
-  const parsed = parseDeliveryTarget(rawTarget);
-  if (isParseError(parsed)) {
-    log(`[delivery] Malformed delivery_to for '${agentCodeName}': ${parsed.code} \u2014 ${parsed.detail}`);
-    await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: parsed.code });
-    return;
-  }
-  if (parsed.kind === "channel") {
-    if (parsed.provider === "slack") {
-      const channelId = parsed.channel_id ?? "";
-      const threadTs = parsed.thread_ts;
-      let sent = await postSlackChannelMessage(agentCodeName, channelId, withLink(body, "slack"), threadTs);
-      let deliveredInThread = Boolean(threadTs);
-      if (!sent.ok && threadTs && (sent.error === "thread_not_found" || sent.error === "message_not_found")) {
-        log(`[delivery] Originating thread ${threadTs} gone in ${channelId} for '${agentCodeName}' \u2014 falling back to top-level post`);
-        sent = await postSlackChannelMessage(agentCodeName, channelId, withLink(body, "slack"));
-        deliveredInThread = false;
-      }
-      await reportDeliveryStatus(agentId, taskId, {
-        status: sent.ok ? "ok" : "failed",
-        medium: "slack",
-        // Preserve Slack's concrete failure code (channel_not_found,
-        // not_in_channel, auth errors, …) in the observability row rather
-        // than collapsing everything to the generic constant.
-        error_code: sent.ok ? null : sent.error ? `SLACK_SEND_FAILED:${sent.error}` : "SLACK_SEND_FAILED"
-      });
-      if (sent.ok) {
-        if (!deliveredInThread) {
-          await maybePostSlackThreadHint(agentCodeName, channelId, sent.ts);
-        }
-        if (sent.ts && taskId) {
-          await maybePostScheduledTaskRatingPrompt(agentId, taskId, channelId, sent.ts);
-        }
-      }
-      return;
-    }
-    const chatId = parsed.chat_id ?? "";
-    const toStr = `chat:${chatId}`;
-    const result = await sendTaskNotification(agentCodeName, "telegram", toStr, withLink(body, "telegram"));
-    await reportDeliveryStatus(agentId, taskId, {
-      status: result.ok ? "ok" : "failed",
-      medium: "telegram",
-      error_code: result.ok ? null : result.error_code ?? "TELEGRAM_SEND_FAILED"
-    });
-    if (result.ok) {
-      const botToken = agentChannelTokens.get(agentCodeName)?.telegram;
-      if (botToken) await maybeSendTelegramFollowUpHint(agentCodeName, botToken, chatId);
-    }
-    return;
-  }
-  const agentRow = agentInfoForDelivery.get(agentCodeName);
-  if (!agentRow) {
-    log(`[delivery] No agent metadata cached for '${agentCodeName}' \u2014 dropping DM`);
-    await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "AGENT_METADATA_UNAVAILABLE" });
-    return;
-  }
-  const resolved = resolveDmTarget(parsed, agentRow.resolverAgent, agentRow.peopleByPersonId);
-  if (isResolveError(resolved)) {
-    log(`[delivery] Cannot resolve DM target for '${agentCodeName}': ${resolved.code} \u2014 ${resolved.detail}`);
-    await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: resolved.code });
-    return;
-  }
-  const attributionBody = appendDmFooter(
-    body,
-    agentRow.ownerTeamName,
-    agentRow.agentDisplayName
-  );
-  const footeredBody = resolved.kind === "dm" ? withLink(attributionBody, resolved.medium === "slack" ? "slack" : "telegram") : attributionBody;
-  if (resolved.kind === "dm" && resolved.medium === "slack") {
-    const tokens = agentChannelTokens.get(agentCodeName);
-    const botToken = tokens?.slack;
-    if (!botToken) {
-      await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "SLACK_MISSING_SCOPE", medium: "slack" });
-      log(`[delivery] No Slack bot token for '${agentCodeName}' \u2014 DM dropped`);
-      return;
-    }
-    try {
-      const controller = new AbortController();
-      const timeoutHandle = setTimeout(() => controller.abort(), 5e3);
-      let openJson;
-      try {
-        const openResp = await fetch("https://slack.com/api/conversations.open", {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${botToken}`,
-            "Content-Type": "application/json; charset=utf-8"
-          },
-          body: JSON.stringify({ users: resolved.slack_user_id }),
-          signal: controller.signal
-        });
-        openJson = await openResp.json();
-      } finally {
-        clearTimeout(timeoutHandle);
-      }
-      if (!openJson.ok || !openJson.channel?.id) {
-        const errCode = openJson.error === "missing_scope" ? "SLACK_MISSING_SCOPE" : `SLACK_OPEN_FAILED:${openJson.error ?? "unknown"}`;
-        log(`[delivery] conversations.open failed for '${agentCodeName}': ${openJson.error}`);
-        await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: errCode, medium: "slack" });
-        return;
+        try {
+          const agentId = agentState.codeNameToAgentId.get(codeName);
+          if (agentId) {
+            await api.post("/host/kanban", {
+              agent_id: agentId,
+              update: kanbanUpdates
+            });
+            log(`Updated ${kanbanUpdates.length} kanban items for '${codeName}'`);
+          }
+        } catch (err) {
+          log(`Failed to update kanban for '${codeName}': ${err.message}`);
+        }
       }
-      const sent = await postSlackChannelMessage(agentCodeName, openJson.channel.id, footeredBody);
-      await reportDeliveryStatus(agentId, taskId, {
-        status: sent.ok ? "ok" : "failed",
-        medium: "slack",
-        error_code: sent.ok ? null : "SLACK_SEND_FAILED"
-      });
-      if (sent.ok) await maybePostSlackThreadHint(agentCodeName, openJson.channel.id, sent.ts);
-    } catch (err) {
-      const isAbort = err.name === "AbortError";
-      const errCode = isAbort ? "SLACK_OPEN_TIMEOUT" : "SLACK_EXCEPTION";
-      log(`[delivery] Slack DM ${isAbort ? "timeout" : "failure"} for '${agentCodeName}': ${err.message}`);
-      await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: errCode, medium: "slack" });
     }
-    return;
   }
-  if (resolved.kind === "dm" && resolved.medium === "telegram") {
-    const tokens = agentChannelTokens.get(agentCodeName);
-    const botToken = tokens?.telegram;
-    if (!botToken) {
-      log(`[delivery] No Telegram bot token for '${agentCodeName}' \u2014 DM dropped`);
-      await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "TELEGRAM_NO_TOKEN", medium: "telegram" });
-      return;
-    }
+}
+var LATE_THRESHOLD_MS = 5 * 60 * 1e3;
+async function monitorCronHealth(agentStates) {
+  const alerts = [];
+  const now = Date.now();
+  for (const agent of agentStates) {
+    if (!agent.gatewayRunning || !agent.gatewayPort) continue;
+    const token = readGatewayToken(agent.codeName);
+    const gwArgs = ["--url", `ws://127.0.0.1:${agent.gatewayPort}`, ...token ? ["--token", token] : []];
+    let jobs = [];
     try {
-      const result = await telegramApiCall(botToken, "sendMessage", {
-        chat_id: resolved.telegram_chat_id,
-        text: footeredBody
-      });
-      if (!result.ok) {
-        log(`[delivery] Telegram DM failed for '${agentCodeName}': ${result.description}`);
-        await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: `TELEGRAM_SEND_FAILED:${result.description ?? "unknown"}`, medium: "telegram" });
-        return;
+      const cliBin = resolveAgentFramework(agent.codeName).cliBinary ?? "openclaw";
+      const { stdout } = await execFilePromise(cliBin, ["--profile", agent.codeName, "cron", "list", "--json", ...gwArgs]);
+      const parsed = JSON.parse(stdout);
+      jobs = parsed.jobs ?? [];
+    } catch {
+      continue;
+    }
+    for (const job of jobs) {
+      if (!job.enabled || !job.name.startsWith("aug:")) continue;
+      const alertKey = `${agent.codeName}:${job.id}`;
+      const displayInfo = taskDisplayInfo.get(`${agent.codeName}:${job.name}`);
+      const taskName = displayInfo?.taskName ?? job.name;
+      const schedule = displayInfo?.schedule ?? "";
+      const agentDisplayName = displayInfo?.agentDisplayName ?? agent.codeName;
+      if (job.state?.nextRunAtMs && job.state.nextRunAtMs + LATE_THRESHOLD_MS < now) {
+        if (!alertedJobs.has(`late:${alertKey}`)) {
+          const minsLate = Math.round((now - job.state.nextRunAtMs) / 6e4);
+          alerts.push({
+            type: "late_standup",
+            agentCodeName: agent.codeName,
+            agentDisplayName,
+            jobName: job.name,
+            taskName,
+            schedule,
+            jobId: job.id,
+            detail: `Job is ${minsLate}m late (expected at ${new Date(job.state.nextRunAtMs).toISOString()})`
+          });
+          alertedJobs.add(`late:${alertKey}`);
+        }
+      } else {
+        alertedJobs.delete(`late:${alertKey}`);
+      }
+      if (job.state?.lastRunStatus === "error" || job.state?.consecutiveErrors && job.state.consecutiveErrors > 0) {
+        if (!alertedJobs.has(`fail:${alertKey}`)) {
+          alerts.push({
+            type: "cron_failure",
+            agentCodeName: agent.codeName,
+            agentDisplayName,
+            jobName: job.name,
+            taskName,
+            schedule,
+            jobId: job.id,
+            detail: `Last run failed (${job.state.consecutiveErrors ?? 1} consecutive error(s))`
+          });
+          alertedJobs.add(`fail:${alertKey}`);
+        }
+      } else {
+        alertedJobs.delete(`fail:${alertKey}`);
       }
-      await reportDeliveryStatus(agentId, taskId, { status: "ok", medium: "telegram" });
-      await maybeSendTelegramFollowUpHint(agentCodeName, botToken, resolved.telegram_chat_id);
-    } catch (err) {
-      log(`[delivery] Telegram DM exception for '${agentCodeName}': ${err.message}`);
-      await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "TELEGRAM_EXCEPTION", medium: "telegram" });
     }
   }
-}
-var agentInfoForDelivery = /* @__PURE__ */ new Map();
-function cacheAgentDeliveryMetadata(codeName, refreshData) {
-  const agentRow = refreshData["agent"] ?? {};
-  const displayName = agentRow["display_name"] ?? codeName;
-  const ownerTeamName = agentRow["owner_team_name"] ?? null;
-  const framework = agentRow["framework"] ?? "openclaw";
-  const reportsToPersonId = agentRow["reports_to"] ?? null;
-  const reportsToType = agentRow["reports_to_type"] ?? null;
-  const channelConfigs = refreshData["channel_configs"] ?? {};
-  const dmCapable = [];
-  const slackBotToken = channelConfigs["slack"]?.config?.["bot_token"];
-  if (typeof slackBotToken === "string" && slackBotToken.length > 0) {
-    dmCapable.push("slack");
-  }
-  const telegramBotToken = channelConfigs["telegram"]?.config?.["bot_token"];
-  if (typeof telegramBotToken === "string" && telegramBotToken.length > 0) {
-    dmCapable.push("telegram");
-  }
-  const resolverAgent = {
-    agent_id: agentRow["agent_id"] ?? "",
-    framework,
-    dm_capable_mediums: dmCapable,
-    reports_to_person_id: reportsToType === "person" ? reportsToPersonId : null,
-    reports_to_type: reportsToType
-  };
-  const peopleByPersonId = /* @__PURE__ */ new Map();
-  if (reportsToPersonId && reportsToType === "person") {
-    peopleByPersonId.set(reportsToPersonId, {
-      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
-    });
+  if (alerts.length === 0) return;
+  for (const alert of alerts) {
+    log(`ALERT [${alert.type}] ${alert.agentCodeName}/${alert.jobName}: ${alert.detail}`);
   }
-  const people = refreshData["people"] ?? [];
-  for (const p of people) {
-    const personId = p["person_id"];
-    if (!personId) continue;
-    const contactPrefs = p["contact_preferences"] ?? {};
-    peopleByPersonId.set(personId, {
-      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
-    });
+  if (getAlertSlackWebhook()) {
+    await sendSlackAlert(alerts);
   }
-  agentInfoForDelivery.set(codeName, {
-    agentDisplayName: displayName,
-    ownerTeamName,
-    resolverAgent,
-    peopleByPersonId
-  });
-}
-async function reportDeliveryStatus(agentId, taskId, payload) {
-  if (!taskId) return;
   try {
-    await api.post("/host/schedules/delivery-status", {
-      agent_id: agentId,
-      task_id: taskId,
-      status: payload.status,
-      medium: payload.medium ?? null,
-      error_code: payload.error_code ?? null
-    });
-  } catch (err) {
-    log(`[delivery] Failed to report delivery status for ${agentId}/${taskId}: ${err.message}`);
+    await api.post("/host/cron-alerts", { alerts });
+  } catch {
   }
 }
+async function sendSlackAlert(alerts) {
+  const blocks = alerts.map((a) => {
+    const emoji = a.type === "late_standup" ? ":warning:" : ":x:";
+    const label = a.type === "late_standup" ? "Late" : "Failed";
+    const scheduleInfo = a.schedule ? ` (${a.schedule})` : "";
+    return `${emoji} *${label}* \u2014 *${a.agentDisplayName}* / ${a.taskName}${scheduleInfo}
+${a.detail}`;
+  });
+  await sendSlackWebhookMessage(`:rotating_light: *Cron Health Alert*
+
+${blocks.join("\n\n")}`);
+}
 var spawnedPairIds = /* @__PURE__ */ new Set();
 async function processClaudePairSessions(agents) {
   if (agents.length === 0 && spawnedPairIds.size === 0) return;
@@ -11222,7 +11298,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-UKOL6GWJ.js");
+  } = await import("../claude-pair-runtime-RLIUZRLZ.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));
@@ -11329,76 +11405,6 @@ async function processClaudePairSessions(agents) {
     }
   }
 }
-async function maybePostScheduledTaskRatingPrompt(agentId, taskId, channelId, messageTs) {
-  try {
-    await api.post("/host/scheduled-task/rating-prompt", {
-      agent_id: agentId,
-      task_id: taskId,
-      channel: channelId,
-      message_ts: messageTs
-    });
-  } catch (err) {
-    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") {
-    const botToken = tokens?.slack;
-    const channelId = to.replace(/^channel:/, "");
-    if (!botToken) {
-      log(`No Slack bot token for '${agentCodeName}' \u2014 targeted notification dropped`);
-      return { ok: false, error_code: "SLACK_NO_TOKEN" };
-    }
-    const sent = await sendSlackChannelMessage(agentCodeName, channelId, text);
-    return sent ? { ok: true } : { ok: false, error_code: "SLACK_SEND_FAILED" };
-  }
-  if (channel === "telegram") {
-    const botToken = tokens?.telegram;
-    const chatId = to.replace(/^chat:/, "");
-    if (!botToken) {
-      log(`No Telegram bot token for '${agentCodeName}' \u2014 notification dropped`);
-      return { ok: false, error_code: "TELEGRAM_NO_TOKEN" };
-    }
-    const allowedChats = tokens?.telegramAllowedChats;
-    if (allowedChats && allowedChats.length > 0 && !allowedChats.includes(chatId)) {
-      log(`Telegram chat ${chatId} not in allowed_chat_ids for '${agentCodeName}'`);
-      return { ok: false, error_code: "TELEGRAM_CHAT_NOT_ALLOWED" };
-    }
-    try {
-      const result = await telegramApiCall(botToken, "sendMessage", { chat_id: chatId, text });
-      if (!result.ok) {
-        log(`Telegram sendMessage failed for '${agentCodeName}': ${result.description}`);
-        return { ok: false, error_code: `TELEGRAM_SEND_FAILED:${result.description ?? "unknown"}` };
-      }
-      log(`Telegram notification sent for '${agentCodeName}' to chat ${chatId}`);
-      return { ok: true };
-    } catch (err) {
-      log(`Telegram API error for '${agentCodeName}': ${err.message}`);
-      return { ok: false, error_code: "TELEGRAM_EXCEPTION" };
-    }
-  }
-  log(`Unknown notify_channel '${channel}' for '${agentCodeName}'`);
-  return { ok: false, error_code: `UNKNOWN_CHANNEL:${channel}` };
-}
 function generateArtifacts(agent, refreshData, adapter) {
   if (!refreshData.charter || !refreshData.tools) {
     throw new Error("No charter/tools available");
@@ -12178,13 +12184,11 @@ export {
   SCHEDULED_CARD_DELIVERY_CONTRACT,
   __resetScheduledDeliveryDedupeForTest,
   applyRestartAcks,
-  buildDoneCardNotification,
   buildSchedulerTaskInput,
   claudeCodeUpgradeMarkerPath,
   claudeCodeUpgradeThrottled,
   claudeManagedSettingsPath,
   deliverScheduledCardResult,
-  deliverScheduledTaskOutput,
   deriveMcpServerKey,
   deriveScheduledTaskNotify,
   ensureClaudeManagedSettings,