slack-term 1.26.6 → 1.27.0

package/README.md

@@ -93,6 +93,36 @@ slack delete "<permalink>"
 slack react "#general:1700000000.000100" white_check_mark
 slack react "<permalink>" eyes --remove   # take a reaction back
 
+# Ask a question with its choices pre-seeded as 1️⃣..🔟 reactions — answering is
+# one tap on an existing pill, no emoji picker. Same two-step confirm gate as send.
+slack ask "@bob" "本番に出してよい?" "出してよい" "待って"
+# --wait blocks until answered and prints ONLY the answer on stdout, so it composes:
+ANS=$(slack ask "@bob" "本番に出してよい?" "出してよい" "待って" --code=<code> --wait)
+# exit 0 = answered, 2 = timed out (--timeout, default 3600s), 3 = transport failure.
+#
+# The question must say WHO may answer — only their reaction/reply is taken as the
+# answer, so a bystander can't decide it for them. `ask` refuses to post otherwise.
+slack ask "#eng" "@alice この PR 出してよい?" "出す" "待つ"     # only alice's answer counts
+slack ask "#eng" "@here 誰か見れる?" "見る" "あとで"            # anyone in #eng; real broadcast
+# (In a 1:1 DM the other party counts automatically — no tag needed.)
+#
+# With no choices the question asks for a free-text reply and the reply is the answer.
+# In a DM a plain reply counts; in a channel only reactions and thread replies do.
+# Once answered, the question is edited to "✅ …回答済み > <answer>" and the unpressed
+# seeds are removed, leaving the chosen pill visible.
+#
+# WITHOUT --wait, stdout is the command that collects the answer later:
+RESUME=$(slack ask "@bob" "本番に出してよい?" "出してよい" "待って" --code=<code>)
+#   -> slack ask --waitFor='https://acme.slack.com/archives/C00000001/p1700000000000100'
+# Run it whenever you like: it re-reads the question from Slack, so nothing is
+# stored locally and any machine holding the link can collect. Same stdout/exit
+# contract as --wait, plus --timeout 0 = check once (exit 2 while still open),
+# which is what a periodic monitor should use instead of parking on --wait.
+eval "$RESUME --timeout 0" && echo answered
+# A pressed pill is invisible to `slack tail` (it only sees `type: "message"`
+# events and drops `message_changed`), so this is the only way to hear about an
+# answer to a question you did not block on.
+
 # Task tracking on top of reactions — :pushpin: marks a message as a task,
 # a second reaction carries its progress (see "todo" below)
 slack todo ls                                  # my open tasks
@@ -238,7 +268,12 @@ Requires a Slack user token (`xoxp-...`) with the following scopes:
 - `channels:read`, `groups:read`, `im:read`, `mpim:read` — for channel listing
 - `users:read` — for resolving display names
 - `chat:write` — for sending messages
-- `reactions:write` — for `react` (add/remove reactions)
+- `reactions:write` — for `react` and for `ask` (seeding / clearing the choice pills)
+
+`ask` needs no `reactions:read`: it reads the answers back from
+`conversations.history`, which returns each message's `reactions` (with the user
+list) under the `*:history` scopes above. `reactions.get` would need
+`reactions:read`, so it is deliberately not used.
 
 > Add each scope to the **token type the CLI actually uses**. The CLI defaults to the
 > **user token** (`xoxp-...`), so `reactions:write` must be under **User Token Scopes**.

package/SKILL.md

@@ -85,6 +85,14 @@ slack delete "<permalink>"
 slack react "#general:1700000000.000100" white_check_mark
 slack react "<permalink>" eyes --remove   # take it back
 
+# Ask a question with its choices pre-seeded as 1️⃣..🔟 reactions (same confirm gate)
+# The question MUST @tag whoever may answer — only their reaction/reply counts.
+slack ask "#eng" "@alice この PR 出してよい?" "出す" "待つ"
+ANS=$(slack ask "@bob" "出してよい?" "はい" "待って" --code=<code> --wait)  # blocks
+RESUME=$(slack ask "@bob" "出してよい?" "はい" "待って" --code=<code>)      # does not
+#   RESUME -> slack ask --waitFor='<permalink>'    # collect the answer later
+eval "$RESUME --timeout 0"                        # check once: 0 answered / 2 still open
+
 # Task tracking on reactions — 📌 marks a task, a second reaction holds progress
 slack todo ls                                     # EVERYONE's open tasks (has:)
 slack mytodo ls                                   # only tasks YOU reacted to (hasmy:)
@@ -138,6 +146,37 @@ and no one has replied since — `⚠ 相手はまだ返信していません…
 on that message instead of piling on a new one. Reply-status based, not time-based; opt
 out with `SLACK_UNREPLIED_WARN=0`.
 
+### ask — a question whose answer is one tap
+
+Choices are posted as 1️⃣..🔟 reactions on the question itself, so answering costs one tap
+on an existing pill. Reactions, not Block Kit buttons: `block_actions` are delivered only
+to a Request URL or a Socket Mode socket, neither of which a short-lived CLI can own
+without losing clicks. A reaction is durable state anyone can read back later.
+
+- **The question must @tag whoever may answer** (`@alice`, or `@here`/`@channel` for the
+  whole channel). Only their reaction/reply is taken as the answer; an unaddressed
+  question is refused (exit 3) rather than let the first bystander decide it. In a 1:1 DM
+  the other party counts automatically.
+- **Answer paths**: a pill, or free text. In a DM a plain reply counts; in a channel only
+  reactions and thread replies do (a channel carries unrelated traffic).
+- **Two pills pressed = no answer.** Changing your mind leaves both reactions in place, so
+  `ask` says so in the thread once and keeps waiting rather than guessing.
+- **Exit codes** are the contract: `0` answered (the answer alone on stdout), `2` timed
+  out, `3` transport/config failure. Everything human-facing goes to stderr, so
+  `ANS=$(slack ask … --wait)` is safe.
+
+**Collecting an answer you did not block on.** Without `--wait`, stdout is a runnable
+`slack ask --waitFor='<permalink>'`. Run it any time — it re-reads the question from Slack
+and recovers everything it needs by parsing the message, so nothing is stored locally and
+any machine with the link can collect. It reports an already-answered question (the
+✅-stamped body) immediately, and refuses (exit 3) a message that is not an ask.
+`--timeout 0` checks exactly once, which is what a periodic monitor should use: `--wait`
+parks the process, and a parked lane still looks *active* in `ay ls`.
+
+This path is not optional convenience — **a pressed pill is invisible to `slack tail`**,
+which only sees `type: "message"` events and drops `message_changed`. Without `--waitFor`
+an answer can be pressed and nobody ever hears about it.
+
 ### todo — tasks as reactions
 
 A task is any message carrying the marker reaction 📌 `:pushpin:`. Progress lives in a