@inetafrica/open-claudia 2.0.5 → 2.1.0

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,
+};

package/core/loopback.js

@@ -18,6 +18,14 @@ const { CONFIG_DIR } = require("./config");
 const jobsStore = require("./jobs");
 const tasksStore = require("./tasks");
 const scheduler = require("./scheduler");
+const peopleStore = require("./people");
+const intros = require("./intros");
+const introFlow = require("./intro-flow");
+const relay = require("./relay");
+const audit = require("./audit");
+const fs2 = require("fs");
+const path2 = require("path");
+const { TRANSCRIPTS_DIR } = require("./config");
 
 const INFO_DIR = path.join(CONFIG_DIR, "loopback");
 const INFO_FILE = path.join(INFO_DIR, `${process.pid}.json`);
@@ -65,8 +73,19 @@ const SEND_KINDS = new Set(["send-file", "send-voice", "send-photo"]);
 const JSON_KINDS = new Set([
   "schedule-wakeup", "cron-add", "cron-remove", "job-list",
   "task-add", "task-plan", "task-update", "task-remove", "task-list", "task-tree", "task-clear-completed",
+  "people-list", "people-show", "people-add", "people-note", "people-link", "people-unlink",
+  "people-remove", "people-set-primary",
+  "intros-list", "intros-approve", "intros-reject",
+  "relay-send", "recent-fetch", "audit-tail",
 ]);
 
+function callerIsOwner(payload) {
+  const caller = payload?.canonicalUserId;
+  if (!caller) return false;
+  const person = peopleStore.findByCanonicalUserId(caller);
+  return !!(person && person.isOwner);
+}
+
 function readBodyAsString(req, max = 64 * 1024) {
   return new Promise((resolve, reject) => {
     let buf = "";
@@ -226,9 +245,210 @@ async function handleJson(req, res, url, kind) {
     return reply(res, 200, { ok: true, tasks: remaining });
   }
 
+  if (kind === "people-list") {
+    return reply(res, 200, { ok: true, people: peopleStore.roster() });
+  }
+
+  if (kind === "people-show") {
+    const ref = payload.id || payload.name || null;
+    if (!ref) return reply(res, 400, { error: "missing id or name" });
+    const person = peopleStore.findById(ref) || peopleStore.findByName(ref);
+    if (!person) return reply(res, 404, { error: "not found" });
+    return reply(res, 200, { ok: true, person });
+  }
+
+  if (kind === "people-add") {
+    if (!callerIsOwner(payload)) return reply(res, 403, { error: "owner only" });
+    if (!payload.name) return reply(res, 400, { error: "missing name" });
+    try {
+      const p = peopleStore.add({ name: payload.name, bio: payload.bio || null, isOwner: !!payload.isOwner });
+      audit.log("people.add", { by: payload.canonicalUserId, personId: p.id, name: p.name });
+      return reply(res, 200, { ok: true, person: p });
+    } catch (e) { return reply(res, 400, { error: e.message }); }
+  }
+
+  if (kind === "people-note") {
+    const ref = payload.id || payload.name;
+    if (!ref || !payload.text) return reply(res, 400, { error: "missing id/name or text" });
+    const person = peopleStore.findById(ref) || peopleStore.findByName(ref);
+    if (!person) return reply(res, 404, { error: "not found" });
+    const entry = peopleStore.note(person.id, payload.text, { by: payload.canonicalUserId || null });
+    audit.log("people.note", { by: payload.canonicalUserId, personId: person.id });
+    return reply(res, 200, { ok: true, note: entry });
+  }
+
+  if (kind === "people-link") {
+    if (!callerIsOwner(payload)) return reply(res, 403, { error: "owner only" });
+    const ref = payload.id || payload.name;
+    if (!ref) return reply(res, 400, { error: "missing id or name" });
+    if (!payload.linkAdapter || !payload.linkChannelId) return reply(res, 400, { error: "missing linkAdapter/linkChannelId" });
+    const person = peopleStore.findById(ref) || peopleStore.findByName(ref);
+    if (!person) return reply(res, 404, { error: "not found" });
+    try {
+      const updated = peopleStore.linkHandle(person.id, {
+        adapter: payload.linkAdapter,
+        channelId: payload.linkChannelId,
+        displayName: payload.displayName || null,
+        approvedBy: payload.canonicalUserId || null,
+      });
+      audit.log("people.link", { by: payload.canonicalUserId, personId: person.id, adapter: payload.linkAdapter, channelId: payload.linkChannelId });
+      return reply(res, 200, { ok: true, person: updated });
+    } catch (e) { return reply(res, 400, { error: e.message }); }
+  }
+
+  if (kind === "people-unlink") {
+    if (!callerIsOwner(payload)) return reply(res, 403, { error: "owner only" });
+    const ref = payload.id || payload.name;
+    if (!ref) return reply(res, 400, { error: "missing id or name" });
+    if (!payload.linkAdapter || !payload.linkChannelId) return reply(res, 400, { error: "missing linkAdapter/linkChannelId" });
+    const person = peopleStore.findById(ref) || peopleStore.findByName(ref);
+    if (!person) return reply(res, 404, { error: "not found" });
+    const updated = peopleStore.unlinkHandle(person.id, { adapter: payload.linkAdapter, channelId: payload.linkChannelId });
+    if (!updated) return reply(res, 404, { error: "handle not found on person" });
+    audit.log("people.unlink", { by: payload.canonicalUserId, personId: person.id, adapter: payload.linkAdapter, channelId: payload.linkChannelId });
+    return reply(res, 200, { ok: true, person: updated });
+  }
+
+  if (kind === "people-set-primary") {
+    if (!callerIsOwner(payload)) return reply(res, 403, { error: "owner only" });
+    const ref = payload.id || payload.name;
+    if (!ref || !payload.linkAdapter || !payload.linkChannelId) return reply(res, 400, { error: "missing fields" });
+    const person = peopleStore.findById(ref) || peopleStore.findByName(ref);
+    if (!person) return reply(res, 404, { error: "not found" });
+    try {
+      const updated = peopleStore.setPrimary(person.id, { adapter: payload.linkAdapter, channelId: payload.linkChannelId });
+      audit.log("people.set-primary", { by: payload.canonicalUserId, personId: person.id });
+      return reply(res, 200, { ok: true, person: updated });
+    } catch (e) { return reply(res, 400, { error: e.message }); }
+  }
+
+  if (kind === "people-remove") {
+    if (!callerIsOwner(payload)) return reply(res, 403, { error: "owner only" });
+    const ref = payload.id || payload.name;
+    if (!ref) return reply(res, 400, { error: "missing id or name" });
+    const person = peopleStore.findById(ref) || peopleStore.findByName(ref);
+    if (!person) return reply(res, 404, { error: "not found" });
+    if (person.isOwner) return reply(res, 400, { error: "refusing to delete owner record" });
+    peopleStore.remove(person.id);
+    audit.log("people.remove", { by: payload.canonicalUserId, personId: person.id, name: person.name });
+    return reply(res, 200, { ok: true, removed: person });
+  }
+
+  if (kind === "intros-list") {
+    intros.sweep();
+    return reply(res, 200, { ok: true, intros: intros.listPending() });
+  }
+
+  if (kind === "intros-approve") {
+    if (!callerIsOwner(payload)) return reply(res, 403, { error: "owner only" });
+    if (!payload.id) return reply(res, 400, { error: "missing id" });
+    const intro = intros.byId(payload.id);
+    if (!intro) return reply(res, 404, { error: "intro not found" });
+    try {
+      const result = await introFlow.applyApproval(intro, payload.canonicalUserId || "owner");
+      await introFlow.notifyIntroUser(intro, `You're in. Welcome${result.person ? ", " + result.person.name : ""}.`);
+      return reply(res, 200, { ok: true, person: result.person });
+    } catch (e) { return reply(res, 400, { error: e.message }); }
+  }
+
+  if (kind === "intros-reject") {
+    if (!callerIsOwner(payload)) return reply(res, 403, { error: "owner only" });
+    if (!payload.id) return reply(res, 400, { error: "missing id" });
+    const intro = intros.byId(payload.id);
+    if (!intro) return reply(res, 404, { error: "intro not found" });
+    intros.reject(intro.id, payload.canonicalUserId || "owner", payload.reason || null);
+    await introFlow.notifyIntroUser(intro, "Your access request was denied.");
+    audit.log("intro.rejected", { introId: intro.id, by: payload.canonicalUserId });
+    return reply(res, 200, { ok: true });
+  }
+
+  if (kind === "relay-send") {
+    if (!payload.text) return reply(res, 400, { error: "missing text" });
+    try {
+      const result = await relay.send({
+        text: payload.text,
+        from: payload.canonicalUserId || null,
+        target: {
+          personId: payload.targetPersonId || null,
+          personName: payload.targetPersonName || null,
+          canonicalUserId: payload.targetCanonicalUserId || null,
+          adapter: payload.targetAdapter || null,
+          channelId: payload.targetChannelId || null,
+        },
+        kind: "relay",
+      });
+      return reply(res, 200, { ok: true, ...result, to: { adapter: result.to.adapter, channelId: result.to.channelId, person: result.to.person ? { id: result.to.person.id, name: result.to.person.name } : null } });
+    } catch (e) { return reply(res, 400, { error: e.message }); }
+  }
+
+  if (kind === "recent-fetch") {
+    const limit = Math.max(1, Math.min(parseInt(payload.limit || 20, 10) || 20, 200));
+    try {
+      let targetAdapter = payload.adapter;
+      let targetChannel = payload.channelId;
+      if (payload.personName || payload.personId) {
+        const person = peopleStore.findById(payload.personId || "") || peopleStore.findByName(payload.personName || "");
+        if (!person) return reply(res, 404, { error: "person not found" });
+        const handle = person.primaryChannel
+          ? (person.handles || []).find((h) => h.adapter === person.primaryChannel.adapter && String(h.channelId) === String(person.primaryChannel.channelId))
+          : (person.handles || [])[0];
+        if (!handle) return reply(res, 404, { error: "person has no handles" });
+        targetAdapter = handle.adapter;
+        targetChannel = handle.channelId;
+      }
+      if (!targetAdapter || !targetChannel) return reply(res, 400, { error: "need adapter+channelId or person" });
+      const entries = readRecentTranscript(targetAdapter, targetChannel, limit);
+      return reply(res, 200, { ok: true, adapter: targetAdapter, channelId: targetChannel, entries });
+    } catch (e) { return reply(res, 400, { error: e.message }); }
+  }
+
+  if (kind === "audit-tail") {
+    if (!callerIsOwner(payload)) return reply(res, 403, { error: "owner only" });
+    const n = Math.max(1, Math.min(parseInt(payload.limit || 50, 10) || 50, 500));
+    return reply(res, 200, { ok: true, entries: audit.tail(n) });
+  }
+
   return reply(res, 404, { error: "not found" });
 }
 
+function readRecentTranscript(adapter, channelId, limit) {
+  if (!TRANSCRIPTS_DIR) return [];
+  try {
+    if (!fs2.existsSync(TRANSCRIPTS_DIR)) return [];
+    const candidates = fs2.readdirSync(TRANSCRIPTS_DIR)
+      .filter((f) => f.endsWith(".jsonl"))
+      .map((f) => path2.join(TRANSCRIPTS_DIR, f))
+      .map((p) => ({ p, mtime: fs2.statSync(p).mtimeMs }))
+      .sort((a, b) => b.mtime - a.mtime);
+    const out = [];
+    const adapterPrefix = String(adapter).toLowerCase();
+    const channelStr = String(channelId);
+    for (const { p } of candidates) {
+      if (out.length >= limit) break;
+      const raw = fs2.readFileSync(p, "utf-8").trim();
+      if (!raw) continue;
+      const lines = raw.split("\n").slice(-1000);
+      for (const line of lines) {
+        try {
+          const obj = JSON.parse(line);
+          const objAdapter = (obj.adapter || obj.adapterType || "").toLowerCase();
+          const objChannel = String(obj.channelId || "");
+          if (objAdapter && objAdapter !== adapterPrefix) continue;
+          if (objChannel && objChannel !== channelStr) continue;
+          out.push({
+            at: obj.at || obj.timestamp || null,
+            role: obj.role || obj.author || null,
+            text: typeof obj.text === "string" ? obj.text.slice(0, 600) : null,
+            kind: obj.kind || null,
+          });
+          if (out.length >= limit) break;
+        } catch (e) {}
+      }
+    }
+    return out.slice(-limit);
+  } catch (e) { return []; }
+}
+
 async function handle(req, res) {
   try {
     if (req.method !== "POST") return reply(res, 405, { error: "method not allowed" });