@inetafrica/open-claudia 2.0.5 → 2.1.1

package/core/handlers.js

@@ -121,6 +121,7 @@ register({
       "Session: /session /sessions /projects /continue /status /stop /end",
       "Settings: /model /effort /budget /plan /compact /worktree /mode",
       "Identity: /whoami /link",
+      "Team: /people /intros /auth (owner)",
       "Automation: /cron /vault /soul",
       "Claude auth: /auth_status /login /setup_token /use_oauth_token /clear_oauth_token",
       "Codex auth: /codex_auth_status /codex_login /codex_setup_token",
@@ -133,9 +134,41 @@ register({
 });
 
 register({
-  name: "auth", description: "Request access to this bot",
+  name: "auth", description: "Request access (or list/revoke as owner)", args: "[list | revoke <chatId>]",
   authRequired: false,
-  handler: async (env) => {
+  handler: async (env, { tail }) => {
+    if (tail) {
+      if (!authorized(env)) return;
+      if (!ownerEnv(env)) return send("Owner only — auth list/revoke are restricted.");
+      if (tail === "list") {
+        const raw = accessStore.listAuthorizedRaw();
+        const lines = ["Authorized chats:"];
+        for (const a of raw.authorized) {
+          const person = peopleStore.findByHandle("telegram", a.chatId) || peopleStore.findByHandle("kazee", a.chatId);
+          lines.push(`  ${a.chatId}${a.isOwner ? " (owner)" : ""}  ${a.name || a.username || ""}${person ? "  → " + person.name : "  → (no person)"}`);
+        }
+        if (raw.authorized.length === 0) lines.push("  (none)");
+        if (raw.pending.length > 0) {
+          lines.push("", "Pending:");
+          for (const p of raw.pending) lines.push(`  ${p.chatId}  ${p.name || p.username || ""}`);
+        }
+        return send(lines.join("\n"));
+      }
+      const revokeMatch = tail.match(/^revoke\s+(\S+)$/i);
+      if (revokeMatch) {
+        const chatId = revokeMatch[1];
+        const person = peopleStore.findByHandle("telegram", chatId) || peopleStore.findByHandle("kazee", chatId);
+        if (person && person.isOwner) return send("Refusing to revoke owner chat.");
+        if (person) {
+          const detected = (person.handles || []).find((h) => String(h.channelId) === String(chatId));
+          if (detected) peopleStore.unlinkHandle(person.id, { adapter: detected.adapter, channelId: detected.channelId });
+        }
+        const result = accessStore.revokeChat(chatId);
+        if (!result.ok) return send(`Revoke failed: ${result.reason}`);
+        return send(`Revoked ${chatId}${person ? ` (was ${person.name})` : ""}.`);
+      }
+      return send("Usage: /auth | /auth list | /auth revoke <chatId>");
+    }
     if (authorized(env)) {
       send("You're already authorized.");
       return;
@@ -1001,4 +1034,149 @@ register({
   },
 });
 
-module.exports.startSession = startSession;
+// ── Team (people / intros / auth) ─────────────────────────────────
+
+const peopleStore = require("./people");
+const introsStore = require("./intros");
+const introFlow = require("./intro-flow");
+const accessStore = require("./access");
+
+function formatPersonShort(p) {
+  const handles = (p.handles || []).map((h) => `${h.adapter}:${h.channelId}`).join(", ") || "(no handles)";
+  return `${p.name}${p.isOwner ? " (owner)" : ""} — ${handles}`;
+}
+
+register({
+  name: "people", description: "Manage team members", args: "[show|note|link|unlink|set-primary|add|remove ...]",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    if (!tail || tail === "list") {
+      const all = peopleStore.list();
+      if (all.length === 0) return send("No people yet.");
+      const lines = ["Team:"];
+      for (const p of all) lines.push(`  ${formatPersonShort(p)}`);
+      lines.push("", "More: /people show <name>, /people note <name> <text>");
+      return send(lines.join("\n"));
+    }
+    const showMatch = tail.match(/^show\s+(.+)$/i);
+    if (showMatch) {
+      const ref = showMatch[1].trim();
+      const person = peopleStore.findById(ref) || peopleStore.findByName(ref);
+      if (!person) return send(`Not found: ${ref}`);
+      const handles = (person.handles || []).map((h) => `  ${h.adapter}:${h.channelId}${person.primaryChannel && person.primaryChannel.adapter === h.adapter && String(person.primaryChannel.channelId) === String(h.channelId) ? " (primary)" : ""}`).join("\n");
+      const notes = (person.notes || []).slice(-5).map((n) => `  - [${(n.at || "").slice(0, 10)}] ${n.text}`).join("\n");
+      return send([
+        `${person.name}${person.isOwner ? " (owner)" : ""}  id=${person.id}`,
+        person.bio ? `Bio: ${person.bio}` : null,
+        "Handles:",
+        handles || "  (none)",
+        notes ? "Notes:" : null,
+        notes || null,
+      ].filter((x) => x !== null && x !== "").join("\n"));
+    }
+    const noteMatch = tail.match(/^note\s+(\S+)\s+(.+)$/i);
+    if (noteMatch) {
+      const person = peopleStore.findById(noteMatch[1]) || peopleStore.findByName(noteMatch[1]);
+      if (!person) return send(`Not found: ${noteMatch[1]}`);
+      const entry = peopleStore.note(person.id, noteMatch[2], { by: env.canonicalUserId || null });
+      return send(`Noted on ${person.name}: ${entry.text}`);
+    }
+    if (!ownerEnv(env)) return send("Owner only — add/link/unlink/set-primary/remove.");
+    const addMatch = tail.match(/^add\s+(.+)$/i);
+    if (addMatch) {
+      try {
+        const p = peopleStore.add({ name: addMatch[1].trim() });
+        return send(`Added ${p.name} (${p.id}). Link a channel with /people link ${p.name} <adapter> <channelId>.`);
+      } catch (e) { return send(`Failed: ${e.message}`); }
+    }
+    const linkMatch = tail.match(/^link\s+(\S+)\s+(\S+)\s+(\S+)$/i);
+    if (linkMatch) {
+      const person = peopleStore.findById(linkMatch[1]) || peopleStore.findByName(linkMatch[1]);
+      if (!person) return send(`Not found: ${linkMatch[1]}`);
+      try {
+        peopleStore.linkHandle(person.id, { adapter: linkMatch[2], channelId: linkMatch[3], approvedBy: env.canonicalUserId });
+        return send(`Linked ${linkMatch[2]}:${linkMatch[3]} → ${person.name}`);
+      } catch (e) { return send(`Failed: ${e.message}`); }
+    }
+    const unlinkMatch = tail.match(/^unlink\s+(\S+)\s+(\S+)\s+(\S+)$/i);
+    if (unlinkMatch) {
+      const person = peopleStore.findById(unlinkMatch[1]) || peopleStore.findByName(unlinkMatch[1]);
+      if (!person) return send(`Not found: ${unlinkMatch[1]}`);
+      const updated = peopleStore.unlinkHandle(person.id, { adapter: unlinkMatch[2], channelId: unlinkMatch[3] });
+      if (!updated) return send("Handle not found on that person.");
+      if (!person.isOwner) accessStore.revokeChat(unlinkMatch[3]);
+      return send(`Unlinked ${unlinkMatch[2]}:${unlinkMatch[3]} from ${person.name}.`);
+    }
+    const setPrimaryMatch = tail.match(/^set-primary\s+(\S+)\s+(\S+)\s+(\S+)$/i);
+    if (setPrimaryMatch) {
+      const person = peopleStore.findById(setPrimaryMatch[1]) || peopleStore.findByName(setPrimaryMatch[1]);
+      if (!person) return send(`Not found: ${setPrimaryMatch[1]}`);
+      try {
+        peopleStore.setPrimary(person.id, { adapter: setPrimaryMatch[2], channelId: setPrimaryMatch[3] });
+        return send(`Primary for ${person.name} → ${setPrimaryMatch[2]}:${setPrimaryMatch[3]}`);
+      } catch (e) { return send(`Failed: ${e.message}`); }
+    }
+    const removeMatch = tail.match(/^remove\s+(.+)$/i);
+    if (removeMatch) {
+      const person = peopleStore.findById(removeMatch[1]) || peopleStore.findByName(removeMatch[1]);
+      if (!person) return send(`Not found: ${removeMatch[1]}`);
+      if (person.isOwner) return send("Refusing to remove the owner.");
+      const handles = (person.handles || []).slice();
+      peopleStore.remove(person.id);
+      let revokedCount = 0;
+      for (const h of handles) { const r = accessStore.revokeChat(h.channelId); if (r.ok) revokedCount += 1; }
+      return send(`Removed ${person.name}. Deauthed ${revokedCount} chat${revokedCount === 1 ? "" : "s"}.`);
+    }
+    send("Usage: /people | /people show <name> | /people note <name> <text> | /people add|link|unlink|set-primary|remove ... (owner)");
+  },
+});
+
+register({
+  name: "intros", description: "Pending intros from unknown chats", args: "[approve|reject <id>]", ownerOnly: true,
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    if (!ownerEnv(env)) return send("Owner only.");
+    introsStore.sweep();
+    if (!tail || tail === "list") {
+      const pending = introsStore.listPending();
+      if (pending.length === 0) return send("No pending intros.");
+      const lines = ["Pending intros:"];
+      const buttons = [];
+      for (const i of pending) {
+        const claim = i.claim || {};
+        let claimLine = "no claim yet";
+        if (claim.kind === "existing") {
+          const p = peopleStore.findById(claim.personId);
+          claimLine = `claims to be ${p ? p.name : claim.personId}`;
+        } else if (claim.kind === "new") {
+          claimLine = `new: ${claim.name}${claim.bio ? " — " + claim.bio : ""}`;
+        }
+        lines.push(`  ${i.id}  ${i.adapter}:${i.channelId}  ${claimLine}`);
+        buttons.push([
+          { text: `Approve ${i.id.slice(-6)}`, callback_data: `intro:approve:${i.id}` },
+          { text: `Reject ${i.id.slice(-6)}`, callback_data: `intro:reject:${i.id}` },
+        ]);
+      }
+      return send(lines.join("\n"), buttons.length ? { keyboard: { inline_keyboard: buttons } } : undefined);
+    }
+    const approveMatch = tail.match(/^approve\s+(\S+)$/i);
+    if (approveMatch) {
+      const intro = introsStore.byId(approveMatch[1]);
+      if (!intro) return send(`No intro: ${approveMatch[1]}`);
+      try {
+        const result = await introFlow.applyApproval(intro, env.from?.name || env.canonicalUserId || "owner");
+        await introFlow.notifyIntroUser(intro, `You're in. Welcome${result.person ? ", " + result.person.name : ""}.`);
+        return send(`Approved. Person: ${result.person?.name || "?"}`);
+      } catch (e) { return send(`Failed: ${e.message}`); }
+    }
+    const rejectMatch = tail.match(/^reject\s+(\S+)(?:\s+(.+))?$/i);
+    if (rejectMatch) {
+      const intro = introsStore.byId(rejectMatch[1]);
+      if (!intro) return send(`No intro: ${rejectMatch[1]}`);
+      introsStore.reject(intro.id, env.from?.name || env.canonicalUserId || "owner", rejectMatch[2] || null);
+      await introFlow.notifyIntroUser(intro, "Your access request was denied.");
+      return send(`Rejected ${intro.id}.`);
+    }
+    send("Usage: /intros | /intros approve <id> | /intros reject <id> [reason]");
+  },
+});

package/core/intro-flow.js

@@ -0,0 +1,241 @@
+// Runtime side of the intro flow. Detects unknown chats, walks them
+// through "who are you", and pings the owner with approve/reject
+// buttons. Data lives in core/intros.js; people resolution lives in
+// core/people.js. This module wires both into the inbound router.
+
+const people = require("./people");
+const intros = require("./intros");
+const audit = require("./audit");
+const registry = require("./adapter-registry");
+const { bootstrapOwner, loadAuth, saveAuth, updateAuthorizedChatEnv } = require("./access");
+const { CHAT_ID } = require("./config");
+
+const MAX_BIO_LEN = 500;
+
+function envAdapterId(envelope) {
+  return envelope.adapter?.id || envelope.adapter?.type || null;
+}
+
+function envAdapterType(envelope) {
+  return envelope.adapter?.type || null;
+}
+
+function displayNameFromEnvelope(envelope) {
+  const raw = envelope.raw || {};
+  const from = raw.from || raw.user || {};
+  return from.first_name || from.name || from.displayName || envelope.userId || null;
+}
+
+function usernameFromEnvelope(envelope) {
+  const raw = envelope.raw || {};
+  const from = raw.from || raw.user || {};
+  return from.username || from.handle || null;
+}
+
+function rosterLines() {
+  const all = people.list();
+  if (all.length === 0) return "(no one is registered yet)";
+  return all
+    .map((p, i) => `${i + 1}. ${p.name}${p.isOwner ? " (owner)" : ""}`)
+    .join("\n");
+}
+
+function rosterPrompt() {
+  return [
+    "Hi, I'm Open Claudia. I don't recognize this chat yet.",
+    "",
+    "Existing team:",
+    rosterLines(),
+    "",
+    "Reply with the number if that's you, or type \"new <your name>\" if you're new.",
+  ].join("\n");
+}
+
+function ownerPrimaryAdapterAndChannel() {
+  const owner = people.owners()[0];
+  if (!owner) return null;
+  if (owner.primaryChannel && owner.primaryChannel.adapter && owner.primaryChannel.channelId) {
+    return { adapter: owner.primaryChannel.adapter, channelId: owner.primaryChannel.channelId, owner };
+  }
+  const h = (owner.handles || [])[0];
+  if (h) return { adapter: h.adapter, channelId: h.channelId, owner };
+  if (CHAT_ID) return { adapter: "telegram", channelId: String(CHAT_ID), owner };
+  return null;
+}
+
+async function notifyOwnerAboutIntro(intro) {
+  const target = ownerPrimaryAdapterAndChannel();
+  if (!target) {
+    console.warn("intro-flow: no owner record to notify");
+    return;
+  }
+  const adapter = registry.findAdapter(target.adapter) || registry.getAdapters().find((a) => a.type === target.adapter);
+  if (!adapter) {
+    console.warn(`intro-flow: no live adapter for owner channel ${target.adapter}`);
+    return;
+  }
+
+  const claim = intro.claim || {};
+  let line;
+  if (claim.kind === "existing") {
+    const person = people.findById(claim.personId);
+    line = `New chat on ${intro.adapter} (${intro.channelId}) — ${intro.displayName || "(no name)"} claims to be ${person ? person.name : claim.personId}.`;
+  } else if (claim.kind === "new") {
+    line = `New chat on ${intro.adapter} (${intro.channelId}) — wants to join as "${claim.name}".${claim.bio ? "\nBio: " + claim.bio : ""}`;
+  } else {
+    line = `New chat on ${intro.adapter} (${intro.channelId}) — ${intro.displayName || "(no name)"}`;
+  }
+  const text = `Intro request:\n\n${line}`;
+  try {
+    await adapter.send(target.channelId, text, {
+      keyboard: { inline_keyboard: [[
+        { text: "Approve", callback_data: `intro:approve:${intro.id}` },
+        { text: "Reject", callback_data: `intro:reject:${intro.id}` },
+      ]] },
+    });
+  } catch (e) {
+    console.warn(`intro-flow: failed to notify owner: ${e.message}`);
+  }
+}
+
+async function handleInbound(envelope, sendFn) {
+  intros.sweep();
+  const adapter = envAdapterType(envelope);
+  const channelId = String(envelope.channelId);
+  if (!adapter) return false;
+
+  let intro = intros.activeForChannel(adapter, channelId);
+  const text = String(envelope.text || "").trim();
+
+  if (!intro) {
+    if (!people.hasOwnerRecord()) {
+      people.seedOwnerFromLegacy();
+    }
+    if (!people.hasOwnerRecord()) {
+      const displayName = displayNameFromEnvelope(envelope) || "Owner";
+      const person = people.add({ name: displayName, isOwner: true, bio: "Auto-registered on first message" });
+      try { people.linkHandle(person.id, { adapter, channelId, displayName, approvedBy: "bootstrap" }); } catch (e) {}
+      try { bootstrapOwner({ chatId: channelId, name: displayName, username: usernameFromEnvelope(envelope) }); } catch (e) {}
+      audit.log("people.bootstrap-owner", { personId: person.id, adapter, channelId });
+      await sendFn(`Welcome, ${displayName}. You're registered as the bot owner. Send /start to begin.`);
+      return true;
+    }
+    intro = intros.start({
+      adapter,
+      channelId,
+      displayName: displayNameFromEnvelope(envelope),
+      username: usernameFromEnvelope(envelope),
+    });
+    intros.markPrompted(intro.id);
+    audit.log("intro.started", { introId: intro.id, adapter, channelId });
+    await sendFn(rosterPrompt());
+    return true;
+  }
+
+  if (intro.step === "awaiting_choice") {
+    if (!text) {
+      await sendFn("Reply with a number from the list, or \"new <your name>\".");
+      return true;
+    }
+    const num = parseInt(text, 10);
+    const all = people.list();
+    if (Number.isFinite(num) && num >= 1 && num <= all.length) {
+      const person = all[num - 1];
+      intros.setClaim(intro.id, { kind: "existing", personId: person.id });
+      await sendFn(`Got it. I've asked ${people.owners()[0]?.name || "the owner"} to confirm you're ${person.name}. Hold tight.`);
+      const updated = intros.byId(intro.id);
+      await notifyOwnerAboutIntro(updated);
+      audit.log("intro.claim-existing", { introId: intro.id, personId: person.id });
+      return true;
+    }
+    const m = text.match(/^new\s+(.+)/i);
+    if (m) {
+      const name = m[1].trim();
+      intros.setStep(intro.id, "awaiting_bio", { claim: { kind: "new", name, bio: null } });
+      await sendFn(`Got it, ${name}. In one line, tell me who you are / what you do, so I can introduce you to the owner.`);
+      audit.log("intro.claim-new", { introId: intro.id, name });
+      return true;
+    }
+    await sendFn("Didn't catch that. Reply with a number from the list, or \"new <your name>\".");
+    return true;
+  }
+
+  if (intro.step === "awaiting_bio") {
+    const bio = text.slice(0, MAX_BIO_LEN);
+    if (!bio) {
+      await sendFn("Tell me one line about yourself.");
+      return true;
+    }
+    intros.setClaim(intro.id, { kind: "new", name: intro.claim?.name || "Unknown", bio });
+    const updated = intros.byId(intro.id);
+    await sendFn("Got it. Pinging the owner now. Hold tight.");
+    await notifyOwnerAboutIntro(updated);
+    audit.log("intro.bio-collected", { introId: intro.id });
+    return true;
+  }
+
+  if (intro.step === "awaiting_owner") {
+    await sendFn("Still waiting on owner approval. I'll let you know.");
+    return true;
+  }
+
+  return false;
+}
+
+async function applyApproval(intro, by) {
+  if (intro.step === "approved") return { ok: true, person: people.findByHandle(intro.adapter, intro.channelId) };
+  const claim = intro.claim || {};
+  let person;
+  if (claim.kind === "existing") {
+    person = people.findById(claim.personId);
+    if (!person) throw new Error(`intro claim references missing person ${claim.personId}`);
+    people.linkHandle(person.id, {
+      adapter: intro.adapter,
+      channelId: intro.channelId,
+      displayName: intro.displayName,
+      approvedBy: by || null,
+    });
+  } else if (claim.kind === "new") {
+    person = people.add({ name: claim.name, bio: claim.bio || null });
+    people.linkHandle(person.id, {
+      adapter: intro.adapter,
+      channelId: intro.channelId,
+      displayName: intro.displayName,
+      approvedBy: by || null,
+    });
+  } else {
+    throw new Error("intro has no claim — owner approved a half-finished intro");
+  }
+  // Also write into auth.json so legacy isChatAuthorized + isChatOwner still work.
+  const auth = loadAuth();
+  if (!auth.authorized.some((a) => String(a.chatId) === String(intro.channelId))) {
+    auth.authorized.push({
+      chatId: String(intro.channelId),
+      name: intro.displayName || person.name,
+      username: intro.username || null,
+      isOwner: false,
+      authorizedAt: new Date().toISOString(),
+    });
+    saveAuth(auth);
+    if (intro.adapter === "telegram") {
+      try { updateAuthorizedChatEnv(auth); } catch (e) {}
+    }
+  }
+  intros.approve(intro.id, by);
+  audit.log("intro.approved", { introId: intro.id, personId: person.id, by });
+  return { ok: true, person };
+}
+
+async function notifyIntroUser(intro, text) {
+  const adapter = registry.findAdapter(intro.adapter) || registry.getAdapters().find((a) => a.type === intro.adapter);
+  if (!adapter) return;
+  try { await adapter.send(intro.channelId, text); } catch (e) {}
+}
+
+module.exports = {
+  handleInbound,
+  applyApproval,
+  notifyIntroUser,
+  notifyOwnerAboutIntro,
+  rosterPrompt,
+};

package/core/intros.js

@@ -0,0 +1,158 @@
+// Intro flow: when an unknown chat sends a message, the bot asks who
+// they are and lets the owner approve. Approved intros become person
+// records (or new handles on existing people) and the chat gets
+// authorized in auth.json so the rest of the router treats it normally.
+//
+// State machine per pending intro:
+//   awaiting_choice  -> bot showed roster + "who are you?"
+//   awaiting_bio     -> user picked "new", bot asked for a one-line bio
+//   awaiting_owner   -> intro packaged, owner pinged, buttons live
+//   approved / rejected — terminal
+
+const fs = require("fs");
+const { INTROS_FILE } = require("./config");
+
+const AUTO_REJECT_AFTER_MS = 7 * 24 * 60 * 60 * 1000;
+
+function nowIso() { return new Date().toISOString(); }
+function nowMs() { return Date.now(); }
+function nextId() {
+  return `intro_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function load() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(INTROS_FILE, "utf-8"));
+    return Array.isArray(raw) ? raw : [];
+  } catch (e) { return []; }
+}
+
+function save(list) {
+  const tmp = `${INTROS_FILE}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(list, null, 2));
+  fs.renameSync(tmp, INTROS_FILE);
+}
+
+function activeForChannel(adapter, channelId) {
+  const a = String(adapter || "").toLowerCase();
+  const c = String(channelId || "");
+  return load().find((i) =>
+    i.adapter === a && String(i.channelId) === c &&
+    (i.step === "awaiting_choice" || i.step === "awaiting_bio" || i.step === "awaiting_owner")
+  ) || null;
+}
+
+function byId(id) { return load().find((i) => i.id === id) || null; }
+
+function listPending() {
+  return load().filter((i) => i.step !== "approved" && i.step !== "rejected");
+}
+
+function start({ adapter, channelId, displayName, username }) {
+  const a = String(adapter || "").toLowerCase();
+  const c = String(channelId || "");
+  const all = load();
+  const existing = all.find((i) =>
+    i.adapter === a && String(i.channelId) === c &&
+    (i.step === "awaiting_choice" || i.step === "awaiting_bio" || i.step === "awaiting_owner")
+  );
+  if (existing) return existing;
+  const intro = {
+    id: nextId(),
+    adapter: a,
+    channelId: c,
+    displayName: displayName || null,
+    username: username || null,
+    step: "awaiting_choice",
+    claim: null,
+    createdAt: nowIso(),
+    updatedAt: nowIso(),
+    promptedAt: null,
+    resolvedAt: null,
+    resolvedBy: null,
+    rejectReason: null,
+  };
+  all.push(intro);
+  save(all);
+  return intro;
+}
+
+function markPrompted(id) {
+  const all = load();
+  const i = all.find((x) => x.id === id);
+  if (!i) return null;
+  i.promptedAt = nowIso();
+  i.updatedAt = nowIso();
+  save(all);
+  return i;
+}
+
+function setClaim(id, claim) {
+  const all = load();
+  const i = all.find((x) => x.id === id);
+  if (!i) return null;
+  i.claim = claim;
+  i.step = "awaiting_owner";
+  i.updatedAt = nowIso();
+  save(all);
+  return i;
+}
+
+function setStep(id, step, patch = {}) {
+  const all = load();
+  const i = all.find((x) => x.id === id);
+  if (!i) return null;
+  i.step = step;
+  Object.assign(i, patch);
+  i.updatedAt = nowIso();
+  save(all);
+  return i;
+}
+
+function approve(id, by) {
+  return setStep(id, "approved", { resolvedAt: nowIso(), resolvedBy: by || null });
+}
+
+function reject(id, by, reason = null) {
+  return setStep(id, "rejected", { resolvedAt: nowIso(), resolvedBy: by || null, rejectReason: reason });
+}
+
+function remove(id) {
+  const all = load();
+  const idx = all.findIndex((x) => x.id === id);
+  if (idx < 0) return null;
+  const [removed] = all.splice(idx, 1);
+  save(all);
+  return removed;
+}
+
+// Drop terminal entries older than 7 days; auto-reject stale pending.
+function sweep() {
+  const all = load();
+  const cutoff = nowMs() - AUTO_REJECT_AFTER_MS;
+  let changed = false;
+  const kept = [];
+  for (const i of all) {
+    const t = new Date(i.updatedAt || i.createdAt).getTime();
+    if (i.step === "approved" || i.step === "rejected") {
+      if (t < cutoff) { changed = true; continue; }
+      kept.push(i);
+      continue;
+    }
+    if (t < cutoff) {
+      kept.push({ ...i, step: "rejected", resolvedAt: nowIso(), resolvedBy: "system", rejectReason: "auto-reject after 7 days" });
+      changed = true;
+    } else {
+      kept.push(i);
+    }
+  }
+  if (changed) save(kept);
+  return kept;
+}
+
+module.exports = {
+  load, save, listPending, byId,
+  activeForChannel, start, markPrompted,
+  setClaim, setStep, approve, reject, remove,
+  sweep, AUTO_REJECT_AFTER_MS,
+};