@inetafrica/open-claudia 2.0.5 → 2.1.1

package/bin/auth.js

@@ -0,0 +1,62 @@
+// open-claudia auth <subcommand>
+// Owner-only view of the raw auth.json store and direct deauth. Use
+// `open-claudia people` for richer roster operations. This is the
+// low-level escape hatch for legacy entries that don't have a person
+// record yet.
+
+const { postJson } = require("./loopback-client");
+
+const HELP = `
+Raw authorization store.
+
+  open-claudia auth list
+  open-claudia auth revoke <chatId>
+
+Owner-only. Revoking also unlinks the chat from any matching person.
+Owner entries are protected — refuse to self-deauth.
+`;
+
+async function runList() {
+  try {
+    const res = await postJson("auth-list", {});
+    const authorized = res.authorized || [];
+    const pending = res.pending || [];
+    if (authorized.length === 0 && pending.length === 0) { console.log("No authorized or pending chats."); process.exit(0); }
+    if (authorized.length) {
+      console.log("Authorized:");
+      for (const a of authorized) {
+        const owner = a.isOwner ? " (owner)" : "";
+        const person = a.personName ? `  → ${a.personName}` : "  → (no person record)";
+        console.log(`  ${a.chatId}${owner}  ${a.name || a.username || ""}${person}`);
+      }
+    }
+    if (pending.length) {
+      console.log("\nPending:");
+      for (const p of pending) console.log(`  ${p.chatId}  ${p.name || p.username || ""}  (requested ${p.requestedAt})`);
+    }
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runRevoke(args) {
+  const chatId = args[0];
+  if (!chatId) { console.error("Usage: auth revoke <chatId>"); process.exit(2); }
+  try {
+    const res = await postJson("auth-revoke", { chatId });
+    console.log(`Revoked ${chatId}${res.personId ? ` (was linked to person ${res.personId})` : ""}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function run(args) {
+  const sub = args[0];
+  const rest = args.slice(1);
+  if (!sub || sub === "--help" || sub === "help") { console.log(HELP); process.exit(sub ? 0 : 2); }
+  switch (sub) {
+    case "list": case "ls": return runList();
+    case "revoke": case "rm": return runRevoke(rest);
+    default: console.error(`Unknown auth subcommand: ${sub}`); console.log(HELP); process.exit(2);
+  }
+}
+
+module.exports = { run, HELP };

package/bin/cli.js

@@ -188,11 +188,17 @@ switch (command) {
     break;
   }
 
-  case "auth":
-    // Pass through to setup.js auth mode
+  case "auth": {
+    const sub = args[1];
+    if (["list", "ls", "revoke", "rm"].includes(sub)) {
+      require("./auth").run(args.slice(1));
+      break;
+    }
+    // Legacy: open-claudia auth (no subcommand) → setup.js auth mode
     process.argv = [process.argv[0], process.argv[1], "--auth"];
     require(path.join(botDir, "setup.js"));
     break;
+  }
 
   case "stop": {
     const pids = findBotProcesses();
@@ -267,6 +273,23 @@ switch (command) {
     break;
   }
 
+  case "people": {
+    require("./people").run(args.slice(1));
+    break;
+  }
+  case "intros": {
+    require("./intros").run(args.slice(1));
+    break;
+  }
+  case "send-to": {
+    require("./send-to").run(args.slice(1));
+    break;
+  }
+  case "recent": {
+    require("./recent").run(args.slice(1));
+    break;
+  }
+
   default:
     console.log(`
 Open Claudia — AI Coding Assistant via Telegram
@@ -298,6 +321,13 @@ Background work (only inside an active bot-spawned task):
   open-claudia task add|list|start|done|remove     Per-channel todo (survives restarts)
   open-claudia agent "<prompt>" [--role X]         Spawn a throwaway sub-agent for research
 
+Multi-user / cross-channel:
+  open-claudia people list|show|add|note|link      Roster of known team members
+  open-claudia intros list|approve|reject          Pending introductions from unknown chats
+  open-claudia auth list|revoke <chatId>           Raw authorization view + direct deauth
+  open-claudia send-to --person "<name>" "<msg>"   Relay a message to another team member
+  open-claudia recent --person "<name>" [--limit]  Read recent activity from another chat
+
 Start options:
   --web           Also start the web UI
   --quick         Skip slow health checks (Claude auth, Telegram API)

package/bin/intros.js

@@ -0,0 +1,75 @@
+// open-claudia intros <subcommand>
+// Pending introductions from unknown chats. Owner-only mutations.
+
+const { postJson } = require("./loopback-client");
+
+const HELP = `
+Pending introductions from unknown chats.
+
+  open-claudia intros list
+  open-claudia intros approve <id>
+  open-claudia intros reject <id> [--reason "<...>"]
+
+Owner-only: approve, reject.
+`;
+
+function takeFlag(args, name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx < 0) return null;
+  const v = args[idx + 1];
+  args.splice(idx, 2);
+  return v;
+}
+
+function formatIntro(i) {
+  const claim = i.claim || {};
+  let claimLine = "(no claim yet)";
+  if (claim.kind === "existing") claimLine = `claims to be person ${claim.personId}`;
+  if (claim.kind === "new") claimLine = `new person "${claim.name}"${claim.bio ? ` — ${claim.bio}` : ""}`;
+  return `${i.id}  ${i.adapter}:${i.channelId}  step=${i.step}  ${claimLine}`;
+}
+
+async function runList() {
+  try {
+    const res = await postJson("intros-list", {});
+    const list = res.intros || [];
+    if (list.length === 0) { console.log("No pending intros."); process.exit(0); }
+    for (const i of list) console.log(formatIntro(i));
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runApprove(args) {
+  const id = args[0];
+  if (!id) { console.error("Usage: intros approve <id>"); process.exit(2); }
+  try {
+    const res = await postJson("intros-approve", { id });
+    console.log(`Approved. Person: ${res.person?.name || "?"} (${res.person?.id || "?"}).`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runReject(args) {
+  const reason = takeFlag(args, "reason");
+  const id = args[0];
+  if (!id) { console.error("Usage: intros reject <id> [--reason \"<...>\"]"); process.exit(2); }
+  try {
+    await postJson("intros-reject", { id, reason });
+    console.log(`Rejected ${id}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function run(args) {
+  const sub = args[0];
+  const rest = args.slice(1);
+  if (!sub || sub === "--help" || sub === "help") { console.log(HELP); process.exit(sub ? 0 : 2); }
+  switch (sub) {
+    case "list": case "ls": return runList();
+    case "approve": return runApprove(rest);
+    case "reject": return runReject(rest);
+    default: console.error(`Unknown intros subcommand: ${sub}`); console.log(HELP); process.exit(2);
+  }
+}
+
+module.exports = { run, HELP };

package/bin/people.js

@@ -0,0 +1,159 @@
+// open-claudia people <subcommand>
+// Roster of team members the bot knows about. Owner-only mutations;
+// list/show/note are open to any authorized caller.
+
+const { postJson } = require("./loopback-client");
+
+const HELP = `
+Team roster — humans the bot knows.
+
+  open-claudia people list
+  open-claudia people show <id|name>
+  open-claudia people add "<name>" [--bio "<...>"] [--owner]
+  open-claudia people note <id|name> "<note>"
+  open-claudia people link <id|name> --adapter <kazee|telegram> --channel <id>
+  open-claudia people unlink <id|name> --adapter <type> --channel <id>
+  open-claudia people set-primary <id|name> --adapter <type> --channel <id>
+  open-claudia people remove <id|name>
+
+Owner-only: add, link, unlink, set-primary, remove.
+`;
+
+function takeFlag(args, name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx < 0) return null;
+  const v = args[idx + 1];
+  args.splice(idx, 2);
+  return v;
+}
+
+function hasFlag(args, name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx < 0) return false;
+  args.splice(idx, 1);
+  return true;
+}
+
+function formatPerson(p) {
+  const handles = (p.handles || []).map((h) => `${h.adapter}:${h.channelId}${p.primaryChannel && p.primaryChannel.adapter === h.adapter && String(p.primaryChannel.channelId) === String(h.channelId) ? " *" : ""}`).join(", ") || "(none)";
+  const lines = [
+    `${p.name}${p.isOwner ? " (owner)" : ""}  [${p.id}]`,
+    `  Handles: ${handles}`,
+  ];
+  if (p.bio) lines.push(`  Bio: ${p.bio}`);
+  const notes = p.notes || [];
+  if (notes.length) {
+    lines.push("  Recent notes:");
+    for (const n of notes.slice(-5)) lines.push(`    - [${(n.at || "").slice(0, 10)}] ${n.text}`);
+  }
+  return lines.join("\n");
+}
+
+async function runList() {
+  try {
+    const res = await postJson("people-list", {});
+    const list = res.people || [];
+    if (list.length === 0) { console.log("No people."); process.exit(0); }
+    for (const p of list) console.log(formatPerson(p));
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runShow(args) {
+  const ref = args.join(" ").trim();
+  if (!ref) { console.error("Usage: people show <id|name>"); process.exit(2); }
+  try {
+    const res = await postJson("people-show", { id: ref, name: ref });
+    console.log(formatPerson(res.person));
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runAdd(args) {
+  const bio = takeFlag(args, "bio");
+  const isOwner = hasFlag(args, "owner");
+  const name = args.join(" ").trim();
+  if (!name) { console.error("Usage: people add \"<name>\" [--bio \"<...>\"] [--owner]"); process.exit(2); }
+  try {
+    const res = await postJson("people-add", { name, bio, isOwner });
+    console.log(`Added ${res.person.name} (${res.person.id})${isOwner ? " as owner" : ""}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runNote(args) {
+  const ref = args.shift();
+  const text = args.join(" ").trim();
+  if (!ref || !text) { console.error("Usage: people note <id|name> \"<note>\""); process.exit(2); }
+  try {
+    const res = await postJson("people-note", { id: ref, name: ref, text });
+    console.log(`Noted [${res.note.at?.slice(0, 19)}]: ${res.note.text}`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runLink(args) {
+  const linkAdapter = takeFlag(args, "adapter");
+  const linkChannelId = takeFlag(args, "channel");
+  const displayName = takeFlag(args, "display");
+  const ref = args.join(" ").trim();
+  if (!ref || !linkAdapter || !linkChannelId) { console.error("Usage: people link <id|name> --adapter <type> --channel <id>"); process.exit(2); }
+  try {
+    const res = await postJson("people-link", { id: ref, name: ref, linkAdapter, linkChannelId, displayName });
+    console.log(`Linked ${linkAdapter}:${linkChannelId} → ${res.person.name}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runUnlink(args) {
+  const linkAdapter = takeFlag(args, "adapter");
+  const linkChannelId = takeFlag(args, "channel");
+  const ref = args.join(" ").trim();
+  if (!ref || !linkAdapter || !linkChannelId) { console.error("Usage: people unlink <id|name> --adapter <type> --channel <id>"); process.exit(2); }
+  try {
+    const res = await postJson("people-unlink", { id: ref, name: ref, linkAdapter, linkChannelId });
+    console.log(`Unlinked ${linkAdapter}:${linkChannelId} from ${res.person.name}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runSetPrimary(args) {
+  const linkAdapter = takeFlag(args, "adapter");
+  const linkChannelId = takeFlag(args, "channel");
+  const ref = args.join(" ").trim();
+  if (!ref || !linkAdapter || !linkChannelId) { console.error("Usage: people set-primary <id|name> --adapter <type> --channel <id>"); process.exit(2); }
+  try {
+    const res = await postJson("people-set-primary", { id: ref, name: ref, linkAdapter, linkChannelId });
+    console.log(`Primary for ${res.person.name} → ${linkAdapter}:${linkChannelId}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runRemove(args) {
+  const ref = args.join(" ").trim();
+  if (!ref) { console.error("Usage: people remove <id|name>"); process.exit(2); }
+  try {
+    const res = await postJson("people-remove", { id: ref, name: ref });
+    console.log(`Removed ${res.removed.name}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function run(args) {
+  const sub = args[0];
+  const rest = args.slice(1);
+  if (!sub || sub === "--help" || sub === "help") { console.log(HELP); process.exit(sub ? 0 : 2); }
+  switch (sub) {
+    case "list": case "ls": return runList();
+    case "show": return runShow(rest);
+    case "add": return runAdd(rest);
+    case "note": return runNote(rest);
+    case "link": return runLink(rest);
+    case "unlink": return runUnlink(rest);
+    case "set-primary": return runSetPrimary(rest);
+    case "remove": case "rm": return runRemove(rest);
+    default: console.error(`Unknown people subcommand: ${sub}`); console.log(HELP); process.exit(2);
+  }
+}
+
+module.exports = { run, HELP };

package/bin/recent.js

@@ -0,0 +1,46 @@
+// open-claudia recent — fetch recent activity from another chat without
+// pulling it into every system prompt. Reads from transcript jsonls.
+
+const { postJson } = require("./loopback-client");
+
+const HELP = `
+Read recent activity from a chat.
+
+  open-claudia recent --person "<name>" [--limit 20]
+  open-claudia recent --adapter <type> --channel <id> [--limit 20]
+`;
+
+function takeFlag(args, name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx < 0) return null;
+  const v = args[idx + 1];
+  args.splice(idx, 2);
+  return v;
+}
+
+async function run(args) {
+  if (args[0] === "--help" || args[0] === "help") { console.log(HELP); process.exit(0); }
+  const personName = takeFlag(args, "person");
+  const personId = takeFlag(args, "person-id");
+  const adapter = takeFlag(args, "adapter");
+  const channelId = takeFlag(args, "channel");
+  const limit = takeFlag(args, "limit") || 20;
+  if (!personName && !personId && !(adapter && channelId)) {
+    console.error("Need a target: --person or --adapter/--channel."); process.exit(2);
+  }
+  try {
+    const res = await postJson("recent-fetch", { personName, personId, adapter, channelId, limit });
+    const entries = res.entries || [];
+    if (entries.length === 0) { console.log("(no recent activity)"); process.exit(0); }
+    console.log(`Recent on ${res.adapter}:${res.channelId} (${entries.length}):\n`);
+    for (const e of entries) {
+      const at = (e.at || "").slice(0, 19);
+      const role = e.role || e.kind || "?";
+      const txt = (e.text || "").replace(/\s+/g, " ").slice(0, 200);
+      console.log(`[${at}] ${role}: ${txt}`);
+    }
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+module.exports = { run, HELP };

package/bin/send-to.js

@@ -0,0 +1,52 @@
+// open-claudia send-to — cross-channel relay primitive. Send a message
+// to another person on their primary channel (or an explicit target).
+
+const { postJson } = require("./loopback-client");
+
+const HELP = `
+Send a message to another team member or an explicit channel.
+
+  open-claudia send-to --person "<name>" "<message>"
+  open-claudia send-to --person-id <id> "<message>"
+  open-claudia send-to --canonical <id> "<message>"
+  open-claudia send-to --adapter <type> --channel <id> "<message>"
+
+Be honest about provenance — prefix forwarded messages with "From <name>: "
+and autonomous ones with "Open Claudia: ". Every relay is logged.
+`;
+
+function takeFlag(args, name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx < 0) return null;
+  const v = args[idx + 1];
+  args.splice(idx, 2);
+  return v;
+}
+
+async function run(args) {
+  if (!args.length || args[0] === "--help" || args[0] === "help") {
+    console.log(HELP); process.exit(args[0] === "--help" || args[0] === "help" ? 0 : 2);
+  }
+  const targetPersonName = takeFlag(args, "person");
+  const targetPersonId = takeFlag(args, "person-id");
+  const targetCanonicalUserId = takeFlag(args, "canonical");
+  const targetAdapter = takeFlag(args, "adapter");
+  const targetChannelId = takeFlag(args, "channel");
+  const text = args.join(" ").trim();
+  if (!text) { console.error("Missing message text."); process.exit(2); }
+  if (!targetPersonName && !targetPersonId && !targetCanonicalUserId && !(targetAdapter && targetChannelId)) {
+    console.error("Need a target: --person, --person-id, --canonical, or --adapter/--channel.");
+    process.exit(2);
+  }
+  try {
+    const res = await postJson("relay-send", {
+      text, targetPersonName, targetPersonId, targetCanonicalUserId, targetAdapter, targetChannelId,
+    });
+    const to = res.to || {};
+    const who = to.person ? `${to.person.name} on ${to.adapter}` : `${to.adapter}:${to.channelId}`;
+    console.log(`Sent to ${who}. messageId=${res.messageId || "?"}`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+module.exports = { run, HELP };

package/core/access.js

@@ -48,7 +48,16 @@ function isChatAuthorized(chatId) {
   if (CHAT_IDS.includes(id)) return true;
   try {
     const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
-    return Array.isArray(auth.authorized) && auth.authorized.some((a) => String(a.chatId) === id);
+    if (Array.isArray(auth.authorized) && auth.authorized.some((a) => String(a.chatId) === id)) return true;
+  } catch (e) {}
+  // Also accept any chat that has been linked to a person via an intro.
+  try {
+    const { currentTransport } = require("./context");
+    const transport = currentTransport();
+    if (transport) {
+      const people = require("./people");
+      if (people.findByHandle(transport, id)) return true;
+    }
   } catch (e) {}
   return false;
 }
@@ -125,6 +134,36 @@ function recordPendingAuthRequest({ chatId, name, username }) {
   return { status: "queued" };
 }
 
+// Remove a chatId from the legacy auth.json. Owners are never removed
+// this way to avoid self-locking; the caller has to handle owner
+// demotion explicitly. Returns { ok, reason }.
+function revokeChat(chatId) {
+  const id = String(chatId || "");
+  if (!id) return { ok: false, reason: "missing_id" };
+  const auth = loadAuth();
+  const before = auth.authorized.length;
+  auth.authorized = auth.authorized.filter((a) => {
+    if (String(a.chatId) !== id) return true;
+    if (a.isOwner === true) return true;
+    return false;
+  });
+  auth.pending = auth.pending.filter((p) => String(p.chatId) !== id);
+  if (auth.authorized.length === before) {
+    if (auth.pending.length === 0) return { ok: false, reason: "not_found" };
+  }
+  saveAuth(auth);
+  updateAuthorizedChatEnv(auth);
+  return { ok: true };
+}
+
+function listAuthorizedRaw() {
+  const auth = loadAuth();
+  return {
+    authorized: auth.authorized.slice(),
+    pending: auth.pending.slice(),
+  };
+}
+
 function hasOwner() {
   if (CHAT_ID) return true;
   try {
@@ -164,4 +203,6 @@ module.exports = {
   updateAuthorizedChatEnv,
   hasOwner,
   bootstrapOwner,
+  revokeChat,
+  listAuthorizedRaw,
 };

package/core/actions.js

@@ -10,6 +10,8 @@ const { currentState, resetSettings, resetSessionUsage, saveState } = require(".
 const { runClaude, getActiveSessionId } = require("./runner");
 const { listProjects, projectKeyboard, workspacePath } = require("./projects");
 const { isChatOwner, approveAuthRequest, denyAuthRequest, authRequestLabel } = require("./access");
+const intros = require("./intros");
+const introFlow = require("./intro-flow");
 const { finishOnboarding } = require("./onboarding");
 const { startSession } = require("./handlers");
 const jobs = require("./jobs");
@@ -52,6 +54,38 @@ async function handleAction(envelope) {
     return;
   }
 
+  if (d.startsWith("intro:")) {
+    if (!isChatOwner(envelope.channelId)) return send("Owner only — intro approvals are restricted.");
+    const [, action, introId] = d.split(":");
+    if (!introId || !["approve", "reject"].includes(action)) return;
+    const intro = intros.byId(introId);
+    if (!intro) return send(`No intro found for ${introId}.`);
+    if (intro.step === "approved" || intro.step === "rejected") {
+      return send(`Intro ${introId} was already ${intro.step}.`);
+    }
+    if (action === "approve") {
+      try {
+        const ownerName = envelope.from?.name || "owner";
+        const result = await introFlow.applyApproval(intro, ownerName);
+        await introFlow.notifyIntroUser(intro, `You're in. Welcome${result.person ? ", " + result.person.name : ""}. Send /start to begin.`);
+        if (envelope.action?.sourceMessageId) {
+          await adapter.edit(envelope.channelId, envelope.action.sourceMessageId, `Approved intro ${introId}.`, {});
+        } else {
+          await send(`Approved intro ${introId}.`);
+        }
+      } catch (e) { await send(`Approval failed: ${e.message}`); }
+      return;
+    }
+    intros.reject(introId, envelope.from?.name || "owner");
+    await introFlow.notifyIntroUser(intro, "Your access request was denied.");
+    if (envelope.action?.sourceMessageId) {
+      await adapter.edit(envelope.channelId, envelope.action.sourceMessageId, `Rejected intro ${introId}.`, {});
+    } else {
+      await send(`Rejected intro ${introId}.`);
+    }
+    return;
+  }
+
   if (d.startsWith("ob:")) { finishOnboarding(d.slice(3)); return; }
 
   if (d === "show:projects") { await send("Pick:", { keyboard: projectKeyboard() }); return; }

package/core/audit.js

@@ -0,0 +1,40 @@
+// Append-only audit log for security-sensitive events: people CRUD,
+// intro decisions, cross-channel sends. One JSON record per line.
+// Auto-rotates when the file exceeds MAX_BYTES — the current file is
+// renamed to <name>.1 (overwriting any previous archive) and a fresh
+// file starts.
+
+const fs = require("fs");
+const { AUDIT_FILE } = require("./config");
+
+const MAX_BYTES = 2 * 1024 * 1024; // 2 MB; rotate at this size
+
+function rotateIfNeeded() {
+  try {
+    const stat = fs.statSync(AUDIT_FILE);
+    if (stat.size > MAX_BYTES) {
+      try { fs.renameSync(AUDIT_FILE, `${AUDIT_FILE}.1`); } catch (e) {}
+    }
+  } catch (e) {} // file may not exist yet
+}
+
+function log(kind, payload) {
+  const entry = { at: new Date().toISOString(), kind, ...payload };
+  const line = JSON.stringify(entry) + "\n";
+  try {
+    rotateIfNeeded();
+    fs.appendFileSync(AUDIT_FILE, line);
+  } catch (e) {}
+  return entry;
+}
+
+function tail(n = 50) {
+  try {
+    const raw = fs.readFileSync(AUDIT_FILE, "utf-8").trim().split("\n");
+    return raw.slice(-Math.max(1, n)).map((line) => {
+      try { return JSON.parse(line); } catch (e) { return { at: null, kind: "parse-error", raw: line }; }
+    });
+  } catch (e) { return []; }
+}
+
+module.exports = { log, tail, MAX_BYTES };

package/core/config.js

@@ -62,6 +62,9 @@ const TASKS_DIR = config.TASKS_DIR || path.join(CONFIG_DIR, "tasks");
 const VAULT_FILE = config.VAULT_FILE || path.join(CONFIG_DIR, "vault.enc");
 const AUTH_FILE = config.AUTH_FILE || path.join(CONFIG_DIR, "auth.json");
 const IDENTITIES_FILE = config.IDENTITIES_FILE || path.join(CONFIG_DIR, "identities.json");
+const PEOPLE_FILE = config.PEOPLE_FILE || path.join(CONFIG_DIR, "people.json");
+const INTROS_FILE = config.INTROS_FILE || path.join(CONFIG_DIR, "intros.json");
+const AUDIT_FILE = config.AUDIT_FILE || path.join(CONFIG_DIR, "audit.log");
 const STATE_FILE = path.join(CONFIG_DIR, "state.json");
 const SESSIONS_FILE = path.join(CONFIG_DIR, "sessions.json");
 
@@ -194,6 +197,7 @@ module.exports = {
   TRANSCRIPTS_DIR,
   WHISPER_CLI, WHISPER_MODEL, FFMPEG,
   SOUL_FILE, CRONS_FILE, JOBS_FILE, TASKS_DIR, VAULT_FILE, AUTH_FILE, IDENTITIES_FILE,
+  PEOPLE_FILE, INTROS_FILE, AUDIT_FILE,
   STATE_FILE, SESSIONS_FILE,
   TEMP_DIR, FILES_DIR,
   MAX_FILE_SIZE, MAX_VOICE_SIZE, MAX_PROCESS_TIMEOUT,