@inetafrica/open-claudia 2.0.4 → 2.1.0

package/bin/cli.js

@@ -267,6 +267,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 +315,12 @@ 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 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/bin/task.js

@@ -1,42 +1,101 @@
 // open-claudia task <subcommand>
 // Per-channel todo list. Use this for multi-step work so progress
-// survives compactions and restarts.
+// survives compactions and restarts. Supports one level of hierarchy:
+// a parent "plan" task can have child subtasks via --parent.
 
 const { postJson } = require("./loopback-client");
 
 const HELP = `
-Per-channel todo list.
+Per-channel todo list with optional plan/subtask hierarchy.
 
-  open-claudia task add "<content>"
+  open-claudia task add "<content>" [--parent <id>] [--description "<...>"]
+  open-claudia task plan "<title>" "<sub1>" "<sub2>" ... [--description "<...>"]
   open-claudia task list [--status pending|in_progress|completed]
   open-claudia task start <id>
   open-claudia task done <id>
-  open-claudia task remove <id>
-  open-claudia task clear-completed
+  open-claudia task remove <id>          # removing a plan removes its subtasks
+  open-claudia task clear-completed      # only clears plans whose subtasks are all done
+
+Use plans for any work with 3+ distinct steps. Mark subtasks in_progress
+as you start them and done as you finish, so a resumed turn or a new
+turn after compaction can pick up where you left off.
 `;
 
-function fmt(t, idx) {
-  const mark = t.status === "completed" ? "[x]" : t.status === "in_progress" ? "[~]" : "[ ]";
-  return `${idx + 1}. ${mark} ${t.content}    (${t.id})`;
+function statusMark(t) {
+  return t.status === "completed" ? "[x]" : t.status === "in_progress" ? "[~]" : "[ ]";
+}
+
+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 renderTree(list) {
+  const byParent = new Map();
+  const roots = [];
+  for (const t of list) {
+    if (t.parentId) {
+      if (!byParent.has(t.parentId)) byParent.set(t.parentId, []);
+      byParent.get(t.parentId).push(t);
+    } else {
+      roots.push(t);
+    }
+  }
+  const lines = [];
+  roots.forEach((root, i) => {
+    lines.push(`${i + 1}. ${statusMark(root)} ${root.content}    (${root.id})`);
+    if (root.description) lines.push(`      ${root.description}`);
+    (byParent.get(root.id) || []).forEach((c) => {
+      lines.push(`    ${statusMark(c)} ${c.content}    (${c.id})`);
+    });
+  });
+  for (const orphan of list) {
+    if (orphan.parentId && !roots.find((r) => r.id === orphan.parentId)) {
+      lines.push(`    ${statusMark(orphan)} ${orphan.content}    (${orphan.id}) [orphan]`);
+    }
+  }
+  return lines.join("\n");
 }
 
 async function runAdd(args) {
+  const parentId = takeFlag(args, "parent");
+  const description = takeFlag(args, "description");
   const content = args.join(" ").trim();
-  if (!content) { console.error("Usage: task add \"<content>\""); process.exit(2); }
+  if (!content) { console.error("Usage: task add \"<content>\" [--parent <id>] [--description \"<...>\"]"); process.exit(2); }
   try {
-    const res = await postJson("task-add", { content });
+    const res = await postJson("task-add", { content, parentId, description });
     console.log(`Added task ${res.task.id}.`);
     process.exit(0);
   } catch (e) { console.error(e.message); process.exit(1); }
 }
 
+async function runPlan(args) {
+  const description = takeFlag(args, "description");
+  if (args.length < 2) {
+    console.error("Usage: task plan \"<title>\" \"<sub1>\" \"<sub2>\" ... [--description \"<...>\"]");
+    process.exit(2);
+  }
+  const [title, ...subtasks] = args;
+  try {
+    const res = await postJson("task-plan", { title, subtasks, description });
+    const parent = res.plan.parent;
+    const kids = res.plan.children || [];
+    console.log(`Plan ${parent.id}: ${parent.content}`);
+    kids.forEach((c) => console.log(`  - ${c.content}  (${c.id})`));
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
 async function runList(args) {
-  const status = args[args.indexOf("--status") + 1] && args.includes("--status") ? args[args.indexOf("--status") + 1] : null;
+  const status = args.includes("--status") ? args[args.indexOf("--status") + 1] : null;
   try {
     const res = await postJson("task-list", status ? { status } : {});
     const list = res.tasks || [];
     if (list.length === 0) { console.log("No tasks."); process.exit(0); }
-    list.forEach((t, i) => console.log(fmt(t, i)));
+    console.log(renderTree(list));
     process.exit(0);
   } catch (e) { console.error(e.message); process.exit(1); }
 }
@@ -58,7 +117,8 @@ async function runRemove(args) {
   try {
     const res = await postJson("task-remove", { id });
     if (!res.ok) { console.error(`Not found: ${id}`); process.exit(1); }
-    console.log(`Removed ${id}.`);
+    const extra = (res.removed && res.removed.alsoRemoved) ? ` (and ${res.removed.alsoRemoved} subtask${res.removed.alsoRemoved === 1 ? "" : "s"})` : "";
+    console.log(`Removed ${id}${extra}.`);
     process.exit(0);
   } catch (e) { console.error(e.message); process.exit(1); }
 }
@@ -77,6 +137,7 @@ async function run(args) {
   if (!sub || sub === "--help" || sub === "help") { console.log(HELP); process.exit(sub ? 0 : 2); }
   switch (sub) {
     case "add": return runAdd(rest);
+    case "plan": return runPlan(rest);
     case "list": case "ls": return runList(rest);
     case "start": return runUpdate(rest, "in_progress");
     case "done": case "complete": return runUpdate(rest, "completed");

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

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,23 @@
+// Append-only audit log for security-sensitive events: people CRUD,
+// intro decisions, cross-channel sends. One JSON record per line.
+
+const fs = require("fs");
+const { AUDIT_FILE } = require("./config");
+
+function log(kind, payload) {
+  const entry = { at: new Date().toISOString(), kind, ...payload };
+  const line = JSON.stringify(entry) + "\n";
+  try { 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 };

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");
 
@@ -78,7 +81,7 @@ if (!CLAUDE_PATH) { console.error("CLAUDE_PATH not set"); process.exit(1); }
 if (!fs.existsSync(WORKSPACE)) {
   try {
     fs.mkdirSync(WORKSPACE, { recursive: true });
-    console.log(`Created workspace: ${WORKSPACE}`);
+    console.error(`Created workspace: ${WORKSPACE}`);
   } catch (e) {
     console.error(`Failed to create workspace: ${e.message}`);
     process.exit(1);
@@ -99,14 +102,14 @@ if (!resolvedCursorPath) {
   try { resolvedCursorPath = execSync("which agent 2>/dev/null", { encoding: "utf-8" }).trim() || null; }
   catch (e) { resolvedCursorPath = null; }
 }
-if (resolvedCursorPath) console.log(`Cursor Agent CLI: ${resolvedCursorPath}`);
+if (resolvedCursorPath) console.error(`Cursor Agent CLI: ${resolvedCursorPath}`);
 
 let resolvedCodexPath = CODEX_PATH;
 if (!resolvedCodexPath) {
   try { resolvedCodexPath = execSync("which codex 2>/dev/null", { encoding: "utf-8" }).trim() || null; }
   catch (e) { resolvedCodexPath = null; }
 }
-if (resolvedCodexPath) console.log(`Codex CLI: ${resolvedCodexPath}`);
+if (resolvedCodexPath) console.error(`Codex CLI: ${resolvedCodexPath}`);
 
 if (!fs.existsSync(TEMP_DIR)) fs.mkdirSync(TEMP_DIR, { recursive: true });
 if (!fs.existsSync(FILES_DIR)) fs.mkdirSync(FILES_DIR, { recursive: true });
@@ -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,