@integrity-labs/agt-cli 0.12.9 → 0.14.0

package/dist/lib/manager-worker.js

@@ -9,6 +9,7 @@ import {
   getIntegration,
   isParseError,
   isResolveError,
+  isSuppressOutput,
   parseDeliveryTarget,
   provision,
   provisionIsolationHook,
@@ -17,7 +18,7 @@ import {
   resolveChannels,
   resolveDmTarget,
   wrapScheduledTaskPrompt
-} from "../chunk-ZFTZDO5E.js";
+} from "../chunk-Y2ZGJIXI.js";
 import {
   findTaskByTemplate,
   getProjectDir,
@@ -451,6 +452,237 @@ function parseExpiresAt(raw) {
   return null;
 }
 
+// src/lib/channel-sweep.ts
+import { execFileSync } from "child_process";
+var CHANNEL_BASENAMES = [
+  "slack-channel",
+  "direct-chat-channel",
+  "telegram-channel"
+];
+function parseEtime(s) {
+  const trimmed = s.trim();
+  if (!trimmed) return 0;
+  let days = 0;
+  let rest = trimmed;
+  const dashIdx = rest.indexOf("-");
+  if (dashIdx >= 0) {
+    days = parseInt(rest.slice(0, dashIdx), 10) || 0;
+    rest = rest.slice(dashIdx + 1);
+  }
+  const parts = rest.split(":").map((p) => parseInt(p, 10) || 0);
+  let h = 0;
+  let m = 0;
+  let sec = 0;
+  if (parts.length === 3) {
+    [h, m, sec] = parts;
+  } else if (parts.length === 2) {
+    [m, sec] = parts;
+  } else if (parts.length === 1) {
+    [sec] = parts;
+  }
+  return days * 86400 + h * 3600 + m * 60 + sec;
+}
+function parsePsOutput(psOutput) {
+  const results = [];
+  const lines = psOutput.split("\n");
+  for (const rawLine of lines) {
+    const line = rawLine.trimStart();
+    if (!line) continue;
+    const firstSpace = line.search(/\s+/);
+    if (firstSpace < 0) continue;
+    const pid = parseInt(line.slice(0, firstSpace), 10);
+    if (!Number.isFinite(pid)) continue;
+    const afterPid = line.slice(firstSpace).trimStart();
+    const secondSpace = afterPid.search(/\s+/);
+    if (secondSpace < 0) continue;
+    const ppid = parseInt(afterPid.slice(0, secondSpace), 10);
+    if (!Number.isFinite(ppid)) continue;
+    const afterPpid = afterPid.slice(secondSpace).trimStart();
+    const thirdSpace = afterPpid.search(/\s+/);
+    if (thirdSpace < 0) continue;
+    const etime = afterPpid.slice(0, thirdSpace);
+    const command = afterPpid.slice(thirdSpace).trimStart();
+    const channelMatch = command.match(
+      new RegExp(`(?:^|\\s)(?:[^\\s=]*/)?(${CHANNEL_BASENAMES.join("|")})\\.js(?:\\s|$)`)
+    );
+    const channelType = channelMatch?.[1];
+    if (!channelType) continue;
+    const match = command.match(/(?:^|\s)AGT_AGENT_CODE_NAME=([^\s]+)/);
+    if (!match) continue;
+    const codeName = match[1];
+    results.push({
+      pid,
+      ppid,
+      channelType,
+      codeName,
+      etimeSeconds: parseEtime(etime),
+      command: command.slice(0, 500)
+    });
+  }
+  return results;
+}
+function pickKillTargets(processes, agentCodeNames) {
+  const kills = [];
+  const ambiguousGroups = [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const proc of processes) {
+    if (!agentCodeNames.has(proc.codeName)) continue;
+    const key = `${proc.codeName}:${proc.channelType}`;
+    const bucket = groups.get(key);
+    if (bucket) bucket.push(proc);
+    else groups.set(key, [proc]);
+  }
+  for (const [key, bucket] of groups) {
+    const orphans = bucket.filter((p) => p.ppid === 1);
+    const nonOrphans = bucket.filter((p) => p.ppid !== 1);
+    if (orphans.length === 0 && nonOrphans.length <= 1) continue;
+    if (nonOrphans.length > 1) {
+      ambiguousGroups.push(key);
+      continue;
+    }
+    for (const proc of orphans) {
+      kills.push({
+        pid: proc.pid,
+        codeName: proc.codeName,
+        channelType: proc.channelType,
+        etimeSeconds: proc.etimeSeconds,
+        reason: "orphan"
+      });
+    }
+  }
+  return { kills, ambiguousGroups };
+}
+function defaultKill(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+}
+async function sweepChannelProcesses(opts) {
+  const { agentCodeNames, dryRun, log: log2 } = opts;
+  const kill = opts.killFn ?? defaultKill;
+  let psOutput = "";
+  try {
+    psOutput = execFileSync("ps", ["eww", "-o", "pid=,ppid=,etime=,command="], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      maxBuffer: 10 * 1024 * 1024
+    });
+  } catch (err) {
+    log2(`[channel-sweep] ps failed: ${err.message}`);
+    return { kills: [], inspected: 0, scannedAgents: [...agentCodeNames], dryRun };
+  }
+  const processes = parsePsOutput(psOutput);
+  const { kills, ambiguousGroups } = pickKillTargets(processes, agentCodeNames);
+  for (const target of kills) {
+    const ageMin = Math.round(target.etimeSeconds / 60);
+    log2(
+      `[channel-sweep]${dryRun ? "[dry-run]" : ""} surplus ${target.channelType} for ${target.codeName}: killing pid=${target.pid} (${target.reason}, age=${ageMin}m)`
+    );
+    if (!dryRun) kill(target.pid);
+  }
+  for (const group of ambiguousGroups) {
+    log2(
+      `[channel-sweep] ambiguous group ${group} \u2014 >1 non-orphan process, cannot determine which is live. Manual check recommended.`
+    );
+  }
+  return {
+    kills,
+    inspected: processes.length,
+    scannedAgents: [...agentCodeNames],
+    dryRun
+  };
+}
+
+// src/lib/delivery-hint.ts
+var DEFAULT_PROBABILITY = 0.1;
+function envSuffixFor(codeName) {
+  return codeName.replace(/[^A-Za-z0-9]+/g, "_").toUpperCase();
+}
+function hintProbability(codeName, env = process.env) {
+  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);
+  if (env["AGT_DELIVERY_HINT_DISABLED"] === "1") return 0;
+  const host = env["AGT_DELIVERY_HINT_PROBABILITY"];
+  if (host != null) return clampProbability(host);
+  return DEFAULT_PROBABILITY;
+}
+function clampProbability(raw) {
+  const parsed = parseFloat(raw);
+  if (!Number.isFinite(parsed)) return DEFAULT_PROBABILITY;
+  if (parsed < 0) return 0;
+  if (parsed > 1) return 1;
+  return parsed;
+}
+function shouldIncludeHint(probability, rng = Math.random) {
+  if (probability <= 0) return false;
+  if (probability >= 1) return true;
+  return rng() < probability;
+}
+var HINT_VARIANTS = Object.freeze([
+  'Quick note: you can change this scheduled task just by asking me \u2014 e.g. "Change the schedule for this task" or "Make this report less verbose in future".',
+  `By the way, this is on a schedule \u2014 if you'd like to tweak it, just say something like "run this weekly instead of daily" or "make this report less verbose in future" and I'll handle it.`,
+  'Heads up: I deliver this on a schedule you can edit conversationally. Try "Change the schedule for this task" or "Make this report shorter" whenever you want to adjust it.',
+  `PS \u2014 no UI needed to tune this. Just tell me "Send this at 9am instead" or "Skip weekends for this report" and I'll update the schedule.`,
+  'FYI this is a scheduled delivery. You can reshape it in plain English \u2014 e.g. "Make this fortnightly" or "Only include items from the last 24 hours".',
+  `You're the boss of this schedule \u2014 ask me things like "Pause this for two weeks" or "Include a summary at the top next time" and I'll apply it.`,
+  `Side note: you can say "Change this to Mondays only" or "Drop the preamble in future reports" and I'll update the task. No config screen required.`,
+  'Reminder: I run this on a schedule you can edit by talking. Good openers: "Change when this fires" or "Make future reports more concise".',
+  `Small tip \u2014 this delivery is editable on the fly. Try "Move this to afternoons" or "Cut the detail down in future runs" and I'll retune it.`,
+  `If this cadence or format isn't quite right, just ask \u2014 "Only run this on weekdays" or "Shorter summaries from now on" both work, no form to fill out.`
+]);
+function pickHintVariant(rng = Math.random) {
+  const idx = Math.floor(rng() * HINT_VARIANTS.length) % HINT_VARIANTS.length;
+  return HINT_VARIANTS[idx];
+}
+
+// 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}`;
+}
+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) return opts.body;
+  const url = buildScheduleEditLink(consoleUrl, opts.agentId, opts.taskId);
+  return appendScheduleLinkFooter(opts.body, url, opts.medium);
+}
+
 // src/lib/realtime-chat.ts
 import { createClient } from "@supabase/supabase-js";
 var client = null;
@@ -736,6 +968,13 @@ var GATEWAY_PORT_STEP = 10;
 var GATEWAY_PORT_MAX = 18899;
 var AUGMENTED_DIR = join2(process.env["HOME"] ?? "/tmp", ".augmented");
 var GATEWAY_PORTS_FILE = join2(AUGMENTED_DIR, "gateway-ports.json");
+var CHANNEL_SWEEP_INTERVAL_MS = (() => {
+  const raw = parseInt(process.env["AGT_CHANNEL_SWEEP_INTERVAL_MS"] ?? "", 10);
+  if (!Number.isFinite(raw)) return 5 * 60 * 1e3;
+  return Math.max(raw, 3e4);
+})();
+var CHANNEL_SWEEP_DRY_RUN = process.env["AGT_CHANNEL_SWEEP_DRY_RUN"] === "1";
+var lastChannelSweepAt = 0;
 var config = null;
 var running = false;
 var pollTimer = null;
@@ -811,9 +1050,9 @@ function clearAgentCaches(agentId, codeName) {
 var cachedFrameworkVersion = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
-function resolveBrewPath(execFileSync) {
+function resolveBrewPath(execFileSync2) {
   try {
-    const out = execFileSync("which", ["brew"], { timeout: 5e3 }).toString().trim();
+    const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
     if (out) return out;
   } catch {
   }
@@ -835,9 +1074,9 @@ async function ensureToolkitCli(toolkitSlug) {
   }
   const { binary, installer, package: pkg, script } = integration.cli_tool;
   const resolvedInstaller = installer ?? "manual";
-  const { execFileSync, execSync } = await import("child_process");
+  const { execFileSync: execFileSync2, execSync } = await import("child_process");
   try {
-    execFileSync("which", [binary], { timeout: 5e3, stdio: "pipe" });
+    execFileSync2("which", [binary], { timeout: 5e3, stdio: "pipe" });
     toolkitCliEnsured.add(toolkitSlug);
     toolkitCliRetryAfter.delete(toolkitSlug);
     return;
@@ -857,14 +1096,14 @@ async function ensureToolkitCli(toolkitSlug) {
         return;
       }
       log(`[toolkit-install] ${toolkitSlug}: installing via npm (${pkg})\u2026`);
-      execFileSync("npm", ["install", "-g", pkg], { timeout: 18e4, stdio: "pipe" });
+      execFileSync2("npm", ["install", "-g", pkg], { timeout: 18e4, stdio: "pipe" });
     } else if (resolvedInstaller === "brew") {
       if (!pkg) {
         log(`[toolkit-install] ${toolkitSlug}: installer=brew but no package declared`);
         toolkitCliEnsured.add(toolkitSlug);
         return;
       }
-      const brewPath = resolveBrewPath(execFileSync);
+      const brewPath = resolveBrewPath(execFileSync2);
       if (!brewPath) {
         log(`[toolkit-install] ${toolkitSlug}: installer=brew but Homebrew not available \u2014 install manually: brew install ${pkg}`);
         toolkitCliEnsured.add(toolkitSlug);
@@ -874,9 +1113,9 @@ async function ensureToolkitCli(toolkitSlug) {
       const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
       log(`[toolkit-install] ${toolkitSlug}: installing via brew (${pkg})\u2026`);
       if (isRoot) {
-        execFileSync("sudo", ["-u", "ec2-user", "-H", brewPath, "install", pkg], { timeout: 18e4, stdio: "pipe" });
+        execFileSync2("sudo", ["-u", "ec2-user", "-H", brewPath, "install", pkg], { timeout: 18e4, stdio: "pipe" });
       } else {
-        execFileSync(brewPath, ["install", pkg], { timeout: 18e4, stdio: "pipe" });
+        execFileSync2(brewPath, ["install", pkg], { timeout: 18e4, stdio: "pipe" });
       }
     } else if (resolvedInstaller === "script") {
       if (!script) {
@@ -897,7 +1136,7 @@ async function ensureToolkitCli(toolkitSlug) {
     process.env.PATH = `${brewBinDir}:${process.env.PATH ?? ""}`;
   }
   try {
-    execFileSync("which", [binary], { timeout: 5e3, stdio: "pipe" });
+    execFileSync2("which", [binary], { timeout: 5e3, stdio: "pipe" });
     log(`[toolkit-install] ${toolkitSlug}: installed \u2014 ${binary} now on PATH`);
     toolkitCliEnsured.add(toolkitSlug);
     toolkitCliRetryAfter.delete(toolkitSlug);
@@ -910,8 +1149,8 @@ async function ensureFrameworkBinary(frameworkId) {
   if (frameworkId !== "claude-code") return;
   if (frameworkBinaryChecked.has(frameworkId)) return;
   frameworkBinaryChecked.add(frameworkId);
-  const { execFileSync } = await import("child_process");
-  const brewPath = resolveBrewPath(execFileSync);
+  const { execFileSync: execFileSync2 } = await import("child_process");
+  const brewPath = resolveBrewPath(execFileSync2);
   if (!brewPath) {
     log("Homebrew not found (no `brew` on PATH, no /home/linuxbrew/.linuxbrew/bin/brew). Cannot auto-install Claude Code. Install manually: https://claude.ai/download");
     return;
@@ -921,14 +1160,14 @@ async function ensureFrameworkBinary(frameworkId) {
   const runBrew = (args, opts) => {
     if (isRoot) {
       const sudoArgs = ["-u", "ec2-user", "-H", brewPath, ...args];
-      return execFileSync("sudo", sudoArgs, { ...opts, stdio: "pipe" }).toString();
+      return execFileSync2("sudo", sudoArgs, { ...opts, stdio: "pipe" }).toString();
     }
-    return execFileSync(brewPath, args, { ...opts, stdio: "pipe" }).toString();
+    return execFileSync2(brewPath, args, { ...opts, stdio: "pipe" }).toString();
   };
   let claudeExists = existsSync("/home/linuxbrew/.linuxbrew/bin/claude");
   if (!claudeExists) {
     try {
-      execFileSync("which", ["claude"], { timeout: 5e3 });
+      execFileSync2("which", ["claude"], { timeout: 5e3 });
       claudeExists = true;
     } catch {
     }
@@ -981,20 +1220,20 @@ async function checkAndUpdateCli() {
     if (Date.now() - lastCheck < UPDATE_CHECK_INTERVAL_MS) return;
   } catch {
   }
-  const { execFileSync } = await import("child_process");
+  const { execFileSync: execFileSync2 } = await import("child_process");
   let brewPath;
   try {
-    brewPath = execFileSync("which", ["brew"], { timeout: 5e3 }).toString().trim();
+    brewPath = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
   } catch {
     return;
   }
   try {
-    execFileSync(brewPath, ["update", "--quiet"], { timeout: 6e4, stdio: "pipe" });
+    execFileSync2(brewPath, ["update", "--quiet"], { timeout: 6e4, stdio: "pipe" });
   } catch (err) {
     log(`[self-update] brew update failed (continuing with stale cache): ${err.message}`);
   }
   try {
-    const outdated = execFileSync(brewPath, ["outdated", "--json=v2"], {
+    const outdated = execFileSync2(brewPath, ["outdated", "--json=v2"], {
       timeout: 3e4,
       encoding: "utf-8"
     });
@@ -1005,7 +1244,7 @@ async function checkAndUpdateCli() {
       const latest = agtOutdated.current_version ?? "unknown";
       log(`[self-update] agt CLI update available: ${installed} \u2192 ${latest}. Upgrading...`);
       try {
-        execFileSync(brewPath, ["upgrade", "integrity-labs/tap/agt"], {
+        execFileSync2(brewPath, ["upgrade", "integrity-labs/tap/agt"], {
           timeout: 12e4,
           stdio: "pipe"
         });
@@ -1591,6 +1830,17 @@ async function pollCycle() {
       }
     }
     await healthCheckGateways(agentStates);
+    if (Date.now() - lastChannelSweepAt >= CHANNEL_SWEEP_INTERVAL_MS) {
+      lastChannelSweepAt = Date.now();
+      const agentCodeNames = new Set(agentStates.map((a) => a.codeName));
+      sweepChannelProcesses({
+        agentCodeNames,
+        dryRun: CHANNEL_SWEEP_DRY_RUN,
+        log
+      }).catch((err) => {
+        log(`[channel-sweep] sweep error: ${err.message}`);
+      });
+    }
     const lastHealthCheck = lastHarvestAt.get("__cron_health__") ?? 0;
     if (Date.now() - lastHealthCheck >= HARVEST_INTERVAL_MS) {
       lastHarvestAt.set("__cron_health__", Date.now());
@@ -2958,6 +3208,16 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
 }
 async function processClaudeTaskResult(codeName, agentId, templateId, output, delivery) {
   try {
+    if (isSuppressOutput(output)) {
+      log(`[claude-scheduler] Suppressing delivery for '${codeName}' \u2014 output matched no-delivery sentinel or was empty`);
+      if (delivery?.mode === "announce" && delivery.to) {
+        await reportDeliveryStatus(agentId, delivery.taskId, {
+          status: "skipped",
+          error_code: "NO_CONTENT"
+        });
+      }
+      return;
+    }
     if (STANDUP_TEMPLATES.has(templateId)) {
       const standup = parseStandupSummary(output);
       await api.post("/host/agent-status", {
@@ -2991,7 +3251,7 @@ async function processClaudeTaskResult(codeName, agentId, templateId, output, de
         log(`[claude-scheduler] Kanban updates posted for '${codeName}' (${kanbanUpdates.length} updates)`);
       }
     }
-    if (delivery?.mode === "announce" && delivery.to && output) {
+    if (delivery?.mode === "announce" && delivery.to) {
       await deliverScheduledTaskOutput(
         codeName,
         agentId,
@@ -4086,37 +4346,68 @@ async function sendSlackWebhookMessage(text) {
   }
 }
 async function sendSlackChannelMessage(agentCodeName, channelId, text) {
+  const result = await postSlackChannelMessage(agentCodeName, channelId, text);
+  return result.ok;
+}
+async function postSlackChannelMessage(agentCodeName, channelId, text, threadTs) {
   const botToken = agentChannelTokens.get(agentCodeName)?.slack;
   if (!botToken) {
     log(`No Slack bot token cached for '${agentCodeName}' \u2014 cannot post to ${channelId}`);
-    return false;
+    return { ok: false };
   }
   try {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 5e3);
     try {
+      const body = { channel: channelId, text };
+      if (threadTs) body.thread_ts = threadTs;
       const response = await fetch("https://slack.com/api/chat.postMessage", {
         method: "POST",
         headers: {
           "Authorization": `Bearer ${botToken}`,
           "Content-Type": "application/json"
         },
-        body: JSON.stringify({ channel: channelId, text }),
+        body: JSON.stringify(body),
         signal: controller.signal
       });
       clearTimeout(timeout);
       const data = await response.json();
       if (!data.ok) {
         log(`Slack chat.postMessage failed for '${agentCodeName}' to ${channelId}: ${data.error}`);
-        return false;
+        return { ok: false };
       }
-      return true;
+      return { ok: true, ts: data.ts };
     } finally {
       clearTimeout(timeout);
     }
   } catch (err) {
     log(`Slack channel message error for '${agentCodeName}': ${err.message}`);
-    return false;
+    return { ok: false };
+  }
+}
+async function maybePostSlackThreadHint(agentCodeName, channelId, primaryTs) {
+  if (!shouldIncludeHint(hintProbability(agentCodeName))) return;
+  if (!primaryTs) {
+    return;
+  }
+  const hint = pickHintVariant();
+  const result = await postSlackChannelMessage(agentCodeName, channelId, hint, primaryTs);
+  if (result.ok) {
+    log(`[delivery-hint] Slack thread hint posted for '${agentCodeName}'`);
+  }
+}
+async function maybeSendTelegramFollowUpHint(agentCodeName, botToken, chatId) {
+  if (!shouldIncludeHint(hintProbability(agentCodeName))) return;
+  const hint = pickHintVariant();
+  try {
+    const result = await telegramApiCall(botToken, "sendMessage", { chat_id: chatId, text: hint });
+    if (!result.ok) {
+      log(`[delivery-hint] Telegram follow-up failed for '${agentCodeName}': ${result.description ?? "unknown"}`);
+      return;
+    }
+    log(`[delivery-hint] Telegram follow-up hint posted for '${agentCodeName}'`);
+  } catch (err) {
+    log(`[delivery-hint] Telegram follow-up failed for '${agentCodeName}': ${err.message}`);
   }
 }
 async function sendSlackAlert(alerts) {
@@ -4132,9 +4423,10 @@ ${a.detail}`;
 ${blocks.join("\n\n")}`);
 }
 async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, body, taskId) {
+  const withLink = (b, medium) => withScheduleLinkFooter({ body: b, medium, codeName: agentCodeName, agentId, taskId });
   if (typeof rawTarget === "string") {
     if (rawTarget.startsWith("channel:")) {
-      const result = await sendTaskNotification(agentCodeName, "slack", rawTarget, body);
+      const result = await sendTaskNotification(agentCodeName, "slack", rawTarget, withLink(body, "slack"));
       await reportDeliveryStatus(agentId, taskId, {
         status: result.ok ? "ok" : "failed",
         medium: "slack",
@@ -4143,7 +4435,7 @@ async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, bod
       return;
     }
     if (rawTarget.startsWith("chat:")) {
-      const result = await sendTaskNotification(agentCodeName, "telegram", rawTarget, body);
+      const result = await sendTaskNotification(agentCodeName, "telegram", rawTarget, withLink(body, "telegram"));
       await reportDeliveryStatus(agentId, taskId, {
         status: result.ok ? "ok" : "failed",
         medium: "telegram",
@@ -4163,21 +4455,28 @@ async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, bod
   }
   if (parsed.kind === "channel") {
     if (parsed.provider === "slack") {
-      const sent = await sendSlackChannelMessage(agentCodeName, parsed.channel_id ?? "", body);
+      const channelId = parsed.channel_id ?? "";
+      const sent = await postSlackChannelMessage(agentCodeName, channelId, withLink(body, "slack"));
       await reportDeliveryStatus(agentId, taskId, {
-        status: sent ? "ok" : "failed",
+        status: sent.ok ? "ok" : "failed",
         medium: "slack",
-        error_code: sent ? null : "SLACK_SEND_FAILED"
+        error_code: sent.ok ? null : "SLACK_SEND_FAILED"
       });
+      if (sent.ok) await maybePostSlackThreadHint(agentCodeName, channelId, sent.ts);
       return;
     }
-    const toStr = `chat:${parsed.chat_id ?? ""}`;
-    const result = await sendTaskNotification(agentCodeName, "telegram", toStr, body);
+    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);
@@ -4192,11 +4491,12 @@ async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, bod
     await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: resolved.code });
     return;
   }
-  const footeredBody = appendDmFooter(
+  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;
@@ -4229,12 +4529,13 @@ async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, bod
         await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: errCode, medium: "slack" });
         return;
       }
-      const sent = await sendSlackChannelMessage(agentCodeName, openJson.channel.id, footeredBody);
+      const sent = await postSlackChannelMessage(agentCodeName, openJson.channel.id, footeredBody);
       await reportDeliveryStatus(agentId, taskId, {
-        status: sent ? "ok" : "failed",
+        status: sent.ok ? "ok" : "failed",
         medium: "slack",
-        error_code: sent ? null : "SLACK_SEND_FAILED"
+        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";
@@ -4262,6 +4563,7 @@ async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, bod
         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" });