@flowapt/flowiq-cli 0.7.2 → 0.7.4

package/README.md

@@ -193,7 +193,7 @@ flowiq ct list
 - **Retailer gateway credential:** `{{retailer_tools_internal_key}}` is super-admin-only and resolves only as the `x-api-key` value for `https://express.chatcart.io/retailer-tools/*` (or loopback in local tests). Validation and runtime both reject putting it in a body or sending it to any other host.
 - `--agent` + filenames behave like `prompts`/`knowledge`; the file carries `agent_id`, so `push` targets the agent it was pulled from.
 
-### Broadcast — `flowiq broadcast map|preview|send|resume|list-remote|status|retry|list` (alias `bc`)
+### Broadcast — `flowiq broadcast map|preview|send|resume|list-remote|status|route|retry|list` (alias `bc`)
 
 Send an **APPROVED** WhatsApp template to every row of a CSV, filling the
 template's variables **per row** from the CSV's own columns. The
@@ -237,6 +237,16 @@ flowiq bc scheduled list <org_id>                   # open rows (pending + await
 flowiq bc scheduled list <org_id> --all             # incl. fired / cancelled
 flowiq bc scheduled approve <org_id> <queue_id>     # 'request' → 'pending' (--at re-times it)
 flowiq bc scheduled cancel  <org_id> <queue_id> --confirm
+
+# REPLY ROUTING (v0.7.4): assign EVERY reply to this broadcast to a team / person.
+flowiq bc send <org_id> --tag <batch-tag> --template <name> --body param1="…" \
+  --route-team "Spa" --commit                       # typed replies AND button taps → the Spa team
+flowiq bc send … --route-team "Spa" --route-member kim@client.com --route-window 48h --no-route-notify
+flowiq bc send … --csv people.csv --campaign 17Sep_Spa --route-team "Spa" --at "2026-09-18 09:00" --commit
+
+flowiq bc route <org_id> <broadcastId>                                   # show what a broadcast routes to + how many chats it has routed
+flowiq bc route <org_id> <broadcastId> --team "Spa" --commit             # set it on a broadcast that already went out
+flowiq bc route <org_id> <broadcastId> --clear --commit                  # switch it off
 ```
 
 - **Scheduling (v0.4.4 tag / v0.6.1 CSV)** — `--at "YYYY-MM-DD HH:MM"` queues the
@@ -295,6 +305,37 @@ flowiq bc scheduled cancel  <org_id> <queue_id> --confirm
   template. In **tag mode the campaign slug defaults to the tag**, so to send
   template A then template B to the SAME tag, pass a distinct `--campaign` for
   each. `resume` passes no `--template`, so it is never affected.
+- **Reply routing — `--route-team` / `--route-member` on `send`, and `bc route` (v0.7.4)**:
+  "every reply to this broadcast goes to team X / person Y". The first message a
+  recipient sends inside the window (default **72 h** after the send, `--route-window
+  48h|3d`, max 14 d) assigns the chat — **once per recipient per broadcast** — and
+  notifies the target through the normal assignment notification (the Teams-page
+  notify settings + the org's two notification flags still decide whether anything is
+  actually sent; `--no-route-notify` assigns silently). It is the fix for the gap a
+  quick-reply button + exact keyword + `assign_chat` cannot close: that route only
+  catches button TAPS, and a broad keyword mutes the AI agent. Routing is a side
+  effect — **keywords and the AI agent answer exactly as they would have**, and it
+  also applies to a chat whose agent is switched off. Skipped: business auto-replies
+  ("thank you for contacting…", out of office) and opt-outs (`stop`). An internal
+  note in the chat says why it was assigned. **An existing assignment is
+  overwritten**, same as the keyword action.
+  - `--route-team` takes a team name (case-insensitive; a unique partial match is
+    fine) or id; `--route-member` takes an email, a name or an id and must be an
+    ACTIVE member of that org. A typo stops the run in the **dry run** with the org's
+    teams listed — nothing is tagged, queued or sent.
+  - The routing is stored on the broadcast (`broadcasts.reply_routing`), so it
+    **forces the python engine at any size** (the per-row Node engine writes one
+    broadcast per recipient). Works in tag mode, CSV mode and with `--at` (the queued
+    send carries it and it is applied the moment the send fires).
+  - After a commit the CLI prints `Replies → … ✓ saved`. If it prints **REPLY ROUTING
+    NOT SAVED / NOT CONFIRMED**, the messages still went out — fix it straight away
+    with `bc route <org> <broadcastId> --team … --commit`.
+  - `bc route` with no flags shows the current routing and how many chats it has
+    routed; with `--team/--member` sets it; `--clear` removes it. Dry-run unless
+    `--commit`, audited. Only replies arriving AFTER the change are routed — nothing
+    is applied retroactively. `bc status` prints the routing too.
+  - Using routing AND a button keyword with `assign_chat` on the same campaign is
+    harmless but notifies twice on a tap — drop the keyword's assign when routing is on.
 - **`list-remote <org>` (v0.3.9)**: list the org's broadcasts **newest-first** with
   the **full broadcastId** per row + template, status, recipient count and SAST
   created time — the discovery step `status` / `retry` need (previously the id
@@ -1586,6 +1627,38 @@ flowiq au resolve <update_id> --status declined --internal "duplicate of …"
 - An interactive confirm shows exactly what the client will read; `--yes`
   skips the confirm (but never the `--note` requirement).
 
+### Broadcast planning — `flowiq plans list|show|status` (alias `planning`) (v0.7.3)
+
+The Broadcast → Planning board in the app (the campaign plans clients submit
+and Flowapt reviews), from the terminal.
+
+```bash
+flowiq plans list                                        # open plans across every ACTIVE client
+flowiq plans list --status pending_review                # waiting for Flowapt review
+flowiq plans list <organization_id> --status all --since 2026-09-01
+flowiq plans show <plan_id>                              # copy, second message, buttons, creative, audience, notes
+flowiq plans show <plan_id> --json --out plan.json
+flowiq plans status <plan_id> --to approved              # dry run
+flowiq plans status <plan_id> --to rejected --comment "Please send the image as a PNG" --commit
+flowiq plans status <plan_id> --to sent --commit
+```
+
+- **`list`** defaults to open plans (`draft`, `pending_review`, `approved`,
+  `scheduled`) across all active orgs; pass an org id for one client,
+  `--status all` / a status / a comma list to widen or narrow, `--since` to
+  filter by send date, `--include-inactive` for inactive orgs. The header
+  shows the totals for every status, and each row prints the full plan id.
+- **`show`** prints the plan the way the dialog does: message copy, the
+  second message sent when a button is tapped, buttons with their URLs, the
+  creative (file name + link), audience, template link, the response to the
+  client, internal notes and the notes thread.
+- **`status`** is a dry run until `--commit`. `--comment` is the response the
+  **client reads**; `--internal` is staff-only. `approved` and `rejected`
+  record you as the reviewer; `rejected` requires `--comment`. Every commit is
+  in `flowiq audit --endpoint plans`.
+- Editing a plan's copy, buttons or links is not in the CLI yet; do that in
+  the app.
+
 ### Chat export — `flowiq export chats <organization_id> [--out <path>]`
 
 Full chat history → TXT, byte-identical to the in-app "Export Settings TXT"

package/TEAM-GUIDE.md

@@ -87,6 +87,9 @@ When you see it, run `npm i -g @flowapt/flowiq-cli` — a stale version also mea
 | Make a follow-up button **close the customer's ticket** ("Query solved") or **re-alert the team** ("I still need help") | keyword action `{"type":"update_ticket_status","status":"resolved"}` / `{"type":"renotify_ticket"}` — see *Keywords* in `flowiq guide --reference`. CLI-only, no dashboard field yet |
 | Make a keyword/button **hand the chat to a team or person** (assign in the inbox + email/WhatsApp them) | keyword action `{"type":"assign_chat","team_id":"…","assignee_user_id":"…","notify_member":true}` — see *Keywords* in `flowiq guide --reference`. Also in the dashboard (action type "Assign Chat") |
 | **Find an org's ID** (needed by nearly every command) | `flowiq org list` — or `flowiq org list african` to filter |
+| See broadcast plans waiting for Flowapt review, across every client | `flowiq plans list --status pending_review`, then `flowiq plans show <plan_id>` for the copy, second message, buttons, creative and audience |
+| See one client's broadcast plans | `flowiq plans list <org_id>` (open plans) or `flowiq plans list <org_id> --status all --since 2026-09-01` |
+| Mark a broadcast plan approved, scheduled or sent | `flowiq plans status <plan_id> --to sent` (a dry run), then add `--commit`. Rejecting needs `--comment "..."`, which the client reads |
 | What's the stock on a product, per branch? | `flowiq shopify stock <org_id> "olive oil"` — shows each location by NAME, and says "not tracked" rather than a confusing 0 |
 | Has this order shipped? What's the tracking? | `flowiq shopify order <org_id> '#14728'` — status, courier, tracking number + link |
 | **Size a customer cohort** | Use `customers(first:250, query:…)` and paginate — **NOT `customersCount(query:…)`, which Shopify ignores the filter on** and answers 10,000 every time. Any count showing `precision: AT_LEAST` is a cap, not a total; the CLI warns you. |
@@ -169,6 +172,8 @@ several.
 | Check how a broadcast is landing (accepted → delivered → read, plus failed/pending) | `flowiq bc status <org_id> <broadcastId>` (from the send output, or `bc list-remote`) |
 | See WHO failed on a broadcast + why (Meta error) | `flowiq bc status <org_id> <broadcastId> --failures` |
 | Re-send a broadcast to only the ones that failed | `flowiq bc retry <org_id> <broadcastId>` (dry-run) → `… --commit` |
+| Make EVERY reply to a broadcast land with a team or a person (client asks "all replies to the Spa team") | Add `--route-team "Spa"` (and/or `--route-member kim@client.com`) to the `bc send`. The first reply from each recipient within 72 hours (`--route-window 48h` to change) assigns the chat and notifies them, typed replies and button taps alike. The AI agent and keywords still answer as normal, so nothing is muted. The dry run shows `Replies → team Spa …`; a wrong team name stops the run and lists the org's teams. Works with `--csv` and `--at` too. |
+| Add, check or remove that routing on a broadcast that already went out | `flowiq bc route <org_id> <broadcastId>` shows it and how many chats it has routed · `… --team "Spa" --commit` sets it · `… --clear --commit` removes it. Only replies from now on are affected. |
 | **Get an OLD version of a prompt back** | `flowiq prompts history <org_id>` (pick the version) → `flowiq prompts restore <org_id> <audit_id>` (dry-run) → `… --commit` |
 | **See who changed what, and when** | `flowiq audit <org_id>` — add `--endpoint prompts`, `--user <name>`, `--since 2026-07-01` to narrow |
 | See exactly what a change looked like (before → after) | `flowiq audit show <audit_id> --content` (or `--out entry.json`) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowapt/flowiq-cli",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Command-line tool for FlowIQ staff: round-trip agent prompts, questionnaires, fine-tuning, pin-board tasks, webhooks, templates, agent-updates, chat exports, and live agent testing without ever touching service-role credentials.",
   "type": "module",
   "bin": {

package/src/commands/broadcast.js

@@ -944,6 +944,10 @@ async function runPipeline(orgId, opts, { commitStage, isResume }) {
     }
   }
 
+  // Reply routing: resolved before the dry-run exit so the preview shows it, and
+  // before the upsert so a bad team name never tags a single contact.
+  const replyRouting = isResume ? null : await checkRouting(orgId, opts);
+
   if (!commitStage) {
     console.log("");
     console.log(`DRY RUN — nothing was ${scheduledAt ? "scheduled" : "sent"}, no contacts written or tagged. Add --commit to ${scheduledAt ? "queue it" : "send"}.`);
@@ -968,6 +972,7 @@ async function runPipeline(orgId, opts, { commitStage, isResume }) {
     body_parameters: tokens.body,
     ...(tokens.button ? { button_parameters: { param1: tokens.button } } : {}),
     ...(headerMedia ? { header_media: headerMedia } : {}),
+    ...(replyRouting ? { reply_routing: replyRouting } : {}),
     dry_run: dryRun,
   });
   let pyTotal = null;
@@ -1013,6 +1018,7 @@ async function runPipeline(orgId, opts, { commitStage, isResume }) {
         body_parameters: tokens.body,
         ...(tokens.button ? { button_parameters: { param1: tokens.button } } : {}),
         ...(headerMedia ? { header_media: headerMedia } : {}),
+        ...(replyRouting ? { reply_routing: replyRouting } : {}),
       });
     } catch (e) {
       console.error(`Schedule failed: ${e.message}${e.body?.error ? ` — ${e.body.error}` : ""}`);
@@ -1035,6 +1041,10 @@ async function runPipeline(orgId, opts, { commitStage, isResume }) {
       console.log(`      flowiq bc scheduled approve ${orgId} ${resp.queue_id}`);
     }
     console.log(`  Also visible/manageable on the dashboard's Scheduled sends page.`);
+    if (replyRouting) {
+      if (resp.reply_routing?.saved) console.log(`  Replies → ${describeRouting(resp.reply_routing.requested)}  ✓ queued with the send (applied the moment it fires)`);
+      else console.log(`  ⚠ REPLY ROUTING NOT CONFIRMED by the server — set it after it fires with: flowiq bc route ${orgId} <broadcast_id> --team … --commit`);
+    }
     return;
   }
 
@@ -1052,6 +1062,7 @@ async function runPipeline(orgId, opts, { commitStage, isResume }) {
   console.log(`   Python is sending in the background to tag "${tag}" (${pyTotal ?? workSet.length} contact(s)) and tracking it under that broadcast id.`);
   console.log(`   Delivery:  flowiq bc status ${orgId} ${out.broadcastId || "<broadcast_id>"} [--failures]`);
   console.log(`   Failures:  flowiq bc retry  ${orgId} ${out.broadcastId || "<broadcast_id>"} --commit`);
+  if (replyRouting) reportRoutingResult(orgId, out.reply_routing, out.broadcastId ?? out.broadcast_id ?? null);
 }
 
 /** The paced, write-ahead-logged per-row send loop + final report. */
@@ -1146,13 +1157,98 @@ export function collectKV(pair, mapAcc) {
  *  (allow_broadcast=true, not blocked) and sends in the background, returning a
  *  broadcastId. No CLI write-ahead log / resume for this engine (python owns the
  *  broadcast record). Dry-run (no --commit) asks python for the eligible count. */
-async function runPythonTagSend(orgId, { opts, tag, templateName, template, headerMedia, bodyLiterals, buttonLiteral, commitStage, cardOverrides = null, cardLines = [] }) {
+// ── Reply routing (v0.7.4) ───────────────────────────────────────────────────
+// `--route-team` / `--route-member` = "assign every reply to this broadcast to …".
+// The server resolves names → ids, stores it on the broadcast, and the agent runtime
+// applies it once per recipient inside the window WITHOUT muting keywords or the AI.
+
+/** "72" | "72h" | "3d" → whole hours, or { error }. */
+export function parseRouteWindow(input) {
+  if (input === undefined || input === null || input === "") return { hours: null };
+  const m = String(input).trim().toLowerCase().match(/^(\d{1,4})\s*(h|hr|hrs|hours?|d|days?)?$/);
+  if (!m) return { error: `"${input}" is not a window — use hours or days, e.g. 72, 72h or 3d` };
+  const n = Number(m[1]);
+  const hours = m[2] && m[2].startsWith("d") ? n * 24 : n;
+  if (hours < 1 || hours > 336) return { error: `the window must be between 1 hour and 14 days (got ${hours} h)` };
+  return { hours };
+}
+
+/** The send flags → the request's reply_routing object (null when no routing asked for). */
+export function routingFromOpts(opts = {}, keys = { team: "routeTeam", member: "routeMember", window: "routeWindow", notify: "routeNotify" }) {
+  const team = typeof opts[keys.team] === "string" ? opts[keys.team].trim() : "";
+  const member = typeof opts[keys.member] === "string" ? opts[keys.member].trim() : "";
+  const hasWindow = opts[keys.window] !== undefined && opts[keys.window] !== null && opts[keys.window] !== "";
+  const noNotify = opts[keys.notify] === false;
+  if (!team && !member) {
+    if (hasWindow || noNotify) return { error: "the routing window / no-notify flags need a team or a member to route to" };
+    return { routing: null };
+  }
+  const win = parseRouteWindow(opts[keys.window]);
+  if (win.error) return { error: win.error };
+  return {
+    routing: {
+      ...(team ? { team } : {}),
+      ...(member ? { member } : {}),
+      ...(win.hours ? { window_hours: win.hours } : {}),
+      ...(noNotify ? { notify: false } : {}),
+    },
+  };
+}
+
+export function describeRouting(d) {
+  if (!d) return "none";
+  const who = [d.team_name ? `team ${d.team_name}` : null, d.member_name || d.member_email || null].filter(Boolean).join(" + ") || "(unnamed target)";
+  const notes = [];
+  if (d.team_name) notes.push(d.notify_team === false ? "team not notified" : "team notified");
+  if (d.member_name || d.member_email) notes.push(d.notify_member === false ? "person not notified" : "person notified");
+  return `${who} · first reply within ${d.window_hours ?? 72} h · ${notes.join(", ")}`;
+}
+
+/** Resolve the routing on the server BEFORE anything is tagged, queued or sent. Exits on a bad team/member. */
+async function checkRouting(orgId, opts) {
+  const parsed = routingFromOpts(opts);
+  if (parsed.error) { console.error(`Error: ${parsed.error}`); process.exit(1); }
+  if (!parsed.routing) return null;
+  let resp;
+  try { resp = await http.post("broadcast", { action: "resolve-routing", organization_id: orgId, reply_routing: parsed.routing }); }
+  catch (e) {
+    console.error(`Reply routing refused: ${e.body?.error || e.message}`);
+    if (/unknown action|Unknown action|not supported/i.test(String(e.body?.error || "")) || e.status === 404) {
+      console.error("  (the server does not know reply routing yet — run `flowiq doctor`)");
+    }
+    process.exit(1);
+  }
+  if (!resp?.reply_routing) {
+    console.error("Reply routing refused: the server did not confirm it (it may predate v0.7.4 — run `flowiq doctor`). Nothing sent.");
+    process.exit(1);
+  }
+  console.log(`Replies →    ${describeRouting(resp.reply_routing)}`);
+  console.log(`             (assigned once per recipient; keywords and the AI agent still answer as normal)`);
+  return parsed.routing;
+}
+
+/** After a commit: say plainly whether the routing landed. */
+function reportRoutingResult(orgId, rr, broadcastId) {
+  if (!rr) {
+    console.log("   ⚠ REPLY ROUTING NOT CONFIRMED by the server — replies will NOT be assigned.");
+    if (broadcastId) console.log(`     Fix now: flowiq bc route ${orgId} ${broadcastId} --team … --commit`);
+    return;
+  }
+  if (rr.saved) console.log(`   Replies → ${describeRouting(rr.requested)}  ✓ saved`);
+  else {
+    console.log(`   ⚠ REPLY ROUTING NOT SAVED: ${rr.error || "unknown reason"}`);
+    if (broadcastId) console.log(`     Fix now: flowiq bc route ${orgId} ${broadcastId} --team … --commit`);
+  }
+}
+
+async function runPythonTagSend(orgId, { opts, tag, templateName, template, headerMedia, bodyLiterals, buttonLiteral, commitStage, cardOverrides = null, cardLines = [], replyRouting = null }) {
   const reqBody = (dryRun) => ({
     action: "send-python", organization_id: orgId, tag, template_name: templateName,
     body_parameters: bodyLiterals,
     ...(buttonLiteral ? { button_parameters: { param1: buttonLiteral } } : {}),
     ...(headerMedia ? { header_media: headerMedia } : {}),
     ...(cardOverrides ? { card_overrides: cardOverrides } : {}),
+    ...(replyRouting ? { reply_routing: replyRouting } : {}),
     dry_run: dryRun,
   });
 
@@ -1189,6 +1285,7 @@ async function runPythonTagSend(orgId, { opts, tag, templateName, template, head
   console.log("");
   console.log(`✅ ${out.message || "Broadcast started"}${out.broadcastId ? `  ·  broadcastId ${out.broadcastId}` : ""}`);
   console.log(`   Python is sending in the background${out.mode ? ` (${out.mode})` : ""} and tracking it under that broadcast id — no CLI resume for this engine.`);
+  if (replyRouting) reportRoutingResult(orgId, out.reply_routing, out.broadcastId ?? out.broadcast_id ?? null);
 }
 
 async function runTagPipeline(orgId, opts, { commitStage }) {
@@ -1259,7 +1356,11 @@ async function runTagPipeline(orgId, opts, { commitStage }) {
   const cardOverrides = carouselPlan?.overrides ?? null;
   const cardLines = carouselPlan?.lines ?? [];
 
-  if (opts.at) return scheduleTagSend(orgId, { opts, tag, templateName, template, headerMedia, bodyLiterals, buttonLiteral, commitStage, cardOverrides, cardLines });
+  // Reply routing is resolved HERE — after the template checks, before any engine is
+  // picked — so a mistyped team stops the run in the dry run, not after a send.
+  const replyRouting = await checkRouting(orgId, opts);
+
+  if (opts.at) return scheduleTagSend(orgId, { opts, tag, templateName, template, headerMedia, bodyLiterals, buttonLiteral, commitStage, cardOverrides, cardLines, replyRouting });
 
   // ENGINE ROUTING (policy): any send of MORE THAN 10 recipients ALWAYS uses the
   // python /meta-broadcast engine (the proven bulk sender). --python forces it at
@@ -1270,8 +1371,13 @@ async function runTagPipeline(orgId, opts, { commitStage }) {
   if (template.is_carousel && !opts.python) {
     console.log("Carousel template → PYTHON engine at any size (the per-row Node engine cannot send carousels).");
   }
-  if (opts.python || template.is_carousel) {
-    return runPythonTagSend(orgId, { opts, tag, templateName, template, headerMedia, bodyLiterals, buttonLiteral, commitStage, cardOverrides, cardLines });
+  // Reply routing lives on ONE broadcasts row, which only the python engine creates per
+  // send (the per-row Node engine writes a row per recipient) → python at any size.
+  if (replyRouting && !opts.python && !template.is_carousel) {
+    console.log("Reply routing → PYTHON engine at any size (the routing is stored on the single broadcast python creates).");
+  }
+  if (opts.python || template.is_carousel || replyRouting) {
+    return runPythonTagSend(orgId, { opts, tag, templateName, template, headerMedia, bodyLiterals, buttonLiteral, commitStage, cardOverrides, cardLines, replyRouting });
   }
 
   // resolve the tag server-side (broadcast-safe recipients only). A >2000 tag
@@ -1433,7 +1539,7 @@ const fmtSast = (iso) =>
   new Date(iso).toLocaleString("en-ZA", { timeZone: "Africa/Johannesburg", dateStyle: "medium", timeStyle: "short" });
 
 /** Queue a tag broadcast to fire later (server writes the api_request_queue row). */
-async function scheduleTagSend(orgId, { opts, tag, templateName, template, headerMedia, bodyLiterals, buttonLiteral, commitStage, cardOverrides = null, cardLines = [] }) {
+async function scheduleTagSend(orgId, { opts, tag, templateName, template, headerMedia, bodyLiterals, buttonLiteral, commitStage, cardOverrides = null, cardLines = [], replyRouting = null }) {
   const when = parseSastAt(opts.at);
   if (when.error) { console.error(`Error: --at ${when.error}`); process.exit(1); }
   if (new Date(when.iso).getTime() <= Date.now()) {
@@ -1475,6 +1581,7 @@ async function scheduleTagSend(orgId, { opts, tag, templateName, template, heade
       ...(buttonLiteral ? { button_parameters: { param1: buttonLiteral } } : {}),
       ...(headerMedia ? { header_media: headerMedia } : {}),
       ...(cardOverrides ? { card_overrides: cardOverrides } : {}),
+      ...(replyRouting ? { reply_routing: replyRouting } : {}),
     });
   } catch (e) {
     console.error(`Schedule failed: ${e.message}`);
@@ -1491,6 +1598,10 @@ async function scheduleTagSend(orgId, { opts, tag, templateName, template, heade
     console.log(`  ⚠ PARKED awaiting approval — it will NOT fire until you run:`);
     console.log(`      flowiq bc scheduled approve ${orgId} ${resp.queue_id}`);
   }
+  if (replyRouting) {
+    if (resp.reply_routing?.saved) console.log(`  Replies → ${describeRouting(resp.reply_routing.requested)}  ✓ queued with the send (applied the moment it fires)`);
+    else console.log(`  ⚠ REPLY ROUTING NOT CONFIRMED by the server — cancel and re-schedule, or set it after it fires with: flowiq bc route ${orgId} <broadcast_id> --team … --commit`);
+  }
 }
 
 /** List scheduled broadcasts (queue rows). Read-only. */
@@ -1515,6 +1626,7 @@ export async function scheduledList(orgId, opts = {}) {
     console.log(`    ${fmtSast(s.scheduled_for)} SAST · ${s.status}${flag}`);
     console.log(`    template ${s.template_name ?? "?"} → tag ${s.tag ?? "?"} · ${s.engine} · via ${s.source}${s.scheduled_by ? ` (${s.scheduled_by})` : ""}`);
     if (s.audience_at_schedule != null) console.log(`    ~${s.audience_at_schedule} recipients at schedule time`);
+    if (s.reply_routing) console.log(`    replies → ${describeRouting(s.reply_routing)}`);
     if (s.processed_at) console.log(`    fired ${fmtSast(s.processed_at)} SAST${s.broadcast_id ? ` · broadcastId ${s.broadcast_id}` : ""}`);
     if (s.error_message) console.log(`    error: ${s.error_message}`);
   }
@@ -1628,6 +1740,11 @@ export async function status(orgId, broadcastId, opts = {}) {
   if (b.total_recipients) {
     console.log(`    ${((accepted / b.total_recipients) * 100).toFixed(1)}% of ${b.total_recipients} recipients accepted${d.linked < b.total_recipients ? "  (still sending?)" : ""}`);
   }
+  if (resp.reply_routing) {
+    const rr = resp.reply_routing;
+    console.log(`  replies →   ${describeRouting(rr)}${rr.enabled === false ? "  (switched OFF)" : ""}`);
+    console.log(`              ${rr.routed} chat(s) routed so far${rr.set_by ? ` · set by ${rr.set_by}` : ""}`);
+  }
   if (opts.failures && resp.failures) {
     console.log("");
     console.log(`  Failures by reason:`);
@@ -1641,6 +1758,41 @@ export async function status(orgId, broadcastId, opts = {}) {
   }
 }
 
+/** Show / set / clear reply routing on a broadcast that already exists. Dry run unless --commit. */
+export async function route(orgId, broadcastId, opts = {}) {
+  if (!UUID_RE.test(orgId)) { console.error(`Error: "${orgId}" is not a valid organization UUID.`); process.exit(1); }
+  if (!UUID_RE.test(broadcastId)) { console.error("Error: broadcast id must be a UUID (see `flowiq bc list-remote <org>`)."); process.exit(1); }
+  const parsed = routingFromOpts(opts, { team: "team", member: "member", window: "window", notify: "notify" });
+  if (parsed.error) { console.error(`Error: ${parsed.error}`); process.exit(1); }
+  if (opts.clear && parsed.routing) { console.error("Error: pass --clear OR a --team/--member, not both."); process.exit(1); }
+  let resp;
+  try {
+    resp = await http.post("broadcast", {
+      action: "route", organization_id: orgId, broadcast_id: broadcastId,
+      ...(parsed.routing ? { reply_routing: parsed.routing } : {}),
+      ...(opts.clear ? { clear: true } : {}),
+      commit: !!opts.commit,
+    });
+  } catch (e) { console.error(`Route failed: ${e.body?.error || e.message}`); process.exit(1); }
+  if (opts.json) { console.log(JSON.stringify(resp, null, 2)); return; }
+  const b = resp.broadcast;
+  console.log(`Broadcast ${b.id} — ${resp.organization_name}`);
+  console.log(`  template:   ${b.template_name} · sent ${fmtSast(b.created_at)} SAST · ${b.total_recipients ?? "?"} recipient(s)`);
+  console.log(`  replies →   ${resp.current ? describeRouting(resp.current) : "no routing set"}`);
+  console.log(`              ${resp.routed} chat(s) routed so far`);
+  if (resp.mode === "show") {
+    console.log("");
+    console.log(`Set it:   flowiq bc route ${orgId} ${b.id} --team "<team>" [--member <email>] [--window 72h] [--no-notify] --commit`);
+    console.log(`Clear it: flowiq bc route ${orgId} ${b.id} --clear --commit`);
+    return;
+  }
+  console.log("");
+  console.log(`  ${resp.mode === "clear" ? "CLEAR" : "SET"} →     ${resp.mode === "clear" ? "no routing (replies are no longer assigned)" : describeRouting(resp.next)}`);
+  for (const w of resp.warnings || []) console.log(`  ⚠ ${w}`);
+  if (resp.dry_run) { console.log(""); console.log("DRY RUN — nothing changed. Add --commit to apply."); return; }
+  console.log(`  ✓ saved. Only replies that arrive from now on are routed; chats already routed are left as they are.`);
+}
+
 /** Re-send a broadcast to ONLY its failed recipients (transient-failure recovery).
  *  Reconstructs the send from the broadcasts row + re-fires via python. The dry-run
  *  shows the failed count + reason breakdown; --commit creates a NEW broadcast. */

package/src/commands/plans.js

@@ -0,0 +1,258 @@
+// `flowiq plans list|show|status` — Broadcast Planning (the Broadcast → Planning
+// board in the app, table broadcast_planning), via /cli/plans.
+//   list   read: open plans across all active orgs, or one org
+//   show   read: one plan in full (copy, second message, buttons, creative, notes)
+//   status write: dry run unless --commit; audited server-side
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { http } from "../http.js";
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const STATUSES = ["draft", "pending_review", "approved", "rejected", "scheduled", "sent", "cancelled"];
+const STATUS_ORDER = ["pending_review", "approved", "scheduled", "draft", "rejected", "sent", "cancelled"];
+const STATUS_LABEL = {
+  pending_review: "PENDING REVIEW",
+  approved: "APPROVED",
+  scheduled: "SCHEDULED",
+  draft: "DRAFT",
+  rejected: "REJECTED",
+  sent: "SENT",
+  cancelled: "CANCELLED",
+};
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+
+function sastParts(ts) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "Africa/Johannesburg",
+    year: "numeric", month: "2-digit", day: "2-digit",
+    hour: "2-digit", minute: "2-digit", hour12: false,
+  }).formatToParts(new Date(ts));
+  return Object.fromEntries(parts.map((p) => [p.type, p.value]));
+}
+
+function fmtTs(ts) {
+  if (!ts) return "-";
+  const p = sastParts(ts);
+  const hour = p.hour === "24" ? "00" : p.hour;
+  return `${Number(p.day)} ${MONTHS[Number(p.month) - 1]} ${p.year} ${hour}:${p.minute}`;
+}
+
+function fmtDate(dateStr, timeStr) {
+  if (!dateStr) return "no date";
+  const [y, m, d] = String(dateStr).split("-");
+  return `${Number(d)} ${MONTHS[Number(m) - 1]} ${y} ${timeStr ? String(timeStr).slice(0, 5) : "--:--"}`;
+}
+
+function indent(text, pad = "  ") {
+  const t = String(text ?? "").trim();
+  if (!t) return `${pad}(empty)`;
+  return t.split("\n").map((line) => `${pad}${line}`).join("\n");
+}
+
+function fail(prefix, e) {
+  console.error(`${prefix}: ${e.message}`);
+  if (e.body?.error && !String(e.message).includes(e.body.error)) console.error(`  ${e.body.error}`);
+  process.exit(1);
+}
+
+export async function list(orgId, opts = {}) {
+  if (orgId && !UUID_RE.test(orgId)) {
+    console.error(`Error: "${orgId}" is not a valid organization UUID (find it with \`flowiq org list\`).`);
+    process.exit(1);
+  }
+  const query = {};
+  if (orgId) query.organization_id = orgId;
+  if (opts.status) query.status = opts.status;
+  if (opts.since) query.since = opts.since;
+  if (opts.includeInactive) query.include_inactive = "1";
+  if (opts.limit != null) query.limit = String(opts.limit);
+
+  let resp;
+  try {
+    resp = await http.get("plans", query);
+  } catch (e) {
+    fail("List failed", e);
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(resp, null, 2));
+    return;
+  }
+
+  const scope = resp.organization_name
+    ? resp.organization_name
+    : `all ${resp.include_inactive ? "" : "active "}orgs`;
+  const totals = STATUS_ORDER.filter((s) => resp.counts?.[s]).map((s) => `${s} ${resp.counts[s]}`).join(" · ");
+  console.log(`Broadcast plans · ${scope} · status ${resp.status_filter}${resp.since ? ` · from ${resp.since}` : ""}`);
+  console.log(`  every status in this scope: ${totals || "none"}`);
+
+  const plans = resp.plans || [];
+  if (!plans.length) {
+    console.log("  (no matching plans)");
+    return;
+  }
+
+  for (const s of STATUS_ORDER) {
+    const group = plans.filter((p) => p.status === s);
+    if (!group.length) continue;
+    console.log(`\n${STATUS_LABEL[s]} (${group.length})`);
+    for (const p of group) {
+      const flag = p.date_passed ? " (date passed)" : p.scheduled_date === resp.today ? " (today)" : "";
+      console.log(`  ${fmtDate(p.scheduled_date, p.scheduled_time)}${flag}  ${p.organization_name ?? p.organization_id}  ·  ${p.topic}`);
+      const bits = [
+        p.type || "type not set",
+        p.audience,
+        p.origin === "flowapt" ? `Flowapt suggestion (client: ${p.client_status ?? "-"})` : null,
+        p.creative_file ? `creative ${p.creative_file}` : null,
+        p.template_id ? "template linked" : null,
+        p.has_client_comment ? "has response to client" : null,
+        p.notes_count ? `${p.notes_count} note(s)` : null,
+      ].filter(Boolean);
+      console.log(`    ${bits.join(" · ")}`);
+      const reviewed = p.reviewed_at
+        ? ` · reviewed ${fmtTs(p.reviewed_at)}${p.reviewed_by_name ? ` by ${p.reviewed_by_name}` : ""}`
+        : "";
+      console.log(`    submitted ${fmtTs(p.created_at)}${p.created_by_name ? ` by ${p.created_by_name}` : ""}${reviewed}`);
+      console.log(`    id ${p.id}`);
+    }
+  }
+  if (resp.truncated) {
+    console.log(`\n⚠ ${plans.length} shown and the limit (${resp.limit}) was reached: pass --limit, or narrow with --status / --since.`);
+  }
+  console.log("\nFull plan: flowiq plans show <plan_id>");
+}
+
+export async function show(planId, opts = {}) {
+  if (!UUID_RE.test(planId)) {
+    console.error(`Error: "${planId}" is not a valid plan UUID (get it from \`flowiq plans list\`).`);
+    process.exit(1);
+  }
+  let resp;
+  try {
+    resp = await http.get("plans", { plan_id: planId });
+  } catch (e) {
+    fail("Show failed", e);
+  }
+  if (opts.out) {
+    const out = path.resolve(process.cwd(), opts.out);
+    await fs.mkdir(path.dirname(out), { recursive: true });
+    await fs.writeFile(out, JSON.stringify(resp, null, 2) + "\n", "utf8");
+    console.error(`Wrote ${out}`);
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(resp, null, 2));
+    return;
+  }
+
+  const p = resp.plan;
+  const more = p.more && typeof p.more === "object" ? p.more : {};
+  const creative = p.creative && typeof p.creative === "object" ? p.creative : {};
+  const flag = p.scheduled_date && p.scheduled_date < resp.today
+    ? " (date passed)"
+    : p.scheduled_date === resp.today ? " (today)" : "";
+
+  console.log(p.topic);
+  console.log(`  org:        ${p.organization_name ?? "?"} (${p.organization_id})${p.organization_inactive ? " [inactive org]" : ""}`);
+  console.log(`  status:     ${p.status}${p.origin === "flowapt" ? ` · Flowapt suggestion, client: ${p.client_status ?? "-"}` : ""}`);
+  console.log(`  send:       ${fmtDate(p.scheduled_date, p.scheduled_time)}${flag}`);
+  console.log(`  type:       ${more.type ?? "-"}`);
+  console.log(`  audience:   ${p.has_segment ? (p.segment_details || "segment (no details given)") : "whole list"}`);
+  if (p.shopify_segment_formula) console.log(`  formula:    ${p.shopify_segment_formula}`);
+  if (p.product_focus) console.log(`  product:    ${p.product_focus}`);
+  if (p.landing_page_url) console.log(`  landing:    ${p.landing_page_url}`);
+  console.log(`  submitted:  ${fmtTs(p.created_at)}${p.created_by_name ? ` by ${p.created_by_name}` : ""}`);
+  if (p.reviewed_at) console.log(`  reviewed:   ${fmtTs(p.reviewed_at)}${p.reviewed_by_name ? ` by ${p.reviewed_by_name}` : ""}`);
+  if (p.client_approved_at) console.log(`  client OK:  ${fmtTs(p.client_approved_at)}${p.client_approved_by_name ? ` by ${p.client_approved_by_name}` : ""}`);
+  console.log(`  id:         ${p.id}`);
+
+  console.log("\nMessage copy");
+  console.log(indent(p.copy_text));
+
+  if (more.slide2?.message) {
+    console.log("\nSecond message (sent when a button is tapped)");
+    console.log(indent(more.slide2.message));
+  }
+  if (more.slides && typeof more.slides === "object") {
+    for (const [key, slide] of Object.entries(more.slides)) {
+      if (!slide || typeof slide !== "object") continue;
+      console.log(`\n${key}${slide.triggered_by ? ` (after ${slide.triggered_by})` : ""}`);
+      if (slide.message) console.log(indent(slide.message));
+      if (slide.media_url) console.log(`  media: ${slide.media_url}`);
+    }
+  }
+
+  const buttons = Array.isArray(more.buttons) ? more.buttons : [];
+  if (buttons.length) {
+    console.log("\nButtons");
+    for (const b of buttons) console.log(`  [${b?.type ?? "?"}] ${b?.text ?? ""}${b?.url ? ` → ${b.url}` : ""}`);
+  }
+
+  console.log("\nCreative");
+  if (creative.original_filename || creative.file_url) {
+    const size = creative.file_size ? ` · ${(creative.file_size / 1024 / 1024).toFixed(1)} MB` : "";
+    console.log(`  ${creative.original_filename ?? "(unnamed)"} · ${creative.file_type ?? "type ?"}${size} · supplied by ${creative.supplier ?? "?"}`);
+    if (creative.file_url) console.log(`  ${creative.file_url}`);
+  } else {
+    console.log(`  none attached${creative.supplier ? ` (supplied by ${creative.supplier})` : ""}`);
+  }
+
+  if (p.template) console.log(`\nTemplate: ${p.template.template_name} (${p.template.status ?? "status ?"}, ${p.template.category ?? "category ?"})`);
+  else if (p.template_id) console.log(`\nTemplate id: ${p.template_id}`);
+  if (p.send_draft_id) console.log(`Send draft id: ${p.send_draft_id}`);
+
+  if (p.superadmin_comment) {
+    console.log("\nResponse to client");
+    console.log(indent(p.superadmin_comment));
+  }
+  if (p.internal_notes) {
+    console.log("\nInternal notes (staff only)");
+    console.log(indent(p.internal_notes));
+  }
+  const notes = resp.notes || [];
+  if (notes.length) {
+    console.log(`\nNotes (${notes.length})`);
+    for (const n of notes) console.log(`  ${fmtTs(n.created_at)} ${n.author_name ?? "?"} [${n.kind ?? "note"}]: ${String(n.body ?? "").replace(/\s+/g, " ").trim()}`);
+  }
+
+  console.log(`\nChange status: flowiq plans status ${p.id} --to <status> [--comment "..."] [--commit]`);
+}
+
+export async function status(planId, opts = {}) {
+  if (!UUID_RE.test(planId)) {
+    console.error(`Error: "${planId}" is not a valid plan UUID (get it from \`flowiq plans list\`).`);
+    process.exit(1);
+  }
+  const to = String(opts.to || "").toLowerCase();
+  if (!STATUSES.includes(to)) {
+    console.error(`Error: --to must be one of ${STATUSES.join(" | ")} (got "${opts.to}").`);
+    process.exit(1);
+  }
+  if (to === "rejected" && !(opts.comment && opts.comment.trim())) {
+    console.error("Refusing to reject without --comment: the client reads it as the response to their plan.");
+    process.exit(1);
+  }
+
+  let resp;
+  try {
+    resp = await http.post("plans", {
+      action: "status",
+      plan_id: planId,
+      status: to,
+      superadmin_comment: opts.comment ?? null,
+      internal_notes: opts.internal ?? null,
+      dry_run: !opts.commit,
+    });
+  } catch (e) {
+    fail("Status change failed", e);
+  }
+
+  const prev = resp.previous || {};
+  const next = resp.next || {};
+  console.log(`${resp.dry_run ? "DRY RUN" : "Updated"} · ${resp.topic}`);
+  console.log(`  org:       ${resp.organization_name ?? resp.organization_id}`);
+  console.log(`  status:    ${prev.status} → ${next.status}`);
+  if (next.superadmin_comment !== prev.superadmin_comment) console.log(`  client reads: ${next.superadmin_comment}`);
+  if (next.internal_notes !== prev.internal_notes) console.log(`  internal:  ${next.internal_notes}`);
+  if (resp.reviewer_email) console.log(`  reviewer:  ${resp.reviewer_email} (reviewed_at ${fmtTs(next.reviewed_at)})`);
+  if (resp.dry_run) console.log("\nNothing written. Re-run with --commit to apply.");
+}

package/src/index.js

@@ -25,6 +25,7 @@ import * as teamUpdatesCmd from "./commands/team-updates.js";
 import * as agentConfigCmd from "./commands/agent-config.js";
 import * as agentsCmd from "./commands/agents.js";
 import * as agentUpdatesCmd from "./commands/agent-updates.js";
+import * as plansCmd from "./commands/plans.js";
 import * as exportCmd from "./commands/export.js";
 import * as testCmd from "./commands/agent-test.js";
 import * as knowledgeCmd from "./commands/knowledge.js";
@@ -445,6 +446,31 @@ export function run(argv) {
     .option("--yes", "skip the interactive confirm gate (the --note requirement still applies)")
     .action((updateId, opts) => agentUpdatesCmd.resolve(updateId, opts));
 
+  // plans (Broadcast Planning board: list across orgs, show one plan, change status)
+  const plans = program.command("plans")
+    .alias("planning")
+    .description("Broadcast Planning (Broadcast → Planning): list plans across orgs, show one in full, change a plan's status");
+  plans.command("list [organization_id]")
+    .description("List plans, default open (draft, pending_review, approved, scheduled), across all active orgs or one org")
+    .option("--status <status>", "open (default) | all | pending_review | draft | approved | rejected | scheduled | sent | cancelled (comma-separated allowed)")
+    .option("--since <date>", "only plans scheduled on or after YYYY-MM-DD")
+    .option("--include-inactive", "include plans from inactive orgs (cross-org listing)")
+    .option("--limit <n>", "max plans returned (default 100, max 500)")
+    .option("--json", "print the raw response")
+    .action((orgId, opts) => plansCmd.list(orgId, opts));
+  plans.command("show <plan_id>")
+    .description("Show one plan in full: copy, second message, buttons, creative, audience, notes")
+    .option("--json", "print the raw response")
+    .option("--out <file>", "also write the full plan JSON to a file")
+    .action((planId, opts) => plansCmd.show(planId, opts));
+  plans.command("status <plan_id>")
+    .description("Change a plan's status (dry run unless --commit); approved/rejected also record you as the reviewer")
+    .requiredOption("--to <status>", "draft | pending_review | approved | rejected | scheduled | sent | cancelled")
+    .option("--comment <text>", "response to the client, shown on their plan (required for rejected)")
+    .option("--internal <text>", "staff-only internal notes (replaces the current internal notes)")
+    .option("--commit", "apply the change (default is a dry run)")
+    .action((planId, opts) => plansCmd.status(planId, opts));
+
   // audit (who did what, when — with the full before/after content)
   const audit = program.command("audit")
     .description("Staff-CLI audit trail: who changed what, when — with full before/after content")
@@ -602,6 +628,10 @@ export function run(argv) {
     .option("--python", "with --tag: force the python /meta-broadcast engine (same as the dashboard's Python toggle). NOTE: any tag send >10 recipients ALWAYS uses python automatically")
     .option("--at <when>", "SCHEDULE instead of sending now (tag AND CSV mode, v0.6.1) — \"YYYY-MM-DD HH:MM\" in SAST (e.g. --at \"2026-08-05 09:00\"). CSV: rows are imported+tagged NOW, the python call is queued server-side and shows on the dashboard's Scheduled sends page. Fires automatically; the tag is re-resolved at send time")
     .option("--needs-approval", "with --at: park it awaiting approval (flowiq bc scheduled approve) instead of firing automatically")
+    .option("--route-team <team>", "REPLY ROUTING (v0.7.4): assign every reply to this broadcast to this team (name or id). Once per recipient, typed replies AND button taps, without muting keywords or the AI agent. Forces the python engine")
+    .option("--route-member <who>", "REPLY ROUTING: also/instead assign to this person (email, name or id) — must be an active member of the org")
+    .option("--route-window <dur>", "REPLY ROUTING: how long after the send a reply still counts, e.g. 72h or 3d (default 72h, max 14d)")
+    .option("--no-route-notify", "REPLY ROUTING: assign silently — do not send the team/person their assignment notification")
     .option("--commit", "actually send (omit to dry-run)")
     .option("--yes", "skip the type-the-campaign-name confirm gate (CI)")
     .option("--force-remap", "ignore the saved mapping and rebuild interactively")
@@ -653,6 +683,16 @@ export function run(argv) {
     .option("--limit <n>", "with --failures: how many failed rows to print", "40")
     .option("--json", "raw JSON")
     .action((orgId, broadcastId, opts) => broadcastCmd.status(orgId, broadcastId, opts));
+  broadcast.command("route <organization_id> <broadcast_id>")
+    .description("Reply routing on an EXISTING broadcast: no flags = show it; --team/--member = set it; --clear = switch it off. DRY-RUN unless --commit. Only replies arriving after the change are routed")
+    .option("--team <team>", "assign replies to this team (name or id)")
+    .option("--member <who>", "assign replies to this person (email, name or id)")
+    .option("--window <dur>", "how long after the SEND a reply still counts, e.g. 72h or 3d (default 72h, max 14d)")
+    .option("--no-notify", "assign silently (no assignment notification)")
+    .option("--clear", "remove the routing from this broadcast")
+    .option("--commit", "apply (omit to dry-run)")
+    .option("--json", "raw JSON")
+    .action((orgId, broadcastId, opts) => broadcastCmd.route(orgId, broadcastId, opts));
   broadcast.command("retry <organization_id> <broadcast_id>")
     .description("Re-send a broadcast to ONLY its failed recipients (transient-failure recovery). DRY-RUN by default; --commit re-fires via python")
     .option("--commit", "actually re-send (omit to see the failed count + reasons)")

package/src/reply-routing.test.mjs

@@ -0,0 +1,58 @@
+// Reply routing flag parsing (v0.7.4) — pure functions only, no network.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { parseRouteWindow, routingFromOpts, describeRouting } from "./commands/broadcast.js";
+
+test("window: hours, h suffix, days", () => {
+  assert.deepEqual(parseRouteWindow("72"), { hours: 72 });
+  assert.deepEqual(parseRouteWindow("72h"), { hours: 72 });
+  assert.deepEqual(parseRouteWindow(" 3D "), { hours: 72 });
+  assert.deepEqual(parseRouteWindow("14 days"), { hours: 336 });
+  assert.deepEqual(parseRouteWindow(undefined), { hours: null });
+});
+
+test("window: rejects garbage, zero and anything past 14 days", () => {
+  assert.ok(parseRouteWindow("soon").error);
+  assert.ok(parseRouteWindow("0").error);
+  assert.ok(parseRouteWindow("15d").error);
+  assert.ok(parseRouteWindow("-5").error);
+  assert.ok(parseRouteWindow("1.5h").error);
+});
+
+test("no routing flags = no routing, and the send request stays untouched", () => {
+  assert.deepEqual(routingFromOpts({ routeNotify: true }), { routing: null });
+  assert.deepEqual(routingFromOpts({}), { routing: null });
+});
+
+test("a window or --no-route-notify without a target is an error, never a silent no-op", () => {
+  assert.ok(routingFromOpts({ routeWindow: "48h" }).error);
+  assert.ok(routingFromOpts({ routeNotify: false }).error);
+});
+
+test("team + member + window + silent", () => {
+  assert.deepEqual(
+    routingFromOpts({ routeTeam: " Spa ", routeMember: "kim@example.com", routeWindow: "2d", routeNotify: false }),
+    { routing: { team: "Spa", member: "kim@example.com", window_hours: 48, notify: false } },
+  );
+  // Defaults are left to the server (72 h, notify on) — the client sends only what was typed.
+  assert.deepEqual(routingFromOpts({ routeTeam: "Spa", routeNotify: true }), { routing: { team: "Spa" } });
+});
+
+test("a bad window stops the run", () => {
+  assert.ok(routingFromOpts({ routeTeam: "Spa", routeWindow: "whenever" }).error);
+});
+
+test("`bc route` reads its own flag names", () => {
+  const keys = { team: "team", member: "member", window: "window", notify: "notify" };
+  assert.deepEqual(routingFromOpts({ team: "Spa", window: "24", notify: true }, keys), { routing: { team: "Spa", window_hours: 24 } });
+  assert.deepEqual(routingFromOpts({ notify: true }, keys), { routing: null });
+});
+
+test("describeRouting reads like a sentence", () => {
+  assert.equal(describeRouting(null), "none");
+  assert.equal(
+    describeRouting({ team_name: "Spa", member_name: null, window_hours: 72, notify_team: true, notify_member: null }),
+    "team Spa · first reply within 72 h · team notified",
+  );
+  assert.match(describeRouting({ team_name: "Spa", member_name: "Kim", window_hours: 24, notify_team: false, notify_member: false }), /team Spa \+ Kim .* 24 h .* team not notified, person not notified/);
+});