slack-term 1.44.0 → 1.46.0

package/ts/cli.ts

@@ -20,6 +20,8 @@ import { agentCommands } from "./agent.ts";
 import {
   ASK_KEYCAPS,
   ASK_MARKER,
+  ASK_OTHER_MARKER,
+  ASK_OTHER_MARKERS,
   ASK_EXPLAIN_MARKER,
   ASK_RESOLVED_MARKER,
   ASK_MAX_REACTION_CHOICES,
@@ -27,6 +29,7 @@ import {
   askIsExplainNote,
   askBuildResolvedText,
   askParseMessage,
+  askSeedMarker,
   askExplainReject,
   askFlatten,
   askMatchChoice,
@@ -114,7 +117,10 @@ import {
   userName,
   getPath,
   type Json,
+  savedAdd,
+  savedDelete,
   savedList,
+  savedUpdate,
 } from "./slack.ts";
 import { isDone, messagePermalink, parseSavedItems, sortTodos, TODO_FILTERS, todoStatus, type TodoFilter, type TodoItem } from "./slackTodos.ts";
 import {
@@ -880,8 +886,13 @@ async function cmdDrafts(token: string, cookie?: string, showAll = false): Promi
 }
 
 // --- todos (Slack's To-dos tab) ---
-// Read-only. Pages through saved.list up to `limit` items, then shows each
-// to-do with its due date, where it lives, and the message it points at.
+// Read-only. Reads the whole view, sorts it by due date, then shows the first
+// `limit` with where each lives and the message it points at. saved.list does
+// not return items in due order, so cutting before sorting could hide an
+// overdue to-do behind a later one; the read is capped at TODOS_MAX_PAGES.
+const TODOS_PAGE = 50;
+const TODOS_MAX_PAGES = 20;
+
 async function cmdTodos(
   token: string,
   cookie: string | undefined,
@@ -889,12 +900,14 @@ async function cmdTodos(
 ): Promise<void> {
   const items: TodoItem[] = [];
   let cursor: string | undefined;
+  let pages = 0;
   do {
-    const resp = asRecord((await savedList(token, { filter: opts.filter, limit: Math.min(opts.limit, 100), cursor }, cookie)) as Json);
+    const resp = asRecord((await savedList(token, { filter: opts.filter, limit: TODOS_PAGE, cursor }, cookie)) as Json);
     items.push(...parseSavedItems(resp as Json));
     const next = asRecord(resp.response_metadata).next_cursor;
     cursor = typeof next === "string" && next ? next : undefined;
-  } while (cursor && items.length < opts.limit);
+  } while (cursor && ++pages < TODOS_MAX_PAGES);
+  if (cursor) console.error(`Note: read the first ${items.length} items only (${TODOS_MAX_PAGES} pages); the order covers those.`);
   const shown = sortTodos(items).slice(0, opts.limit);
 
   if (shown.length === 0) {
@@ -938,6 +951,139 @@ async function cmdTodos(
   }
 }
 
+// --- todos add / done / edit / rm — gated writes to your To-dos ---
+// Every To-do points at a message, so the target is a message (permalink or
+// #chan:<ts>). Same two-step as send: the first run previews and prints a code,
+// the rerun with --code=<code> writes. Your own To-dos only — the session token
+// can touch no one else's.
+type TodoOp =
+  | { kind: "add"; due?: number; saved?: boolean }
+  | { kind: "done"; undo: boolean }
+  | { kind: "edit"; due?: number; todo?: boolean }
+  | { kind: "rm" };
+
+// The saved item for one message (saved.delete answers ok even when there is
+// nothing to delete, so writes check first). Views are searched in the order
+// the op most likely needs, stopping at the first match, and the whole search
+// is capped at TODOS_MAX_PAGES pages so a long saved history can't turn one
+// command into a burst of saved.list calls. "unknown" = cap hit, not found.
+function findOrder(op: TodoOp): TodoFilter[] {
+  if (op.kind === "done") return op.undo ? ["completed", "todo", "saved", "archived"] : ["todo", "saved", "completed", "archived"];
+  return ["todo", "saved", "completed", "archived"];
+}
+
+async function findSavedItem(
+  token: string,
+  cookie: string | undefined,
+  channel: string,
+  ts: string,
+  order: TodoFilter[],
+): Promise<TodoItem | "unknown" | undefined> {
+  let pages = 0;
+  for (const filter of order) {
+    let cursor: string | undefined;
+    do {
+      if (pages++ >= TODOS_MAX_PAGES) return "unknown";
+      const resp = asRecord((await savedList(token, { filter, limit: TODOS_PAGE, cursor }, cookie)) as Json);
+      const hit = parseSavedItems(resp as Json).find((t) => t.channel === channel && t.ts === ts);
+      if (hit) return hit;
+      const next = asRecord(resp.response_metadata).next_cursor;
+      cursor = typeof next === "string" && next ? next : undefined;
+    } while (cursor);
+  }
+  return undefined;
+}
+
+function todoOpLines(op: TodoOp, fmtDue: (sec: number) => string): string[] {
+  const due = (d: number | undefined) => (d === undefined ? [] : [`  Due:    ${d ? fmtDue(d) : "(clear the due date)"}`]);
+  switch (op.kind) {
+    case "add": return [`  Action: add as ${op.saved ? "a saved item (no checkbox)" : "a to-do"}`, ...due(op.due)];
+    case "done": return [`  Action: mark ${op.undo ? "NOT done (reopen)" : "done"}`];
+    case "edit": return [
+      "  Action: edit",
+      ...(op.todo === undefined ? [] : [`  Kind:   ${op.todo ? "to-do" : "saved item (no checkbox)"}`]),
+      ...due(op.due),
+    ];
+    case "rm": return ["  Action: REMOVE from your To-dos (the message itself is untouched)"];
+  }
+}
+
+async function cmdTodosWrite(token: string, cookie: string | undefined, target: string, op: TodoOp, code?: string): Promise<void> {
+  const { ref, ts } = splitRefTs(target);
+  if (!ts) {
+    console.error("Error: a To-do points at a message — give its permalink or #chan:<ts> (see `slack todos ls`).");
+    process.exit(2);
+  }
+  if (op.kind === "edit" && op.due === undefined && op.todo === undefined) {
+    console.error("Error: nothing to edit — pass --due <time|none>, --todo or --saved.");
+    process.exit(2);
+  }
+  const channel = await resolveChannel(token, ref, cookie);
+  const found = await findSavedItem(token, cookie, channel, ts, findOrder(op));
+  if (found === "unknown" && op.kind !== "add") {
+    console.error(`Error: not found in the first ${TODOS_MAX_PAGES * TODOS_PAGE} saved items — stopped there to stay under Slack's rate limits. Nothing was changed.`);
+    process.exit(1);
+  }
+  const existing = found === "unknown" ? undefined : found;
+  if (op.kind === "add" && existing) {
+    console.error(`Error: that message is already in your To-dos (${isDone(existing) ? "done" : existing.todoState || "saved"}) — use \`slack todos edit\` or \`done\`.`);
+    process.exit(1);
+  }
+  if (op.kind !== "add" && !existing) {
+    console.error("Error: that message is not in your To-dos — nothing to change. `slack todos ls --filter saved` lists everything saved.");
+    process.exit(1);
+  }
+
+  let teamUrl = "";
+  let me = "";
+  try { ({ url: teamUrl, userId: me } = await authScopes(token, cookie)); } catch { /* preview degrades */ }
+  const label = await (await buildChLabelResolver(token, cookie, me))(channel);
+  let msg: Record<string, Json> | undefined;
+  try {
+    const r = asRecord((await replies(token, channel, ts, 1, cookie)) as Json);
+    msg = asArray(r.messages).map(asRecord).find((m) => m.ts === ts);
+  } catch { /* not readable */ }
+  const author = typeof msg?.user === "string" ? `@${await userName(token, msg.user, cookie)}: ` : "";
+  const raw = typeof msg?.text === "string" ? msg.text.split("\n")[0] ?? "" : "(message not readable)";
+  const head = maskSecrets(raw.length > 100 ? `${raw.slice(0, 100)}…` : raw);
+  const now = Date.now() / 1000;
+
+  const expected = safetyCode("todos", JSON.stringify(op), channel, ts, me);
+  if (code !== expected) {
+    requireCode(code, expected, [
+      "--- To-do ------------------------------------",
+      `  For:    ${me ? `@${await userName(token, me, cookie)} (your own To-dos)` : "(your own To-dos)"}`,
+      `  Where:  ${stripTerminalControls(label)}`,
+      `  Msg:    ${stripTerminalControls(author + head)}`,
+      ...(teamUrl ? [`  Link:   ${messagePermalink(teamUrl, channel, ts)}`] : []),
+      ...(existing ? [`  Now:    ${todoStatus(existing, now, formatYmdHm)}`] : []),
+      ...(found === "unknown" ? [`  Note:   not checked beyond the first ${TODOS_MAX_PAGES * TODOS_PAGE} saved items — it may already be saved`] : []),
+      ...todoOpLines(op, fmtPostAt),
+      "----------------------------------------------",
+    ]);
+  }
+
+  const at = { channel, ts };
+  switch (op.kind) {
+    case "add":
+      await savedAdd(token, at, { todo: !op.saved, ...(op.due ? { due: op.due } : {}) }, cookie);
+      console.log(`✓ Added to your To-dos${op.due ? ` (due ${formatYmdHm(op.due)})` : ""}`);
+      break;
+    case "done":
+      await savedUpdate(token, at, { mark: op.undo ? "uncompleted" : "completed" }, cookie);
+      console.log(op.undo ? "✓ Reopened" : "✓ Marked done");
+      break;
+    case "edit":
+      await savedUpdate(token, at, { ...(op.todo === undefined ? {} : { todo: op.todo }), ...(op.due === undefined ? {} : { due: op.due }) }, cookie);
+      console.log("✓ Updated");
+      break;
+    case "rm":
+      await savedDelete(token, at, cookie);
+      console.log("✓ Removed from your To-dos");
+      break;
+  }
+}
+
 // --- drafts get ---
 async function cmdDraftGet(token: string, cookie: string | undefined, draftId: string): Promise<void> {
   const resp = (await listDrafts(token, cookie)) as Record<string, Json>;
@@ -2612,6 +2758,9 @@ interface AskWaitCtx {
    *  nothing". */
   overflow: string[];
   threadOnly: boolean;
+  /** The marker reaction this question was seeded with (➕, or ❓ on a
+   *  free-text question or one posted before ➕) — what the ✅ swap takes off. */
+  seedMarker: string;
   /** The language the question's copy is in — the ✅ stamp and the
    *  invalid-ballot line are written in the same one. */
   lang: AskLang;
@@ -2869,17 +3018,21 @@ function askPoller(token: string, ctx: AskWaitCtx, readOnly = false): {
     }
   }
 
-  /** Who has pressed ❓ ("other"). Not an answer — ❓ carries no text — so it
-   *  never resolves anything; the reply that should follow it does. Reported
-   *  once per person so the operator knows a reply is on its way rather than
-   *  reading the silence as "nobody looked". */
+  /** Who has pressed ➕ ("other") — or ❓, the other pill on questions posted
+   *  before ➕, which is still pressed out of habit. Not an answer — neither
+   *  carries text — so it never resolves anything; the reply that should
+   *  follow it does. Reported once per person so the operator knows a reply is
+   *  on its way rather than reading the silence as "nobody looked". */
   const otherReported = new Set<string>();
   function noteOther(msg: Record<string, Json>): void {
-    const r = asArray(msg.reactions).map(asRecord).find((x) => x.name === ASK_MARKER);
-    for (const u of r ? asArray(r.users).filter(isAnswerer) : []) {
-      if (otherReported.has(u)) continue;
-      otherReported.add(u);
-      if (!readOnly) console.error(`  (<@${u}> が ❓ その他 を押しました。返信を待ちます)`);
+    for (const r of asArray(msg.reactions).map(asRecord)) {
+      if (typeof r.name !== "string" || !ASK_OTHER_MARKERS.includes(r.name)) continue;
+      const glyph = r.name === ASK_OTHER_MARKER ? "➕" : "❓";
+      for (const u of asArray(r.users).filter(isAnswerer)) {
+        if (otherReported.has(u)) continue;
+        otherReported.add(u);
+        if (!readOnly) console.error(`  (<@${u}> が ${glyph} その他 を押しました。返信を待ちます)`);
+      }
     }
   }
 
@@ -3158,12 +3311,12 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
       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
-      // ever asked. Removal last — a crash between the two leaves the question
+      // `has::question: OR has::heavy_plus_sign:` should list what still needs
+      // answering, not everything ever asked. Removal last — a crash between the two leaves the question
       // findable under BOTH, which is recoverable; the reverse loses it.
       try {
         await reactionAdd(token, channelId, ts, ASK_RESOLVED_MARKER, cookie);
-        await reactionRemove(token, channelId, ts, ASK_MARKER, cookie);
+        await reactionRemove(token, channelId, ts, ctx.seedMarker, cookie);
       } catch {
         // Cosmetic: the ✅ in the body is what actually marks it resolved.
       }
@@ -3513,10 +3666,12 @@ async function cmdAsk(token: string, args: AskArgs): Promise<void> {
   const ts = await slackSend(token, channelId, message, threadTs, false, cookie, true, attr.metadata);
 
   // The marker goes on LAST, after 1,2,3, because it doubles as the "other"
-  // choice the body lists under the numbered ones (people were already pressing
-  // ❓ for "none of these fit"). It is a reaction so
-  // `has::question:` lists every question the way `has::pushpin:` lists every
-  // todo. Body text cannot do that job: Slack's index splits on punctuation, so
+  // choice the body lists under the numbered ones: ➕ (ASK_OTHER_MARKER). A
+  // free-text question has no other choice and seeds ❓. It is a reaction so
+  // `has::question: OR has::heavy_plus_sign:` lists every open question the
+  // way `has::pushpin:` lists every todo — though ➕ is a common emoji, so that
+  // search can also match unrelated messages (`slack ask --ls` reads the local
+  // sent-log and is unaffected). Body text cannot do that job: Slack's index splits on punctuation, so
   // a `:question:` written in the text is indexed as the word "question" and
   // matches unrelated messages (measured). Only a real reaction is searchable.
   //
@@ -3527,14 +3682,15 @@ async function cmdAsk(token: string, args: AskArgs): Promise<void> {
   // enough: measured on two real questions from the same build, one came back
   // `two|one|question|three`. See ts/reactionSeed.ts for the evidence and for
   // SLACK_REACTION_SEED_GAP_MS.
+  const seedMarker = reactable.length ? ASK_OTHER_MARKER : ASK_MARKER;
   await seedReactionsInOrder(
-    [...reactable.map((_, i) => ASK_KEYCAPS[i]!.name), ASK_MARKER, ...(explain ? [ASK_EXPLAIN_MARKER] : [])],
+    [...reactable.map((_, i) => ASK_KEYCAPS[i]!.name), seedMarker, ...(explain ? [ASK_EXPLAIN_MARKER] : [])],
     (name) => reactionAdd(token, channelId, ts, name, cookie),
     (name, e) => {
       const why = e instanceof Error ? e.message : String(e);
       // The marker is cosmetic + searchability; a keycap only costs the
       // answerer a trip to the emoji picker. Neither abandons a posted question.
-      if (name === ASK_MARKER) console.error(`  (marker ${name} を付けられませんでした: ${why})`);
+      if (name === seedMarker) console.error(`  (marker ${name} を付けられませんでした: ${why})`);
       else console.error(`  (リアクション ${name} を付けられませんでした: ${why})`);
     },
   );
@@ -3575,6 +3731,7 @@ async function cmdAsk(token: string, args: AskArgs): Promise<void> {
     reactable,
     overflow,
     threadOnly,
+    seedMarker,
     lang,
     audience,
     broadcast,
@@ -3667,7 +3824,7 @@ async function askLoadOwnOpen(token: string, link: string, self: Self | null, as
   if (parsed.kind === "void") return "void";
   if (parsed.kind === "resolved") { console.error(`✗ ${shown}: 回答済みの質問です（回答: ${stripTerminalControls(parsed.answer.split("\n")[0] ?? "")}）— 変更できません`); return null; }
   if (parsed.kind !== "open") { console.error(`✗ ${shown}: \`slack ask\` の質問として読み取れません — ${askExplainReject(text)}`); return null; }
-  const out: AskVoidTarget & { msg: Record<string, Json>; threadTs?: string } = { link, channelId: got.channelId, ts: got.ts, parsed, msg };
+  const out: AskVoidTarget & { msg: Record<string, Json>; threadTs?: string } = { link, channelId: got.channelId, ts: got.ts, parsed, seedMarker: askSeedMarker(text) ?? ASK_MARKER, msg };
   if (got.threadTs) out.threadTs = got.threadTs;
   return out;
 }
@@ -3695,7 +3852,7 @@ async function askHasResponses(token: string, t: { channelId: string; ts: string
 }
 
 /** `slack ask --edit=<link> ["new question" [choices…]] [--body …]` — change an
- *  open question THROUGH the ask builder, so pills, ❓, the instructions and the
+ *  open question THROUGH the ask builder, so pills, ➕, the instructions and the
  *  body stay in the layout collect reads back (a free-hand `slack edit` is what
  *  this replaces; `edit` now refuses ask messages without --force).
  *
@@ -3778,17 +3935,32 @@ async function cmdAskEdit(token: string, args: {
   }
 
   await editMessage(token, t.channelId, t.ts, next, args.cookie, true);
+  // The body was rebuilt, so its other line now says ➕ (or there is none, on
+  // a free-text question) — the marker seed follows it.
+  const seedMarker = reactable.length ? ASK_OTHER_MARKER : ASK_MARKER;
+  const oldSeed = askSeedMarker(oldText) ?? ASK_MARKER;
   if (choicesChanged) {
-    // Re-seed in order: 1..n then ❓ last, as a fresh question has them.
-    const tail = old.explain ? [ASK_MARKER, ASK_EXPLAIN_MARKER] : [ASK_MARKER];
-    for (const name of [...old.reactable.map((_, i) => ASK_KEYCAPS[i]!.name), ...tail]) {
+    // Re-seed in order: 1..n then ➕ last, as a fresh question has them. The
+    // old marker comes off as whatever it was seeded as (❓ on an old pill).
+    const tail = (m: string) => old.explain ? [m, ASK_EXPLAIN_MARKER] : [m];
+    for (const name of [...old.reactable.map((_, i) => ASK_KEYCAPS[i]!.name), ...tail(oldSeed)]) {
       try { await reactionRemove(token, t.channelId, t.ts, name, args.cookie); } catch { /* already gone */ }
     }
     await seedReactionsInOrder(
-      [...reactable.map((_, i) => ASK_KEYCAPS[i]!.name), ...tail],
+      [...reactable.map((_, i) => ASK_KEYCAPS[i]!.name), ...tail(seedMarker)],
       (name) => reactionAdd(token, t.channelId, t.ts, name, args.cookie),
       (name, e) => console.error(`  (リアクション ${name} を付けられませんでした: ${e instanceof Error ? e.message : String(e)})`),
     );
+  } else if (oldSeed !== seedMarker) {
+    // An old ❓ pill edited without touching its choices: the body now lists
+    // ➕, so swap the seed to match. Add before remove, as the ✅ swap does —
+    // a failure in between leaves both, which still collects.
+    try {
+      await reactionAdd(token, t.channelId, t.ts, seedMarker, args.cookie);
+      await reactionRemove(token, t.channelId, t.ts, oldSeed, args.cookie);
+    } catch (e: unknown) {
+      console.error(`  (marker を ${seedMarker} に替えられませんでした: ${e instanceof Error ? e.message : String(e)})`);
+    }
   }
   console.error(`✓ 編集しました: ${stripTerminalControls(args.link)}`);
 }
@@ -4031,9 +4203,12 @@ interface AskVoidTarget {
   channelId: string;
   ts: string;
   parsed: Extract<ReturnType<typeof askParseMessage>, { kind: "open" }>;
+  /** The marker reaction it was seeded with (➕, or ❓ on an old pill / free
+   *  text) — what the void takes off. */
+  seedMarker: string;
 }
 
-/** Void one question: the 🚫 text (body kept), our seeds and ❓ off, 🚫 on.
+/** Void one question: the 🚫 text (body kept), our seeds and marker (➕, or ❓) off, 🚫 on.
  *  The text is what marks it void; the reactions are cleanup + searchability,
  *  so a failure there is reported and does not undo the void. */
 async function askApplyVoid(token: string, t: AskVoidTarget, reason: string, supersededBy: string | undefined, cookie?: string): Promise<boolean> {
@@ -4045,7 +4220,7 @@ async function askApplyVoid(token: string, t: AskVoidTarget, reason: string, sup
     console.error(`✗ ${shown}: 書き換えに失敗しました: ${e instanceof Error ? e.message : String(e)}`);
     return false;
   }
-  for (const name of [...t.parsed.reactable.map((_, i) => ASK_KEYCAPS[i]!.name), ASK_MARKER, ...(t.parsed.explain ? [ASK_EXPLAIN_MARKER] : [])]) {
+  for (const name of [...t.parsed.reactable.map((_, i) => ASK_KEYCAPS[i]!.name), t.seedMarker, ...(t.parsed.explain ? [ASK_EXPLAIN_MARKER] : [])]) {
     try { await reactionRemove(token, t.channelId, t.ts, name, cookie); } catch { /* not ours / already gone */ }
   }
   try {
@@ -4068,7 +4243,7 @@ async function askApplyVoid(token: string, t: AskVoidTarget, reason: string, sup
  *
  *  What voiding does, per question: the text becomes the 🚫 form (head, void
  *  stamp with the reason, optional pointer to the replacement, the body); our
- *  seeded pills and the ❓ marker come off; a 🚫 reaction goes on. Pills someone
+ *  seeded pills and the marker (➕, or ❓) come off; a 🚫 reaction goes on. Pills someone
  *  already pressed stay — Slack lets only their owner remove them — and are
  *  never collected, because a void is never polled again.
  *
@@ -4101,7 +4276,7 @@ async function cmdAskVoid(token: string, args: { links: string[]; reason: string
       process.exit(ASK_EXIT_ERROR);
     }
   }
-  type Target = { link: string; channelId: string; ts: string; text: string; parsed: Extract<ReturnType<typeof askParseMessage>, { kind: "open" }>; pressed: string[]; unreadable?: boolean };
+  type Target = { link: string; channelId: string; ts: string; text: string; parsed: Extract<ReturnType<typeof askParseMessage>, { kind: "open" }>; seedMarker: string; pressed: string[]; unreadable?: boolean };
   const targets: Target[] = [];
   let refused = 0;
   for (const link of args.links) {
@@ -4144,11 +4319,16 @@ async function cmdAskVoid(token: string, args: { links: string[]; reason: string
       };
       unreadable = true;
     }
+    // Our marker: what the body names, or — for an unreadable body — ➕ if we
+    // seeded one, else ❓ (an old pill, or free text).
+    const seedMarker = unreadable
+      ? (asArray(msg.reactions).map(asRecord).some((r) => r.name === ASK_OTHER_MARKER && asArray(r.users).includes(self?.userId ?? "\u0000")) ? ASK_OTHER_MARKER : ASK_MARKER)
+      : askSeedMarker(text) ?? ASK_MARKER;
     const pressed = asArray(msg.reactions).map(asRecord)
       .filter((r) => typeof r.name === "string" && ASK_KEYCAPS.some((k) => k.name === r.name))
       .filter((r) => asArray(r.users).some((u) => u !== self?.userId))
       .map((r) => `:${String(r.name)}:`);
-    targets.push({ link, channelId: got.channelId, ts: got.ts, text, parsed, pressed, ...(unreadable ? { unreadable } : {}) });
+    targets.push({ link, channelId: got.channelId, ts: got.ts, text, parsed, seedMarker, pressed, ...(unreadable ? { unreadable } : {}) });
   }
   if (!targets.length) {
     console.error(refused ? "無効化できる質問がありません。" : "何もすることがありません。");
@@ -4166,7 +4346,7 @@ async function cmdAskVoid(token: string, args: { links: string[]; reason: string
       ...targets.map((t) => `   • ${stripTerminalControls(t.link)}\n     ${stripTerminalControls(t.parsed.question.split("\n")[0] ?? "").slice(0, 100)}` +
         (t.pressed.length ? `\n     (already pressed: ${t.pressed.join(" ")} — left in place, never collected)` : "") +
         (t.unreadable ? `\n     ⚠ its layout no longer reads as an ask (edited by hand?) — voided from a best-effort read: question and the rest of the text kept as they are` : "")),
-      `  Each becomes 🚫 (body kept, options and instructions removed); our pills and ❓ come off; a 🚫 reaction is added.`,
+      `  Each becomes 🚫 (body kept, options and instructions removed); our pills and marker (➕, or ❓) come off; a 🚫 reaction is added.`,
       ...(refused ? [`  (${refused} link(s) above were refused and will be skipped)`] : []),
       `----------------------------------------------`,
     ]);
@@ -4350,6 +4530,7 @@ function askWaitCtxFrom(
     reactable: parsed.reactable,
     overflow: parsed.overflow,
     threadOnly: parsed.threadOnly,
+    seedMarker: askSeedMarker(q.text) ?? ASK_MARKER,
     lang: parsed.lang,
     audience: q.audience,
     broadcast: q.broadcast,
@@ -4714,6 +4895,16 @@ async function botDmForTarget(
   return openDm(botToken, userId);
 }
 
+/** A `--due` value as epoch seconds; exits 2 on an unparseable one. */
+function todoDue(v: string): number {
+  try {
+    return parsePostAt(v);
+  } catch {
+    console.error(`Error: cannot parse --due "${v}" — use an ISO datetime (2026-11-01T18:00) or a Unix ts.`);
+    process.exit(2);
+  }
+}
+
 function parsePostAt(at: string): number {
   if (/^\d{10,}$/.test(at)) return parseInt(at, 10);
   const d = new Date(at.replace(" ", "T"));
@@ -5919,7 +6110,7 @@ async function main(): Promise<void> {
         .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("explain", { type: "boolean", describe: "Also offer an ℹ️ 'explain' pill (seeded after ❓): pressing it asks YOU to explain the question in its thread and is never an answer — the question stays open. --wait/--waitFor report it on stderr (and as `explain` in --json), and post one thread note per question. Default: $SLACK_TERM_ASK_EXPLAIN=1 turns it on; --no-explain turns it off." })
+        .option("explain", { type: "boolean", describe: "Also offer an ℹ️ 'explain' pill (seeded after ➕): pressing it asks YOU to explain the question in its thread and is never an answer — the question stays open. --wait/--waitFor report it on stderr (and as `explain` in --json), and post one thread note per question. Default: $SLACK_TERM_ASK_EXPLAIN=1 turns it on; --no-explain turns it off." })
         .option("explain-exit", { type: "boolean", default: false, describe: "With --wait / --waitFor: exit 7 (stdout empty; --json status \"explain\") when someone presses ℹ️ — once per question, on the run that posts the thread note. The question stays open: explain, then collect again." })
         .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)" })
@@ -7109,7 +7300,7 @@ async function main(): Promise<void> {
     )
     .command(
       "todos",
-      "Slack's To-dos tab — your personal to-dos (read-only; requires xoxc desktop token). Not `slack todo` (reaction tasks)",
+      "Slack's To-dos tab — your personal to-dos (requires xoxc desktop token). Not `slack todo` (reaction tasks)",
       (y) => y.command(
         ["$0", "ls", "list"],
         "List your To-dos, soonest due first",
@@ -7124,7 +7315,59 @@ async function main(): Promise<void> {
           }
           await cmdTodos(tok(argv as W), ck(argv as W), { filter: argv.filter as TodoFilter, limit: argv.limit, json: argv.json });
         },
-      ),
+      )
+        .command(
+          "add <target>",
+          "Add a message to your To-dos (two-step: preview, then --code)",
+          (y2) => y2
+            .positional("target", { type: "string", demandOption: true, describe: "Message permalink or #chan:<ts>" })
+            .option("due", { type: "string", describe: "Due time (ISO datetime or Unix ts)" })
+            .option("saved", { type: "boolean", default: false, describe: "Save it without a checkbox instead of as a to-do" })
+            .option("code", { type: "string", describe: "Confirmation code from the preview" }),
+          async (argv) => {
+            const due = argv.due === undefined ? undefined : todoDue(argv.due);
+            await cmdTodosWrite(tok(argv as W), ck(argv as W), argv.target!, { kind: "add", ...(due ? { due } : {}), saved: argv.saved }, argv.code);
+          },
+        )
+        .command(
+          ["done <target>", "complete <target>"],
+          "Check a to-do off (--undo reopens it)",
+          (y2) => y2
+            .positional("target", { type: "string", demandOption: true, describe: "Message permalink or #chan:<ts>" })
+            .option("undo", { type: "boolean", default: false, describe: "Mark it not done again" })
+            .option("code", { type: "string", describe: "Confirmation code from the preview" }),
+          async (argv) => {
+            await cmdTodosWrite(tok(argv as W), ck(argv as W), argv.target!, { kind: "done", undo: argv.undo }, argv.code);
+          },
+        )
+        .command(
+          "edit <target>",
+          "Change a to-do's due date, or switch it between to-do and saved item",
+          (y2) => y2
+            .positional("target", { type: "string", demandOption: true, describe: "Message permalink or #chan:<ts>" })
+            .option("due", { type: "string", describe: "New due time (ISO datetime or Unix ts), or `none` to clear it" })
+            .option("todo", { type: "boolean", describe: "Make it a to-do (with a checkbox)" })
+            .option("saved", { type: "boolean", describe: "Make it a plain saved item (no checkbox)" })
+            .conflicts("todo", "saved")
+            .option("code", { type: "string", describe: "Confirmation code from the preview" }),
+          async (argv) => {
+            const due = argv.due === undefined ? undefined : argv.due === "none" ? 0 : todoDue(argv.due);
+            const todo = argv.todo ? true : argv.saved ? false : undefined;
+            await cmdTodosWrite(tok(argv as W), ck(argv as W), argv.target!, {
+              kind: "edit", ...(due === undefined ? {} : { due }), ...(todo === undefined ? {} : { todo }),
+            }, argv.code);
+          },
+        )
+        .command(
+          ["rm <target>", "remove <target>", "delete <target>"],
+          "Remove a message from your To-dos (the message stays)",
+          (y2) => y2
+            .positional("target", { type: "string", demandOption: true, describe: "Message permalink or #chan:<ts>" })
+            .option("code", { type: "string", describe: "Confirmation code from the preview" }),
+          async (argv) => {
+            await cmdTodosWrite(tok(argv as W), ck(argv as W), argv.target!, { kind: "rm" }, argv.code);
+          },
+        ),
     )
     .command(
       "drafts",

package/ts/slack.ts

@@ -1119,6 +1119,38 @@ export async function savedList(
   return postSession(token, "saved.list", params, cookie);
 }
 
+// To-dos writes (internal, session token). Verified live 2026-10-26: add with
+// todo_state=to_do (+ date_due) creates a to-do; update mark=completed checks it
+// off (todo_state becomes "completed"); delete removes it. A To-do always
+// points at a message: item_type=message, item_id=channel, ts=message ts.
+export type SavedRef = { channel: string; ts: string };
+const savedIds = (r: SavedRef) => ({ item_type: "message", item_id: r.channel, ts: r.ts });
+
+export async function savedAdd(token: string, ref: SavedRef, opts: { todo?: boolean; due?: number } = {}, cookie?: string): Promise<Json> {
+  const params: Record<string, string> = { ...savedIds(ref), todo_state: opts.todo === false ? "saved" : "to_do" };
+  if (opts.due) params.date_due = String(opts.due);
+  return postSession(token, "saved.add", params, cookie);
+}
+
+/** `mark`: completed | uncompleted | archived | unarchived. `due`: epoch seconds, 0 clears it. */
+export async function savedUpdate(
+  token: string,
+  ref: SavedRef,
+  opts: { mark?: "completed" | "uncompleted" | "archived" | "unarchived"; todo?: boolean; due?: number },
+  cookie?: string,
+): Promise<Json> {
+  const params: Record<string, string> = savedIds(ref);
+  if (opts.mark) params.mark = opts.mark;
+  if (opts.todo !== undefined) params.todo_state = opts.todo ? "to_do" : "saved";
+  if (opts.due !== undefined) params.date_due = String(opts.due);
+  return postSession(token, "saved.update", params, cookie);
+}
+
+/** Slack answers ok even when nothing was saved — callers check first. */
+export async function savedDelete(token: string, ref: SavedRef, cookie?: string): Promise<Json> {
+  return postSession(token, "saved.delete", savedIds(ref), cookie);
+}
+
 // Draft API (internal — requires xoxc session token + xoxd cookie)
 export async function listDrafts(token: string, cookie?: string): Promise<Json> {
   return postSession(token, "drafts.list", {}, cookie);

package/ts/slackTodos.ts

@@ -1,4 +1,4 @@
-// Slack's To-dos tab (app.slack.com/client/<team>/to-dos) — read-only helpers.
+// Slack's To-dos tab (app.slack.com/client/<team>/to-dos) — parsing helpers.
 //
 // Not to be confused with `slack todo` (todo.ts), which tracks tasks as
 // reactions on messages. To-dos are Slack's own PERSONAL list: it replaced
@@ -26,7 +26,7 @@ export type TodoItem = {
   due: number;
   /** Epoch seconds; 0 = not completed. */
   completed: number;
-  /** "to_do" | "saved" (as Slack reports it). */
+  /** "to_do" | "saved" | "completed" (as Slack reports it). */
   todoState: string;
   state: string;
   archived: boolean;
@@ -68,7 +68,8 @@ export function sortTodos(items: TodoItem[]): TodoItem[] {
 }
 
 export function isDone(t: TodoItem): boolean {
-  return t.completed > 0 || t.state === "completed";
+  // Checking one off sets state AND todo_state to "completed" (seen live).
+  return t.completed > 0 || t.state === "completed" || t.todoState === "completed";
 }
 
 /** The status column: a checkbox, plus the due date (and OVERDUE when past it). */