pm-slack-standup 2026.6.2 → 2026.6.4

package/dist/index.js

@@ -18,7 +18,7 @@ const EXIT_CODE = {
     USAGE: 2,
     NOT_FOUND: 3,
 };
-class CommandError extends Error {
+export class CommandError extends Error {
     exitCode;
     constructor(message, exitCode = EXIT_CODE.GENERIC_FAILURE) {
         super(message);
@@ -26,6 +26,12 @@ class CommandError extends Error {
         this.exitCode = exitCode;
     }
 }
+export const ALL_SECTIONS = [
+    "in_progress",
+    "blocked",
+    "done",
+    "up_next",
+];
 // ---------------------------------------------------------------------------
 // Option helpers
 // ---------------------------------------------------------------------------
@@ -37,7 +43,7 @@ class CommandError extends Error {
 function camelCase(key) {
     return key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
-function readBoolOption(options, key) {
+export function readBoolOption(options, key) {
     for (const candidate of [key, camelCase(key)]) {
         const value = options[candidate];
         if (typeof value === "boolean")
@@ -52,7 +58,7 @@ function readBoolOption(options, key) {
     }
     return false;
 }
-function readStrOption(options, key) {
+export function readStrOption(options, key) {
     for (const candidate of [key, camelCase(key)]) {
         const value = options[candidate];
         if (typeof value === "string" && value.trim().length > 0) {
@@ -66,7 +72,7 @@ function readStrOption(options, key) {
  * Accepts `author=@handle,other=@h2` (commas) or semicolon separators.
  * A leading `@` on the handle is optional and normalized on.
  */
-function parseMentionMap(spec) {
+export function parseMentionMap(spec) {
     const map = {};
     if (!spec)
         return map;
@@ -84,6 +90,176 @@ function parseMentionMap(spec) {
     }
     return map;
 }
+/**
+ * Normalize a `--format` value. Accepts the four public formats plus the
+ * legacy `text` alias (== `plain`). Unknown values raise a USAGE CommandError.
+ */
+export function parseFormat(raw) {
+    if (raw == null)
+        return "slack";
+    const v = raw.trim().toLowerCase();
+    if (v === "" || v === "slack")
+        return "slack";
+    if (v === "blockkit" || v === "block-kit" || v === "blocks")
+        return "blockkit";
+    if (v === "markdown" || v === "md")
+        return "markdown";
+    if (v === "plain" || v === "text" || v === "txt")
+        return "plain";
+    throw new CommandError(`Unknown --format '${raw}'. Valid: slack | blockkit | markdown | plain.`, EXIT_CODE.USAGE);
+}
+export function parseGroupBy(raw) {
+    if (raw == null)
+        return "status";
+    const v = raw.trim().toLowerCase();
+    if (v === "" || v === "status")
+        return "status";
+    if (v === "assignee" || v === "owner")
+        return "assignee";
+    if (v === "sprint")
+        return "sprint";
+    if (v === "type")
+        return "type";
+    throw new CommandError(`Unknown --group-by '${raw}'. Valid: status | assignee | sprint | type.`, EXIT_CODE.USAGE);
+}
+const SECTION_ALIASES = {
+    in_progress: "in_progress",
+    "in-progress": "in_progress",
+    wip: "in_progress",
+    progress: "in_progress",
+    blocked: "blocked",
+    done: "done",
+    closed: "done",
+    up_next: "up_next",
+    "up-next": "up_next",
+    upnext: "up_next",
+    next: "up_next",
+};
+/**
+ * Parse a `--sections` spec (comma/semicolon list) into an ordered, de-duped
+ * list of section keys. Empty spec → all sections in default order. An
+ * unknown token is a USAGE error rather than a silent drop.
+ */
+export function parseSections(spec) {
+    if (!spec || !spec.trim())
+        return [...ALL_SECTIONS];
+    const out = [];
+    for (const raw of spec.split(/[,;]/)) {
+        const token = raw.trim().toLowerCase();
+        if (!token)
+            continue;
+        const key = SECTION_ALIASES[token];
+        if (!key) {
+            throw new CommandError(`Unknown --sections value '${raw.trim()}'. Valid: in_progress | blocked | done | up_next.`, EXIT_CODE.USAGE);
+        }
+        if (!out.includes(key))
+            out.push(key);
+    }
+    return out.length > 0 ? out : [...ALL_SECTIONS];
+}
+/**
+ * Parse a `--section-labels` spec overriding section titles (and optionally
+ * an emoji). Accepts `key=Label,other=Label2` (comma/semicolon separated).
+ * The label value may itself lead with an emoji + space, e.g.
+ * `blocked=🔥 On Fire` sets emoji "🔥" and title "On Fire"; a label with no
+ * leading emoji keeps the section's default emoji and only changes the title.
+ * Keys use the same aliases as `--sections` (wip→in_progress, etc.).
+ * Unknown keys are a USAGE error rather than a silent drop.
+ */
+export function parseSectionLabels(spec) {
+    const out = {};
+    if (!spec || !spec.trim())
+        return out;
+    for (const pair of spec.split(/[,;]/)) {
+        const eq = pair.indexOf("=");
+        if (eq < 0)
+            continue;
+        const rawKey = pair.slice(0, eq).trim().toLowerCase();
+        const rawVal = pair.slice(eq + 1).trim();
+        if (!rawKey || !rawVal)
+            continue;
+        const key = SECTION_ALIASES[rawKey];
+        if (!key) {
+            throw new CommandError(`Unknown --section-labels key '${rawKey}'. Valid: in_progress | blocked | done | up_next.`, EXIT_CODE.USAGE);
+        }
+        // Split on the first space; treat the head as an emoji override only
+        // when it carries a non-ASCII codepoint (emoji/symbol). A plain ASCII
+        // word is part of the title, so the section keeps its default emoji.
+        const spaceIdx = rawVal.indexOf(" ");
+        const override = {};
+        if (spaceIdx > 0) {
+            const head = rawVal.slice(0, spaceIdx);
+            const tail = rawVal.slice(spaceIdx + 1).trim();
+            const headHasNonAscii = [...head].some((ch) => ch.codePointAt(0) > 127);
+            if (tail && headHasNonAscii) {
+                override.emoji = head;
+                override.title = tail;
+            }
+            else {
+                override.title = rawVal;
+            }
+        }
+        else {
+            override.title = rawVal;
+        }
+        out[key] = override;
+    }
+    return out;
+}
+/**
+ * Parse a `--channels` spec (comma/semicolon list) into an ordered, de-duped
+ * list of channel targets. Each target is either a Slack channel name
+ * (e.g. `#team-eng`) or a full webhook URL — multi-channel posting accepts
+ * both (a name is shown in the message; a URL is POSTed to). Empty → [].
+ */
+export function parseChannels(spec) {
+    if (!spec || !spec.trim())
+        return [];
+    const out = [];
+    for (const raw of spec.split(/[,;]/)) {
+        const token = raw.trim();
+        if (token && !out.includes(token))
+            out.push(token);
+    }
+    return out;
+}
+/** True when a channel token is a full webhook URL rather than a name. */
+export function isWebhookUrl(token) {
+    return /^https?:\/\//i.test(token.trim());
+}
+/**
+ * Resolve the "recently closed" window start (ms epoch) from `--since` and/or
+ * `--days`. `--since` is an explicit ISO date/time; `--days <n>` is N days
+ * before now. If both are given the *later* (more restrictive) bound wins.
+ * Returns NaN when neither is set (no windowing). Invalid input → USAGE error.
+ */
+export function resolveSinceMs(since, days, now = Date.now()) {
+    let bound = NaN;
+    if (since != null) {
+        const ms = Date.parse(since);
+        if (isNaN(ms)) {
+            throw new CommandError(`Invalid --since value '${since}' (expected an ISO date/time).`, EXIT_CODE.USAGE);
+        }
+        bound = ms;
+    }
+    if (days != null) {
+        if (!Number.isFinite(days) || days < 0) {
+            throw new CommandError(`Invalid --days value '${days}' (expected a non-negative number).`, EXIT_CODE.USAGE);
+        }
+        const daysBound = now - days * 86_400_000;
+        bound = isNaN(bound) ? daysBound : Math.max(bound, daysBound);
+    }
+    return bound;
+}
+export function parseDays(raw) {
+    if (raw == null || raw.trim() === "")
+        return undefined;
+    const n = Number(raw.trim());
+    if (!Number.isFinite(n)) {
+        throw new CommandError(`Invalid --days value '${raw}' (expected a number).`, EXIT_CODE.USAGE);
+    }
+    return n;
+}
 // ---------------------------------------------------------------------------
 // Data fetch
 // ---------------------------------------------------------------------------
@@ -92,7 +268,7 @@ function parseMentionMap(spec) {
  * status locally. This is a single pm invocation (vs. four list-by-status
  * calls) and gives us bodies + assignee + timestamps for grouping/windowing.
  */
-function fetchAllItems(pmRoot) {
+export function fetchAllItems(pmRoot) {
     const result = spawnSync("pm", ["--path", pmRoot, "list-all", "--json", "--include-body"], { encoding: "utf-8" });
     if (result.error || result.status !== 0) {
         console.error(`pm list-all failed: ${result.stderr ?? result.error?.message ?? ""}`);
@@ -113,29 +289,152 @@ const DONE_STATUSES = new Set(["closed", "done", "complete", "completed"]);
 function statusOf(item) {
     return (item.status ?? "").trim().toLowerCase();
 }
+/**
+ * True when an item's last activity falls within the [sinceMs, now] window.
+ * NaN sinceMs means "no window" → always true.
+ */
+export function withinWindow(item, sinceMs) {
+    if (isNaN(sinceMs))
+        return true;
+    const ts = Date.parse(item.updated_at ?? item.created_at ?? "");
+    return isNaN(ts) ? false : ts >= sinceMs;
+}
+/**
+ * True when an item carries a `blocked_by` dependency, regardless of its
+ * status. pm surfaces this either as a top-level `blocked_by` string (item ID
+ * or free-text reason) or as one/more `dependencies` entries with
+ * `kind: "blocked_by"`. Used to surface impediments that are NOT explicitly
+ * status=blocked under the Blocked section.
+ */
+export function hasBlockedByDep(item) {
+    const top = item.blocked_by;
+    if (typeof top === "string" && top.trim().length > 0)
+        return true;
+    const deps = item.dependencies;
+    if (Array.isArray(deps)) {
+        for (const d of deps) {
+            if (d && typeof d.kind === "string" && d.kind.trim().toLowerCase() === "blocked_by") {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Local-day key (YYYY-MM-DD in the host's local timezone) for an item's last
+ * activity. Used by the `--yesterday` split. Falls back to created_at, then
+ * to the empty string when no timestamp is parseable.
+ */
+export function localDayKey(item) {
+    const ts = Date.parse(item.updated_at ?? item.created_at ?? "");
+    if (isNaN(ts))
+        return "";
+    const d = new Date(ts);
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}`;
+}
+/** Local-day key (YYYY-MM-DD) for a given epoch-ms instant. */
+export function localDayKeyOf(ms) {
+    const d = new Date(ms);
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}`;
+}
 /**
  * Bucket items into standup sections.
- * `since` (ISO date/time) filters the Done section to items updated within the
- * window; WIP/blocked/up-next always reflect current state.
+ * `sinceMs` (epoch ms, NaN = no window) filters the Done section to items
+ * updated within the window; WIP/blocked/up-next always reflect current state.
  */
-function buildStandupData(items, opts) {
-    const sinceMs = opts.since ? Date.parse(opts.since) : NaN;
-    const withinWindow = (item) => {
-        if (isNaN(sinceMs))
-            return true;
-        const ts = Date.parse(item.updated_at ?? item.created_at ?? "");
-        return isNaN(ts) ? false : ts >= sinceMs;
-    };
-    const wip = items.filter((i) => WIP_STATUSES.has(statusOf(i)));
-    const blocked = items.filter((i) => BLOCKED_STATUSES.has(statusOf(i)));
-    const open = items.filter((i) => OPEN_STATUSES.has(statusOf(i)));
+export function buildStandupData(items, opts, sinceMs = NaN, now = Date.now()) {
+    const isDone = (i) => DONE_STATUSES.has(statusOf(i));
+    // An item is "blocked" for standup purposes when its status is blocked/
+    // on_hold OR it carries a blocked_by dependency — but a done item is never
+    // re-surfaced as blocked (a closed impediment is no longer an impediment).
+    const isBlocked = (i) => !isDone(i) && (BLOCKED_STATUSES.has(statusOf(i)) || hasBlockedByDep(i));
+    const wip = items.filter((i) => WIP_STATUSES.has(statusOf(i)) && !isBlocked(i));
+    const blocked = items.filter(isBlocked);
+    const open = items.filter((i) => OPEN_STATUSES.has(statusOf(i)) && !isBlocked(i));
     const done = opts.includeDone
-        ? items.filter((i) => DONE_STATUSES.has(statusOf(i)) && withinWindow(i))
+        ? items.filter((i) => isDone(i) && withinWindow(i, sinceMs))
         : [];
     const upNext = [...open]
         .sort((a, b) => (a.priority ?? 9999) - (b.priority ?? 9999))
         .slice(0, 3);
-    return { wip, blocked, done, upNext, total: items.length };
+    const data = { wip, blocked, done, upNext, total: items.length };
+    if (opts.splitYesterday && done.length > 0) {
+        const todayKey = localDayKeyOf(now);
+        const yesterdayKey = localDayKeyOf(now - 86_400_000);
+        data.doneToday = done.filter((i) => localDayKey(i) === todayKey);
+        data.doneYesterday = done.filter((i) => localDayKey(i) === yesterdayKey);
+    }
+    return data;
+}
+const SECTION_META = {
+    in_progress: { emoji: "🏃", title: "In Progress", emptyNote: "nothing in progress", withPriority: false },
+    blocked: { emoji: "🚫", title: "Blocked", emptyNote: "nothing blocked", withPriority: false },
+    done: { emoji: "✅", title: "Done", emptyNote: null, withPriority: false },
+    up_next: { emoji: "📋", title: "Up Next", emptyNote: null, withPriority: true },
+};
+/**
+ * Apply any `--section-labels` override for `key` to the given emoji/title.
+ */
+function labeled(key, emoji, title, opts) {
+    const ov = opts.sectionLabels[key];
+    if (!ov)
+        return { emoji, title };
+    return { emoji: ov.emoji ?? emoji, title: ov.title ?? title };
+}
+/**
+ * Resolve the ordered, selected section definitions for the given data.
+ * `in_progress` and `blocked` always render (even empty, with their note);
+ * `done` and `up_next` only render when they hold items — preserving the
+ * historical message shape. `--sections` filters which keys are eligible.
+ *
+ * When `--yesterday` is active and Done has items, the single Done section is
+ * expanded into "Done Yesterday" + "Done Today" (only the non-empty subsets
+ * render), preserving the section's position in the ordering.
+ */
+export function resolveSections(data, opts) {
+    const itemsFor = {
+        in_progress: data.wip,
+        blocked: data.blocked,
+        done: data.done,
+        up_next: data.upNext,
+    };
+    const alwaysShow = {
+        in_progress: true,
+        blocked: true,
+        done: false,
+        up_next: false,
+    };
+    const out = [];
+    for (const key of opts.sections) {
+        const items = itemsFor[key];
+        const meta = SECTION_META[key];
+        if (key === "done" && opts.splitYesterday && data.doneYesterday && data.doneToday) {
+            const subsets = [
+                ["Done Yesterday", data.doneYesterday],
+                ["Done Today", data.doneToday],
+            ];
+            // The day distinction owns the title here, so a --section-labels
+            // override for `done` contributes only its emoji (not its title).
+            const doneEmoji = opts.sectionLabels.done?.emoji ?? meta.emoji;
+            for (const [subTitle, subItems] of subsets) {
+                if (subItems.length === 0)
+                    continue;
+                out.push({ key, emoji: doneEmoji, title: subTitle, items: subItems, emptyNote: meta.emptyNote, withPriority: meta.withPriority });
+            }
+            continue;
+        }
+        if (!alwaysShow[key] && items.length === 0)
+            continue;
+        const { emoji, title } = labeled(key, meta.emoji, meta.title, opts);
+        out.push({ key, emoji, title, items, emptyNote: meta.emptyNote, withPriority: meta.withPriority });
+    }
+    return out;
 }
 // ---------------------------------------------------------------------------
 // Rendering helpers
@@ -147,12 +446,12 @@ function typeLabel(item) {
     return `[${label}]`;
 }
 function mentionFor(item, mentionMap) {
-    const author = item.assignee;
+    const author = item.assignee ?? item.author;
     if (author && mentionMap[author])
         return ` (${mentionMap[author]})`;
     return "";
 }
-function itemText(item, mentionMap, withPriority = false) {
+export function itemText(item, mentionMap, withPriority = false) {
     const label = typeLabel(item);
     const title = label ? `${label} ${item.title}` : item.title;
     const prio = withPriority && item.priority != null ? ` (priority ${item.priority})` : "";
@@ -162,68 +461,122 @@ function todayISO() {
     return new Date().toISOString().slice(0, 10);
 }
 /**
- * Group a list of items by assignee. Items with no assignee bucket under
- * "_unassigned". Returns entries sorted by assignee name for stable output.
+ * Group a list of items by the configured field (assignee, sprint or type).
+ * Items missing the field bucket under a synthetic "_none" key (rendered as a
+ * friendly label). Returns entries sorted by group key for stable output.
  */
-function groupByAssignee(items) {
+export function groupItems(items, groupBy) {
     const groups = new Map();
     for (const item of items) {
-        const key = item.assignee ?? "_unassigned";
-        (groups.get(key) ?? groups.set(key, []).get(key)).push(item);
+        let key;
+        if (groupBy === "assignee")
+            key = item.assignee ?? "_none";
+        else if (groupBy === "sprint")
+            key = item.sprint ?? "_none";
+        else if (groupBy === "type")
+            key = item.type ?? "_none";
+        else
+            key = "_none";
+        const bucket = groups.get(key);
+        if (bucket)
+            bucket.push(item);
+        else
+            groups.set(key, [item]);
     }
     return [...groups.entries()].sort((a, b) => a[0].localeCompare(b[0]));
 }
+function groupLabel(key, groupBy) {
+    if (key !== "_none")
+        return key;
+    if (groupBy === "assignee")
+        return "Unassigned";
+    if (groupBy === "sprint")
+        return "No sprint";
+    if (groupBy === "type")
+        return "Untyped";
+    return key;
+}
+const isGrouped = (opts) => opts.groupBy !== "status";
 // ---------------------------------------------------------------------------
-// Plain-text / mrkdwn message (fallback + dry-run preview)
+// Plain-text / mrkdwn / markdown message (fallback + dry-run preview)
 // ---------------------------------------------------------------------------
-function renderSection(lines, emoji, title, items, emptyNote, opts, withPriority = false) {
-    const heading = opts.format === "slack" ? `${emoji} *${title}* (${items.length})` : `${emoji} ${title} (${items.length})`;
-    lines.push(heading);
-    if (items.length === 0) {
-        if (emptyNote)
-            lines.push(opts.format === "slack" ? `• _${emptyNote}_` : `• ${emptyNote}`);
+function bold(text, format) {
+    if (format === "slack")
+        return `*${text}*`;
+    if (format === "markdown")
+        return `**${text}**`;
+    return text;
+}
+function italic(text, format) {
+    if (format === "slack")
+        return `_${text}_`;
+    if (format === "markdown")
+        return `_${text}_`;
+    return text;
+}
+function renderSection(lines, def, opts) {
+    const count = `(${def.items.length})`;
+    if (opts.format === "markdown") {
+        lines.push(`## ${def.emoji} ${def.title} ${count}`);
+    }
+    else {
+        lines.push(`${def.emoji} ${bold(def.title, opts.format)} ${count}`);
+    }
+    if (def.items.length === 0) {
+        if (def.emptyNote) {
+            const bullet = opts.format === "markdown" ? "- " : "• ";
+            lines.push(`${bullet}${italic(def.emptyNote, opts.format)}`);
+        }
         return;
     }
-    if (opts.groupBy === "assignee") {
-        for (const [assignee, group] of groupByAssignee(items)) {
-            const name = assignee === "_unassigned" ? "Unassigned" : assignee;
-            lines.push(opts.format === "slack" ? `  *${name}*` : `  ${name}`);
-            for (const item of group)
-                lines.push(`    • ${itemText(item, opts.mentionMap, withPriority)}`);
+    if (isGrouped(opts)) {
+        for (const [key, group] of groupItems(def.items, opts.groupBy)) {
+            const name = groupLabel(key, opts.groupBy);
+            if (opts.format === "markdown")
+                lines.push(`- ${bold(name, opts.format)}`);
+            else
+                lines.push(`  ${bold(name, opts.format)}`);
+            for (const item of group) {
+                const bullet = opts.format === "markdown" ? "  - " : "    • ";
+                lines.push(`${bullet}${itemText(item, opts.mentionMap, def.withPriority)}`);
+            }
         }
     }
     else {
-        for (const item of items)
-            lines.push(`• ${itemText(item, opts.mentionMap, withPriority)}`);
+        const bullet = opts.format === "markdown" ? "- " : "• ";
+        for (const item of def.items)
+            lines.push(`${bullet}${itemText(item, opts.mentionMap, def.withPriority)}`);
     }
 }
-function buildTextMessage(data, opts) {
+/**
+ * Render the standup as a single text blob for the chosen non-Block-Kit
+ * format. `slack` is byte-identical to the historical output (mrkdwn);
+ * `plain` drops emphasis punctuation; `markdown` uses `#`/`**`/`-`.
+ */
+export function buildTextMessage(data, opts) {
     const lines = [];
     const dateStr = todayISO();
-    if (opts.channel)
-        lines.push(`> Channel: ${opts.channel}`);
-    lines.push(opts.format === "slack" ? `📊 *pm standup* — ${dateStr}` : `📊 pm standup — ${dateStr}`);
-    lines.push("");
-    renderSection(lines, "🏃", "In Progress", data.wip, "nothing in progress", opts);
-    lines.push("");
-    renderSection(lines, "🚫", "Blocked", data.blocked, "nothing blocked", opts);
-    if (data.done.length > 0) {
-        lines.push("");
-        renderSection(lines, "✅", "Done", data.done, null, opts);
-    }
-    if (data.upNext.length > 0) {
-        lines.push("");
-        renderSection(lines, "📋", "Up Next", data.upNext, null, opts, true);
+    if (opts.channel) {
+        lines.push(opts.format === "markdown" ? `> Channel: ${opts.channel}` : `> Channel: ${opts.channel}`);
     }
+    const title = `📊 ${bold("pm standup", opts.format)} — ${dateStr}`;
+    lines.push(opts.format === "markdown" ? `# 📊 pm standup — ${dateStr}` : title);
+    lines.push("");
+    const sections = resolveSections(data, opts);
+    sections.forEach((def, idx) => {
+        if (idx > 0)
+            lines.push("");
+        renderSection(lines, def, opts);
+    });
     return lines.join("\n");
 }
 function mrkdwnList(items, opts, withPriority = false) {
     if (items.length === 0)
         return "_none_";
-    if (opts.groupBy === "assignee") {
+    if (isGrouped(opts)) {
         const parts = [];
-        for (const [assignee, group] of groupByAssignee(items)) {
-            const name = assignee === "_unassigned" ? "Unassigned" : assignee;
+        for (const [key, group] of groupItems(items, opts.groupBy)) {
+            const name = groupLabel(key, opts.groupBy);
             parts.push(`*${name}*`);
             for (const item of group)
                 parts.push(`• ${itemText(item, opts.mentionMap, withPriority)}`);
@@ -233,17 +586,23 @@ function mrkdwnList(items, opts, withPriority = false) {
     return items.map((item) => `• ${itemText(item, opts.mentionMap, withPriority)}`).join("\n");
 }
 /**
- * Build a Slack Block Kit `blocks` array: a header, a section per standup
- * bucket (In Progress / Blocked / Up Next / optional Done) and a context
- * footer. Returns the blocks plus a plain-text `fallback` Slack renders in
- * notifications and old clients.
+ * Build a Slack Block Kit `blocks` array: a header, a section per selected
+ * standup bucket and a context footer. Returns the blocks plus a plain-text
+ * `fallback` Slack renders in notifications and old clients.
+ *
+ * Block Kit schema choices: a single `header` block (plain_text, capped at
+ * Slack's 150-char limit), one `section`/`mrkdwn` block per bucket (Slack
+ * caps section text at 3000 chars — long buckets are truncated with an
+ * ellipsis to stay valid), a `divider`, then a `context` footer summarizing
+ * counts / window / grouping.
  */
-function buildBlockKit(data, opts) {
+export function buildBlockKit(data, opts) {
     const blocks = [];
     const dateStr = todayISO();
+    const truncate = (text, max) => text.length <= max ? text : text.slice(0, max - 1) + "…";
     blocks.push({
         type: "header",
-        text: { type: "plain_text", text: `📊 pm standup — ${dateStr}`, emoji: true },
+        text: { type: "plain_text", text: truncate(`📊 pm standup — ${dateStr}`, 150), emoji: true },
     });
     if (opts.channel) {
         blocks.push({
@@ -251,39 +610,52 @@ function buildBlockKit(data, opts) {
             elements: [{ type: "mrkdwn", text: `Channel: ${opts.channel}` }],
         });
     }
-    const section = (emoji, title, items, withPriority = false) => {
+    for (const def of resolveSections(data, opts)) {
         blocks.push({
             type: "section",
             text: {
                 type: "mrkdwn",
-                text: `${emoji} *${title}* (${items.length})\n${mrkdwnList(items, opts, withPriority)}`,
+                text: truncate(`${def.emoji} *${def.title}* (${def.items.length})\n${mrkdwnList(def.items, opts, def.withPriority)}`, 3000),
             },
         });
-    };
-    section("🏃", "In Progress", data.wip);
-    section("🚫", "Blocked", data.blocked);
-    section("📋", "Up Next", data.upNext, true);
-    if (data.done.length > 0)
-        section("✅", "Done", data.done);
+    }
     blocks.push({ type: "divider" });
+    const groupNote = {
+        status: null,
+        assignee: "grouped by assignee",
+        sprint: "grouped by sprint",
+        type: "grouped by type",
+    };
     const footerBits = [
         `${data.total} item(s) total`,
         opts.since ? `since ${opts.since}` : null,
-        opts.groupBy === "assignee" ? "grouped by assignee" : null,
+        groupNote[opts.groupBy],
     ].filter(Boolean);
     blocks.push({
         type: "context",
         elements: [{ type: "mrkdwn", text: `🤖 pm-slack-standup · ${footerBits.join(" · ")}` }],
     });
-    // Plain-text fallback mirrors the text message (slack mrkdwn variant).
+    // Plain-text fallback mirrors the slack-mrkdwn text message.
     const fallback = buildTextMessage(data, { ...opts, format: "slack" });
     return { blocks, fallback };
 }
+/**
+ * Render the standup in whichever `--format` was selected, as the string the
+ * command prints (dry-run) or the exporter writes. `blockkit` returns the
+ * pretty-printed `{ blocks }` JSON; everything else returns text.
+ */
+export function renderStandup(data, opts) {
+    if (opts.format === "blockkit") {
+        const { blocks } = buildBlockKit(data, opts);
+        return JSON.stringify({ blocks }, null, 2);
+    }
+    return buildTextMessage(data, opts);
+}
 // ---------------------------------------------------------------------------
 // Slack transport
 // ---------------------------------------------------------------------------
 function postToSlack(webhookUrl, payload) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolvePromise, reject) => {
         const body = JSON.stringify(payload);
         const url = new URL(webhookUrl);
         const options = {
@@ -300,7 +672,7 @@ function postToSlack(webhookUrl, payload) {
             res.on("data", (chunk) => (respBody += chunk.toString()));
             res.on("end", () => {
                 if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-                    resolve();
+                    resolvePromise();
                 }
                 else {
                     reject(new Error(`Slack webhook returned HTTP ${res.statusCode ?? "unknown"}: ${respBody}`));
@@ -313,27 +685,92 @@ function postToSlack(webhookUrl, payload) {
         req.end();
     });
 }
+/**
+ * Resolve the ordered list of post targets from `--webhook`/env + `--channel`
+ * + `--channels`. Each `--channels` token is either a `#name` (posted to the
+ * base webhook, just changing the displayed channel) or a full webhook URL
+ * (posted to that URL). When no `--channels` is given, a single target using
+ * the base webhook + `--channel` is returned. De-dupes (webhook,channel) pairs.
+ */
+export function resolvePostTargets(baseWebhook, baseChannel, channels) {
+    if (channels.length === 0) {
+        return [{ webhookUrl: baseWebhook, channel: baseChannel }];
+    }
+    const out = [];
+    const seen = new Set();
+    for (const token of channels) {
+        const target = isWebhookUrl(token)
+            ? { webhookUrl: token, channel: baseChannel }
+            : { webhookUrl: baseWebhook, channel: token };
+        const dedupeKey = `${target.webhookUrl}${target.channel ?? ""}`;
+        if (seen.has(dedupeKey))
+            continue;
+        seen.add(dedupeKey);
+        out.push(target);
+    }
+    return out;
+}
+/**
+ * Post the standup to every resolved target, re-rendering per target so each
+ * channel's message shows its own channel name. Returns a per-target result;
+ * never throws — the caller decides how to treat failures (e.g. fallback to
+ * stdout). The `poster` is injectable so this is testable without a network.
+ */
+export async function postStandupTargets(targets, data, baseOpts, poster) {
+    const results = [];
+    for (const target of targets) {
+        const opts = { ...baseOpts, channel: target.channel };
+        const { blocks, fallback } = buildBlockKit(data, opts);
+        try {
+            await poster(target.webhookUrl, { text: fallback, blocks, mrkdwn: true });
+            results.push({ channel: target.channel, ok: true });
+        }
+        catch (err) {
+            results.push({
+                channel: target.channel,
+                ok: false,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return results;
+}
 // ---------------------------------------------------------------------------
 // Shared option resolution
 // ---------------------------------------------------------------------------
-function resolveStandupOptions(options) {
-    const rawFormat = readStrOption(options, "format");
-    const rawGroup = readStrOption(options, "group-by");
-    return {
+/**
+ * Resolve every standup option except the render `format`, which differs
+ * between the command (slack|blockkit|markdown|plain) and the exporter
+ * (md|json file format). Callers supply the format they want.
+ */
+export function resolveStandupOptions(options, format) {
+    const since = readStrOption(options, "since");
+    const days = parseDays(readStrOption(options, "days"));
+    const splitYesterday = readBoolOption(options, "yesterday");
+    const opts = {
         channel: readStrOption(options, "channel"),
-        format: rawFormat === "text" ? "text" : "slack",
-        includeDone: readBoolOption(options, "include-done"),
-        since: readStrOption(options, "since"),
-        groupBy: rawGroup === "assignee" ? "assignee" : "status",
+        format,
+        // `--yesterday` is meaningless without a Done section, so it implies
+        // `--include-done` (additive: passing only `--include-done` is unchanged).
+        includeDone: readBoolOption(options, "include-done") || splitYesterday,
+        since,
+        groupBy: parseGroupBy(readStrOption(options, "group-by")),
+        sections: parseSections(readStrOption(options, "sections")),
         mentionMap: parseMentionMap(readStrOption(options, "mention-map")),
+        splitYesterday,
+        sectionLabels: parseSectionLabels(readStrOption(options, "section-labels")),
     };
+    // `--days` implies windowing the Done section; surface it even without
+    // `--include-done` being set so the footer/window stays accurate.
+    const sinceMs = resolveSinceMs(since, days);
+    return { opts, sinceMs };
 }
 // ---------------------------------------------------------------------------
 // Extension
 // ---------------------------------------------------------------------------
 export default defineExtension({
     name: "pm-slack-standup",
-    version: "2026.6.2",
+    version: "2026.6.4",
     activate(api) {
         api.registerCommand({
             name: "standup",
@@ -342,43 +779,48 @@ export default defineExtension({
             examples: [
                 "pm standup --webhook https://hooks.slack.com/services/...",
                 "pm standup --channel '#team-eng' --dry-run",
-                "pm standup --include-done --since 2026-06-01",
+                "pm standup --dry-run --format blockkit",
+                "pm standup --dry-run --format markdown --include-done --days 7",
                 "pm standup --group-by assignee --mention-map 'alice=@alice.s,bob=@bob'",
+                "pm standup --group-by sprint --sections in_progress,blocked",
+                "pm standup --dry-run --yesterday --format plain",
+                "pm standup --channels '#team-eng,#standups' --dry-run",
+                "pm standup --section-labels 'in_progress=Rolling,blocked=🔥 On Fire' --dry-run",
                 "PM_SLACK_WEBHOOK=https://... pm standup --channel '#standups'",
             ],
             flags: [
                 { long: "--webhook", value_name: "url", description: "Slack incoming webhook URL (overrides PM_SLACK_WEBHOOK env var)" },
                 { long: "--channel", value_name: "name", description: "Channel name shown in the message (e.g. #team-eng)" },
-                { long: "--dry-run", description: "Print the message without posting to Slack" },
+                { long: "--dry-run", description: "Build and print the message in the chosen format WITHOUT posting to Slack" },
+                { long: "--format", value_name: "fmt", description: "Output format: slack (mrkdwn, default) | blockkit (JSON) | markdown | plain" },
                 { long: "--include-done", description: "Include recently-closed items in a Done section" },
-                { long: "--since", value_name: "iso", description: "ISO date/time window; filters the Done section to items updated since then" },
-                { long: "--group-by", value_name: "field", description: "Group section items by 'status' (default) or 'assignee'" },
+                { long: "--since", value_name: "iso", description: "ISO date/time window; scopes the Done section to items updated since then" },
+                { long: "--days", value_name: "n", description: "Relative window: scope Done to items updated in the last N days" },
+                { long: "--group-by", value_name: "field", description: "Group section items by status (default) | assignee | sprint | type" },
+                { long: "--sections", value_name: "list", description: "Comma list of sections to render: in_progress,blocked,done,up_next" },
                 { long: "--mention-map", value_name: "map", description: "Map pm authors to Slack handles, e.g. 'alice=@alice,bob=@bob'" },
-                { long: "--format", value_name: "fmt", description: "Plain-text rendering: 'slack' uses mrkdwn, 'text' is plain (default: slack)" },
+                { long: "--yesterday", description: "Split the Done section into 'Done Yesterday' / 'Done Today' by local day (implies --include-done)" },
+                { long: "--channels", value_name: "list", description: "Post the same standup to multiple targets: comma list of #channel names and/or webhook URLs" },
+                { long: "--fallback-to-stdout", description: "If the Slack post fails, print the rendered standup to stdout instead of exiting non-zero" },
+                { long: "--section-labels", value_name: "map", description: "Override section titles/emoji, e.g. 'in_progress=Rolling,blocked=🔥 On Fire'" },
             ],
             async run(ctx) {
                 const webhookUrl = readStrOption(ctx.options, "webhook") ?? process.env["PM_SLACK_WEBHOOK"] ?? "";
                 const dryRun = readBoolOption(ctx.options, "dry-run");
-                const opts = resolveStandupOptions(ctx.options);
-                if (!dryRun && !webhookUrl) {
-                    // Graceful no-op when no webhook is configured: warn and exit 0 so the
-                    // command never blocks a workflow on a missing/unset webhook.
-                    console.error("PM_SLACK_WEBHOOK not set and no --webhook provided — Slack posting disabled. " +
-                        "Use --dry-run to preview the message.");
-                    return { posted: false, disabled: true, reason: "no-webhook" };
-                }
+                const { opts, sinceMs } = resolveStandupOptions(ctx.options, parseFormat(readStrOption(ctx.options, "format")));
                 const items = fetchAllItems(ctx.pm_root);
-                const data = buildStandupData(items, opts);
-                const { blocks, fallback } = buildBlockKit(data, opts);
-                const textPreview = opts.format === "text" ? buildTextMessage(data, opts) : fallback;
+                const data = buildStandupData(items, opts, sinceMs);
                 if (dryRun) {
-                    console.error("--- DRY RUN (message not posted) ---");
-                    process.stdout.write(textPreview + "\n");
-                    console.error("--- Block Kit payload ---");
-                    process.stdout.write(JSON.stringify({ blocks }, null, 2) + "\n");
+                    // No network call happens on this path.
+                    const rendered = renderStandup(data, opts);
+                    console.error(`--- DRY RUN (${opts.format}, message not posted) ---`);
+                    process.stdout.write(rendered + "\n");
                     console.error("--- END ---");
+                    const { blocks, fallback } = buildBlockKit(data, opts);
                     return {
                         dryRun: true,
+                        format: opts.format,
+                        rendered,
                         blocks,
                         fallback,
                         wip: data.wip.length,
@@ -387,17 +829,46 @@ export default defineExtension({
                         upNext: data.upNext.length,
                     };
                 }
-                try {
-                    await postToSlack(webhookUrl, { text: fallback, blocks, mrkdwn: true });
+                const channels = parseChannels(readStrOption(ctx.options, "channels"));
+                const fallbackToStdout = readBoolOption(ctx.options, "fallback-to-stdout");
+                // Real post path: a missing webhook is a hard, structured error (exit 1)
+                // rather than a crash or silent success. `--channels` entries that are
+                // bare #names still need a base webhook to post to. Use --dry-run to
+                // preview, or --fallback-to-stdout to print instead of erroring.
+                const needsBaseWebhook = channels.length === 0 || channels.some((c) => !isWebhookUrl(c));
+                if (!webhookUrl && needsBaseWebhook) {
+                    throw new CommandError("No Slack webhook configured. Set PM_SLACK_WEBHOOK or pass --webhook <url>, " +
+                        "or use --dry-run to preview the message without posting.", EXIT_CODE.GENERIC_FAILURE);
                 }
-                catch (err) {
-                    // Never throw on network failure: warn and exit 0 so a flaky Slack
-                    // endpoint doesn't break the caller's workflow.
-                    console.error(`Slack post failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
-                    return { posted: false, error: err instanceof Error ? err.message : String(err) };
+                const targets = resolvePostTargets(webhookUrl, opts.channel, channels);
+                const results = await postStandupTargets(targets, data, opts, postToSlack);
+                const failures = results.filter((r) => !r.ok);
+                if (failures.length > 0 && fallbackToStdout) {
+                    // Print the rendered standup so the work isn't lost on a transport
+                    // failure. We exit 0 here: stdout delivery is the requested fallback.
+                    for (const f of failures) {
+                        console.error(`Slack post to ${f.channel ?? "(default channel)"} failed: ${f.error ?? "unknown error"} — falling back to stdout.`);
+                    }
+                    const rendered = renderStandup(data, opts);
+                    process.stdout.write(rendered + "\n");
+                    return {
+                        posted: results.some((r) => r.ok),
+                        fallbackToStdout: true,
+                        results,
+                        wip: data.wip.length,
+                        blocked: data.blocked.length,
+                        done: data.done.length,
+                        upNext: data.upNext.length,
+                    };
+                }
+                if (failures.length > 0) {
+                    throw new CommandError(`Slack post failed for ${failures.length} of ${targets.length} target(s): ` +
+                        failures.map((f) => `${f.channel ?? "(default)"}: ${f.error ?? "unknown"}`).join("; "), EXIT_CODE.GENERIC_FAILURE);
                 }
                 return {
                     posted: true,
+                    channel: opts.channel,
+                    channels: targets.length > 1 ? targets.map((t) => t.channel) : undefined,
                     wip: data.wip.length,
                     blocked: data.blocked.length,
                     done: data.done.length,
@@ -412,14 +883,16 @@ export default defineExtension({
         // (No collision with the `pm standup` command — different invocation.)
         // -----------------------------------------------------------------------
         api.registerExporter("standup", async (ctx) => {
-            const opts = resolveStandupOptions(ctx.options);
             const rawFormat = (readStrOption(ctx.options, "format") ?? "md").toLowerCase();
-            // For the exporter, --format selects the file format (md|json); the
-            // mrkdwn-vs-plain text choice is irrelevant here so default text to plain.
+            // For the exporter, --format selects the file format (md|json); the text
+            // rendering is always markdown. We resolve options with markdown rather
+            // than routing the exporter's md|json through the command's --format
+            // validator (which only knows slack|blockkit|markdown|plain).
             const fileFormat = rawFormat === "json" ? "json" : "md";
-            const exportOpts = { ...opts, format: "text" };
+            const { opts, sinceMs } = resolveStandupOptions(ctx.options, "markdown");
+            const exportOpts = opts;
             const items = fetchAllItems(ctx.pm_root);
-            const data = buildStandupData(items, exportOpts);
+            const data = buildStandupData(items, exportOpts, sinceMs);
             let output;
             if (fileFormat === "json") {
                 const { blocks, fallback } = buildBlockKit(data, opts);
@@ -428,6 +901,7 @@ export default defineExtension({
                     channel: opts.channel,
                     since: opts.since,
                     groupBy: opts.groupBy,
+                    sections: opts.sections,
                     counts: {
                         wip: data.wip.length,
                         blocked: data.blocked.length,
@@ -435,7 +909,7 @@ export default defineExtension({
                         upNext: data.upNext.length,
                         total: data.total,
                     },
-                    sections: {
+                    sections_data: {
                         in_progress: data.wip,
                         blocked: data.blocked,
                         up_next: data.upNext,
@@ -445,11 +919,7 @@ export default defineExtension({
                 }, null, 2);
             }
             else {
-                // Markdown: reuse the plain-text renderer, upgrade headings to `##`.
-                const md = buildTextMessage(data, exportOpts)
-                    .replace(/^📊 pm standup — (.+)$/m, "# pm standup — $1")
-                    .replace(/^(🏃|🚫|✅|📋) (.+)$/gm, "## $1 $2");
-                output = md;
+                output = buildTextMessage(data, exportOpts);
             }
             const outputPath = readStrOption(ctx.options, "output");
             if (outputPath) {