slack-term 1.41.2 → 1.43.0

package/ts/cli.ts

@@ -12,7 +12,9 @@ import { guardUrlBoundaries } from "./urlGuard.ts";
 import { listProfiles, removeProfile, resolveBotToken, resolveCookie, resolveToken, useProfile, type Profile } from "./profiles.ts";
 import { diagnoseBotMessaging, formatDiagnosis } from "./botdoctor.ts";
 import { cmdAuthLogin, cmdAuthLoginChrome, cmdAuthChrome, cmdAuthFirefox, cmdAuthToken, cmdAuthApp, cmdAuthSave, cmdAuthTokens } from "./auth.ts";
-import { cmdTail } from "./tail.ts";
+import { cmdTail, parseSince as parseDuration } from "./tail.ts";
+import { runStream, webClient } from "./stream.ts";
+import { relaySubscriber } from "./relay.ts";
 import { agentCommands } from "./agent.ts";
 
 import {
@@ -54,10 +56,11 @@ import {
 } from "./poll.ts";
 import { seedReactionsInOrder } from "./reactionSeed.ts";
 import { buildListSchema, cellValue, completedColumn, findColumn, parseColumnSpec, parseListSchema, parseSets, type ListColumn } from "./lists.ts";
-import { attributionEnabled, attributionMetadata, captureAttribution, parseSince, querySent, recordSent, SENT_LOG_UNAVAILABLE, sentDbPath, type RecordSent, type SentKind, type SentRow } from "./sentlog.ts";
+import { attributionEnabled, attributionMetadata, captureAttribution, markAskCollected, markAskDelivered, parseSince, querySent, recordSent, SENT_LOG_UNAVAILABLE, sentDbPath, senderAlive, uncollectedAsks, type RecordSent, type SentKind, type SentRow } from "./sentlog.ts";
 import {
   authTest,
   authScopes,
+  botsInfo,
   authTestSession,
   conversationInfoSession,
   createChannel,
@@ -2740,12 +2743,33 @@ async function askEmit(
 }
 
 
-/** Poll until answered. Never returns: exits 0 with the answer on stdout, or 2
- *  on timeout. A timeout of 0 means "look exactly once", so a caller can poll
- *  cheaply on its own schedule instead of parking a process on `--wait`. */
-async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never> {
-  const { channelId, ts, question, reactable, threadOnly, audience, broadcast, cookie, timeout, shown } = ctx;
+/** What one look at a question found besides the answer — read back by the
+ *  `--wait` loop between polls, and by `ask --pending` after its single look. */
+interface AskPollState {
+  /** The earliest audience reply that picked none of the choices. */
+  unchosen?: { text: string; who: string; ts: string; ambiguous: boolean };
+  /** Set when the question has been voided. */
+  voided?: Extract<ReturnType<typeof askParseMessage>, { kind: "void" }>;
+  /** The question's `reply_count` as last seen — undefined until seen. */
+  replyCount?: number;
+  /** The question's text as last read — what the ✅ rewrite keeps the body of. */
+  ownText?: string;
+}
+
+/** The polling half of `--wait`: one `poll()` is one look at the question,
+ *  shared with `ask --pending`. `readOnly` drops the one WRITE a look can make
+ *  (the invalid-ballot notice edited into the question) and the progress lines
+ *  on stderr — `--pending` inspects questions other sessions are responsible
+ *  for, and must neither touch them nor narrate their state as if waiting. */
+function askPoller(token: string, ctx: AskWaitCtx, readOnly = false): {
+  poll: () => Promise<AskFound | null>;
+  state: AskPollState;
+  isAnswerer: (user: unknown) => user is string;
+  candidates: string[];
+} {
+  const { channelId, ts, reactable, threadOnly, audience, broadcast, cookie } = ctx;
   const copy = ASK_COPY[ctx.lang];
+  const state: AskPollState = {};
   const askerUserId = ctx.askerUserId;
   const askerBotId = ctx.askerBotId;
 
@@ -2756,25 +2780,19 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
   const isAnswerer = (user: unknown): user is string =>
     typeof user === "string" && !!user && user !== askerUserId && (broadcast || audience.has(user));
 
-  /** The question's `reply_count` as last seen — whether its thread is worth a
-   *  fetch when collecting notes. Undefined until the question itself is seen. */
-  let replyCount: number | undefined;
-  /** The question's text as last read — what the ✅ rewrite keeps the body of. */
-  let ownText: string | undefined;
+  /** The question as last seen: its `reply_count` (whether its thread is worth
+   *  a fetch when collecting notes) and its text (what the ✅ rewrite keeps). */
+  const seen = (own: Record<string, Json>): void => {
+    state.replyCount = Number(own.reply_count) || 0;
+    if (typeof own.text === "string") state.ownText = own.text;
+  };
   /** Set when the question is voided while we wait — the wait ends there. */
-  let voided: Extract<ReturnType<typeof askParseMessage>, { kind: "void" }> | undefined;
   const checkVoid = (own: Record<string, Json>): boolean => {
     const p = typeof own.text === "string" ? askParseMessage(own.text) : undefined;
-    if (p?.kind === "void") voided = p;
-    return !!voided;
+    if (p?.kind === "void") state.voided = p;
+    return !!state.voided;
   };
 
-  /** The earliest reply from an answerer that picked none of the choices. Kept
-   *  across polls so the timeout can report it, and so the operator is told once
-   *  rather than on every tick. */
-  let unchosen: { text: string; who: string; ts: string; ambiguous: boolean } | undefined;
-  let unchosenReported = "";
-
   /** Every seed an answerer is on — not just the first. Changing your mind
    *  leaves BOTH reactions in place (Slack only drops one when you actively
    *  un-react), so taking the lowest index would answer with the abandoned
@@ -2800,6 +2818,7 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
    *  the API call when nothing changed, which is what makes this safe to run on
    *  every poll tick rather than once per process. */
   async function noteInvalid(msg: Record<string, Json>, offenders: string[]): Promise<void> {
+    if (readOnly) return;
     const text = typeof msg.text === "string" ? msg.text : "";
     if (!text) return;
     const next = applyInvalidNotice(text, offenders, ctx.lang);
@@ -2822,7 +2841,7 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
     for (const u of r ? asArray(r.users).filter(isAnswerer) : []) {
       if (otherReported.has(u)) continue;
       otherReported.add(u);
-      console.error(`  (<@${u}> が ❓ その他 を押しました。返信を待ちます)`);
+      if (!readOnly) console.error(`  (<@${u}> が ❓ その他 を押しました。返信を待ちます)`);
     }
   }
 
@@ -2845,7 +2864,7 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
     const pillsPerUser = new Map<string, number>();
     for (const p of picks) for (const u of p.users) pillsPerUser.set(u, (pillsPerUser.get(u) ?? 0) + 1);
     const multi = [...pillsPerUser].filter(([, n]) => n > 1).map(([u]) => u);
-    console.error(multi.length
+    if (!readOnly) console.error(multi.length
       ? `  (${glyphs} が同時に選ばれています。1 つに絞ってもらうまで待ちます)`
       : `  (回答が分かれています: ${glyphs}。どちらか一方にそろうまで待ちます)`);
     // Whoever is on more than one pill — and ONLY them. Naming everyone on any
@@ -2895,9 +2914,10 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
       // must not hide it behind the refuse-to-guess path. Within a class, the
       // earliest wins.
       const ambiguous = match.kind === "ambiguous";
+      const unchosen = state.unchosen;
       if (!unchosen || (unchosen.ambiguous && !ambiguous) ||
           (unchosen.ambiguous === ambiguous && Number(m.ts) < Number(unchosen.ts))) {
-        unchosen = { text: t, who: typeof m.user === "string" ? m.user : "", ts: String(m.ts), ambiguous };
+        state.unchosen = { text: t, who: typeof m.user === "string" ? m.user : "", ts: String(m.ts), ambiguous };
       }
     }
     return null;
@@ -2910,7 +2930,7 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
     // longer there, and exit 4 where exit 2 is the truth. `unchosenReported`
     // persists on purpose — it is what keeps the operator from being told the
     // same thing on every tick.
-    unchosen = undefined;
+    delete state.unchosen;
     // A question that is itself a thread reply is invisible to
     // `conversations.history`, so the entire poll — reactions included — has to
     // come from the thread.
@@ -2919,8 +2939,7 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
       const messages = asArray(rep.messages).map(asRecord);
       const own = messages.find((m) => m.ts === ts);
       if (own) {
-        replyCount = Number(own.reply_count) || 0;
-        if (typeof own.text === "string") ownText = own.text;
+        seen(own);
         if (checkVoid(own)) return null;
         const byReaction = await answerFromReactions(own);
         if (byReaction) return byReaction;
@@ -2936,8 +2955,7 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
     const own = messages.find((m) => m.ts === ts);
 
     if (own) {
-      replyCount = Number(own.reply_count) || 0;
-      if (typeof own.text === "string") ownText = own.text;
+      seen(own);
       if (checkVoid(own)) return null;
     }
     // A reaction is the intended path, so it wins when both are present.
@@ -2970,6 +2988,21 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
     return null;
   }
 
+  return { poll, state, isAnswerer, candidates };
+}
+
+/** Poll until answered. Never returns: exits 0 with the answer on stdout, or 2
+ *  on timeout. A timeout of 0 means "look exactly once", so a caller can poll
+ *  cheaply on its own schedule instead of parking a process on `--wait`. */
+async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never> {
+  const { channelId, ts, question, reactable, threadOnly, cookie, timeout, shown } = ctx;
+  const askerUserId = ctx.askerUserId;
+  const askerBotId = ctx.askerBotId;
+  const { poll, state, isAnswerer, candidates } = askPoller(token, ctx);
+  /** Kept across polls so the operator is told about one reply once, rather
+   *  than on every tick. */
+  let unchosenReported = "";
+
   /** Stamp the question resolved. Removing our seeds clears the pills that still
    *  invite an answer; the answerer's own reaction cannot be removed by us and
    *  stays put — which is exactly what leaves the chosen number visible. */
@@ -2996,7 +3029,7 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
       // The body and the chosen option stay; only what no longer applies goes.
       // Built from the message as it is NOW (an edit made in Slack after asking
       // is kept). Not seen this run — the bare form, as before.
-      const keep = ownText ? askResolvedKeep(ownText, found.choice) : undefined;
+      const keep = state.ownText ? askResolvedKeep(state.ownText, found.choice) : undefined;
       await editMessage(token, channelId, ts, askBuildResolvedText(question, found, who, ctx.lang, keep), cookie, true);
       // Swap the marker for the resolved one so search reflects reality:
       // `has::question:` should list what still needs answering, not everything
@@ -3019,6 +3052,7 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
   const deadline = Date.now() + timeout * 1000;
   let errors = 0;
   let delay = ASK_POLL_MIN_MS;
+  let unchosen: AskPollState["unchosen"];
   for (;;) {
     let found: AskFound | null = null;
     try {
@@ -3033,6 +3067,8 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
       }
       console.error(`  (Slack エラー ${errors}/${ASK_MAX_CONSECUTIVE_ERRORS}, 再試行します: ${e instanceof Error ? e.message : String(e)})`);
     }
+    unchosen = state.unchosen;
+    const voided = state.voided;
     if (voided) {
       askReportVoid(voided, shown);
       if (ctx.json) {
@@ -3050,7 +3086,7 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
       // BEFORE ✅ is written, and delivered right after — ✅ is what tells a
       // later --waitFor the question is settled.
       const notes = await askCollectNotes(token, {
-        channelId, ts, threadOnly, replyCount, isAnswerer, askerUserId, askerBotId,
+        channelId, ts, threadOnly, replyCount: state.replyCount, isAnswerer, askerUserId, askerBotId,
         ...(ctx.threadParentTs ? { threadParentTs: ctx.threadParentTs } : {}),
         ...(cookie ? { cookie } : {}),
       }, ctx.after, (m) => m.ts === found!.ts);
@@ -3059,6 +3095,9 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
         status: "answered", answer: found.answer, how: found.how, notes,
         cursor: askNextCursor(ts, ctx.after, found.ts, ...notes.map((n) => n.ts)),
       };
+      // Collected: the local sent-log row (if this machine asked it) drops off
+      // `ask --pending`. Only here, where the answer actually reaches a caller.
+      markAskCollected(channelId, ts, found.answer, r.cursor);
       if (found.who) r.who = found.who;
       await askEmit(token, ctx, r);
       process.exit(0);
@@ -3079,6 +3118,9 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
       console.error(`  選択肢: ${candidates.map((c, i) => `${i + 1}. ${stripTerminalControls(askFlatten(c))}`).join("  ")}`);
       console.error(`  ${shown}`);
       console.error(`  この返信の後を待つ:  ${askResumeCommand(shown, ctx.asBot, unchosen.ts)}`);
+      // Delivered, not collected: `--pending` will not report THIS reply again,
+      // but still reports a pill pressed after it.
+      markAskDelivered(channelId, ts, unchosen.text, askNextCursor(ts, ctx.after, unchosen.ts));
       if (ctx.json) {
         await askEmit(token, ctx, { status: "freetext", answer: unchosen.text, who: unchosen.who, notes: [], cursor: askNextCursor(ts, ctx.after, unchosen.ts) });
       } else {
@@ -3434,6 +3476,16 @@ async function askFetchByLink(token: string, link: string, cookie?: string): Pro
     channelId = m[1]!;
     ts = m[2]!;
   }
+  return askFetchAt(token, { channelId, ts, threadTs }, cookie);
+}
+
+/** `askFetchByLink` for a location already known — e.g. a sent-log row, whose
+ *  `thread_ts` says where a question posted into a thread lives. */
+async function askFetchAt(token: string, loc: { channelId: string; ts: string; threadTs?: string | undefined }, cookie?: string): Promise<
+  { channelId: string; ts: string; threadTs?: string; msg?: Record<string, Json> }
+> {
+  const { channelId, ts } = loc;
+  const threadTs = loc.threadTs && loc.threadTs !== loc.ts ? loc.threadTs : undefined;
   let msg: Record<string, Json> | undefined;
   if (threadTs) {
     const rep = asRecord((await replies(token, channelId, threadTs, 100, cookie)) as Json);
@@ -3635,8 +3687,8 @@ async function cmdAskLs(tokens: { user?: string; bot?: string; cookie?: string }
     let answer: string | undefined;
     if (token) {
       try {
-        const got = await askFetchByLink(token, `${r.channel}:${r.ts}`, r.as_bot ? undefined : tokens.cookie);
-        if (!got?.msg) state = "gone";
+        const got = await askFetchAt(token, { channelId: r.channel, ts: r.ts, threadTs: r.thread_ts ?? undefined }, r.as_bot ? undefined : tokens.cookie);
+        if (!got.msg) state = "gone";
         else {
           const p = askParseMessage(typeof got.msg.text === "string" ? got.msg.text : "");
           state = p.kind === "resolved" ? "answered" : p.kind === "other" ? "edited" : p.kind;
@@ -3674,6 +3726,150 @@ async function cmdAskLs(tokens: { user?: string; bot?: string; cookie?: string }
   }
 }
 
+/** One answered-but-uncollected ask, as `--pending` reports it. */
+interface AskPendingItem {
+  row: SentRow;
+  link: string;
+  question: string;
+  answer: string;
+  how: string;
+  /** A free-text reply that picked none of the choices — not a decision. */
+  freeText: boolean;
+  alive: boolean;
+  /** The ready-to-run `--waitFor` line, cursor included. */
+  collect: string;
+}
+
+/** `slack ask --pending [--since 7d] [--json]` — questions THIS machine asked
+ *  that somebody answered and nobody collected, grouped by the asking session,
+ *  with whether that agent is still alive.
+ *
+ *  Why it exists: of 71 asks over 8 days, 13 had a pill pressed that nobody
+ *  ever read back (2026-09-27). The answer was sitting in Slack; the agent that
+ *  asked had moved on or died, and nothing connected the two.
+ *
+ *  Read-only, against Slack AND the local log: each open question gets one look
+ *  through the same poller `--wait` uses, with its one write disabled. It only
+ *  REPORTS — collecting is `slack ask --waitFor=<link>`, printed per item,
+ *  which is also what stamps ✅ and takes the ask off this list. Nothing is
+ *  relayed into another process: whoever reads the list (the asking agent, or
+ *  a person) runs the collect line. */
+async function cmdAskPending(
+  tokens: { user?: string; bot?: string; cookie?: string },
+  opts: { sinceMs: number; json: boolean; channel?: string },
+): Promise<void> {
+  const all = uncollectedAsks(opts.sinceMs);
+  if (!all) {
+    console.error(`Error: ${SENT_LOG_UNAVAILABLE}\n  (${sentDbPath()})`);
+    process.exit(ASK_EXIT_ERROR);
+  }
+  const rows = opts.channel ? all.filter((r) => r.channel === opts.channel || r.target === opts.channel) : all;
+  const pending: AskPendingItem[] = [];
+  const count = { unanswered: 0, ambiguous: 0, resolved: 0, void: 0 };
+  const problems: string[] = [];
+  // The log is machine-wide, but a token reads one workspace. Asks recorded
+  // under another workspace are counted and named, not probed with the wrong
+  // token (which would only fail as channel_not_found).
+  const currentTeam = tokens.user
+    ? (await selfIdentity(tokens.user, tokens.cookie))?.team ?? ""
+    : tokens.bot ? (await selfIdentity(tokens.bot))?.team ?? "" : "";
+  const otherTeams = new Map<string, number>();
+
+  for (const row of rows) {
+    if (row.team && currentTeam && row.team !== currentTeam) {
+      otherTeams.set(row.team, (otherTeams.get(row.team) ?? 0) + 1);
+      continue;
+    }
+    const link = row.permalink || `${row.channel}:${row.ts}`;
+    const asBot = !!row.as_bot;
+    const token = asBot ? tokens.bot : tokens.user;
+    if (!token) {
+      problems.push(`${link}: ${asBot ? "--as-bot で聞いた質問ですが bot token がありません" : "user token がありません"}`);
+      continue;
+    }
+    const cookie = asBot ? undefined : tokens.cookie;
+    // Resume from where the last delivery to a caller ended (an exit 5
+    // free-text reply), so that reply is not reported again — and the collect
+    // line carries the same cursor, so `--waitFor` does not re-deliver it.
+    const after = row.delivered_cursor ?? undefined;
+    try {
+      const loc = { channelId: row.channel, ts: row.ts, threadTs: row.thread_ts ?? undefined };
+      const got = await askFetchAt(token, loc, cookie);
+      if (!got.msg) { problems.push(`${link}: メッセージが見つかりません (削除?)`); continue; }
+      const q = await askReadBack(token, { channelId: row.channel, ts: row.ts, msg: got.msg }, cookie);
+      const parsed = q.parsed;
+      // ✅ already stamped: some `--wait`/`--waitFor` collected it (another
+      // machine, another token, or a build before collection was logged).
+      if (parsed.kind === "resolved") { count.resolved++; continue; }
+      if (parsed.kind === "void") { count.void++; continue; }
+      if (parsed.kind === "other") { problems.push(`${link}: \`slack ask\` の質問として読めません — ${askExplainReject(q.text)}`); continue; }
+      if (!q.audience.size && !q.broadcast) { problems.push(`${link}: 誰にも宛てられていない質問です`); continue; }
+      const ctx = askWaitCtxFrom(q, parsed, loc, { timeout: 0, link, asBot, json: false, cookie, after });
+      const poller = askPoller(token, ctx, true);
+      const found = await poller.poll();
+      const unchosen = poller.state.unchosen;
+      if (poller.state.voided) { count.void++; continue; }
+      const collect = askResumeCommand(link, asBot, after);
+      const base = { row, link, question: parsed.question, collect, alive: senderAlive(row) };
+      if (found) {
+        pending.push({ ...base, answer: found.answer, how: found.how, freeText: false });
+      } else if (unchosen && !unchosen.ambiguous && unchosen.text !== row.delivered_answer) {
+        pending.push({ ...base, answer: unchosen.text, how: "返信 (選択肢外)", freeText: true });
+      } else if (unchosen?.ambiguous) {
+        count.ambiguous++;
+      } else {
+        count.unanswered++;
+      }
+    } catch (e: unknown) {
+      problems.push(`${link}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
+  if (opts.json) {
+    for (const it of pending) {
+      const r = it.row;
+      console.log(JSON.stringify({
+        id: r.id, link: it.link, channel: r.channel, ts: r.ts, asked_at: r.sent_at,
+        question: it.question, answer: it.answer, how: it.how, free_text: it.freeText,
+        sender: { session_id: r.session_id ?? null, cli: r.cli ?? null, agent_pid: r.agent_pid ?? null, pid: r.pid, alive: it.alive, cwd: r.cwd, git_branch: r.git_branch ?? null, host: r.host ?? null },
+        delivered_at: r.delivered_at ?? null,
+        collect: it.collect,
+      }));
+    }
+  } else {
+    // Grouped by the session that asked — the unit that has to be told.
+    const groups = new Map<string, AskPendingItem[]>();
+    for (const it of pending) {
+      const key = it.row.session_id ? `session ${it.row.session_id}` : `pid ${it.row.agent_pid ?? it.row.pid}`;
+      groups.set(key, [...(groups.get(key) ?? []), it]);
+    }
+    for (const [key, items] of groups) {
+      const r = items[0]!.row;
+      console.log(
+        `${stripTerminalControls(key)}  ${stripTerminalControls(r.cli ?? "?")}  pid ${r.agent_pid ?? r.pid} ${items[0]!.alive ? "(alive)" : "(gone)"}` +
+        `${r.git_branch ? `  branch=${stripTerminalControls(r.git_branch)}` : ""}  cwd=${stripTerminalControls(r.cwd)}`,
+      );
+      for (const it of items) {
+        console.log(`  ${stripTerminalControls(it.link)}  (${formatYmdHm(it.row.sent_at / 1000)})`);
+        console.log(`    Q: ${stripTerminalControls(askFlatten(it.question))}`);
+        console.log(`    A: ${stripTerminalControls(askFlatten(it.answer))}  — ${stripTerminalControls(it.how)}${it.freeText ? " — 決定ではありません" : ""}`);
+        console.log(`    collect: ${stripTerminalControls(it.collect)}`);
+      }
+    }
+  }
+  for (const p of problems) console.error(`  (${stripTerminalControls(p)})`);
+  for (const [team, n] of otherTeams) {
+    console.error(`  (${n} 件は別のワークスペース「${stripTerminalControls(team)}」の質問です — slack -w <name> ask --pending で確認)`);
+  }
+  console.error(
+    `${pending.length} 件が回答済み・未回収, ${count.unanswered} 件が未回答` +
+    (count.ambiguous ? `, ${count.ambiguous} 件は返信が複数の選択肢に一致 (未確定)` : "") +
+    (count.resolved ? `, ${count.resolved} 件は ✅ 回収済み` : "") +
+    (count.void ? `, ${count.void} 件は無効化済み` : "") +
+    ` — ${rows.length} 件の未回収の質問を確認 (log: ${sentDbPath()})`,
+  );
+}
+
 /** A question about to be voided: where it is, and what it parsed as. */
 interface AskVoidTarget {
   link: string;
@@ -3858,23 +4054,14 @@ async function cmdAskWaitFor(token: string, args: { link: string; timeout: numbe
     ts = m[2]!;
   }
 
-  // Fetch the one message. A question posted into a thread is not in history at
-  // all, so where the permalink says it is a reply, read it from the thread.
-  let msg: Record<string, Json> | undefined;
-  if (threadTs) {
-    const rep = asRecord((await replies(token, channelId, threadTs, 100, args.cookie)) as Json);
-    msg = asArray(rep.messages).map(asRecord).find((m) => m.ts === ts);
-  } else {
-    const hist = asRecord((await history(token, channelId, 1, ts, undefined, args.cookie, true)) as Json);
-    msg = asArray(hist.messages).map(asRecord).find((m) => m.ts === ts);
-  }
-  if (!msg) {
+  const got = await askFetchAt(token, { channelId, ts, threadTs }, args.cookie);
+  if (!got.msg) {
     console.error(`Error: そのメッセージが見つかりません: ${stripTerminalControls(args.link)}`);
     process.exit(ASK_EXIT_ERROR);
   }
-
-  const text = typeof msg.text === "string" ? msg.text : "";
-  const parsed = askParseMessage(text);
+  const msg = got.msg;
+  const q = await askReadBack(token, { channelId, ts, msg }, args.cookie);
+  const { text, parsed, audience, broadcast, askerUserId, askerBotId } = q;
   if (parsed.kind === "other") {
     console.error(
       `Error: これは \`slack ask\` の質問として読み取れません。\n` +
@@ -3887,23 +4074,6 @@ async function cmdAskWaitFor(token: string, args: { link: string; timeout: numbe
     process.exit(ASK_EXIT_ERROR);
   }
 
-  // Who may answer, recovered from the tags the readers can see. They are
-  // already `<@U…>`-encoded in the stored text, so no directory lookup is
-  // needed — and the asker is excluded here for the same reason as when
-  // posting: their tag of themselves grants nothing, and their reactions are
-  // the seeds.
-  const askerUserId = typeof msg.user === "string" ? msg.user : "";
-  const askerBotId = typeof msg.bot_id === "string" ? msg.bot_id : "";
-  const broadcast = /<!(here|channel|everyone)(\^[^>]*)?(\|[^>]*)?>/.test(text);
-  const audience = new Set<string>();
-  for (const m of text.matchAll(/<@([UW][A-Z0-9]+)>/g)) {
-    if (m[1] !== askerUserId) audience.add(m[1]!);
-  }
-  if (!audience.size && !broadcast) {
-    // A 1:1 DM needs no tag — the other party is the only person it could be.
-    const counterpart = await imCounterpart(token, channelId, args.cookie);
-    if (counterpart && counterpart !== askerUserId) audience.add(counterpart);
-  }
   if (parsed.kind === "void") {
     askReportVoid(parsed, args.link);
     if (args.json) {
@@ -3955,10 +4125,11 @@ async function cmdAskWaitFor(token: string, args: { link: string; timeout: numbe
         ...(args.cookie ? { cookie: args.cookie } : {}),
       }, after, isAnswerReply);
     }
+    const cursor = askNextCursor(ts, after, ...notes.map((n) => n.ts));
     await askEmit(token, { json: args.json, shown: args.link, asBot: args.asBot, cookie: args.cookie }, {
-      status: "answered", answer: parsed.answer, notes,
-      cursor: askNextCursor(ts, after, ...notes.map((n) => n.ts)),
+      status: "answered", answer: parsed.answer, notes, cursor,
     });
+    markAskCollected(channelId, ts, parsed.answer, cursor);
     return;
   }
 
@@ -3970,27 +4141,72 @@ async function cmdAskWaitFor(token: string, args: { link: string; timeout: numbe
   if (args.timeout > 0) {
     console.error(`  回答を待っています (最大 ${args.timeout}s)… Ctrl-C で中断`);
   }
+  await askWaitForAnswer(token, askWaitCtxFrom(q, parsed, { channelId, ts, threadTs }, args));
+}
+
+/** A posted question read back: what it parsed as, and who may answer it. */
+interface AskReadBack {
+  text: string;
+  parsed: ReturnType<typeof askParseMessage>;
+  audience: Set<string>;
+  broadcast: boolean;
+  askerUserId: string;
+  askerBotId: string;
+}
+
+/** Recover who may answer from the message alone. Shared by `--waitFor` and
+ *  `--pending` — nothing about a question is stored, so both read it back. */
+async function askReadBack(token: string, t: { channelId: string; ts: string; msg: Record<string, Json> }, cookie?: string): Promise<AskReadBack> {
+  const { msg } = t;
+  const text = typeof msg.text === "string" ? msg.text : "";
+  const parsed = askParseMessage(text);
+  // Who may answer, recovered from the tags the readers can see. They are
+  // already `<@U…>`-encoded in the stored text, so no directory lookup is
+  // needed — and the asker is excluded here for the same reason as when
+  // posting: their tag of themselves grants nothing, and their reactions are
+  // the seeds.
+  const askerUserId = typeof msg.user === "string" ? msg.user : "";
+  const askerBotId = typeof msg.bot_id === "string" ? msg.bot_id : "";
+  const broadcast = /<!(here|channel|everyone)(\^[^>]*)?(\|[^>]*)?>/.test(text);
+  const audience = new Set<string>();
+  for (const m of text.matchAll(/<@([UW][A-Z0-9]+)>/g)) {
+    if (m[1] !== askerUserId) audience.add(m[1]!);
+  }
+  if (parsed.kind !== "other" && !audience.size && !broadcast) {
+    // A 1:1 DM needs no tag — the other party is the only person it could be.
+    const counterpart = await imCounterpart(token, t.channelId, cookie);
+    if (counterpart && counterpart !== askerUserId) audience.add(counterpart);
+  }
+  return { text, parsed, audience, broadcast, askerUserId, askerBotId };
+}
+
+function askWaitCtxFrom(
+  q: AskReadBack,
+  parsed: Extract<AskReadBack["parsed"], { kind: "open" }>,
+  loc: { channelId: string; ts: string; threadTs?: string | undefined },
+  o: { timeout: number; link: string; asBot: boolean; json: boolean; cookie?: string | undefined; after?: string | undefined },
+): AskWaitCtx {
   const ctx: AskWaitCtx = {
-    channelId,
-    ts,
+    channelId: loc.channelId,
+    ts: loc.ts,
     question: parsed.question,
     reactable: parsed.reactable,
     overflow: parsed.overflow,
     threadOnly: parsed.threadOnly,
     lang: parsed.lang,
-    audience,
-    broadcast,
-    askerUserId,
-    askerBotId,
-    timeout: args.timeout,
-    shown: args.link,
-    asBot: args.asBot,
-    json: args.json,
+    audience: q.audience,
+    broadcast: q.broadcast,
+    askerUserId: q.askerUserId,
+    askerBotId: q.askerBotId,
+    timeout: o.timeout,
+    shown: o.link,
+    asBot: o.asBot,
+    json: o.json,
   };
-  if (threadTs) ctx.threadParentTs = threadTs;
-  if (args.cookie) ctx.cookie = args.cookie;
-  if (args.after) ctx.after = args.after;
-  await askWaitForAnswer(token, ctx);
+  if (loc.threadTs) ctx.threadParentTs = loc.threadTs;
+  if (o.cookie) ctx.cookie = o.cookie;
+  if (o.after) ctx.after = o.after;
+  return ctx;
 }
 
 // --- poll ---
@@ -5536,13 +5752,15 @@ async function main(): Promise<void> {
         .option("reask", { type: "boolean", default: false, describe: "With ONE --void: post the question again (same channel/thread, same text and choices unless you give new ones as positionals / --body) and void the old one as replaced by it — one gate for both. The way to change the options of a question someone already answered." })
         .option("edit", { type: "string", describe: "Change an open question you posted: --edit=<permalink> [\"new question\" [choices…]] [--body …]. Rebuilt with the ask layout so collect still reads it. Options can change only while nobody has answered (then: --void=<link> --reask). Same --code gate." })
         .option("ls", { type: "boolean", default: false, describe: "List the questions you posted (local sent-log) with their LIVE state: --state open|answered|void|all (default open), --stale 24h, --channel, --json. With --stale it prints the --void command that would retire them." })
+        .option("pending", { type: "boolean", default: false, describe: "List questions THIS machine asked (local sent-log) that somebody answered but nobody collected, grouped by the asking session, with whether that agent is still alive and the --waitFor line that collects each. Read-only: --since 7d, --channel, --json." })
+        .option("since", { type: "string", default: "7d", describe: "With --pending: how far back to look (30m, 2h, 7d, or an ISO date)" })
         .option("stale", { type: "string", describe: "With --ls: only open questions older than this (24h, 3d)" })
         .option("state", { type: "string", default: "open", choices: ["open", "answered", "void", "edited", "gone", "unknown", "all"], describe: "With --ls: which state to list" })
-        .option("channel", { type: "string", describe: "With --ls: only this channel (id, or the target as typed)" })
+        .option("channel", { type: "string", describe: "With --ls / --pending: only this channel (id, or the target as typed)" })
         .option("limit", { type: "number", default: 50, describe: "With --ls: how many recent asks to check" })
         .option("reason", { type: "string", describe: "With --void: why it is void (written into the message)" })
         .option("superseded-by", { type: "string", describe: "With --void: permalink of the question that replaces it" })
-        .option("json", { type: "boolean", default: false, describe: "With --wait / --waitFor: print ONE JSON object on stdout — {status, answer, how, who, notes:[{ts,user,text,permalink}], cursor, permalink} — instead of the bare answer. `notes` are the audience's replies that are not the answer (thread replies; plain replies too in a 1:1 DM). Exit codes unchanged." })
+        .option("json", { type: "boolean", default: false, describe: "With --pending: one JSON object per answered question (sender, answer, collect command). With --wait / --waitFor: print ONE JSON object on stdout — {status, answer, how, who, notes:[{ts,user,text,permalink}], cursor, permalink} — instead of the bare answer. `notes` are the audience's replies that are not the answer (thread replies; plain replies too in a 1:1 DM). Exit codes unchanged." })
         .option("timeout", { type: "number", default: 3600, describe: "Overall limit for --wait / --waitFor, in seconds (0 with --waitFor = check once)" })
         .option("channel-id", { type: "string", describe: "Raw channel ID" })
         .option("user-id", { type: "string", describe: "Raw user ID (opens DM)" })
@@ -5554,7 +5772,11 @@ async function main(): Promise<void> {
         //   slack ask collect <link>                                        = --waitFor
         // Lifecycle flags (maintainer: "maybe slack ask --edit=<target>"), primary;
         // the bare verbs `void` / `collect` stay as aliases.
-        if (argv.ls) {
+        if (argv.ls || argv.pending) {
+          if (argv.ls && argv.pending) {
+            console.error("Error: --ls and --pending are separate lists — pick one.");
+            process.exit(ASK_EXIT_ERROR);
+          }
           const user = (() => { try { return tok(argv as W); } catch { return undefined; } })();
           const tokens: { user?: string; bot?: string; cookie?: string } = {};
           if (user) tokens.user = user;
@@ -5562,6 +5784,26 @@ async function main(): Promise<void> {
           if (bot) tokens.bot = bot;
           const c = ck(argv as W);
           if (c) tokens.cookie = c;
+          if (argv.pending) {
+            if (argv.target || argv.question || argv.waitFor || argv.wait || argv.void || argv.edit) {
+              console.error("Error: --pending reads the local log — do not also pass a target/question or another ask action.");
+              process.exit(ASK_EXIT_ERROR);
+            }
+            const sinceMs = parseSince(String(argv.since));
+            if (sinceMs === undefined) {
+              console.error(`Error: --since needs 30m / 2h / 7d / 1w or an ISO date (got ${stripTerminalControls(String(argv.since))})`);
+              process.exit(ASK_EXIT_ERROR);
+            }
+            const p: { sinceMs: number; json: boolean; channel?: string } = { sinceMs, json: !!argv.json };
+            if (argv.channel) p.channel = String(argv.channel);
+            try {
+              await cmdAskPending(tokens, p);
+            } catch (e: unknown) {
+              console.error(friendlySlackError(e));
+              process.exit(ASK_EXIT_ERROR);
+            }
+            return;
+          }
           const a: { stale?: string; state: string; channel?: string; json: boolean; limit: number } = {
             state: String(argv.state ?? "open"), json: !!argv.json, limit: Number(argv.limit) || 50,
           };
@@ -6987,6 +7229,153 @@ async function main(): Promise<void> {
         )
         .command("$0", false as unknown as string, () => {}, () => { y.showHelp(); process.exit(0); }),
     )
+    .command(
+      "stream",
+      "Print every new message matching --grep, across all channels the identity is in (threads included); resumable",
+      (y) => y
+        .option("grep", { alias: "e", type: "string", demandOption: true, describe: "Regex matched against each message's text (raw, e.g. <@U00000001>). Non-matching messages are never printed or logged" })
+        .option("ignore-case", { alias: "i", type: "boolean", default: false, describe: "Case-insensitive --grep" })
+        .option("channel", { type: "array", string: true, describe: "Only these channels (#name, id or permalink); repeatable" })
+        .option("replies-to", { type: "array", string: true, describe: "Also print replies in threads this id started or replied in (user U…/bot B…; `self` = the streaming identity), --grep or not; repeatable" })
+        .option("json", { type: "boolean", default: false, describe: "One JSON object per match: type, channel{id,name}, ts, thread_ts, user{id,name}, text, permalink, match (grep | replies-to)" })
+        .option("once", { type: "boolean", default: false, describe: "Scan once from the saved cursor (or --since) and exit: 0 = matches printed, 2 = none, 3 = failure" })
+        .option("since", { type: "string", describe: "Replay from this long ago (e.g. 30m, 2h), ignoring the saved cursor" })
+        .option("interval", { type: "string", default: "45s", describe: "Poll interval (e.g. 30s, 2m)" })
+        .option("thread-window", { type: "string", default: "3d", describe: "Watch replies in threads whose parent is at most this old" })
+        .option("thread-scan", { type: "string", default: "3m", describe: "Polling: re-read each channel's whole --thread-window this often (cycles in between read only what is new)" })
+        .option("calls-per-min", { type: "number", default: 40, describe: "Polling: pace conversations.history/replies to this many calls per minute (0 = unpaced)" })
+        .option("state", { type: "string", describe: "Cursor file (default: one per identity+grep+channels under $XDG_STATE_HOME/slack-term/stream/)" })
+        .option("as-user", { type: "boolean", default: false, describe: "Stream as the user identity (sees the user's DMs) instead of the bot" })
+        .option("relay", { type: "boolean", default: true, describe: "Use the doorbell relay (worker/) when SLACK_RELAY_URL and SLACK_RELAY_TOKEN are set; --no-relay polls only" })
+        .option("reconcile", { type: "string", default: "5m", describe: "While the relay is connected, poll this rarely as a safety net" }),
+      async (argv) => {
+        let re: RegExp;
+        let reconcileMs: number;
+        let intervalMs: number;
+        let windowSec: number;
+        let threadScanSec: number;
+        let sinceSec: number | undefined;
+        try {
+          re = new RegExp(argv.grep, argv["ignore-case"] ? "i" : "");
+          intervalMs = parseDuration(argv.interval) * 1000;
+          windowSec = parseDuration(argv["thread-window"]);
+          threadScanSec = parseDuration(argv["thread-scan"]);
+          sinceSec = argv.since !== undefined ? parseDuration(argv.since) : undefined;
+          reconcileMs = parseDuration(argv.reconcile) * 1000;
+        } catch (e) {
+          console.error(`slack stream: ${e instanceof Error ? e.message : String(e)}`);
+          process.exit(1);
+        }
+        // Privacy-safe default: the bot sees only the channels it was invited
+        // to, never the user's DMs. The user identity is an explicit opt-in.
+        const bot = resolveBotToken();
+        const asUser = argv["as-user"] === true || !bot;
+        const token = asUser ? tok(argv as W) : bot!;
+        const cookie = asUser ? ck(argv as W) : undefined;
+        if (!bot && argv["as-user"] !== true) {
+          console.error("slack stream: no bot token (SLACK_BOT_TOKEN) — streaming as the USER identity, which includes its DMs.");
+        }
+        let me: Awaited<ReturnType<typeof authScopes>>;
+        try {
+          me = await authScopes(token, cookie);
+        } catch (e) {
+          console.error(`slack stream: fatal: ${e instanceof Error ? e.message : String(e)}`);
+          process.exit(3);
+        }
+        // Self-echo exclusion is by sender id: the identity's own user id, its
+        // bot id, and — when streaming as the user — the bot's posts too.
+        const selfUsers = new Set([me.userId].filter(Boolean));
+        const selfBots = new Set([me.botId].filter(Boolean));
+        if (asUser && bot) {
+          try {
+            const b = await authScopes(bot);
+            if (b.userId) selfUsers.add(b.userId);
+            if (b.botId) selfBots.add(b.botId);
+          } catch { /* a dead bot token posts nothing to exclude */ }
+        }
+        // Slack names a bot in a thread either way: `parent_user_id` holds its
+        // bot USER id (auth.test user_id), `reply_users` sometimes its B… bot
+        // id — so `self` stands for both.
+        let repliesTo: Set<string> | undefined;
+        if (argv["replies-to"]?.length) {
+          repliesTo = new Set();
+          for (const r of argv["replies-to"].map(String)) {
+            if (r === "self") {
+              for (const id of [me.userId, me.botId]) if (id) repliesTo.add(id);
+              continue;
+            }
+            if (!/^[UWB][A-Z0-9]{2,}$/.test(r)) {
+              console.error(`slack stream: --replies-to: "${r}" is not a user or bot id (U…/W…/B…) or "self"`);
+              process.exit(1);
+            }
+            repliesTo.add(r);
+            // A bot can be listed under its user id too: add that alias.
+            if (r.startsWith("B")) {
+              try {
+                const { userId } = await botsInfo(token, r, cookie);
+                if (userId) repliesTo.add(userId);
+              } catch (e) {
+                console.error(`slack stream: --replies-to ${r}: cannot resolve its bot user id (${e instanceof Error ? e.message : String(e)}); threads where it shows as a user id are missed`);
+              }
+            }
+          }
+        }
+        let channels: string[] | undefined;
+        if (argv.channel?.length) {
+          try {
+            channels = [];
+            for (const c of argv.channel) channels.push(await resolveChannel(token, String(c), cookie));
+          } catch (e) {
+            console.error(`slack stream: --channel: ${e instanceof Error ? e.message : String(e)}`);
+            process.exit(1);
+          }
+        }
+        const key = createHash("sha256")
+          .update(JSON.stringify([me.url, me.userId, re.source, re.flags, [...(channels ?? [])].sort(),
+            // As given, not as resolved: a failed bots.info lookup must not
+            // move the stream to a fresh state file.
+            ...(argv["replies-to"]?.length ? [[...argv["replies-to"].map(String)].sort()] : [])]))
+          .digest("hex").slice(0, 16);
+        const stateHome = process.env.XDG_STATE_HOME || join(homedir(), ".local", "state");
+        const statePath = argv.state ?? join(stateHome, "slack-term", "stream", `${key}.json`);
+        console.error(`slack stream: as ${asUser ? "user" : "bot"} @${me.user} (${me.userId}); state ${statePath}`);
+        // The relay rings for what the Slack app's bot can see, so it only
+        // stands in for polling when streaming as that bot.
+        const relayUrl = process.env.SLACK_RELAY_URL;
+        const relayToken = process.env.SLACK_RELAY_TOKEN;
+        const relay = argv.relay && !asUser && !argv.once && relayUrl && relayToken
+          ? { url: relayUrl, subscribe: relaySubscriber(relayUrl, relayToken), reconcileMs }
+          : undefined;
+        if (argv.relay && asUser && relayUrl) console.error("slack stream: relay not used with --as-user (it only sees the bot's channels)");
+        const pollReason = !argv.relay ? "--no-relay"
+          : asUser ? (relayUrl ? "--as-user: the relay only rings for the bot's channels" : "streaming as the user; the relay serves the bot identity")
+            : "SLACK_RELAY_URL / SLACK_RELAY_TOKEN not set";
+        const ac = new AbortController();
+        process.on("SIGINT", () => ac.abort());
+        process.on("SIGTERM", () => ac.abort());
+        const code = await runStream(webClient(token, cookie), {
+          grep: re,
+          ...(repliesTo ? { repliesTo } : {}),
+          ...(channels ? { channels } : {}),
+          selfUsers,
+          selfBots,
+          json: argv.json,
+          once: argv.once,
+          ...(sinceSec !== undefined ? { sinceSec } : {}),
+          intervalMs,
+          threadWindowSec: windowSec,
+          threadScanSec,
+          callsPerMin: argv["calls-per-min"],
+          ...(relay ? {} : { pollReason }),
+          statePath,
+          teamUrl: me.url,
+          identity: me.userId,
+          signal: ac.signal,
+          ...(relay ? { relay } : {}),
+        });
+        process.exit(code);
+      },
+    )
     .command(
       "tail [target]",
       "Stream new messages in real time (like tail -f)",