@inetafrica/open-claudia 3.5.13 → 3.5.16

package/core/browser-view.js

@@ -0,0 +1,200 @@
+// Live view of the bot's own browser (agent-browser) for the web dashboard and Agent Space.
+//
+// agent-browser runs one daemon per session and records it in its socket folder as
+// <session>.pid, <session>.stream (port of the session's screen-stream WebSocket) and
+// <session>.target (current tab and page address). The agent's commands run with HOME but
+// without XDG_RUNTIME_DIR (core/providers/env.js), so their sessions land in ~/.agent-browser
+// (/data/.agent-browser in a pod); the other folders cover a bot started with
+// AGENT_BROWSER_SOCKET_DIR or XDG_RUNTIME_DIR.
+//
+// listSessions() finds the sessions that are running and streaming. serveStream() sends one
+// session's frames and page-address updates to a viewer as server-sent events, the same
+// transport as /api/chat/stream, so it passes through Agent Space's bot proxy unchanged.
+// Watch-only by design: there is no path from a viewer to the browser, so watching can never
+// click or type. Page addresses are cut to origin + path so tokens in query strings never
+// reach a viewer.
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const WebSocket = require("ws");
+
+const SESSION_NAME = /^[A-Za-z0-9._-]{1,64}$/;
+const DEFAULT_FPS = 5;
+const MAX_FPS = 10;
+const KEEPALIVE_MS = 25000; // static pages send no frames; comments keep proxies from closing the stream
+
+function socketDirs(env = process.env, home = os.homedir()) {
+  const dirs = [];
+  if (env.AGENT_BROWSER_SOCKET_DIR) dirs.push(env.AGENT_BROWSER_SOCKET_DIR);
+  if (env.XDG_RUNTIME_DIR) dirs.push(path.join(env.XDG_RUNTIME_DIR, "agent-browser"));
+  if (home) dirs.push(path.join(home, ".agent-browser"));
+  return [...new Set(dirs)];
+}
+
+function readSmall(file) {
+  try {
+    return fs.readFileSync(file, "utf8").slice(0, 4096).trim();
+  } catch (_) {
+    return "";
+  }
+}
+
+// In a pod the session files sit on /data and outlive a restart, and pid numbers get reused, so on
+// Linux the pid must also belong to an agent-browser process.
+function processAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+  } catch (err) {
+    if (!err || err.code !== "EPERM") return false;
+  }
+  try {
+    return fs.readFileSync(`/proc/${pid}/cmdline`, "utf8").includes("agent-browser");
+  } catch (_) {
+    return true; // no /proc (macOS): the signal check is all there is
+  }
+}
+
+// Origin + path only: no credentials, query string or fragment.
+function safePageAddress(raw) {
+  if (!raw) return null;
+  try {
+    const u = new URL(String(raw));
+    if (u.protocol === "about:") return u.href.split(/[?#]/)[0];
+    if (u.protocol !== "http:" && u.protocol !== "https:") return null;
+    return `${u.origin}${u.pathname}`;
+  } catch (_) {
+    return null;
+  }
+}
+
+function listSessions({ dirs = socketDirs(), alive = processAlive } = {}) {
+  const seen = new Set();
+  const sessions = [];
+  for (const dir of dirs) {
+    let files;
+    try {
+      files = fs.readdirSync(dir);
+    } catch (_) {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.endsWith(".stream")) continue;
+      const name = file.slice(0, -".stream".length);
+      if (!SESSION_NAME.test(name) || seen.has(name)) continue;
+      const port = Number(readSmall(path.join(dir, file)));
+      if (!Number.isInteger(port) || port < 1 || port > 65535) continue;
+      if (!alive(Number(readSmall(path.join(dir, `${name}.pid`))))) continue;
+      let page = null;
+      try {
+        page = safePageAddress(JSON.parse(readSmall(path.join(dir, `${name}.target`))).url);
+      } catch (_) { /* no target yet */ }
+      let updatedAt = null;
+      for (const f of [`${name}.target`, file]) {
+        try {
+          updatedAt = fs.statSync(path.join(dir, f)).mtime.toISOString();
+          break;
+        } catch (_) { /* try the next file */ }
+      }
+      seen.add(name);
+      sessions.push({ name, port, page, updatedAt });
+    }
+  }
+  return sessions.sort((a, b) => String(b.updatedAt || "").localeCompare(String(a.updatedAt || "")));
+}
+
+// Public view of a session: the stream port stays inside the bot.
+function describeSessions(options) {
+  return listSessions(options).map(({ name, page, updatedAt }) => ({ name, page, updatedAt }));
+}
+
+function clampFps(value) {
+  const n = Math.round(Number(value));
+  if (!Number.isFinite(n) || n < 1) return DEFAULT_FPS;
+  return Math.min(n, MAX_FPS);
+}
+
+// Open one session's screen stream. onMessage gets {type: "frame"|"url", ...}; onEnd(reason) runs
+// once when the session is not running, ends, or cannot be reached. close() stops it quietly.
+function openStream(sessionName, { fps, sessions, connect = (url) => new WebSocket(url), onMessage, onEnd }) {
+  const session = (sessions || listSessions()).find((s) => s.name === sessionName);
+  if (!session) {
+    onEnd("not-running");
+    return { close() {} };
+  }
+  const upstream = connect(`ws://127.0.0.1:${session.port}/?maxFps=${clampFps(fps)}`);
+  let done = false;
+  const stop = () => {
+    if (done) return false;
+    done = true;
+    try { upstream.close(); } catch (_) { /* already closed */ }
+    return true;
+  };
+  if (session.page) onMessage({ type: "url", url: session.page });
+  upstream.on("message", (data) => {
+    if (done) return;
+    let msg;
+    try {
+      msg = JSON.parse(String(data));
+    } catch (_) {
+      return;
+    }
+    if (msg && msg.type === "frame" && typeof msg.data === "string") {
+      onMessage({ type: "frame", seq: msg.seq, data: msg.data, metadata: msg.metadata || {} });
+    } else if (msg && msg.type === "url") {
+      onMessage({ type: "url", url: safePageAddress(msg.url) });
+    }
+  });
+  upstream.on("close", () => { if (stop()) onEnd("ended"); });
+  upstream.on("error", () => { if (stop()) onEnd("unavailable"); });
+  return { close: stop };
+}
+
+// Server-sent events for one session: "frame" and "url" events, a final "end" event with the
+// reason, and ": ping" comments while the page is still. Every payload also carries its type,
+// for readers that only look at data lines. Frames are skipped, never queued, while a slow
+// viewer's connection is backed up.
+function serveStream(res, sessionName, { fps, sessions, connect, keepaliveMs = KEEPALIVE_MS } = {}) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache, no-store",
+    "Connection": "keep-alive",
+    "X-Accel-Buffering": "no",
+  });
+  const write = (event, obj) => {
+    try { res.write(`event: ${event}\ndata: ${JSON.stringify(obj)}\n\n`); } catch (_) { /* viewer gone */ }
+  };
+  const heartbeat = setInterval(() => { try { res.write(": ping\n\n"); } catch (_) { /* viewer gone */ } }, keepaliveMs);
+  const stream = openStream(sessionName, {
+    fps,
+    sessions,
+    connect,
+    onMessage: (msg) => {
+      if (msg.type === "frame" && res.writableNeedDrain) return;
+      write(msg.type, msg);
+    },
+    onEnd: (reason) => {
+      clearInterval(heartbeat);
+      write("end", { type: "end", reason });
+      try { res.end(); } catch (_) { /* viewer gone */ }
+    },
+  });
+  res.on("close", () => {
+    clearInterval(heartbeat);
+    stream.close();
+  });
+}
+
+module.exports = {
+  DEFAULT_FPS,
+  MAX_FPS,
+  clampFps,
+  describeSessions,
+  listSessions,
+  openStream,
+  processAlive,
+  safePageAddress,
+  serveStream,
+  socketDirs,
+};

package/core/cards.js

@@ -12,6 +12,12 @@
 //                   rest wait; Later snoozes, Tell me more asks the origin
 //                   conversation for a voice explainer
 //
+// Open decisions must not sink and go stale (Sumeet, 5 Oct 2026): the ledger
+// keeps each card's state current, the turn's prompt lists the decisions
+// still open in that conversation so the bot closes the ones that no longer
+// apply, a decision left overnight gets one reminder in its own thread, and a
+// late answer wakes with "check this still applies".
+//
 // Safety: an answer wakes the conversation that sent the card, which runs as
 // that card's sender. Anything a person typed (a rating comment) is quoted as
 // their words, never as instructions. Cards that anyone in a group may answer
@@ -29,6 +35,19 @@ const CARD_KEEP_MS = 45 * 24 * 60 * 60 * 1000;
 const CARD_KEEP_MAX = 2000;
 const SNOOZE_MS = Number(process.env.OC_DECISION_SNOOZE_MS || 3 * 60 * 60 * 1000);
 const COMMENT_MAX = 500;
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+const OPEN_DECISION_MAX_AGE_MS = 14 * DAY_MS;
+const REMIND_MAX_AGE_MS = 7 * DAY_MS;
+const REMIND_MIN_WAIT_MS = 8 * HOUR_MS;
+const REMIND_HOUR = 9;
+const REMIND_LAST_HOUR = 18;
+const LATE_ANSWER_MS = 6 * HOUR_MS;
+const PROMPT_DECISIONS_MAX = 5;
+const PROMPT_TITLE_MAX = 80;
+const PROMPT_TITLE_MIN = 20;
+const PROMPT_SECTION_MAX = 600;
+const timeZone = () => process.env.OC_TIMEZONE || "Africa/Nairobi";
 
 function readJson(file, fallback) {
   try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch (_) { return fallback; }
@@ -77,6 +96,97 @@ function updateCardRecord(messageId, patch) {
   return cards[String(messageId)];
 }
 
+/** A card is open unless the server (or the bot) closed or decided it. */
+function cardIsOpen(state) {
+  if (!state) return true;
+  if (state.decided) return false;
+  return !["closed", "decided", "expired"].includes(state.status);
+}
+
+/**
+ * The bot changed one of its own cards (PUT /message/:id/card): keep the
+ * ledger's lastState current. `view` is the server's answer when there is one.
+ */
+function noteCardUpdate(messageId, patch = {}, view = null) {
+  const cur = getCard(messageId);
+  if (!cur) return null;
+  const at = new Date().toISOString();
+  let lastState;
+  if (view && view.state) {
+    lastState = { ...view.state, at };
+  } else {
+    lastState = { ...(cur.lastState || {}), status: patch.status || cur.lastState?.status || "open", at };
+    if (patch.note !== undefined && patch.note !== null) {
+      const note = String(patch.note).trim();
+      if (note) lastState.note = note;
+      else delete lastState.note;
+    }
+  }
+  return updateCardRecord(messageId, { lastState, ...(patch.card?.title ? { title: patch.card.title } : {}) });
+}
+
+/** Where a card was posted: a queued decision's home, else the conversation that sent it. */
+function placeOf(rec) {
+  return rec.home || rec.origin || {};
+}
+
+/**
+ * The bot's own decision cards still waiting for an answer, oldest first.
+ * With channelId: only those asked in that conversation (its thread, or the
+ * main timeline when threadId is empty).
+ */
+function openDecisions({ adapterId = null, channelId, threadId = null, now = Date.now() } = {}) {
+  const queue = new Map(loadDecisions().map((d) => [d.id, d]));
+  return Object.values(loadCards())
+    .filter((c) => c && c.kind === "decision" && !c.answeredAt && cardIsOpen(c.lastState))
+    .filter((c) => now - Date.parse(c.sentAt || 0) <= OPEN_DECISION_MAX_AGE_MS)
+    .filter((c) => !c.decisionId || !queue.has(c.decisionId) || ["queued", "asked", "snoozed"].includes(queue.get(c.decisionId).status))
+    .filter((c) => {
+      if (channelId === undefined || channelId === null) return true;
+      const p = placeOf(c);
+      return String(p.channelId || "") === String(channelId)
+        && String(p.threadId || "") === String(threadId || "")
+        && (!adapterId || !p.adapter || p.adapter === adapterId);
+    })
+    .sort((a, b) => Date.parse(a.sentAt) - Date.parse(b.sentAt));
+}
+
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+
+/** "5 minutes", "3 hours", "2 days". */
+function ageWords(ms) {
+  if (ms < HOUR_MS) return plural(Math.max(1, Math.floor(ms / 60000)), "minute");
+  if (ms < 2 * DAY_MS) return plural(Math.floor(ms / HOUR_MS), "hour");
+  return plural(Math.floor(ms / DAY_MS), "day");
+}
+
+function shortTitle(title, max) {
+  const t = String(title || "a decision").replace(/\s+/g, " ").trim().replace(/"/g, "'");
+  return t.length > max ? `${t.slice(0, max - 1)}…` : t;
+}
+
+/**
+ * The per-turn prompt section listing the decisions this bot asked in this
+ * conversation that are still open, so it closes the ones answered in words
+ * or no longer needed. "" when there are none. Titles are cut to keep the
+ * whole section under PROMPT_SECTION_MAX characters.
+ */
+function openDecisionsPromptSection({ adapterId = null, channelId, threadId = null, now = Date.now() } = {}) {
+  if (!channelId) return "";
+  const open = openDecisions({ adapterId, channelId, threadId, now });
+  if (!open.length) return "";
+  const shown = open.slice(0, PROMPT_DECISIONS_MAX);
+  const head = "## Open decisions you asked here";
+  const more = open.length > shown.length ? [`- and ${open.length - shown.length} more`] : [];
+  const tail = "If the latest message answers one, or it no longer applies, close it: `open-claudia card update <messageId> --close --note \"<why, in plain words>\"`. Never leave an answered or moot decision open.";
+  const line = (c, title) => `- [${c.messageId}] "${title}" — asked ${ageWords(now - Date.parse(c.sentAt))} ago`;
+  const fixed = [head, ...shown.map((c) => line(c, "")), ...more, tail].join("\n").length;
+  const titleMax = Math.max(PROMPT_TITLE_MIN, Math.min(PROMPT_TITLE_MAX, Math.floor((PROMPT_SECTION_MAX - fixed) / shown.length)));
+  return [head, ...shown.map((c) => line(c, shortTitle(c.title, titleMax))), ...more, tail].join("\n");
+}
+
 /** Default wake policy: one person's card wakes on each answer; open polls don't. */
 function defaultWake(card) {
   const responders = card?.policy?.responders;
@@ -117,11 +227,20 @@ function totalsLine(card) {
   return parts.join("; ");
 }
 
-function describeResponse(rec, payload) {
+/** For a wake-up: a card answered long after it was asked may be out of date. */
+function lateAnswerLine(sentAt, now = Date.now()) {
+  const age = now - Date.parse(sentAt || 0);
+  if (!sentAt || !Number.isFinite(age) || age <= LATE_ANSWER_MS) return "";
+  return `This was asked ${ageWords(age)} ago. Before acting on it, check it still applies; if things have moved on, say so briefly instead of acting.`;
+}
+
+function describeResponse(rec, payload, now = Date.now()) {
   const who = payload.userName || (payload.userId ? `user ${payload.userId}` : "Someone (anonymous card)");
   const title = rec.title || payload.card?.title || "your card";
+  const late = lateAnswerLine(rec.sentAt, now);
   if (payload.action) {
-    return `[Card ${payload.messageId}] ${who} tapped "${payload.label || payload.action}" on "${title}".`;
+    const tapped = `[Card ${payload.messageId}] ${who} tapped "${payload.label || payload.action}" on "${title}".`;
+    return late ? `${tapped}\n${late}` : tapped;
   }
   const comment = payload.answer && payload.answer.comment ? quote(payload.answer.comment) : "";
   const lines = [`[Card ${payload.messageId}] ${who} answered "${title}": ${answerLabel(payload)}.`];
@@ -129,6 +248,7 @@ function describeResponse(rec, payload) {
   const totals = totalsLine(payload.card);
   if (totals) lines.push(`Totals: ${totals}.`);
   lines.push("This is their reply to the card you sent. Act on it if your work was waiting for it; otherwise just note it.");
+  if (late) lines.push(late);
   return lines.join("\n");
 }
 
@@ -179,7 +299,12 @@ async function handleCardResponse(envelope, deps = {}) {
     console.log(`[cards] answer on unknown card ${messageId} (sent before this bot kept a ledger, or by another bot)`);
     return { handled: false, reason: "unknown card" };
   }
-  updateCardRecord(messageId, { lastState: payload.card?.state || null, lastResponseAt: new Date().toISOString() });
+  const at = new Date().toISOString();
+  updateCardRecord(messageId, {
+    lastState: payload.card?.state ? { ...payload.card.state, at } : rec.lastState || null,
+    lastResponseAt: at,
+    ...(payload.answer ? { answeredAt: rec.answeredAt || at } : {}),
+  });
 
   if (rec.decisionId) return handleDecisionResponse(rec, payload, envelope, deps);
 
@@ -248,11 +373,19 @@ function decisionCard(d, position, total) {
   return card;
 }
 
+/** The one reply that brings an open decision back to the top of the chat. */
+function reminderText(title) {
+  return `⏳ Still waiting on you: ${title || "a decision"}`;
+}
+
 /**
  * Ask the next decision in a home chat when none is out. `send` posts a card
- * and returns its message id: (home, card) => Promise<string>.
+ * and returns its message id: (home, card) => Promise<string>. `remind`
+ * posts a plain reply: (home, text, { threadId, replyTo }) => Promise. A
+ * snoozed decision keeps its card open; when its time is up it gets one
+ * reply on that card (not a new card) and counts as asked again.
  */
-async function pumpDecisions({ send, now = Date.now(), homeKey = null } = {}) {
+async function pumpDecisions({ send, remind = null, updateCard = null, now = Date.now(), homeKey = null } = {}) {
   const list = loadDecisions();
   const homes = new Map();
   for (const d of list) {
@@ -264,8 +397,37 @@ async function pumpDecisions({ send, now = Date.now(), homeKey = null } = {}) {
   }
   const asked = [];
   for (const [key, ds] of homes) {
-    if (ds.some((d) => d.status === "asked")) continue;
-    const due = ds.filter((d) => d.status === "queued" || (d.status === "snoozed" && Date.parse(d.notBefore || 0) <= now));
+    const isDue = (d) => d.status === "snoozed" && Date.parse(d.notBefore || 0) <= now;
+    let remindedHere = false;
+    for (const d of ds.filter((x) => isDue(x) && x.keptCard && x.askedMessageId)) {
+      if (!remind) continue;
+      try {
+        await remind(d.home, reminderText(d.title), { threadId: d.home.threadId || null, replyTo: d.askedMessageId });
+      } catch (e) {
+        console.error(`[cards] snoozed decision ${d.id} reminder failed:`, e.message);
+        continue;
+      }
+      const fresh = loadDecisions();
+      const target = fresh.find((x) => x.id === d.id);
+      if (!target || target.status !== "snoozed") continue;
+      target.status = "asked";
+      target.remindedAt = new Date(now).toISOString();
+      saveDecisions(fresh);
+      // This reply is the card's one reminder: the overnight pass skips it.
+      updateCardRecord(d.askedMessageId, { remindedAt: target.remindedAt });
+      if (updateCard) {
+        try {
+          const view = await updateCard(d.askedMessageId, { note: "" });
+          noteCardUpdate(d.askedMessageId, { note: "" }, view);
+        } catch (_) { /* the reminder is out; a stale note is harmless */ }
+      }
+      d.status = "asked";
+      remindedHere = true;
+      asked.push({ key, decisionId: d.id, messageId: d.askedMessageId, reminded: true });
+    }
+    if (remindedHere || ds.some((d) => d.status === "asked")) continue;
+    // A decision snoozed before cards stayed open had its card closed: ask it again as a new card.
+    const due = ds.filter((d) => d.status === "queued" || (isDue(d) && !d.keptCard));
     if (!due.length) continue;
     const next = due.sort((a, b) => (a.status === "queued") - (b.status === "queued") || a.seq - b.seq)[0];
     const open = ds.filter((d) => d.status !== "snoozed" || d === next).length;
@@ -299,15 +461,22 @@ async function handleDecisionResponse(rec, payload, envelope, deps = {}) {
   if (!d) return { handled: false, reason: "unknown decision" };
   const updateCard = deps.updateCard || ((messageId, patch) => envelope.adapter?.updateCard?.(messageId, patch));
   const send = deps.sendCard || ((home, card) => envelope.adapter?.sendCard?.(home.channelId, card, { threadId: home.threadId || null }));
+  const remind = deps.remind || ((home, text, opts) => envelope.adapter?.send?.(home.channelId, text, opts));
+  const pump = () => pumpDecisions({ send, remind, updateCard, homeKey: `${d.home.adapter}|${d.home.channelId}` });
 
   if (payload.action === "later") {
+    // The card stays open where it is (no closing it and posting a new one
+    // later); a note on it says when it comes back. A note-only change just
+    // redraws the card: no new message, no notification.
     d.status = "snoozed";
+    d.keptCard = true;
     d.notBefore = new Date(Date.now() + SNOOZE_MS).toISOString();
     d.snoozes = (d.snoozes || 0) + 1;
     saveDecisions(list);
-    const until = new Date(d.notBefore).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit", timeZone: process.env.OC_TIMEZONE || "Africa/Nairobi" });
-    try { await updateCard(rec.messageId, { status: "closed", note: `Snoozed until ${until}. I'll ask again then.` }); } catch (e) { console.error("[cards] snooze note failed:", e.message); }
-    await pumpDecisions({ send, homeKey: `${d.home.adapter}|${d.home.channelId}` });
+    const until = new Date(d.notBefore).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit", timeZone: timeZone() });
+    const patch = { note: `⏰ Later: I'll remind you at ${until}.` };
+    try { noteCardUpdate(rec.messageId, patch, await updateCard(rec.messageId, patch)); } catch (e) { console.error("[cards] snooze note failed:", e.message); }
+    await pump();
     return { handled: true, snoozed: true };
   }
   if (payload.action === "more") {
@@ -320,18 +489,23 @@ async function handleDecisionResponse(rec, payload, envelope, deps = {}) {
     return { handled: true, explained: true };
   }
   if (payload.answer) {
+    const wasSnoozed = d.status === "snoozed" && d.keptCard;
     d.status = "decided";
     d.answer = payload.answer;
     d.answerLabel = answerLabel(payload);
     d.decidedAt = new Date().toISOString();
     saveDecisions(list);
+    if (wasSnoozed) {
+      try { noteCardUpdate(rec.messageId, { note: "" }, await updateCard(rec.messageId, { note: "" })); } catch (_) { /* only clears the "remind you at" note */ }
+    }
+    const late = lateAnswerLine(rec.sentAt);
     wakeOrigin(
       d.origin,
-      `[Decision ${d.id}] Sumeet decided "${d.title}": ${d.answerLabel}.\nThis was queued from this conversation. Carry on with the work that was waiting for it, and tell him briefly what happens next.`,
+      `[Decision ${d.id}] Sumeet decided "${d.title}": ${d.answerLabel}.\nThis was queued from this conversation. Carry on with the work that was waiting for it, and tell him briefly what happens next.${late ? `\n${late}` : ""}`,
       `Decided: ${d.title}`,
       deps,
     );
-    await pumpDecisions({ send, homeKey: `${d.home.adapter}|${d.home.channelId}` });
+    await pump();
     return { handled: true, decided: true };
   }
   return { handled: false, reason: "nothing to do" };
@@ -342,18 +516,94 @@ async function cancelDecision(id, { updateCard } = {}) {
   const d = list.find((x) => x.id === id);
   if (!d) return null;
   if (!["queued", "asked", "snoozed"].includes(d.status)) return d;
-  const wasAsked = d.status === "asked";
+  const cardOpen = d.status === "asked" || (d.status === "snoozed" && d.keptCard);
   d.status = "cancelled";
   d.cancelledAt = new Date().toISOString();
   saveDecisions(list);
-  if (wasAsked && d.askedMessageId && updateCard) {
-    try { await updateCard(d.askedMessageId, { status: "closed", note: "Withdrawn: no longer needed." }); } catch (_) {}
+  if (cardOpen && d.askedMessageId && updateCard) {
+    const patch = { status: "closed", note: "Withdrawn: no longer needed." };
+    try { noteCardUpdate(d.askedMessageId, patch, await updateCard(d.askedMessageId, patch)); } catch (_) {}
   }
   return d;
 }
 
-// Snoozed decisions come back when their time is up; nothing else would ask
-// them again, so the bot looks every few minutes.
+// ---------------------------------------------------------------------------
+// One reminder for a decision left waiting overnight
+
+function zonedParts(t, tz) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz, hourCycle: "h23", year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", second: "2-digit",
+  }).formatToParts(new Date(t));
+  const p = Object.fromEntries(parts.map((x) => [x.type, Number(x.value)]));
+  return { year: p.year, month: p.month, day: p.day, hour: p.hour % 24, minute: p.minute, second: p.second };
+}
+
+/**
+ * The instant of hour:00 on a local calendar day (day may overflow; Date.UTC
+ * rolls it). One offset lookup is enough for a morning hour: clocks change
+ * in the small hours, never within a few hours of 09:00.
+ */
+function zonedTime(year, month, day, hour, tz) {
+  const guess = Date.UTC(year, month - 1, day, hour);
+  const p = zonedParts(guess, tz);
+  const offset = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second) - guess;
+  return guess - offset;
+}
+
+/** The first 09:00 local at least 8 hours after the decision was asked. */
+function reminderDueAt(sentAt, tz = timeZone()) {
+  const earliest = Date.parse(sentAt) + REMIND_MIN_WAIT_MS;
+  const p = zonedParts(earliest, tz);
+  const sameDay = zonedTime(p.year, p.month, p.day, REMIND_HOUR, tz);
+  return sameDay >= earliest ? sameDay : zonedTime(p.year, p.month, p.day + 1, REMIND_HOUR, tz);
+}
+
+/**
+ * Post the one reminder each open decision card is due, as a plain reply to
+ * the card in its own chat and thread. `readState(rec)` asks the server for
+ * the card's current state; only a card the server shows as open gets the
+ * reminder (the ledger misses answers the bot never received), and a failed
+ * or empty read is tried again on a later tick. Without `readState` the
+ * ledger decides. Reminders go out between 09:00 and 18:00 local only, so a
+ * restart at night never posts a batch of them.
+ * `send(place, text, { threadId, replyTo })` posts the reply.
+ */
+async function remindOpenDecisions({ send, readState = null, now = Date.now(), tz = timeZone() } = {}) {
+  const localHour = zonedParts(now, tz).hour;
+  if (localHour < REMIND_HOUR || localHour >= REMIND_LAST_HOUR) return [];
+  const queue = new Map(loadDecisions().map((d) => [d.id, d]));
+  const due = openDecisions({ now }).filter((c) => !c.remindedAt
+    && now - Date.parse(c.sentAt) <= REMIND_MAX_AGE_MS
+    && now >= reminderDueAt(c.sentAt, tz)
+    // a snoozed decision comes back through the queue at its own time
+    && !(c.decisionId && queue.get(c.decisionId)?.status === "snoozed"));
+  const reminded = [];
+  for (const c of due) {
+    if (readState) {
+      let state = null;
+      try { state = await readState(c); } catch (e) { console.error(`[cards] reading card ${c.messageId} failed, trying again later:`, e.message); }
+      if (!state) continue;
+      updateCardRecord(c.messageId, { lastState: { ...state, at: new Date(now).toISOString() } });
+      if (!cardIsOpen(state)) continue;
+    }
+    // Claimed before sending: a reminder is never posted twice, even if the
+    // send fails half way.
+    updateCardRecord(c.messageId, { remindedAt: new Date(now).toISOString() });
+    const place = placeOf(c);
+    try {
+      await send(place, reminderText(c.title), { threadId: place.threadId || null, replyTo: c.messageId });
+      reminded.push(c.messageId);
+    } catch (e) {
+      updateCardRecord(c.messageId, { remindFailed: String(e.message || e).slice(0, 200) });
+      console.error(`[cards] reminder for card ${c.messageId} failed:`, e.message);
+    }
+  }
+  return reminded;
+}
+
+// Snoozed decisions come back when their time is up, and decisions left
+// overnight get their one reminder; nothing else would, so the bot looks
+// every few minutes.
 let pumpTimer = null;
 function startDecisionPump(registry, intervalMs = 5 * 60 * 1000) {
   if (pumpTimer) return pumpTimer;
@@ -362,7 +612,27 @@ function startDecisionPump(registry, intervalMs = 5 * 60 * 1000) {
     if (!adapter || typeof adapter.sendCard !== "function") return null;
     return adapter.sendCard(home.channelId, card, { threadId: home.threadId || null });
   };
-  const tick = () => pumpDecisions({ send }).catch((e) => console.error("[cards] decision pump failed:", e.message));
+  const remind = (place, text, opts) => {
+    const adapter = registry.findAdapter(place.adapter);
+    if (!adapter || typeof adapter.send !== "function") throw new Error(`no adapter ${place.adapter}`);
+    return adapter.send(place.channelId, text, opts);
+  };
+  const updateCard = (messageId, patch) => {
+    const rec = getCard(messageId);
+    const adapter = rec && registry.findAdapter(placeOf(rec).adapter);
+    return adapter && typeof adapter.updateCard === "function" ? adapter.updateCard(messageId, patch) : null;
+  };
+  const readState = async (rec) => {
+    const place = placeOf(rec);
+    const adapter = registry.findAdapter(place.adapter);
+    if (!adapter || typeof adapter.readCard !== "function") return null;
+    const card = await adapter.readCard(place.channelId, rec.messageId);
+    return card?.state || null;
+  };
+  const tick = async () => {
+    await pumpDecisions({ send, remind, updateCard }).catch((e) => console.error("[cards] decision pump failed:", e.message));
+    await remindOpenDecisions({ send: remind, readState }).catch((e) => console.error("[cards] decision reminders failed:", e.message));
+  };
   pumpTimer = setInterval(tick, intervalMs);
   if (pumpTimer.unref) pumpTimer.unref();
   const first = setTimeout(tick, 30 * 1000);
@@ -377,6 +647,14 @@ module.exports = {
   recordSentCard,
   getCard,
   updateCardRecord,
+  noteCardUpdate,
+  cardIsOpen,
+  openDecisions,
+  openDecisionsPromptSection,
+  ageWords,
+  lateAnswerLine,
+  reminderDueAt,
+  remindOpenDecisions,
   defaultWake,
   describeResponse,
   handleCardResponse,

package/core/loopback.js

@@ -234,7 +234,7 @@ async function handleCardKind(res, kind, payload, { channelId, adapterId, adapte
     }
     try {
       const view = await target.updateCard(String(payload.messageId), patch);
-      cards.updateCardRecord(payload.messageId, { lastState: view?.state || null, ...(patch.card?.title ? { title: patch.card.title } : {}) });
+      cards.noteCardUpdate(payload.messageId, patch, view);
       return reply(res, 200, { ok: true, card: view });
     } catch (e) {
       return reply(res, 400, { error: e.message });
@@ -282,7 +282,11 @@ async function handleCardKind(res, kind, payload, { channelId, adapterId, adapte
     });
     let asked = [];
     try {
-      asked = await cards.pumpDecisions({ send: (home, card) => ((registry.findAdapter(home.adapter) || own).sendCard(home.channelId, card, { threadId: home.threadId || null })) });
+      asked = await cards.pumpDecisions({
+        send: (home, card) => ((registry.findAdapter(home.adapter) || own).sendCard(home.channelId, card, { threadId: home.threadId || null })),
+        remind: (home, text, opts) => ((registry.findAdapter(home.adapter) || own).send(home.channelId, text, opts)),
+        updateCard: (messageId, patch) => (typeof own.updateCard === "function" ? own.updateCard(messageId, patch) : null),
+      });
     } catch (e) {
       const waiting = cards.loadDecisions().filter((x) => ["queued", "asked", "snoozed"].includes(x.status)).length;
       return reply(res, 200, { ok: true, decision: d, askedNow: false, waiting, warning: `queued, but asking failed: ${e.message}` });

package/core/passive-replies.js

@@ -66,9 +66,11 @@ function clip(text, limit) {
 
 // A message to the bot that only asks it to go quiet ("snooze") or to speak
 // again ("resume"), with its @-mention and the bot's name taken out; null for
-// anything else, so "@Maya stop the build" is never mistaken for one.
+// anything else, so "@Maya stop the build" is never mistaken for one. The
+// Kazee apps write a tag as @[Name](userId) (5 Oct 2026: "@sales-bot be
+// quiet" from the app was never recognised): such tags are taken out first.
 function quietCommand(text, botName = "") {
-  let t = String(text || "").toLowerCase();
+  let t = String(text || "").replace(/@\[[^\]\n]{1,120}\]\([^)\s]{1,64}\)/g, " ").toLowerCase();
   const name = String(botName || "").trim().toLowerCase();
   if (name) t = t.split(`@${name}`).join(" ");
   t = t.replace(/@\S+/g, " ").replace(/[^\p{L}\p{N}\s']/gu, " ").replace(/\s+/g, " ").trim();