agentel 0.2.8 → 0.3.1

package/src/slack-notify.js

@@ -0,0 +1,732 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { paths, readJson, writeJson } = require("./paths");
+
+// Summary mode posts one recap after a session goes quiet.
+const DEFAULT_QUIET_MINUTES = 10;
+// Firehose batches live events per session at most this often.
+const DEFAULT_STREAM_BATCH_SECONDS = 45;
+// How long the supervisor waits before re-checking when no new archive
+// writes arrive.
+const DEFAULT_NEXT_CHECK_MS = 60 * 1000;
+// A session whose last activity predates this horizon is never posted, so a
+// full reimport (which rewrites thousands of old sessions through
+// writeSession) cannot flood the channel.
+const MAX_SESSION_AGE_MS = 24 * 60 * 60 * 1000;
+// Posted entries are kept briefly to suppress reposts of unchanged sessions.
+const POSTED_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+// Firehose caps. Messages post whole (Slack collapses long ones behind
+// "See more"), bounded only by a hard ceiling well under Slack's 40k limit.
+// Per pass, at most this many turns post per session; picking up a session
+// already in flight replays only the most recent turns instead of its whole
+// history.
+const STREAM_MESSAGE_CHARS = 11500;
+const STREAM_POSTS_PER_PASS = 20;
+const STREAM_REPLAY_MAX = 10;
+
+const QUEUE_FILE = "slack-notify-queue.jsonl";
+const PROCESSING_FILE = "slack-notify-queue.processing.jsonl";
+const STATE_FILE = "slack-notify.json";
+
+// Resolved settings. `summary` and `stream` (firehose) are independent
+// toggles with independent channels. Configs written before the split kept
+// `channel`/`quietMinutes`/`mode` at the top level; those map onto the
+// summary block so existing setups keep working unchanged.
+function slackNotifySettings(cfg, env = process.env) {
+  const raw = cfg?.notify?.slack || {};
+  const summaryRaw = raw.summary || {};
+  const streamRaw = raw.stream || {};
+  const legacyChannel = String(raw.channel || "");
+  const summaryChannel = String(summaryRaw.channel || legacyChannel);
+  const quietMinutes = positiveNumber(summaryRaw.quietMinutes ?? raw.quietMinutes, DEFAULT_QUIET_MINUTES);
+  return {
+    enabled: Boolean(raw.enabled),
+    repos: Array.isArray(raw.repos) ? raw.repos.filter(Boolean) : [],
+    botToken: String(raw.botToken || env.AGENTLOG_SLACK_BOT_TOKEN || env.SLACK_BOT_TOKEN || ""),
+    apiBaseUrl: String(raw.apiBaseUrl || env.AGENTLOG_SLACK_API_BASE_URL || "https://slack.com/api"),
+    summary: {
+      enabled: summaryRaw.enabled !== false,
+      channel: summaryChannel,
+      quietMinutes
+    },
+    stream: {
+      enabled: Boolean(streamRaw.enabled),
+      channel: String(streamRaw.channel || summaryChannel),
+      batchSeconds: positiveNumber(streamRaw.batchSeconds, DEFAULT_STREAM_BATCH_SECONDS),
+      includeTools: Boolean(streamRaw.includeTools),
+      userName: String(streamRaw.userName || defaultUserName(env))
+    }
+  };
+}
+
+function defaultUserName(env) {
+  try {
+    return os.userInfo().username || env.USER || "user";
+  } catch {
+    return env.USER || "user";
+  }
+}
+
+function positiveNumber(value, fallback) {
+  const num = Number(value);
+  return Number.isFinite(num) && num > 0 ? num : fallback;
+}
+
+function queuePath(env) {
+  return path.join(paths(env).state, QUEUE_FILE);
+}
+
+function statePath(env) {
+  return path.join(paths(env).state, STATE_FILE);
+}
+
+// Called from writeSession for every archive write. Hot path: one gated
+// appendFileSync, no config reads (the caller already holds cfg).
+function enqueueSlackNotification(session, cfg, env = process.env) {
+  const settings = slackNotifySettings(cfg, env);
+  if (!settings.enabled) return false;
+  if (settings.repos.length && !settings.repos.includes(session.repoCanonical)) return false;
+  const entry = {
+    key: `${session.provider}:${session.sessionId}`,
+    sessionId: session.sessionId,
+    provider: session.provider,
+    model: Array.isArray(session.models) ? session.models.find(Boolean) || "" : "",
+    repo: session.repoCanonical || session.scopeCanonical || "",
+    title: session.title || "",
+    metadataPath: session.metadataPath || "",
+    eventPath: session.eventPath || "",
+    endedAt: session.endedAt || "",
+    at: new Date().toISOString()
+  };
+  try {
+    fs.mkdirSync(paths(env).state, { recursive: true });
+    fs.appendFileSync(queuePath(env), `${JSON.stringify(entry)}\n`, { mode: 0o600 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Atomically claims queued entries: rename moves the queue aside so importer
+// children appending concurrently start a fresh file, and a leftover
+// processing file from a crashed run is merged back in.
+function drainQueue(env) {
+  const queue = queuePath(env);
+  const processing = path.join(paths(env).state, PROCESSING_FILE);
+  const entries = [];
+  const readEntries = (file) => {
+    let text = "";
+    try {
+      text = fs.readFileSync(file, "utf8");
+    } catch {
+      return;
+    }
+    for (const line of text.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        entries.push(JSON.parse(line));
+      } catch {}
+    }
+  };
+  readEntries(processing);
+  try {
+    fs.renameSync(queue, processing);
+    readEntries(processing);
+  } catch {}
+  return { entries, finish: () => fs.rmSync(processing, { force: true }) };
+}
+
+function loadState(env) {
+  const state = readJson(statePath(env), {});
+  if (!state.sessions || typeof state.sessions !== "object") state.sessions = {};
+  return state;
+}
+
+function saveState(state, env) {
+  writeJson(statePath(env), state);
+}
+
+function sessionEventPath(tracked) {
+  if (tracked.eventPath) return tracked.eventPath;
+  return String(tracked.metadataPath || "").replace(/\.metadata\.json$/, ".events.jsonl");
+}
+
+// Cursor is an event index, not a byte offset: writeSession rewrites the
+// whole events file each import, so only line positions are stable.
+function readEventsAfter(file, cursor) {
+  let text = "";
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return { events: [], total: cursor };
+  }
+  const lines = text.split("\n").filter((line) => line.trim());
+  const events = [];
+  for (const line of lines.slice(cursor)) {
+    try {
+      events.push(JSON.parse(line));
+    } catch {}
+  }
+  return { events, total: lines.length };
+}
+
+function excerpt(text, limit) {
+  const flat = String(text || "").replace(/\s+/g, " ").trim();
+  if (!flat) return "";
+  return flat.length > limit ? `${flat.slice(0, limit - 1)}…` : flat;
+}
+
+// Gentle clean for full-message streaming: strip harness markup but keep the
+// author's line breaks and formatting (unlike cleanPromptText, which
+// flattens for one-line excerpts).
+function cleanStreamText(text) {
+  const raw = String(text || "");
+  const commandArgs = raw.match(/<command-args>([\s\S]*?)<\/command-args>/);
+  const source = commandArgs && commandArgs[1].trim() ? commandArgs[1] : raw;
+  const cleaned = markdownToMrkdwn(
+    source
+      .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "")
+      .replace(/<\/?(?:command-name|command-message|command-args|local-command-stdout)>/g, "")
+      .trim()
+  );
+  if (cleaned.length <= STREAM_MESSAGE_CHARS) return cleaned;
+  return `${cleaned.slice(0, STREAM_MESSAGE_CHARS - 15)}\n_…truncated_`;
+}
+
+function providerDisplayName(provider) {
+  return String(provider || "agent")
+    .split(/[_\s]+/)
+    .filter(Boolean)
+    .map((word) => (word.length <= 3 ? word.toUpperCase() : word[0].toUpperCase() + word.slice(1)))
+    .join(" ")
+    .replace(/^Chatgpt$/, "ChatGPT");
+}
+
+// Agent avatars use GitHub org avatars: Slack's icon_url needs a public
+// raster image, the viewer's brand logos are inline SVGs, and these are the
+// same marks served as stable PNGs.
+const COMPANY_AVATARS = {
+  anthropic: "https://github.com/anthropics.png?size=96",
+  openai: "https://github.com/openai.png?size=96",
+  google: "https://github.com/google.png?size=96",
+  cognition: "https://github.com/cognition-ai.png?size=96",
+  cursor: "https://github.com/getcursor.png?size=96",
+  xai: "https://github.com/xai-org.png?size=96",
+  cline: "https://github.com/cline.png?size=96",
+  opencode: "https://github.com/sst.png?size=96",
+  factory: "https://github.com/Factory-AI.png?size=96",
+  aider: "https://github.com/Aider-AI.png?size=96",
+  copilot: "https://github.com/github.png?size=96"
+};
+
+function agentCompany(model, provider) {
+  const text = String(model || "").toLowerCase();
+  if (/claude|opus|sonnet|haiku|fable|mythos/.test(text)) return "anthropic";
+  if (/gpt|codex|davinci/.test(text) || /(^|[^a-z0-9])o[134]([^a-z0-9]|$)/.test(text)) return "openai";
+  if (/gemini|antigravity/.test(text)) return "google";
+  if (/composer|^cursor/.test(text)) return "cursor";
+  if (/grok|xai/.test(text)) return "xai";
+  if (/devin|swe-|windsurf/.test(text)) return "cognition";
+  const value = String(provider || "").toLowerCase();
+  if (value.startsWith("claude")) return "anthropic";
+  if (value === "codex" || value === "chatgpt") return "openai";
+  if (["gemini_cli", "antigravity", "antigravity_cli", "antigravity_ide"].includes(value)) return "google";
+  if (value === "devin" || value === "windsurf") return "cognition";
+  for (const key of ["cursor", "cline", "opencode", "factory", "aider", "copilot"]) {
+    if (value === key) return key;
+  }
+  if (value === "grok") return "xai";
+  return "";
+}
+
+function modelDisplayName(model, provider) {
+  // Strip deployment suffixes like "[1m]" and date stamps like -20251001.
+  const raw = String(model || "").replace(/\[[^\]]*\]\s*$/, "").replace(/-\d{8}$/, "").trim();
+  if (!raw) return providerDisplayName(provider);
+  return raw
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((token) => {
+      if (/^\d/.test(token)) return token;
+      if (/^(gpt|o\d|swe|glm|cli)$/i.test(token)) return token.toUpperCase();
+      return token[0].toUpperCase() + token.slice(1);
+    })
+    .join(" ");
+}
+
+// Turns new events into per-turn Slack posts mirroring the conversation:
+// user and agent messages post under their own identities — the agent as
+// its model name with the company logo as avatar — and tool calls are
+// skipped unless opted in.
+function streamMessagesForEvents(events, { provider, model, userName, includeTools = false } = {}) {
+  const agentName = modelDisplayName(model, provider);
+  const agentIcon = COMPANY_AVATARS[agentCompany(model, provider)] || "";
+  const agent = agentIcon
+    ? { username: agentName, icon_url: agentIcon }
+    : { username: agentName, icon_emoji: ":robot_face:" };
+  const messages = [];
+  for (const event of events) {
+    const kind = event?.kind || "";
+    if (kind === "prompt.submitted") {
+      const text = cleanStreamText(event.body?.text);
+      if (text) messages.push({ username: userName || "user", icon_emoji: ":bust_in_silhouette:", text });
+    } else if (kind === "response.generated") {
+      const text = cleanStreamText(event.body?.text);
+      if (text) messages.push({ ...agent, text });
+    } else if (includeTools && kind === "tool.called") {
+      const name = event.indexed?.toolName || event.body?.toolCall?.name || "tool";
+      const target = event.indexed?.target ? ` ${excerpt(event.indexed.target, 120)}` : "";
+      messages.push({ ...agent, text: `:wrench: \`${name}\`${target}` });
+    }
+  }
+  return messages;
+}
+
+// Thread parent: title as the headline, session facts as a small context
+// line (Block Kit context renders grey/small). `text` stays as the
+// notification fallback.
+function streamHeader(tracked, meta = null) {
+  const title = cleanPromptText(meta?.title || tracked.title || "") || tracked.sessionId;
+  const resumed = tracked.closedAt || tracked.postedAt ? " _(resumed)_" : "";
+  const facts = [
+    tracked.repo || meta?.repoCanonical || "",
+    modelDisplayName(tracked.model || (Array.isArray(meta?.models) ? meta.models.find(Boolean) : ""), tracked.provider),
+    meta?.device?.name || meta?.device?.slug || ""
+  ].filter(Boolean);
+  const startedAtMs = Date.parse(meta?.startedAt || "");
+  if (Number.isFinite(startedAtMs)) {
+    const unix = Math.floor(startedAtMs / 1000);
+    const fallback = new Date(startedAtMs).toUTCString();
+    facts.push(`started <!date^${unix}^{date_short_pretty} {time}|${fallback}>`);
+  }
+  const headline = `:arrow_forward: *${excerpt(title, 150)}*${resumed}`;
+  return {
+    text: `${headline}${facts.length ? `\n${facts.join(" · ")}` : ""}`,
+    blocks: [
+      { type: "section", text: { type: "mrkdwn", text: headline } },
+      ...(facts.length ? [{ type: "context", elements: [{ type: "mrkdwn", text: facts.join("  ·  ") }] }] : [])
+    ]
+  };
+}
+
+// Slack renders mrkdwn, not Markdown: *bold* (not **), _italic_, ~strike~,
+// <url|text> links, *no* heading syntax, and no language tags on fences.
+// Code spans/fences are stashed first so their contents pass through
+// untouched.
+function markdownToMrkdwn(text) {
+  const stash = [];
+  const shield = (value) => {
+    stash.push(value);
+    return "\u0000" + (stash.length - 1) + "\u0000";
+  };
+  let out = String(text || "")
+    .replace(/```[\w+-]*\r?\n?([\s\S]*?)```/g, (match, body) => shield("```\n" + body.replace(/\n?$/, "\n") + "```"))
+    .replace(/`[^`\n]+`/g, shield);
+  out = out
+    .replace(/^#{1,6}\s+(.+)$/gm, (match, body) => "\u0001" + body.trim().replace(/\*\*/g, "") + "\u0001")
+    .replace(/!?\[([^\]]*)\]\((https?:[^)\s]+)\)/g, (match, label, url) => "<" + url + "|" + (label || url) + ">")
+    .replace(/~~([^~\n]+)~~/g, "~$1~")
+    .replace(/^(\s*)\*\s+/gm, "$1\u2022 ")
+    .replace(/\*\*([^*\n]+)\*\*/g, "\u0001$1\u0001")
+    .replace(/__([^_\n]+)__/g, "\u0001$1\u0001")
+    .replace(/(^|[^\w*\\])\*([^*\n]+)\*(?=[^\w*]|$)/g, "$1_$2_")
+    .replace(/\u0001/g, "*");
+  return out.replace(/\u0000(\d+)\u0000/g, (match, index) => stash[Number(index)]);
+}
+
+// Prompts arrive wrapped in harness markup (<command-name>, <system-reminder>
+// blocks); pull the human-meaningful part out before excerpting.
+function cleanPromptText(text) {
+  const raw = String(text || "");
+  const commandArgs = raw.match(/<command-args>([\s\S]*?)<\/command-args>/);
+  const source = commandArgs && commandArgs[1].trim() ? commandArgs[1] : raw;
+  return markdownToMrkdwn(
+    source.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, " ").replace(/<[^<>]{1,80}>/g, " ")
+  )
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function firstMeaningfulPrompt(events) {
+  for (const event of events) {
+    if (event?.kind !== "prompt.submitted") continue;
+    const text = cleanPromptText(event.body?.text);
+    if (text.length >= 10) return text;
+  }
+  return "";
+}
+
+function lastResponseText(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event?.kind !== "response.generated") continue;
+    const text = cleanPromptText(event.body?.text);
+    if (text) return text;
+  }
+  return "";
+}
+
+function editedFiles(events) {
+  const files = [];
+  const seen = new Set();
+  for (const event of events) {
+    if (event?.kind !== "tool.called") continue;
+    if (event.indexed?.toolCategory !== "edit") continue;
+    const target = String(event.indexed?.target || "").trim();
+    if (!target || seen.has(target)) continue;
+    seen.add(target);
+    // Last two path segments keep the line short but unambiguous.
+    files.push(target.split("/").filter(Boolean).slice(-2).join("/"));
+  }
+  return files;
+}
+
+function buildCompletionMessage(meta, tracked, events = []) {
+  const asked = firstMeaningfulPrompt(events);
+  const cleanTitle = cleanPromptText(meta.title || tracked.title || "");
+  // A bare slash command or near-empty remainder is not a title.
+  const titleUseless = cleanTitle.length < 5 || /^\/[\w-]+$/.test(cleanTitle);
+  const title = (!titleUseless && cleanTitle) || excerpt(asked, 80) || meta.sessionId;
+  const repo = meta.repoCanonical || meta.scopeCanonical || tracked.repo || "";
+  const device = meta.device?.name || meta.device?.slug || "";
+  const lines = [`:checkered_flag: *${excerpt(title, 120)}*`];
+  const facts = [];
+  if (repo) facts.push(repo);
+  facts.push(meta.provider || tracked.provider);
+  if (device) facts.push(device);
+  const startedAt = Date.parse(meta.startedAt || "");
+  const endedAt = Date.parse(meta.endedAt || "");
+  if (Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt > startedAt) {
+    facts.push(formatDuration(endedAt - startedAt));
+  }
+  lines.push(facts.join(" · "));
+  if (asked) lines.push(`*Asked:* ${excerpt(asked, 240)}`);
+  const outcome = lastResponseText(events);
+  if (outcome) lines.push(`*Outcome:* ${excerpt(outcome, 320)}`);
+  const files = editedFiles(events);
+  if (files.length) {
+    const shown = files.slice(0, 4).join(", ");
+    lines.push(`*Edited:* ${shown}${files.length > 4 ? ` +${files.length - 4} more` : ""}`);
+  }
+  const stats = [];
+  const messageCount = Number(meta.messageCount || 0);
+  if (messageCount) stats.push(`${messageCount} messages`);
+  if (meta.toolUsage?.callCount) stats.push(`${meta.toolUsage.callCount} tool calls`);
+  if (stats.length) lines.push(stats.join(" · "));
+  lines.push(`\`agentlog show ${meta.sessionId}\``);
+  return lines.join("\n");
+}
+
+function formatDuration(ms) {
+  const minutes = Math.round(ms / 60000);
+  if (minutes < 1) return "<1m";
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  return `${hours}h ${minutes % 60}m`;
+}
+
+// Slack app manifest for the setup wizard: pre-fills app creation so the
+// user only clicks Create + Install instead of hand-assembling scopes. One
+// app per person keeps the per-person bot identity (see
+// docs/agentlog-slack-scope.md).
+function buildSlackAppManifest(appName) {
+  const name = String(appName || "agentlog").trim().slice(0, 35) || "agentlog";
+  return {
+    display_information: {
+      name,
+      description: "Posts agent coding session summaries from agentlog",
+      background_color: "#1a1a2e"
+    },
+    features: {
+      bot_user: { display_name: name, always_online: false }
+    },
+    oauth_config: {
+      // chat:write.customize lets firehose turns post under per-speaker
+      // identities (user vs agent); plain summaries only need chat:write.
+      scopes: { bot: ["chat:write", "chat:write.customize"] }
+    }
+  };
+}
+
+function slackAppCreationUrl(appName) {
+  const manifest = JSON.stringify(buildSlackAppManifest(appName));
+  return `https://api.slack.com/apps?new_app=1&manifest_json=${encodeURIComponent(manifest)}`;
+}
+
+async function slackAuthTest(settings, fetchImpl = fetch) {
+  const response = await fetchImpl(`${settings.apiBaseUrl.replace(/\/$/, "")}/auth.test`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${settings.botToken}` }
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok || !body.ok) {
+    throw new Error(`Slack auth failed: ${body.error || `status ${response.status}`}`);
+  }
+  return body;
+}
+
+async function postSlackMessage(settings, payload, fetchImpl = fetch) {
+  const response = await fetchImpl(`${settings.apiBaseUrl.replace(/\/$/, "")}/chat.postMessage`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${settings.botToken}`,
+      "content-type": "application/json; charset=utf-8"
+    },
+    body: JSON.stringify(payload)
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok || !body.ok) {
+    throw new Error(`Slack API error: ${body.error || `status ${response.status}`}`);
+  }
+  return body;
+}
+
+// One notify pass: drain queued archive writes into tracked state, stream
+// new events for firehose sessions, post summaries for sessions that have
+// gone quiet, and report when the supervisor should check again. State
+// memory is O(tracked sessions); queue entries are discarded as soon as they
+// update tracking.
+async function runSlackNotify(env = process.env, options = {}) {
+  const { loadConfig } = require("./config");
+  const cfg = options.config || loadConfig(env);
+  const settings = slackNotifySettings(cfg, env);
+  const result = {
+    posted: 0,
+    streamed: 0,
+    tracked: 0,
+    skipped: 0,
+    errors: [],
+    nextCheckMs: DEFAULT_NEXT_CHECK_MS,
+    dryRun: Boolean(options.dryRun),
+    messages: []
+  };
+  if (!settings.enabled && !options.dryRun) return result;
+  const summaryOn = settings.summary.enabled && Boolean(settings.summary.channel);
+  const streamOn = settings.stream.enabled && Boolean(settings.stream.channel);
+  if (!summaryOn && !streamOn) {
+    result.errors.push("nothing to post: configure notify.slack.summary.channel or notify.slack.stream.channel");
+    return result;
+  }
+  if (!settings.botToken && !options.dryRun) {
+    result.errors.push("no Slack bot token (set notify.slack.botToken or SLACK_BOT_TOKEN)");
+    return result;
+  }
+
+  const now = Date.now();
+  const state = loadState(env);
+  // Queue entries only exist for post-enable writes, and fingerprints keep
+  // unchanged sessions out of writeSession, so an age horizon alone is enough
+  // to stop reimport floods of old sessions.
+  const horizon = now - MAX_SESSION_AGE_MS;
+
+  const { entries, finish } = drainQueue(env);
+  for (const entry of entries) {
+    if (!entry || !entry.key) continue;
+    const endedAt = Date.parse(entry.endedAt || "") || now;
+    if (endedAt < horizon) {
+      result.skipped += 1;
+      continue;
+    }
+    const tracked = state.sessions[entry.key] || { firstSeenAt: entry.at || new Date(now).toISOString() };
+    state.sessions[entry.key] = {
+      ...tracked,
+      ...entry,
+      firstSeenAt: tracked.firstSeenAt,
+      lastSeenAt: new Date(now).toISOString(),
+      postedAt: tracked.postedAt || "",
+      postedEndedAt: tracked.postedEndedAt || "",
+      eventCursor: Number(tracked.eventCursor) || 0,
+      streamTs: tracked.streamTs || "",
+      lastStreamAt: tracked.lastStreamAt || ""
+    };
+  }
+
+  let soonest = Infinity;
+
+  if (streamOn) {
+    // Identity overrides need chat:write.customize; older apps without the
+    // scope fall back to plain bot posts (remembered across passes).
+    const stripIdentity = (payload) => ({ ...payload, username: undefined, icon_emoji: undefined, icon_url: undefined });
+    const postStream = async (payload) => {
+      const customized = state.customizeUnsupported ? stripIdentity(payload) : payload;
+      try {
+        return await postSlackMessage(settings, customized, options.fetchImpl);
+      } catch (error) {
+        if (!state.customizeUnsupported && payload.username && /missing_scope|invalid_arguments/.test(error.message)) {
+          state.customizeUnsupported = true;
+          return postSlackMessage(settings, stripIdentity(payload), options.fetchImpl);
+        }
+        throw error;
+      }
+    };
+
+    for (const tracked of Object.values(state.sessions)) {
+      const cursor = Number(tracked.eventCursor) || 0;
+      const lastStreamAt = Date.parse(tracked.lastStreamAt || "") || 0;
+      const batchMs = settings.stream.batchSeconds * 1000;
+      if (now - lastStreamAt < batchMs) {
+        soonest = Math.min(soonest, lastStreamAt + batchMs - now);
+        continue;
+      }
+      const { events, total } = readEventsAfter(sessionEventPath(tracked), cursor);
+      if (total <= cursor || !events.length) continue;
+      let turns = streamMessagesForEvents(events, {
+        provider: tracked.provider,
+        model: tracked.model,
+        userName: settings.stream.userName,
+        includeTools: settings.stream.includeTools
+      });
+      if (!turns.length) {
+        // Nothing renderable (e.g. only tool results); advance past it.
+        if (!options.dryRun) tracked.eventCursor = total;
+        continue;
+      }
+      let skippedNote = "";
+      if (!tracked.streamTs && turns.length > STREAM_REPLAY_MAX) {
+        // Picking up a session already in flight: replay only the tail.
+        skippedNote = `_…picking up mid-session; ${turns.length - STREAM_REPLAY_MAX} earlier turn(s) in \`agentlog show ${tracked.sessionId}\`_`;
+        turns = turns.slice(-STREAM_REPLAY_MAX);
+      } else if (turns.length > STREAM_POSTS_PER_PASS) {
+        skippedNote = `_…${turns.length - STREAM_POSTS_PER_PASS} turn(s) skipped; full transcript via \`agentlog show ${tracked.sessionId}\`_`;
+        turns = turns.slice(-STREAM_POSTS_PER_PASS);
+      }
+      if (options.dryRun) {
+        for (const turn of turns) {
+          result.messages.push({ channel: settings.stream.channel, ...turn, thread: Boolean(tracked.streamTs) });
+        }
+        result.streamed += turns.length;
+        continue;
+      }
+      try {
+        if (!tracked.streamTs) {
+          const header = streamHeader(tracked, readJson(tracked.metadataPath, null));
+          const parent = await postSlackMessage(
+            settings,
+            { channel: settings.stream.channel, text: header.text, blocks: header.blocks, unfurl_links: false },
+            options.fetchImpl
+          );
+          tracked.streamTs = parent.ts || "";
+        }
+        if (skippedNote) {
+          await postStream({ channel: settings.stream.channel, text: skippedNote, thread_ts: tracked.streamTs || undefined, unfurl_links: false });
+        }
+        for (const turn of turns) {
+          await postStream({
+            channel: settings.stream.channel,
+            text: turn.text,
+            username: turn.username,
+            icon_emoji: turn.icon_emoji,
+            icon_url: turn.icon_url,
+            thread_ts: tracked.streamTs || undefined,
+            unfurl_links: false
+          });
+          result.streamed += 1;
+        }
+        tracked.eventCursor = total;
+        tracked.lastStreamAt = new Date(now).toISOString();
+      } catch (error) {
+        result.errors.push(`${tracked.key} stream: ${error.message}`);
+        soonest = Math.min(soonest, DEFAULT_NEXT_CHECK_MS);
+      }
+    }
+  }
+
+  const quietMs = settings.summary.quietMinutes * 60 * 1000;
+  for (const [key, tracked] of Object.entries(state.sessions)) {
+    const lastSeen = Date.parse(tracked.lastSeenAt || tracked.firstSeenAt || "") || now;
+    if (tracked.postedAt) {
+      // Reposts only happen when the session accumulated new activity after
+      // the posted summary (e.g. it was resumed).
+      if (tracked.endedAt && tracked.endedAt === tracked.postedEndedAt) {
+        if (now - (Date.parse(tracked.postedAt) || now) > POSTED_RETENTION_MS) delete state.sessions[key];
+        continue;
+      }
+    }
+    if (now - lastSeen < quietMs) {
+      soonest = Math.min(soonest, lastSeen + quietMs - now);
+      continue;
+    }
+    if (!summaryOn) {
+      // Firehose-only sessions: going quiet closes the thread but keeps the
+      // entry (with its event cursor) so a resume opens a fresh thread and
+      // streams only new turns. Closed entries age out after the retention
+      // window; sessions that never streamed are dropped outright.
+      const caughtUp = !streamOn || readEventsAfter(sessionEventPath(tracked), Number(tracked.eventCursor) || 0).total <= (Number(tracked.eventCursor) || 0);
+      if (caughtUp && !options.dryRun) {
+        if (tracked.streamTs) {
+          tracked.streamTs = "";
+          tracked.closedAt = new Date(now).toISOString();
+        } else if (!tracked.closedAt || now - (Date.parse(tracked.closedAt) || now) > POSTED_RETENTION_MS) {
+          delete state.sessions[key];
+        }
+      }
+      continue;
+    }
+    const meta = readJson(tracked.metadataPath, null);
+    if (!meta) {
+      delete state.sessions[key];
+      continue;
+    }
+    const text = buildCompletionMessage(meta, tracked, readEventsAfter(sessionEventPath(tracked), 0).events);
+    if (options.dryRun) {
+      result.messages.push({ channel: settings.summary.channel, text });
+      result.posted += 1;
+      continue;
+    }
+    try {
+      await postSlackMessage(settings, { channel: settings.summary.channel, text, unfurl_links: false }, options.fetchImpl);
+      // Close out the firehose thread so it is self-contained.
+      if (streamOn && tracked.streamTs) {
+        try {
+          await postSlackMessage(
+            settings,
+            { channel: settings.stream.channel, text, thread_ts: tracked.streamTs, unfurl_links: false },
+            options.fetchImpl
+          );
+        } catch {}
+      }
+      tracked.postedAt = new Date(now).toISOString();
+      tracked.postedEndedAt = meta.endedAt || tracked.endedAt || "";
+      // The recap closes the thread: a session picked back up later opens a
+      // fresh "(resumed)" thread instead of reviving a stale one. The event
+      // cursor survives so only new turns stream.
+      if (tracked.streamTs) {
+        tracked.streamTs = "";
+        tracked.closedAt = tracked.postedAt;
+      }
+      result.posted += 1;
+    } catch (error) {
+      result.errors.push(`${key}: ${error.message}`);
+      // Leave the session tracked; the next pass retries.
+      soonest = Math.min(soonest, DEFAULT_NEXT_CHECK_MS);
+    }
+  }
+
+  result.tracked = Object.keys(state.sessions).length;
+  if (Number.isFinite(soonest)) result.nextCheckMs = Math.max(30 * 1000, soonest);
+  else if (!result.tracked) result.nextCheckMs = 5 * 60 * 1000;
+  saveState(state, env);
+  finish();
+  return result;
+}
+
+module.exports = {
+  DEFAULT_QUIET_MINUTES,
+  DEFAULT_STREAM_BATCH_SECONDS,
+  buildCompletionMessage,
+  buildSlackAppManifest,
+  enqueueSlackNotification,
+  markdownToMrkdwn,
+  modelDisplayName,
+  postSlackMessage,
+  queuePath,
+  runSlackNotify,
+  streamMessagesForEvents,
+  slackAppCreationUrl,
+  slackAuthTest,
+  slackNotifySettings,
+  statePath
+};