Thread-only and non-threadable channels refuse your post

"""Match an integration's Slack posting mode against how a channel is actually used.

Read only. One conversations.history per channel reads the threading convention,
one conversations.replies per stored anchor checks that it still anchors
something. Nothing is sent: the script names the error the current mode would
produce and prints the configuration line that stops producing it.
"""
import argparse
import logging
import os
import sys

import requests

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("slack_thread_mode_match")

API = "https://slack.com/api/"

# System traffic. Nobody chose to post it and it says nothing about how the
# channel is used, so it is dropped before any shape is counted.
NOT_A_POST = frozenset({
    "channel_join", "channel_leave", "channel_topic", "channel_purpose",
    "channel_name", "channel_archive", "channel_unarchive", "pinned_item",
    "unpinned_item", "bot_add", "bot_remove", "reminder_add",
})

MODES = ("top-level", "reply", "parent-then-replies")

# Below this many readable posts nothing is claimed. A non-Marketplace app is
# clamped to 15 objects per conversations.history call, which is thin enough to
# make an ordinary channel look like either extreme.
MIN_SAMPLE = 8
THREAD_HEAVY = 0.8
MIN_PARENTS = 3


def threading_shape(messages):
    """Read a channel's threading convention out of its history. Pure.

    Returns (shape, stats). conversations.history returns top-level messages,
    each carrying reply_count for the thread hanging off it, so the three numbers
    worth having are the top-level count, how many of those were replied to, and
    how many replies exist in total.

    The shapes are named after behaviour rather than policy. Slack exposes no
    threading setting, so "thread-heavy" is the strongest honest claim: this is
    how the channel is used, which is what your message will be judged against.
    """
    posts = parents = replies = broadcasts = 0
    for message in messages or []:
        if message.get("subtype") in NOT_A_POST:
            continue
        posts += 1
        count = int(message.get("reply_count") or 0)
        if count:
            parents += 1
            replies += count
        if message.get("subtype") == "thread_broadcast":
            broadcasts += 1

    stats = {"sample": len(messages or []), "posts": posts, "parents": parents,
             "replies": replies, "broadcasts": broadcasts}
    if posts < MIN_SAMPLE:
        return ("undetermined", stats)

    share = replies / float(replies + posts) if (replies + posts) else 0.0
    if share >= THREAD_HEAVY and parents >= MIN_PARENTS:
        return ("thread-heavy", stats)
    if replies == 0:
        return ("never-threaded", stats)
    return ("mixed", stats)


def mode_mismatch(shape, mode):
    """Compare the channel's convention against the mode the integration uses. Pure.

    Returns (verdict, likely_error, detail). The error string is the useful half:
    it is what somebody already has in their logs, and naming it is what turns a
    shape into a recognisable finding.
    """
    if mode not in MODES:
        return ("unknown-mode", "",
                "%r is not one of %s. The mode is a fact about your code and "
                "nothing in the API will supply it." % (mode, ", ".join(MODES)))
    if shape == "undetermined":
        return ("undetermined", "",
                "too little readable history to describe how this channel is used. "
                "Re-run with a larger sample, or accept that this channel cannot be "
                "assessed from here.")

    if shape == "thread-heavy" and mode == "top-level":
        return ("likely-blocked", "restricted_action_thread_only_channel",
                "almost everything said here is said inside a thread, and this "
                "integration posts at the top level. Where the channel enforces "
                "that convention the post is refused; where it does not, the post "
                "lands somewhere nobody is reading.")
    if shape == "never-threaded" and mode in ("reply", "parent-then-replies"):
        return ("likely-blocked", "restricted_action_non_threadable_channel",
                "nothing in the readable history has ever been replied to, and "
                "this integration threads. Either the channel does not support "
                "threading or nobody uses it, and the first of those refuses the "
                "message outright.")
    if shape == "mixed":
        return ("compatible", "",
                "the channel is used both ways, so neither mode is refused by "
                "convention. Any failure here is a permission or an anchor rather "
                "than a position.")
    return ("compatible", "", "%s matches how this channel is used" % mode)


def anchor_state(body):
    """Whether a stored thread_ts still anchors a live parent. Pure.

    Nothing here is about channel policy. cannot_reply_to_message is usually a
    message-lifetime problem: parents get deleted, and they fall off the end of a
    workspace's retention window, after which a cached anchor refers to nothing.
    """
    if body.get("ok") is not True:
        error = body.get("error") or "<no error field>"
        if error == "thread_not_found":
            return ("missing-parent",
                    "conversations.replies says thread_not_found. The stored ts "
                    "anchors nothing: the parent was deleted or has aged past the "
                    "workspace retention window. A reply under it returns "
                    "cannot_reply_to_message.")
        if error in ("not_in_channel", "channel_not_found", "missing_scope"):
            return ("unreadable",
                    "conversations.replies says %s, which is a membership or scope "
                    "question rather than an answer about the thread." % error)
        return ("unreadable",
                "conversations.replies answered 200 with ok: false, error=%s" % error)

    messages = body.get("messages") or []
    if not messages:
        return ("missing-parent",
                "ok: true with an empty messages array. The thread is gone and "
                "Slack did not consider that an error.")

    parent = messages[0]
    if parent.get("subtype") == "tombstone":
        return ("deleted-parent",
                "the parent is a tombstone: it was deleted while its replies "
                "survived. Slack keeps the thread visible and refuses new replies "
                "to it.")
    count = int(parent.get("reply_count") or 0)
    if count == 0:
        return ("childless-parent",
                "the ts resolves to a message with no replies yet. That is a "
                "perfectly good anchor, and it is indistinguishable from a message "
                "nobody has threaded under.")
    return ("anchored", "the parent is there with %d repl(ies) under it" % count)


def get(session, method, params):
    """One read call. GET only, and the body is returned as Slack sent it."""
    return session.get(API + method, params=params, timeout=30).json()


def main():
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("--channel", required=True, action="append",
                    help="a channel ID the integration posts to; repeatable")
    ap.add_argument("--mode", required=True, choices=list(MODES),
                    help="how this integration posts today")
    ap.add_argument("--anchor", action="append", default=[],
                    help="a stored thread_ts to validate; repeatable")
    ap.add_argument("--sample", type=int, default=100,
                    help="how many messages of history to read per channel")
    ap.add_argument("--token-env", default="SLACK_BOT_TOKEN",
                    help="environment variable holding the bot token")
    args = ap.parse_args()

    token = os.environ.get(args.token_env)
    if not token:
        log.error("set %s (channels:read and channels:history are enough)",
                  args.token_env)
        return 2

    s = requests.Session()
    s.headers.update({"Authorization": "Bearer " + token})

    mismatches = dead = 0
    for cid in args.channel:
        history = get(s, "conversations.history",
                      {"channel": cid, "limit": args.sample})
        if history.get("ok") is not True:
            log.warning("%-12s history  unreadable, error=%s", cid,
                        history.get("error"))
            continue

        shape, stats = threading_shape(history.get("messages") or [])
        verdict, likely, detail = mode_mismatch(shape, args.mode)
        log.info("%-12s shape    %-15s %d top-level post(s), %d with replies, "
                 "%d replies", cid, shape, stats["posts"], stats["parents"],
                 stats["replies"])

        if verdict == "compatible":
            log.info("%-12s mode     %-15s %s", cid, verdict, detail)
        else:
            mismatches += 1
            log.warning("%-12s mode     %-15s %s", cid, verdict, detail)
            if likely:
                log.warning("  expect: %s on the next send", likely)
            log.warning("  repair: set the posting mode on this target rather than "
                        "globally, for example  %s: mode=%s", cid,
                        "reply" if args.mode == "top-level" else "top-level")

        for anchor in args.anchor:
            replies = get(s, "conversations.replies",
                          {"channel": cid, "ts": anchor, "limit": 1})
            state, why = anchor_state(replies)
            if state == "anchored" or state == "childless-parent":
                log.info("%-12s anchor   %-15s %s", cid, state, why)
                continue
            dead += 1
            log.warning("%-12s anchor   %-15s %s", cid, state, why)
            log.warning("  repair: expire stored thread anchors well inside the "
                        "workspace retention window and fall back to a fresh "
                        "parent when the anchor is gone")

    log.info("%d channel(s) checked, %d mismatch(es), %d dead anchor(s)",
             len(args.channel), mismatches, dead)
    return 1 if (mismatches or dead) else 0


if __name__ == "__main__":
    sys.exit(main())

/**
 * Match an integration's Slack posting mode against how a channel is used.
 *
 * Read only. One conversations.history per channel reads the threading
 * convention, one conversations.replies per stored anchor checks that it still
 * anchors something. Nothing is sent: the script names the error the current
 * mode would produce and prints the configuration line that stops it.
 */

const API = 'https://slack.com/api/';

// System traffic. Nobody chose to post it and it says nothing about how the
// channel is used, so it is dropped before any shape is counted.
const NOT_A_POST = new Set([
  'channel_join', 'channel_leave', 'channel_topic', 'channel_purpose',
  'channel_name', 'channel_archive', 'channel_unarchive', 'pinned_item',
  'unpinned_item', 'bot_add', 'bot_remove', 'reminder_add',
]);

export const MODES = ['top-level', 'reply', 'parent-then-replies'];

const MIN_SAMPLE = 8;
const THREAD_HEAVY = 0.8;
const MIN_PARENTS = 3;

/**
 * Read a channel's threading convention out of its history. Pure.
 * The shapes are named after behaviour rather than policy: Slack exposes no
 * threading setting, so `thread-heavy` is the strongest honest claim.
 */
export function threadingShape(messages) {
  let posts = 0; let parents = 0; let replies = 0; let broadcasts = 0;
  for (const message of messages ?? []) {
    if (NOT_A_POST.has(message.subtype)) continue;
    posts += 1;
    const count = Number(message.reply_count ?? 0);
    if (count) { parents += 1; replies += count; }
    if (message.subtype === 'thread_broadcast') broadcasts += 1;
  }

  const stats = { sample: (messages ?? []).length, posts, parents, replies, broadcasts };
  if (posts < MIN_SAMPLE) return ['undetermined', stats];

  const share = (replies + posts) ? replies / (replies + posts) : 0;
  if (share >= THREAD_HEAVY && parents >= MIN_PARENTS) return ['thread-heavy', stats];
  if (replies === 0) return ['never-threaded', stats];
  return ['mixed', stats];
}

/**
 * Compare the channel's convention against the mode the integration uses. Pure.
 * Returns [verdict, likelyError, detail]; the error string is the half somebody
 * already has in their logs.
 */
export function modeMismatch(shape, mode) {
  if (!MODES.includes(mode)) {
    return ['unknown-mode', '',
      `${mode} is not one of ${MODES.join(', ')}. The mode is a fact about your ` +
      'code and nothing in the API will supply it.'];
  }
  if (shape === 'undetermined') {
    return ['undetermined', '',
      'too little readable history to describe how this channel is used. Re-run ' +
      'with a larger sample, or accept that this channel cannot be assessed from here.'];
  }

  if (shape === 'thread-heavy' && mode === 'top-level') {
    return ['likely-blocked', 'restricted_action_thread_only_channel',
      'almost everything said here is said inside a thread, and this integration ' +
      'posts at the top level. Where the channel enforces that convention the post ' +
      'is refused; where it does not, the post lands somewhere nobody is reading.'];
  }
  if (shape === 'never-threaded' && (mode === 'reply' || mode === 'parent-then-replies')) {
    return ['likely-blocked', 'restricted_action_non_threadable_channel',
      'nothing in the readable history has ever been replied to, and this ' +
      'integration threads. Either the channel does not support threading or ' +
      'nobody uses it, and the first of those refuses the message outright.'];
  }
  if (shape === 'mixed') {
    return ['compatible', '',
      'the channel is used both ways, so neither mode is refused by convention. ' +
      'Any failure here is a permission or an anchor rather than a position.'];
  }
  return ['compatible', '', `${mode} matches how this channel is used`];
}

/**
 * Whether a stored thread_ts still anchors a live parent. Pure.
 * Nothing here is about channel policy: cannot_reply_to_message is usually a
 * message-lifetime problem.
 */
export function anchorState(body) {
  if (body.ok !== true) {
    const error = body.error ?? '<no error field>';
    if (error === 'thread_not_found') {
      return ['missing-parent',
        'conversations.replies says thread_not_found. The stored ts anchors ' +
        'nothing: the parent was deleted or has aged past the workspace retention ' +
        'window. A reply under it returns cannot_reply_to_message.'];
    }
    if (['not_in_channel', 'channel_not_found', 'missing_scope'].includes(error)) {
      return ['unreadable',
        `conversations.replies says ${error}, which is a membership or scope ` +
        'question rather than an answer about the thread.'];
    }
    return ['unreadable',
      `conversations.replies answered 200 with ok: false, error=${error}`];
  }

  const messages = body.messages ?? [];
  if (messages.length === 0) {
    return ['missing-parent',
      'ok: true with an empty messages array. The thread is gone and Slack did ' +
      'not consider that an error.'];
  }

  const parent = messages[0];
  if (parent.subtype === 'tombstone') {
    return ['deleted-parent',
      'the parent is a tombstone: it was deleted while its replies survived. ' +
      'Slack keeps the thread visible and refuses new replies to it.'];
  }
  const count = Number(parent.reply_count ?? 0);
  if (count === 0) {
    return ['childless-parent',
      'the ts resolves to a message with no replies yet. That is a perfectly good ' +
      'anchor, and it is indistinguishable from a message nobody has threaded under.'];
  }
  return ['anchored', `the parent is there with ${count} repl(ies) under it`];
}

async function get(token, method, params) {
  const res = await fetch(`${API}${method}?${new URLSearchParams(params)}`, {
    headers: { Authorization: `Bearer ${token}` },
  });
  return res.json();
}

function all(args, name) {
  const out = [];
  for (let i = 0; i < args.length; i += 1) if (args[i] === name) out.push(args[i + 1]);
  return out;
}

function arg(args, name, fallback = null) {
  const i = args.indexOf(name);
  return i === -1 ? fallback : args[i + 1];
}

async function main() {
  const args = process.argv.slice(2);
  const channels = all(args, '--channel');
  const mode = arg(args, '--mode', '');
  if (channels.length === 0 || !MODES.includes(mode)) {
    console.error(`usage: --channel C0... [--channel C1...] --mode ${MODES.join('|')} ` +
      '[--anchor 1735689600.000100] [--sample 100] [--token-env SLACK_BOT_TOKEN]');
    process.exitCode = 2;
    return;
  }
  const anchors = all(args, '--anchor');
  const sample = arg(args, '--sample', '100');
  const tokenEnv = arg(args, '--token-env', 'SLACK_BOT_TOKEN');
  const token = process.env[tokenEnv];
  if (!token) {
    console.error(`set ${tokenEnv} (channels:read and channels:history are enough)`);
    process.exitCode = 2;
    return;
  }

  let mismatches = 0;
  let dead = 0;
  for (const cid of channels) {
    const history = await get(token, 'conversations.history',
      { channel: cid, limit: String(sample) });
    if (history.ok !== true) {
      console.warn(`${cid.padEnd(12)} history  unreadable, error=${history.error}`);
      continue;
    }

    const [shape, stats] = threadingShape(history.messages ?? []);
    const [verdict, likely, detail] = modeMismatch(shape, mode);
    console.log(`${cid.padEnd(12)} shape    ${shape.padEnd(15)} ${stats.posts} ` +
      `top-level post(s), ${stats.parents} with replies, ${stats.replies} replies`);

    if (verdict === 'compatible') {
      console.log(`${cid.padEnd(12)} mode     ${verdict.padEnd(15)} ${detail}`);
    } else {
      mismatches += 1;
      console.warn(`${cid.padEnd(12)} mode     ${verdict.padEnd(15)} ${detail}`);
      if (likely) console.warn(`  expect: ${likely} on the next send`);
      console.warn('  repair: set the posting mode on this target rather than ' +
        `globally, for example  ${cid}: mode=` +
        `${mode === 'top-level' ? 'reply' : 'top-level'}`);
    }

    for (const anchor of anchors) {
      const replies = await get(token, 'conversations.replies',
        { channel: cid, ts: anchor, limit: '1' });
      const [state, why] = anchorState(replies);
      if (state === 'anchored' || state === 'childless-parent') {
        console.log(`${cid.padEnd(12)} anchor   ${state.padEnd(15)} ${why}`);
        continue;
      }
      dead += 1;
      console.warn(`${cid.padEnd(12)} anchor   ${state.padEnd(15)} ${why}`);
      console.warn('  repair: expire stored thread anchors well inside the ' +
        'workspace retention window and fall back to a fresh parent when the ' +
        'anchor is gone');
    }
  }

  console.log(`${channels.length} channel(s) checked, ${mismatches} mismatch(es), ` +
    `${dead} dead anchor(s)`);
  process.exitCode = (mismatches || dead) ? 1 : 0;
}

// Only run when invoked directly, so importing this module in the tests does not
// execute main() and fail the file on a missing token.
if (import.meta.url === `file://${process.argv[1]}`) {
  main().catch((err) => { console.error(err.message); process.exitCode = 2; });
}

from slack_thread_mode_match import anchor_state, mode_mismatch, threading_shape


def threads(parents, replies_each):
    """Top-level messages that each carry a busy thread."""
    return [{"user": "U0AAA", "ts": "17000000%02d.0001" % i,
             "reply_count": replies_each} for i in range(parents)]


def flat(count):
    """Top-level messages nobody has ever replied to."""
    return [{"user": "U0AAA", "ts": "17000000%02d.0001" % i} for i in range(count)]


def test_a_channel_run_in_threads_reads_as_thread_heavy():
    shape, stats = threading_shape(threads(10, 20))
    assert shape == "thread-heavy"
    assert stats["parents"] == 10
    assert stats["replies"] == 200


def test_a_channel_nobody_threads_in_reads_as_never_threaded():
    shape, stats = threading_shape(flat(20))
    assert shape == "never-threaded"
    assert stats["replies"] == 0


def test_a_channel_used_both_ways_is_mixed():
    assert threading_shape(threads(3, 2) + flat(20))[0] == "mixed"


def test_system_traffic_is_not_a_post():
    messages = flat(3) + [{"user": "U0BBB", "subtype": "channel_join"}] * 30
    shape, stats = threading_shape(messages)
    assert stats["posts"] == 3
    assert shape == "undetermined"


def test_a_thin_sample_is_never_classified():
    assert threading_shape(threads(2, 40))[0] == "undetermined"
    assert threading_shape([])[0] == "undetermined"


def test_top_level_posting_into_a_thread_run_channel_names_its_error():
    verdict, likely, detail = mode_mismatch("thread-heavy", "top-level")
    assert verdict == "likely-blocked"
    assert likely == "restricted_action_thread_only_channel"
    assert "nobody is reading" in detail


def test_threading_into_a_channel_that_never_threads_names_the_other_error():
    for mode in ("reply", "parent-then-replies"):
        verdict, likely, _ = mode_mismatch("never-threaded", mode)
        assert verdict == "likely-blocked"
        assert likely == "restricted_action_non_threadable_channel"


def test_the_matching_pairs_are_compatible():
    assert mode_mismatch("thread-heavy", "reply")[0] == "compatible"
    assert mode_mismatch("never-threaded", "top-level")[0] == "compatible"
    assert mode_mismatch("mixed", "top-level")[0] == "compatible"


def test_an_unassessable_channel_produces_no_prediction():
    verdict, likely, _ = mode_mismatch("undetermined", "top-level")
    assert verdict == "undetermined"
    assert likely == ""


def test_a_mode_the_script_does_not_know_is_rejected_rather_than_guessed():
    assert mode_mismatch("thread-heavy", "broadcast")[0] == "unknown-mode"


def test_thread_not_found_is_a_dead_anchor_and_says_which_error_follows():
    state, why = anchor_state({"ok": False, "error": "thread_not_found"})
    assert state == "missing-parent"
    assert "cannot_reply_to_message" in why


def test_an_ok_response_with_no_messages_is_also_a_dead_anchor():
    state, why = anchor_state({"ok": True, "messages": []})
    assert state == "missing-parent"
    assert "not consider that an error" in why


def test_a_tombstoned_parent_is_its_own_state():
    body = {"ok": True, "messages": [{"subtype": "tombstone", "reply_count": 4}]}
    assert anchor_state(body)[0] == "deleted-parent"


def test_a_live_parent_is_anchored():
    body = {"ok": True, "messages": [{"ts": "1735689600.000100", "reply_count": 4}]}
    state, why = anchor_state(body)
    assert state == "anchored"
    assert "4 repl" in why


def test_a_parent_with_no_replies_yet_is_still_a_good_anchor():
    body = {"ok": True, "messages": [{"ts": "1735689600.000100"}]}
    assert anchor_state(body)[0] == "childless-parent"


def test_a_scope_error_is_not_reported_as_a_dead_thread():
    assert anchor_state({"ok": False, "error": "missing_scope"})[0] == "unreadable"
    assert anchor_state({"ok": False, "error": "not_in_channel"})[0] == "unreadable"

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { anchorState, modeMismatch, threadingShape }
  from './slack-thread-mode-match.mjs';

/** Top-level messages that each carry a busy thread. */
function threads(parents, repliesEach) {
  return Array.from({ length: parents }, (_, i) => ({
    user: 'U0AAA', ts: `17000000${String(i).padStart(2, '0')}.0001`,
    reply_count: repliesEach,
  }));
}

/** Top-level messages nobody has ever replied to. */
function flat(count) {
  return Array.from({ length: count }, (_, i) => ({
    user: 'U0AAA', ts: `17000000${String(i).padStart(2, '0')}.0001`,
  }));
}

test('a channel run in threads reads as thread heavy', () => {
  const [shape, stats] = threadingShape(threads(10, 20));
  assert.equal(shape, 'thread-heavy');
  assert.equal(stats.parents, 10);
  assert.equal(stats.replies, 200);
});

test('a channel nobody threads in reads as never threaded', () => {
  const [shape, stats] = threadingShape(flat(20));
  assert.equal(shape, 'never-threaded');
  assert.equal(stats.replies, 0);
});

test('a channel used both ways is mixed', () => {
  assert.equal(threadingShape([...threads(3, 2), ...flat(20)])[0], 'mixed');
});

test('system traffic is not a post', () => {
  const joins = Array.from({ length: 30 },
    () => ({ user: 'U0BBB', subtype: 'channel_join' }));
  const [shape, stats] = threadingShape([...flat(3), ...joins]);
  assert.equal(stats.posts, 3);
  assert.equal(shape, 'undetermined');
});

test('a thin sample is never classified', () => {
  assert.equal(threadingShape(threads(2, 40))[0], 'undetermined');
  assert.equal(threadingShape([])[0], 'undetermined');
});

test('top level posting into a thread run channel names its error', () => {
  const [verdict, likely, detail] = modeMismatch('thread-heavy', 'top-level');
  assert.equal(verdict, 'likely-blocked');
  assert.equal(likely, 'restricted_action_thread_only_channel');
  assert.match(detail, /nobody is reading/);
});

test('threading into a channel that never threads names the other error', () => {
  for (const mode of ['reply', 'parent-then-replies']) {
    const [verdict, likely] = modeMismatch('never-threaded', mode);
    assert.equal(verdict, 'likely-blocked');
    assert.equal(likely, 'restricted_action_non_threadable_channel');
  }
});

test('the matching pairs are compatible', () => {
  assert.equal(modeMismatch('thread-heavy', 'reply')[0], 'compatible');
  assert.equal(modeMismatch('never-threaded', 'top-level')[0], 'compatible');
  assert.equal(modeMismatch('mixed', 'top-level')[0], 'compatible');
});

test('an unassessable channel produces no prediction', () => {
  const [verdict, likely] = modeMismatch('undetermined', 'top-level');
  assert.equal(verdict, 'undetermined');
  assert.equal(likely, '');
});

test('a mode the script does not know is rejected rather than guessed', () => {
  assert.equal(modeMismatch('thread-heavy', 'broadcast')[0], 'unknown-mode');
});

test('thread_not_found is a dead anchor and says which error follows', () => {
  const [state, why] = anchorState({ ok: false, error: 'thread_not_found' });
  assert.equal(state, 'missing-parent');
  assert.match(why, /cannot_reply_to_message/);
});

test('an ok response with no messages is also a dead anchor', () => {
  const [state, why] = anchorState({ ok: true, messages: [] });
  assert.equal(state, 'missing-parent');
  assert.match(why, /not consider that an error/);
});

test('a tombstoned parent is its own state', () => {
  const body = { ok: true, messages: [{ subtype: 'tombstone', reply_count: 4 }] };
  assert.equal(anchorState(body)[0], 'deleted-parent');
});

test('a live parent is anchored', () => {
  const body = { ok: true, messages: [{ ts: '1735689600.000100', reply_count: 4 }] };
  const [state, why] = anchorState(body);
  assert.equal(state, 'anchored');
  assert.match(why, /4 repl/);
});

test('a parent with no replies yet is still a good anchor', () => {
  const body = { ok: true, messages: [{ ts: '1735689600.000100' }] };
  assert.equal(anchorState(body)[0], 'childless-parent');
});

test('a scope error is not reported as a dead thread', () => {
  assert.equal(anchorState({ ok: false, error: 'missing_scope' })[0], 'unreadable');
  assert.equal(anchorState({ ok: false, error: 'not_in_channel' })[0], 'unreadable');
});