@inetafrica/open-claudia 3.5.8 → 3.5.10

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 3.5.10
+
+Passive replies in Kazee groups, and no endless bot-to-bot loops. Needs chat-central with the "Bot replies" group setting (an older server never sends the new mode, so groups keep today's behaviour). Canary first, on the sales bot.
+
+- **"Bot replies: When they can help".** A group admin now picks how bots reply in a group: When tagged (as before), When they can help, or Every message. In "When they can help" the bot reads people's text messages and, after a short pause (6 s after the last message, at most 20 s), a quick check on a small model (utility purpose `passive-reply`, Haiku by default; `PASSIVE_REPLY_PROVIDER` / `PASSIVE_REPLY_MODEL`) decides whether it can help. Only a yes starts a real turn. Unasked replies are read-only (plan mode), at most 6 an hour per group, and the guards hold anything doubtful quietly instead of asking the owner. "@bot be quiet" snoozes the bot in that group for 3 hours; "@bot you can talk again" ends it. Messages from bots, commands, system notices, cards and media are never judged.
+- **No endless bot-to-bot loops.** Two bots in one group could answer each other forever. Another bot now gets this bot's answer only when it @-mentions it: replies to the bot's messages, a shared thread and "Every message" / "When they can help" groups no longer count for bots. Even with a mention, once 4 messages in a row came from bots (`OC_BOT_CHAIN_LIMIT`), the bot stays silent until a person speaks, and it stays silent when it cannot read the conversation to check. People are unaffected.
+- **Fix: `decide` asks in the thread that queued it.** Decision cards went to the owner's main chat even when a thread queued them (Sumeet, 2 Oct: "This is this thread."). When asking fails, `decide` now reports the real number of open decisions instead of "undefined open".
+- **Tests:** `test-passive-replies.js`, `test-passive-replies-router.js`, `test-kazee-bot-loops.js` and additions to `test-enforcer.js`; `test-run-lock.js` uses its own config directory, so a local `.env` cannot change its limits.
+
+## 3.5.9
+
+Kazee Cards: the bot sends interactive and data cards in Kazee Chat, and asks the owner's decisions one card at a time. Needs chat-central with Kazee Cards v1 (cards are refused by an older server). Canary first, on the owner's own bot.
+
+- **`open-claudia card send <spec|->`** posts a card into the turn's own chat and thread: a decision (2-4 options), a choice (poll, one or several answers), a rating (stars, optional comment), a slider, or a report (stat tiles, bar chart, facts). `card update <id> --close | --open | --note "..." | --spec <file>` changes a card the bot sent, `card show <id>` prints what the bot knows about it, and `card example <kind>` prints a starting spec. Only a live, attributed run may send one, and it always lands in that run's own room.
+- **An answer wakes the conversation that sent the card**, as that card's sender. A card a few named people answer wakes on each answer; a poll anyone may answer does not wake per vote unless the sender asks (`--wake each|first|none`). Extras (for example "Later") always reach the sender. Anything a person typed is quoted as their words, never as instructions.
+- **The owner's decision queue: `open-claudia decide "<question>" --option id="label" ... [--pick id] [--body "why"]`.** Decisions go to the owner's chat as cards, one at a time. The answer wakes the conversation that queued it and the next decision is asked. "⏰ Later" closes the card with a note and asks again three hours later; "🎧 Tell me more" asks the conversation for a short voice explainer. `decide list` and `decide cancel <id>`.
+- **Kazee adapter:** `sendCard` / `updateCard`, and `card:response` events from the chat server reach the card ledger (`~/.open-claudia/cards.json`, `decisions.json`).
+- **Tests:** `test-kazee-cards.js` (adapter, wake-ups, comment quoting, the decision queue) and `test-loopback-cards.js` (who may send, change and decide).
+
 ## 3.5.8
 
 GPT-6.1 Sol for Codex, and a /codex_login code you can copy. Canary first on network-bot and procurement-specialist, then the fleet.

package/bin/cards.js

@@ -0,0 +1,163 @@
+// `open-claudia card ...` and `open-claudia decide ...`: Kazee Cards from
+// inside a turn (see core/cards.js and chat-central CARDS-V1).
+
+const fs = require("fs");
+const { postJson } = require("./loopback-client");
+
+const EXAMPLES = {
+  decision: {
+    v: 1, kind: "decision", kicker: "Decision", tag: "Usage",
+    title: "Cut back on helper agents?",
+    body: "Helpers are about 60% of usage since 23 Sep.",
+    input: { options: [{ id: "yes", label: "Yes, cut back", style: "primary" }, { id: "no", label: "Keep as is" }] },
+    recommendation: { option: "yes" },
+    extras: [{ id: "later", label: "⏰ Later" }],
+    policy: { responders: ["<kazeeUserId>"], mode: "first" },
+  },
+  choice: {
+    v: 1, kind: "choice", title: "Which should we build first?",
+    input: { options: [{ id: "calls", label: "📞 Calls" }, { id: "taskbar", label: "🧠 Taskbar" }], multiple: false },
+    policy: { mode: "changeable", results: "live", anonymous: true, closesAt: "2026-10-02T15:00:00Z" },
+  },
+  rating: {
+    v: 1, kind: "rating", title: "How does the ring screen feel?",
+    input: { max: 5, comment: true, commentPlaceholder: "What should change? (optional)" },
+    policy: { mode: "each", results: "closed" },
+  },
+  slider: {
+    v: 1, kind: "slider", title: "Most helpers running at once",
+    input: { min: 0, max: 8, step: 1, value: 3, unit: "helpers at a time", minLabel: "careful", maxLabel: "fast" },
+    recommendation: { value: 3 },
+  },
+  report: {
+    v: 1, kind: "report", title: "Since the switch to Opus 5.5",
+    blocks: [
+      { type: "stats", items: [{ value: "4,763", label: "model calls a day", delta: "▲ 3.7×", tone: "warn" }] },
+      { type: "bars", unit: "$", items: [{ label: "23", value: 416 }, { label: "24", value: 918 }], ref: { value: 259, label: "before" } },
+      { type: "facts", items: [{ label: "Source", value: "Claude Code logs" }] },
+    ],
+    footer: "Source: Claude Code logs",
+  },
+};
+
+function flag(args, name) {
+  const i = args.indexOf(name);
+  if (i < 0) return undefined;
+  const v = args[i + 1];
+  args.splice(i, 2);
+  return v;
+}
+function bool(args, name) {
+  const i = args.indexOf(name);
+  if (i < 0) return false;
+  args.splice(i, 1);
+  return true;
+}
+function readSpec(arg) {
+  if (!arg) throw new Error("missing card spec (a file, JSON, or - for stdin)");
+  if (arg === "-") return JSON.parse(fs.readFileSync(0, "utf8"));
+  if (arg.trim().startsWith("{")) return JSON.parse(arg);
+  return JSON.parse(fs.readFileSync(arg, "utf8"));
+}
+function fail(msg, code = 1) {
+  console.error(msg);
+  process.exit(code);
+}
+
+const CARD_USAGE = `Usage:
+  open-claudia card send <spec.json | '{json}' | -> [--wake each|first|none] [--content "plain text"]
+  open-claudia card update <messageId> [--close | --open] [--note "text"] [--spec <file|json>]
+  open-claudia card show <messageId>
+  open-claudia card example <decision|choice|rating|slider|report>
+Cards are Kazee Chat only. Answers wake this conversation when --wake is each
+(default for a card a few named people answer) or first; polls anyone answers
+default to none. Spec: chat-central CARDS-V1 (v:1, kind, title, input, policy...).`;
+
+async function runCard(args) {
+  const sub = args.shift();
+  try {
+    if (sub === "example") {
+      const kind = args[0];
+      if (!EXAMPLES[kind]) fail(`kinds: ${Object.keys(EXAMPLES).join(", ")}`);
+      console.log(JSON.stringify(EXAMPLES[kind], null, 2));
+      return;
+    }
+    if (sub === "send") {
+      const wake = flag(args, "--wake");
+      const content = flag(args, "--content");
+      const card = readSpec(args[0]);
+      const res = await postJson("card-send", { card, wake, content });
+      console.log(`Sent card ${res.messageId} (answers wake this conversation: ${res.wake})`);
+      return;
+    }
+    if (sub === "update") {
+      const messageId = args.shift();
+      if (!messageId) fail(CARD_USAGE);
+      const note = flag(args, "--note");
+      const spec = flag(args, "--spec");
+      const status = bool(args, "--close") ? "closed" : bool(args, "--open") ? "open" : undefined;
+      if (!note && !spec && !status) fail("nothing to change: --close, --open, --note or --spec");
+      const res = await postJson("card-update", { messageId, note, status, card: spec ? readSpec(spec) : undefined });
+      console.log(`Updated card ${messageId}: ${JSON.stringify(res.card?.state || {})}`);
+      return;
+    }
+    if (sub === "show") {
+      const res = await postJson("card-show", { messageId: args[0] });
+      console.log(JSON.stringify(res.card, null, 2));
+      return;
+    }
+    fail(CARD_USAGE, sub ? 1 : 0);
+  } catch (e) {
+    fail(`card ${sub}: ${e.message}`);
+  }
+}
+
+const DECIDE_USAGE = `Usage:
+  open-claudia decide "<question>" --option <id>="<label>" --option <id>="<label>" [--pick <id>] [--body "why it matters"] [--tag "Area"]
+  open-claudia decide list
+  open-claudia decide cancel <id>
+Owner only. Decisions go to your Kazee chat as cards, one at a time; the answer
+wakes the conversation that queued it. "Later" snoozes it for 3 hours, "Tell me
+more" asks this conversation for a short voice explainer.`;
+
+async function runDecide(args) {
+  const first = args[0];
+  try {
+    if (first === "list") {
+      const res = await postJson("decide-list", {});
+      if (!res.decisions.length) return console.log("No decisions queued.");
+      for (const d of res.decisions) {
+        const extra = d.status === "decided" ? ` -> ${d.answerLabel}` : d.status === "snoozed" ? ` until ${d.notBefore}` : "";
+        console.log(`${d.id}  ${d.status.padEnd(9)} ${d.title}${extra}`);
+      }
+      return;
+    }
+    if (first === "cancel") {
+      const res = await postJson("decide-cancel", { id: args[1] });
+      console.log(`Cancelled ${res.decision.id}: ${res.decision.title}`);
+      return;
+    }
+    const rest = [...args];
+    const title = rest.shift();
+    if (!title || title.startsWith("--")) fail(DECIDE_USAGE, title ? 1 : 0);
+    const options = [];
+    let i;
+    while ((i = rest.indexOf("--option")) >= 0) {
+      const raw = rest[i + 1] || "";
+      rest.splice(i, 2);
+      const eq = raw.indexOf("=");
+      if (eq <= 0) fail(`--option needs id="label" (got ${raw})`);
+      options.push({ id: raw.slice(0, eq).trim(), label: raw.slice(eq + 1).trim() });
+    }
+    const pick = flag(rest, "--pick");
+    const body = flag(rest, "--body");
+    const tag = flag(rest, "--tag");
+    const res = await postJson("decide-add", { title, options, pick, body, tag });
+    const where = res.askedNow ? "asked now" : `queued (${res.waiting} open)`;
+    console.log(`Decision ${res.decision.id} ${where}: ${res.decision.title}${res.warning ? `\n${res.warning}` : ""}`);
+  } catch (e) {
+    fail(`decide: ${e.message}`);
+  }
+}
+
+module.exports = { runCard, runDecide, EXAMPLES };

package/bin/cli.js

@@ -444,6 +444,14 @@ switch (command) {
     break;
   }
 
+  case "card": {
+    require("./cards").runCard(args.slice(1));
+    break;
+  }
+  case "decide": {
+    require("./cards").runDecide(args.slice(1));
+    break;
+  }
   case "schedule-wakeup": {
     require("./schedule").runScheduleWakeup(args.slice(1));
     break;
@@ -612,6 +620,9 @@ Send tools (only work inside an active bot-spawned task):
                                              narration; ext picks format; --voice <id> optional)
   open-claudia transcribe <file>     Speech-to-text: print the transcript of an audio/video file
   open-claudia call [toUserId]       Place a live voice call on the current channel (kazee; owner-only)
+  open-claudia card send <spec|->    Send a Kazee Card (decision, choice, rating, slider, report); answers wake this conversation
+  open-claudia card update <id> ...  Close/open a card you sent, add a note, or replace its spec (card example <kind> for specs)
+  open-claudia decide "<q>" --option id="label" ...   Queue a decision card for the owner (one at a time; decide list|cancel)
 
 Memory tools:
   open-claudia transcript-search <query>     Ranked FTS5 search over indexed transcripts

package/bot.js

@@ -362,6 +362,9 @@ async function safeModeBoot() {
     }
   }
 
+  // Kazee Cards: snoozed owner decisions are asked again when due.
+  try { require("./core/cards").startDecisionPump(registry); } catch (e) { console.error("Decision pump start failed:", e.message); }
+
   // This incarnation counts as healthy once it survives the stable window —
   // resets the crash-loop streak the safe-mode gate counts at boot.
   setTimeout(() => { try { safeBoot.markBootStable(); } catch (e) {} }, safeBoot.STABLE_UPTIME_MS).unref();

package/channels/kazee/adapter.js

@@ -18,6 +18,7 @@ const { createKazeeSocket } = require("./socket");
 const { normalize } = require("./format");
 const { KazeeCallManager } = require("./call/manager");
 const kazeeState = require("./state");
+const { createPassiveGate, quietCommand, CONTEXT_MESSAGES: PASSIVE_CONTEXT_MESSAGES, SNOOZE_MS: PASSIVE_SNOOZE_MS } = require("../../core/passive-replies");
 
 // Group catch-up context sizing: how many messages an engaged turn may carry,
 // how long each rendered body may be, and how far back a chat's very first
@@ -51,6 +52,14 @@ const THREAD_FETCH_TIMEOUT_MS = 4000;
 // A thread whose root someone else posted is re-checked for the bot among its
 // participants at most this often (the answer is "no" until the bot replies).
 const THREAD_NOT_IN_TTL_MS = 60 * 1000;
+// Bots answering bots: once this many messages in a row (the newest one
+// included) came from bots, a bot's @-mention no longer engages the bot until
+// a person speaks again. OC_BOT_CHAIN_LIMIT overrides it (whole number >= 1).
+const BOT_CHAIN_LIMIT = 4;
+function botChainLimit() {
+  const value = parseInt(process.env.OC_BOT_CHAIN_LIMIT, 10);
+  return Number.isSafeInteger(value) && value >= 1 ? value : BOT_CHAIN_LIMIT;
+}
 // How many replies a thread's first turn carries as context.
 const THREAD_CONTEXT_LIMIT = 30;
 const THREAD_ROOT_BODY_LIMIT = 1000;
@@ -125,7 +134,7 @@ const MIME_EXT = {
 };
 
 class KazeeAdapter {
-  constructor({ id = "kazee", url, token, ownerUserId, botUserId }) {
+  constructor({ id = "kazee", url, token, ownerUserId, botUserId, passiveGate = null }) {
     this.id = id;
     this.type = "kazee";
     // KAZEE_URL is the root host (socket.io lives at /). REST routes are
@@ -154,6 +163,21 @@ class KazeeAdapter {
     this._threadNotIn = new Map();
     this._typingThreadWarned = new Set();
     this._callManager = new KazeeCallManager({ adapter: this });
+    // Groups set to "When they can help" (core/passive-replies.js); made on
+    // first use, so a bot in no passive group never builds one.
+    this._passive = passiveGate;
+  }
+
+  _passiveGate() {
+    if (!this._passive) {
+      this._passive = createPassiveGate({
+        store: {
+          getSnooze: (chatId) => kazeeState.getPassiveSnooze(chatId),
+          setSnooze: (chatId, until) => kazeeState.setPassiveSnooze(chatId, until),
+        },
+      });
+    }
+    return this._passive;
   }
 
   // chat-central's chat doc carries the group flag and the per-chat assistant
@@ -168,10 +192,17 @@ class KazeeAdapter {
       const res = await this._request("GET", `/chats/${encodeURIComponent(chatId)}`);
       const chat = res?.chat || res || {};
       if (chat.error) throw new Error(String(chat.error));
+      // Bots are participants of type "AI": in a passive group the bot never
+      // answers another bot unasked. Its own name lets "@Name be quiet" match.
+      const participants = (Array.isArray(chat.participants) ? chat.participants : [])
+        .filter((p) => p && typeof p === "object");
+      const self = participants.find((p) => String(p._id || p.id) === String(this.botUserId));
       const meta = {
         isGroupChat: !!chat.isGroupChat,
         assistantAction: String(chat.assistantAction || ""),
         name: String(chat.chatName || chat.name || ""),
+        botIds: participants.filter((p) => p.type === "AI" || p.type === "Bot").map((p) => String(p._id || p.id)),
+        botName: self && self.name ? String(self.name) : "",
       };
       this._chatMetaCache.set(chatId, { meta, at: Date.now() });
       return meta;
@@ -248,6 +279,32 @@ class KazeeAdapter {
       });
     }
     socket.on("message:new", (msg) => this._handleInboundMessage(msg));
+    // A group admin changed the group (its bot reply setting, name, members):
+    // drop the cached settings so the next message reads them fresh instead
+    // of up to five minutes late.
+    socket.on("chat:updated", (payload) => {
+      const chatId = String(payload?.chatId || payload?.chat?._id || "");
+      if (chatId) this._chatMetaCache.delete(chatId);
+    });
+    // Kazee Cards: someone answered (or tapped an extra on) a card this bot
+    // sent. Routed like a button press; core/cards.js wakes the conversation
+    // the card came from. The payload names its own thread.
+    socket.on("card:response", (payload) => {
+      if (!payload || !payload.messageId) return;
+      const userId = payload.userId ? String(payload.userId) : "";
+      this._emit("action", {
+        adapter: this,
+        channelId: String(payload.chatId),
+        canonicalUserId: userId ? canonicalForChannel("kazee", userId) : null,
+        userId: userId || null,
+        type: "action",
+        messageId: payload.messageId,
+        threadId: payload.threadRoot ? String(payload.threadRoot) : null,
+        action: { buttonId: `kc:${payload.messageId}`, payload: `kc:${payload.messageId}`, sourceMessageId: payload.messageId },
+        card: payload,
+        raw: payload,
+      });
+    });
     socket.on("message:action", (payload) => {
       const channelId = String(payload.chatId);
       const known = this._sentMessages.has(String(payload.messageId || ""));
@@ -562,7 +619,10 @@ class KazeeAdapter {
     // A thread reply also engages it when the bot posted the thread's root or
     // has already replied in that thread (it is part of that conversation).
     // Everyone is gated, owner included: a bot answering every group message
-    // drowns the room. 1:1 chats are never gated. Engaged messages are marked
+    // drowns the room. Other bots are gated harder: only an @-mention, and
+    // never in a chain of bots (no bot-to-bot loops). A passive group lets the
+    // bot judge people's unaddressed messages itself (core/passive-replies.js).
+    // 1:1 chats are never gated. Engaged messages are marked
     // so the router can authorize the turn for non-owner speakers, who then
     // run guarded (mandate/guardrail vetting + owner escalation).
     if (this.botUserId) {
@@ -572,12 +632,55 @@ class KazeeAdapter {
         const mentions = (Array.isArray(msg.mentions) ? msg.mentions : [])
           .map((m) => String(m?._id || m?.id || m));
         const mentioned = mentions.includes(botId);
+        // Another bot (Sumeet, 3 Oct 2026: two bots in one chat "go on an
+        // infinite conversation"): only an explicit @-mention engages the bot,
+        // never a reply to its message, a thread it is in, a passive check or
+        // an every-message group; and never once the conversation is a chain
+        // of bots answering bots (_botChainTooLong) until a person speaks.
+        if ((meta.botIds || []).includes(String(senderId))) {
+          if (!mentioned) {
+            console.log(`Kazee group gate: silent, another bot (chat=${channelId} from=${userId})`);
+            return;
+          }
+          if (await this._botChainTooLong(channelId, envelope.threadId || null, meta, msg)) {
+            console.log(`Kazee group gate: silent, bots answering bots (chat=${channelId} from=${userId})`);
+            return;
+          }
+        }
         const replyToBot = String(envelope.reply?.from?.id || "") === botId;
         const freeReply = meta.assistantAction === "assistant_free_reply";
+        // "When they can help": the bot reads everything and decides itself
+        // (core/passive-replies.js) whether to answer what nobody asked it.
+        const passive = meta.assistantAction === "assistant_passive";
         const inThread = !mentioned && !replyToBot && !freeReply && envelope.threadId
           ? await this._botInThread(channelId, envelope.threadId)
           : false;
+        // "@bot be quiet" / "you can talk again" in a passive group only switch
+        // its unprompted replies off or on: no turn, just a one-line answer.
+        if (passive && (mentioned || replyToBot) && envelope.type === "text") {
+          const command = quietCommand(text, meta.botName);
+          if (command) return this._passiveQuietCommand(channelId, command, envelope);
+        }
         if (!mentioned && !replyToBot && !freeReply && !inThread) {
+          if (passive && this._passiveCandidate(msg, envelope, meta, senderId)) {
+            this._passiveGate().consider({
+              chatId: channelId,
+              key: envelope.threadId ? `${channelId}#thread:${envelope.threadId}` : channelId,
+              envelope,
+              botName: meta.botName,
+              roomName: meta.name,
+              loadContext: () => this._passiveContext(channelId, envelope.threadId),
+              emit: (decided, { reason }) => {
+                decided.engaged = true;
+                decided.surface = "group";
+                decided.isGroup = true;
+                decided.passive = true;
+                decided.passiveReason = reason;
+                this._emit("message", decided);
+              },
+            });
+            return;
+          }
           console.log(`Kazee group gate: silent (chat=${channelId} from=${userId})`);
           return;
         }
@@ -595,6 +698,85 @@ class KazeeAdapter {
     this._emit("message", envelope);
   }
 
+  // Whether the conversation (a thread, or the main timeline) is already a
+  // chain of bots answering bots: its newest messages, this one included, all
+  // came from bots, botChainLimit() of them or more. A failed read counts as
+  // a chain: quiet is the safe side of a possible loop.
+  async _botChainTooLong(chatId, threadId, meta, msg) {
+    const limit = botChainLimit();
+    const bots = new Set([...(meta.botIds || []), String(this.botUserId)]);
+    let recent;
+    try {
+      if (threadId) {
+        const data = await this._fetchThread(chatId, threadId, limit + 2);
+        recent = [...(data.root && typeof data.root === "object" ? [data.root] : []), ...(Array.isArray(data.replies) ? data.replies : [])];
+      } else {
+        recent = await withTimeout(this._messagesSince(chatId, null, limit + 2), THREAD_FETCH_TIMEOUT_MS, "Kazee recent messages");
+      }
+    } catch (e) {
+      console.error(`Kazee bot chain check failed (chat=${chatId}):`, e.message);
+      return true;
+    }
+    const list = (Array.isArray(recent) ? recent : []).filter((m) => m && !m.isDeleted && m.type !== "system");
+    const currentId = String(msg._id || msg.id || "");
+    if (currentId && !list.some((m) => String(m._id || m.id || "") === currentId)) list.push(msg);
+    let streak = 0;
+    for (let i = list.length - 1; i >= 0 && bots.has(senderIdOf(list[i])); i -= 1) streak += 1;
+    return streak >= limit;
+  }
+
+  // Whether an unaddressed message in a passive group is the bot's to judge:
+  // plain text a person wrote. Never another bot (no bot-to-bot chatter),
+  // never a command, system notice, card or media without words (v1).
+  _passiveCandidate(msg, envelope, meta, senderId) {
+    if (envelope.type !== "text" || !String(envelope.text || "").trim()) return false;
+    if (msg.type === "system" || msg.type === "interactive" || msg.card) return false;
+    if ((meta.botIds || []).includes(String(senderId))) return false;
+    return true;
+  }
+
+  // What the passive check reads: the thread (root first) or the main
+  // timeline's recent messages, oldest first, the bot's own marked "You".
+  async _passiveContext(chatId, threadId) {
+    const botId = String(this.botUserId);
+    let raw;
+    if (threadId) {
+      const data = await this._fetchThread(chatId, threadId, PASSIVE_CONTEXT_MESSAGES);
+      raw = [...(data.root && typeof data.root === "object" ? [data.root] : []), ...(Array.isArray(data.replies) ? data.replies : [])];
+    } else {
+      raw = await withTimeout(this._messagesSince(chatId, null, PASSIVE_CONTEXT_MESSAGES), THREAD_FETCH_TIMEOUT_MS, "Kazee recent messages");
+    }
+    return raw
+      .filter((m) => m && !m.isDeleted && m.type !== "system")
+      .map((m) => ({
+        id: String(m._id || m.id || ""),
+        who: senderIdOf(m) === botId ? "You" : (m.sender?.name || "Someone"),
+        text: this._contextBody(m, CONTEXT_BODY_LIMIT),
+        ago: this._ago(m.createdAt),
+      }))
+      .filter((m) => m.text);
+  }
+
+  // "@bot be quiet" (snooze) or "@bot you can talk again" (resume) in a
+  // passive group: anyone in the group may ask; tags keep working meanwhile.
+  async _passiveQuietCommand(chatId, command, envelope) {
+    const gate = this._passiveGate();
+    let reply;
+    if (command === "snooze") {
+      gate.snooze(chatId);
+      const hours = Math.round(PASSIVE_SNOOZE_MS / (60 * 60 * 1000));
+      reply = `Okay, I'll stay quiet here for ${hours} hours. Tag me if you need me.`;
+    } else {
+      gate.resume(chatId);
+      reply = "Okay, I'm back. I'll reply here when I can help.";
+    }
+    try {
+      await this.send(chatId, reply, { threadId: envelope.threadId || null, replyTo: envelope.messageId });
+    } catch (e) {
+      console.error(`Kazee passive ${command} answer failed (chat=${chatId}):`, e.message);
+    }
+  }
+
   _mediaRefs(msg, contextChatId, source) {
     const raw = Array.isArray(msg.medias) && msg.medias.length ? msg.medias
       : msg.media ? [msg.media] : Array.isArray(msg.attachments) ? msg.attachments : [];
@@ -925,6 +1107,37 @@ class KazeeAdapter {
     return null;
   }
 
+  // Kazee Cards (chat-central CARDS-V1): post a card. The server checks the
+  // spec, picks the stored type, the old-app fallback buttons and (unless we
+  // give one) the plain-text version. Returns the card's message id, or null.
+  // Unlike send() there is no retry: a card is not idempotent on our side and
+  // the caller reports the failure instead.
+  async sendCard(channelId, card, opts = {}) {
+    const body = {
+      chat_id: channelId,
+      sender: this.botUserId,
+      type: "interactive",
+      card,
+      findMeCode: `oc-card-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    };
+    if (typeof opts.content === "string" && opts.content.trim()) body.content = normalize(opts.content);
+    const threadId = opts.threadId ? String(opts.threadId) : null;
+    if (threadId) body.threadRootId = threadId;
+    const res = await this._request("POST", `/chat/${encodeURIComponent(channelId)}/message`, body);
+    if (res && res.success === false) throw new Error(res.error || "card refused");
+    const m = res?.message || res || {};
+    const id = m._id || m.id;
+    this._rememberSentSafely(id, threadId, channelId);
+    return id ? String(id) : null;
+  }
+
+  // Change a card this bot sent: { status: "closed"|"open", note, card }.
+  async updateCard(messageId, patch = {}) {
+    const res = await this._request("PUT", `/message/${encodeURIComponent(messageId)}/card`, patch);
+    if (res && res.success === false) throw new Error(res.error || "card update refused");
+    return res?.card || null;
+  }
+
   // Get-or-create the 1:1 chat between the bot and a user, returning its
   // chatId. chat-central's createChat returns the existing DM when one
   // already exists, so this is idempotent. Requires chats.create on the bot

package/channels/kazee/state.js

@@ -49,6 +49,24 @@ function getContextWatermark(chatId) {
   return (c && c.contextAt) || null;
 }
 
+// Passive reply mode (core/passive-replies.js): the time (ms) until which the
+// bot stays quiet in a group after someone told it to; 0 = not snoozed.
+function setPassiveSnooze(chatId, untilMs) {
+  const id = String(chatId || "");
+  if (!id) return;
+  const s = load();
+  const next = { ...(s.chats[id] || {}) };
+  if (Number(untilMs) > 0) next.passiveSnoozeUntil = Number(untilMs);
+  else delete next.passiveSnoozeUntil;
+  s.chats[id] = next;
+  save();
+}
+
+function getPassiveSnooze(chatId) {
+  const c = load().chats[String(chatId || "")];
+  return Number(c && c.passiveSnoozeUntil) || 0;
+}
+
 function getThread(rootId) {
   const s = load();
   const t = s.threads[String(rootId || "")];
@@ -114,6 +132,8 @@ function threadTitled(rootId) {
 module.exports = {
   setContextWatermark,
   getContextWatermark,
+  setPassiveSnooze,
+  getPassiveSnooze,
   getThread,
   markBotRepliedInThread,
   botRepliedInThread,

package/core/actions.js

@@ -147,6 +147,14 @@ function appendMandateLine(rec, lineText, log, opts) {
 }
 
 async function handleAction(envelope) {
+  // Kazee Cards: an answer to a card this bot sent (channels/kazee adapter,
+  // card:response). The card ledger decides what it wakes; nothing is sent
+  // into the chat from here.
+  if (envelope.card) {
+    try { await require("./cards").handleCardResponse(envelope); }
+    catch (e) { console.error("[cards] handling an answer failed:", e.message); }
+    return;
+  }
   const adapter = envelope.adapter;
   const d = envelope.action?.payload || envelope.action?.buttonId || "";
   const state = currentState();