slack-term 1.40.0 → 1.41.1

package/README.md

@@ -123,11 +123,15 @@ 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.
+# A ❓ "その他 (other)" pill always follows the choices: pressing it means "none of
+# these" and the answer comes as a reply (exit 5), not as the ❓ itself.
+# The instructions are posted in ja or en: --lang / SLACK_TERM_LANG, else the
+# answerers' Slack locale, else the question's own language, else $LANG, else ja.
 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,
-# 4 = a reply matched several choices, 5 = a free-text reply that picked NO choice —
+# 4 = a reply matched several choices, 6 = the question was voided, 5 = a free-text reply that picked NO choice —
 # the reply text is on stdout, it is not a decision, and the question stays open.
 #
 # The question must say WHO may answer — only their reaction/reply is taken as the
@@ -138,8 +142,20 @@ slack ask "#eng" "@here 誰か見れる?" "見る" "あとで"            # anyo
 #
 # 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.
+# Once answered, the question is edited to "✅ …回答済み > <answer>" — the body/background
+# and the CHOSEN option line stay; the other options, ❓ line and instructions go. The
+# unpressed seeds are removed, leaving the chosen pill visible.
+#
+# Thread notes (audience replies that are not the answer, even after ✅) go to
+# stderr; --json puts {answer, notes[], cursor} on stdout. Feed cursor back as --after:
+#   slack ask --waitFor='<permalink>' --timeout 0 --json --after=<cursor>
+#
+# Retire a question that expired / stopped meaning anything (無効化) — waits on it exit 6:
+#   slack ask --void='<permalink>' --reason 'head moved' --superseded-by '<new permalink>'
+# Change one: slack ask --edit='<permalink>' ["new question" [choices…]] [--body …]
+#   (options only while unanswered; after that: --void='<permalink>' --reask …)
+# List mine with live state: slack ask --ls [--stale 24h] [--state all] [--json]
+# (`slack edit` refuses an edit that would break an ask/poll; --force overrides.)
 #
 # WITHOUT --wait, stdout is the command that collects the answer later:
 RESUME=$(slack ask "@bob" "本番に出してよい?" "出してよい" "待って" --code=<code>)

package/SKILL.md

@@ -162,11 +162,19 @@ without losing clicks. A reaction is durable state anyone can read back later.
   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).
+- **❓ is the standing "other" choice.** Every question with choices lists it last
+  (`1️⃣ … 2️⃣ … 3️⃣ … ❓ その他 — スレッドで返信`) and seeds it after the keycaps. Pressing it
+  is not an answer — `--wait` notes it on stderr and keeps waiting for the reply, which
+  arrives as free text (exit `5`).
+- **The instructions are posted in `ja` or `en`.** `--lang` (or `SLACK_TERM_LANG`) decides;
+  otherwise the answerers' Slack locale when they all share one, else the language the
+  question is written in, else the system locale, else `ja`. The confirm gate prints the
+  choice and why (`Language: en (answerers' Slack locale; …)`). `--waitFor` reads either.
 - **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` nobody
   replied, `3` transport/config failure, `4` a reply matched several choices (stdout
-  empty), `5` a **free-text reply** that picked none of the offered choices — the reply
+  empty), `6` the question was **voided** (stop waiting), `5` a **free-text reply** that picked none of the offered choices — the reply
   text is on stdout. Everything human-facing goes to stderr, so
   `ANS=$(slack ask … --wait)` is safe.
 - **A reply that chooses nothing is delivered, but is not a decision.** When choices were
@@ -177,6 +185,46 @@ without losing clicks. A reaction is durable state anyone can read back later.
   so a pill pressed later still decides it: re-wait past the delivered reply with
   `slack ask --waitFor='<permalink>' --after=<reply ts>` (stderr prints this line).
 
+**Thread notes ride along with the answer.** A reply from the audience that is not the
+answer (「あと cswap ls も見て」 next to a pressed pill) is a *note*. Notes are read even when
+a pill answered, and again on every `--waitFor` of a ✅ question, so a note written after
+the answer still reaches you. Plain mode: stdout is still the answer alone, and the notes go
+to stderr. `--json`: stdout is one object
+`{status, answer, how, who, notes:[{ts,user,text,permalink}], cursor, permalink}`, with the same
+exit codes. Pass `cursor` back as `--after` on your next `--waitFor --timeout 0` and you
+never get the same note twice. Only the question's audience counts; the asker, bots and
+bystanders are never notes.
+
+**Answering keeps the context.** The ✅ rewrite keeps the question's body (its background)
+and the chosen option; only the options not chosen, the ❓ line and the instructions go.
+The head is unchanged (`:white_check_mark:` prefix, question, stamp, quoted answer), so
+anything that keys on the prefix or re-reads the answer works on old and new ✅ bodies alike.
+
+**Voiding a question (無効化).** When a question has expired or stopped meaning anything
+(the head it was pinned to moved, the decision was made elsewhere), retire it:
+`slack ask --void='<permalink>' --reason '…' [--superseded-by '<new permalink>']`
+(repeatable `--void=`; alias `slack ask void <link…>`; same `--code` gate; own questions
+only, `--as-bot` for the bot's). The text becomes `:no_entry_sign:` + reason with the body
+kept, our pills come off, and a 🚫 reaction is added. Three states, three prefixes:
+`:question:` open, `:white_check_mark:` answered, `:no_entry_sign:` void. `--wait` /
+`--waitFor` on a void question **exit 6** (`--json` → `status: "void"`): stop waiting.
+Answered questions cannot be voided.
+
+**Changing a question: `--edit`, not `slack edit`.**
+`slack ask --edit='<permalink>' ["new question" [choices…]] [--body …]` rebuilds it with the
+ask layout (same `--code` gate), so collect still reads it. Wording can change any time;
+the **options** only while nobody has answered. After that, re-ask it:
+`slack ask --void='<permalink>' --reask [--reason …] ["new question" [choices…]]` posts the
+question again in the same place (old text/choices/body unless you give new ones) and voids
+the old one as replaced by it — one gate for both. Plain `slack edit` refuses an edit that
+would break an ask/poll (text no longer readable, or an answered/void question made open
+again); edits that keep it readable — e.g. a script writing the ✅ form — pass as usual.
+
+**What did I ask, and what became of it.** `slack ask --ls` lists your asks from the local
+sent-log with their LIVE state (`--state open|answered|void|all`, default open; `--channel`;
+`--json`). `--ls --stale 24h` = open and older than 24h, and prints the one `--void=` command
+that would retire them all (behind the usual gate). Only asks sent from this machine.
+
 **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
@@ -367,6 +415,7 @@ slack news --limit 1
 - **`conversations.invite` reports success but the member never shows up** — the invited user is likely a single-channel guest (`is_ultra_restricted`); Slack silently no-ops the invite since that account type can only ever belong to the one channel it was created in. `channel create --invite` now warns about this up front.
 - **Send is rejected with "use #channel or @user"** — the CLI enforces human-readable targets. Use `#channel-name` or `@display-name`, not raw IDs.
 - **Confirm code mismatch on any gated write** — the content, target or acting identity changed between preview and confirm (a different profile/`SLACK_TOKEN`, or `--as-bot` added or dropped). Re-run without `--code` for a fresh preview, and re-check the `From:` line and the `→` destination line (THREAD REPLY vs NEW top-level message).
+- **`refusing to act as YOU — SLACK_BOT_TOKEN is exported …`** — you set a bot token in the shell or a project `.env` (not the global `~/.config/slack-cli/.env`) but ran a write without `--as-bot`, which would post as the logged-in person. Add `--as-bot` to post as the app; to post as yourself, set `SLACK_TOKEN` or clear the bot token for that run (`SLACK_BOT_TOKEN= slack …`). Reads are never refused.
 - **Enterprise Grid / admin-locked workspace** — custom app installation may need admin approval or be disabled outright.
 
 ## Safety