@inetafrica/open-claudia 3.5.74-usage.2 → 3.5.75

package/CHANGELOG.md

@@ -1,17 +1,25 @@
 # Changelog
 
-## 3.5.74-usage.1
+## 3.5.75
 
-Canary: the Rust CLI plus memory cuts from the bot memory review of 5 Nov (Sumeet's card 6aec0fa1).
+3.5.74 plus personal bots act for their owner through a pass (from the Maia build), and the one-tap switch-on card. Nothing changes for a bot until Central has `bot:me` (an older Central answers 404 and the bot stays as it was). Autonomous bots are unchanged.
 
-- **The recall helper stops when quiet** (`core/recall/warm-walker.js`): `RECALL_WARM_WALKER_IDLE_MS`, default 10 minutes, 0 = never.
-- **No usage history read per turn** (`core/runner.js`) unless `USAGE_ALERTS` is on.
-- **Reviews run one at a time** (`core/pack-review.js`): `OC_REVIEW_CONCURRENCY`, default 1, behind a queue of `OC_REVIEW_QUEUE_MAX`, default 20, oldest dropped with one log line.
-- **`OC_NODE_FLAGS`** (`docker-entrypoint.sh`): Node flags on the main process only. Unset is today's command.
-- **`RECALL_ENGINE` in .env works** (`core/recall/index.js`). The per-user setting still comes first.
-- **Call and Telegram libraries load when needed** (`channels/`), and a pack's topic lessons no longer wipe every other lesson's ranking (`core/lessons.js`).
+- **Type check** (`core/bot-profile.js`): on start, and every 15 minutes, the bot asks Central `GET /api/bots/me` with its own key for its kind, its one owner and the owner's consent (ticked apps, end date, `renewDue`). The answer is kept in `bot-profile.json`, so a restart while Central is down still knows.
+- **One owner**: a personal bot's owner is the person in Central. Her id replaces `KAZEE_OWNER_USER_ID`, from config load and on every refresh. `access.isChatOwner` counts no other owner (no people records, `auth.json` or chat ids marked owner), and the web dashboard and the voice bridge reach her rather than being owners themselves.
+- **One pass helper** (`core/app-pass.js`): every app call of a personal bot trades its key for a 10-minute pass for that app (`POST /api/bots/pass`), reused until a minute before it ends, one request per app at a time; the bot's own key is never sent to an app. Kazee Chat keeps the bot's own key. The owner reads each app's own name (Spaces, CRM, Tickets, Agent Space, Infrastructure) for Central's exact app names.
+- **Spaces**: the conversational channel stays idle for a personal bot (no socket of its own); anything still sent through it, and the connected-apps plane watching the apps the owner ticked, goes out with her pass.
+- **One-tap card** (SEC-28, `core/owner-setup.js`): when an app refuses a pass because she has not switched the bot on there, and a week before her consent ends, the owner gets a Kazee Chat card with one button that opens Central at the form (Switch me on / Renew); at most once a day per app and reason. `open-claudia owner-setup [--apps a,b] [--renew]` sends it on request; `open-claudia pass <app>` prints a fresh pass, never the key.
+- **Instructions**: a personal bot gets its own block in the core instructions (who it works for, approvals, money and deletes need her tap, send the one-tap card).
 
-Tests: new `test-walker-idle-stop.js`, `test-usage-history-lazy.js`, `test-review-queue.js`, `test-node-flags-entrypoint.js`, `test-recall-engine-env.js`.
+Tests: `test-bot-acts-for-owner.js` (in the suite).
+
+## 3.5.74
+
+3.5.73 plus the Rust command helper, released on Sumeet's card of 8 Nov ("Yes, Maya Cloud first, then one bot at a time") after 3 clean days on his Mac (about 62,000 commands, no crashes).
+
+- **`open-claudia` is now maia-rs** (`rust/`, built in a static musl stage of the image): cards, decisions, tasks, wakeups, crons, watches, send-file/photo/voice, say/tts/transcribe and tool runs (read-only, and the owner's flagged writes) run without starting Node. Under 1 MB and a few milliseconds per call instead of about 50 MB and a tenth of a second. Anything else is handed to `bin/cli.js` unchanged.
+- **Kill switch per bot**: `OC_RUST_CLI=0` in the bot's environment hands every command to the Node CLI, as before.
+- **Fixes from the Mac trial**: `--quiet` kept on wakeups, crons and watches; exits 0 when its reader has gone (a closed pipe used to abort with exit 134).
 
 ## 3.5.73
 

package/Dockerfile

@@ -102,7 +102,5 @@ EXPOSE 8080
 # Switch to non-root user
 USER 1001
 
-# OC_NODE_FLAGS in a bot's env: docker-entrypoint.sh puts those flags on this
-# node command only. Unset, the command below runs as is.
 ENTRYPOINT ["docker-entrypoint.sh"]
 CMD ["node", "bin/cli.js", "web"]

package/bin/cli.js

@@ -218,6 +218,41 @@ switch (command) {
     break;
   }
 
+  case "pass": {
+    // A fresh pass for one app (core/app-pass.js), for a tool that calls an
+    // app for a personal bot's owner: e.g. `open-claudia pass kazee-spaces-backend`.
+    // Never prints the bot's own key: an autonomous bot has no pass to give.
+    const applicationName = args[1];
+    if (!applicationName) {
+      console.error("Usage: open-claudia pass <Central application name, e.g. kazee-spaces-backend>");
+      process.exit(2);
+    }
+    (async () => {
+      const botProfile = require(path.join(botDir, "core/bot-profile"));
+      const appPass = require(path.join(botDir, "core/app-pass"));
+      await botProfile.refresh();
+      if (!botProfile.isPersonal()) {
+        console.error("Only a personal bot uses passes; this bot calls apps with its own key.");
+        process.exit(2);
+      }
+      try {
+        process.stdout.write(await appPass.tokenFor(applicationName));
+        process.stdout.write("\n");
+        process.exit(0);
+      } catch (e) {
+        console.error(e instanceof appPass.PassRefused ? e.ownerMessage : e.message);
+        process.exit(1);
+      }
+    })();
+    break;
+  }
+
+  case "owner-setup": {
+    // The one-tap card for a personal bot's owner (core/owner-setup.js).
+    require("./owner-setup").run(args.slice(1)).then((code) => process.exit(code));
+    break;
+  }
+
   case "health": {
     console.log("Running health checks...\n");
     const verbose = args.includes("-v") || args.includes("--verbose");
@@ -679,6 +714,12 @@ Background work (only inside an active bot-spawned task):
 Cluster control (self-management of this bot's own deployment via the broker):
   open-claudia cluster status|logs|restart|start|stop|scale <0|1>|sync
 
+Personal bots (acting for their owner):
+  open-claudia pass <app>                    A fresh 10-minute pass to act as your owner at one app
+                                             (e.g. kazee-spaces-backend); never your own key
+  open-claudia owner-setup [--apps a,b] [--renew]  Send your owner a one-tap card in Kazee Chat to switch
+                                             you on (default: apps not switched on yet) or renew
+
 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

package/bin/owner-setup.js

@@ -0,0 +1,56 @@
+// open-claudia owner-setup — send a personal bot's owner the one-tap card that opens
+// Central at the form to switch the bot on (or renew it). See
+// core/owner-setup.js. The running bot sends it to the owner's direct Kazee chat.
+
+const path = require("path");
+
+const HELP = `
+Send your owner a one-tap card to switch you on, or to renew.
+
+  open-claudia owner-setup                  the apps you can work in that your owner hasn't switched on yet
+  open-claudia owner-setup --apps Tickets   just these apps (Central names or Tickets, CRM, Spaces...)
+  open-claudia owner-setup --renew          renew before your owner's permission ends
+
+Personal bots only. You can never switch yourself on: only your owner can confirm.
+`;
+
+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;
+}
+
+// Resolves the exit code. deps (tests): refresh, post, log, error.
+async function run(args, deps = {}) {
+  const log = deps.log || console.log;
+  const error = deps.error || console.error;
+  args = [...args];
+  if (args[0] === "--help" || args[0] === "help") { log(HELP); return 0; }
+  const botProfile = require(path.join(__dirname, "..", "core", "bot-profile"));
+  const ownerSetup = require(path.join(__dirname, "..", "core", "owner-setup"));
+  const renew = args.includes("--renew");
+  const apps = String(takeFlag(args, "apps") || "").split(",").map((s) => s.trim()).filter(Boolean);
+  try {
+    await (deps.refresh || botProfile.refresh)();
+  } catch (_) { /* the last answer on disk */ }
+  const planned = ownerSetup.plan({ apps, renew });
+  if (planned.refused) { error(planned.refused); return 2; }
+  if (planned.nothing) { log(planned.nothing); return 0; }
+  try {
+    const post = deps.post || require("./loopback-client").postJson;
+    const res = await post("owner-setup", { apps, renew });
+    if (res.nothing) { log(res.nothing); return 0; }
+    const who = botProfile.ownerFirstName();
+    if (res.sent === "already-sent") log(`${who} already got this card in the last day; not sent again.`);
+    else if (res.sent === "card") log(`Sent ${who} a card in Kazee Chat: "${res.title}".`);
+    else log(`The card could not be sent, so ${who} got the text with the link instead.`);
+    return 0;
+  } catch (e) {
+    error(`owner-setup: ${e.message}`);
+    return 1;
+  }
+}
+
+module.exports = { run, HELP };

package/bot.js

@@ -264,6 +264,42 @@ setInterval(checkForUpdates, 5 * 60 * 1000);
 
 // ── Boot ────────────────────────────────────────────────────────────
 
+// Tell a personal bot's owner in her Kazee DM that an app refused a pass: a
+// one-tap card to switch the bot on there, else the text (core/owner-setup.js).
+// Best effort: no Kazee adapter or DM means no message.
+async function tellPersonalOwner(text, err) {
+  const ownerSetup = require("./core/owner-setup");
+  const kazee = adapters.find((a) => a.type === "kazee");
+  if (kazee) await ownerSetup.tellOwner(ownerSetup.forRefusal(err, text), { adapter: kazee });
+}
+
+// A week before the consent ends: the renew card, once a day.
+async function maybeSendRenewNotice() {
+  const kazee = adapters.find((a) => a.type === "kazee");
+  if (kazee) await require("./core/owner-setup").maybeSendRenew({ adapter: kazee });
+}
+
+async function startBotProfile() {
+  const botProfile = require("./core/bot-profile");
+  const applyOwner = () => {
+    const owner = botProfile.applyOwner(config);
+    if (!owner) return;
+    for (const a of adapters) {
+      if (a.type === "kazee" || a.type === "spaces") a.ownerUserId = owner;
+    }
+  };
+  await botProfile.refresh();
+  applyOwner();
+  console.log(botProfile.isPersonal()
+    ? `Bot profile: personal, owner ${botProfile.ownerName() || botProfile.ownerUserId()}; apps ticked: ${botProfile.consentApplications().join(", ") || "none"}`
+    : `Bot profile: ${botProfile.get()?.bot?.botKind || "unknown (Central has no bot:me)"}`);
+  require("./core/app-pass").setOwnerNotifier(tellPersonalOwner);
+  botProfile.startRefreshing(applyOwner);
+  const renewTimer = setInterval(() => { maybeSendRenewNotice(); }, 60 * 60 * 1000);
+  if (renewTimer.unref) renewTimer.unref();
+  setTimeout(() => { maybeSendRenewNotice(); }, 60 * 1000).unref?.();
+}
+
 // Minimal boot: adapters + slash commands only. No scheduler/crons, no dream,
 // no connected-apps, no loopback, no web UI, no onboarding — nothing that can
 // run an agent turn or write memory. The alert tells the owner exactly why and
@@ -332,6 +368,12 @@ async function safeModeBoot() {
     }
   } catch (e) {}
 
+  // Personal or autonomous, and who the one owner is: asked of Central before
+  // the adapters start (core/bot-profile.js). A personal bot's app calls go
+  // through passes for that owner (core/app-pass.js).
+  try { await startBotProfile(); }
+  catch (e) { console.error("bot profile init failed:", e.message); }
+
   initScheduler(adapters);
   try { require("./core/dream").initDream(adapters); }
   catch (e) { console.error("dream init failed:", e.message); }

package/channels/kazee/call/camera.js

@@ -11,6 +11,7 @@ const fs = require("fs");
 const os = require("os");
 const path = require("path");
 const { spawn } = require("child_process");
+const { dePacketizeRtpPackets } = require("werift");
 
 const STILL_EVERY_S = 2;
 const STILL_SIZE = 768;
@@ -151,7 +152,7 @@ class CameraStills {
       if ((packets[index].header.sequenceNumber - packets[index - 1].header.sequenceNumber + 65536) % 65536 !== 1) return this._lost();
     }
     let frame;
-    try { frame = require("werift").dePacketizeRtpPackets("VP8", packets); } catch (_) { return this._lost(); }
+    try { frame = dePacketizeRtpPackets("VP8", packets); } catch (_) { return this._lost(); }
     if (!frame?.data?.length) return;
     const size = frame.isKeyframe ? vp8KeyframeSize(frame.data) : null;
     if (this._needKeyframe) {

package/channels/kazee/call/session.js

@@ -1,7 +1,6 @@
 "use strict";
 
-// Loaded on the first call, so a bot that takes no calls never holds this library.
-const werift = () => require("werift");
+const { MediaStreamTrack, RTCPeerConnection, RTCRtpHeaderExtensionParameters, RtpHeader, RtpPacket } = require("werift");
 const { JanusClient } = require("./janus-client");
 const { projectAssignedIce, supportedIceServers } = require("./access");
 const { AdaptiveTurnDetector, OpusAudioCodec, WEBRTC_SAMPLES, downsample48To16, upsampleTo48, rmsDbfs } = require("./audio");
@@ -228,7 +227,7 @@ class KazeeCallSession {
   constructor({ roomId, chatId, callerId, botUserId, janusUrl, janusToken, janusTokenExpiresAt, roomToken, roomTokenExpiresAt, managedRoom = false, refreshRoomAccess, iceServers = [], iceCredentialsExpiresAt, onTranscript, onEnded, onMediaReady,
     maxCallMs, idleMs, checkInMs, checkInGraceMs, dropMs, dropGiveUpMs, humDb, finalWaitMs, synthesize = synthesizePcm, synthesizeStream = null, asCaller = false, greeting = null,
     turnDecision = detectTurn, acknowledgement = selectAcknowledgement, onSpeechStart, onSpeechNoise, onEarlyWords, onUtteranceDropped,
-    JanusClientImpl = JanusClient, PeerConnectionImpl = werift().RTCPeerConnection, SpeechStreamImpl = SpeechStream } = {}) {
+    JanusClientImpl = JanusClient, PeerConnectionImpl = RTCPeerConnection, SpeechStreamImpl = SpeechStream } = {}) {
     this.roomId = Number(roomId);
     this.chatId = String(chatId);
     this.callerId = String(callerId);
@@ -358,7 +357,7 @@ class KazeeCallSession {
     // A feed's connection also takes the caller's camera; with the
     // orientation extension a phone held upright gives an upright still.
     const pc = new this.PeerConnectionImpl(camera
-      ? { iceServers: this.iceServers, headerExtensions: { audio: [], video: [new (werift().RTCRtpHeaderExtensionParameters)({ id: 13, uri: VIDEO_ORIENTATION_URI })] } }
+      ? { iceServers: this.iceServers, headerExtensions: { audio: [], video: [new RTCRtpHeaderExtensionParameters({ id: 13, uri: VIDEO_ORIENTATION_URI })] } }
       : { iceServers: this.iceServers });
     if (Number.isFinite(expiresAt)) {
       this._transportIceExpiry.set(pc, expiresAt);
@@ -516,7 +515,7 @@ class KazeeCallSession {
         this._maybeGreet();
       }
     });
-    const track = new (werift().MediaStreamTrack)({ kind: "audio" });
+    const track = new MediaStreamTrack({ kind: "audio" });
     const sender = pc.addTrack(track);
     this.publisher = { pc, track, sender, pending: [], remoteSet: false };
     const offer = await pc.createOffer();
@@ -1047,7 +1046,7 @@ class KazeeCallSession {
     if (frame.length < WEBRTC_SAMPLES * 2) frame = Buffer.concat([frame, Buffer.alloc(WEBRTC_SAMPLES * 2 - frame.length)]);
     const opus = this.codec.encode(frame);
     const payloadType = this.publisher?.sender?.codec?.payloadType || 111;
-    this.publisher?.track?.writeRtp(new (werift().RtpPacket)(new (werift().RtpHeader)({
+    this.publisher?.track?.writeRtp(new RtpPacket(new RtpHeader({
       payloadType, sequenceNumber: this.sequence++ & 0xffff, timestamp: this.timestamp >>> 0, ssrc: this.ssrc,
     }), opus));
     this.timestamp = (this.timestamp + WEBRTC_SAMPLES) >>> 0;

package/channels/spaces/adapter.js

@@ -21,6 +21,15 @@ const { SpacesClient, contentText } = require("./client");
 const { createSpacesSocket } = require("./socket");
 const spacesState = require("./state");
 
+// Central's name for the Spaces back end, the app a personal bot's pass is for.
+const SPACES_APPLICATION = "kazee-spaces-backend";
+
+function spacesBearer(token) {
+  let personal = false;
+  try { personal = require("../../core/bot-profile").isPersonal(); } catch (_) { /* no profile: as before */ }
+  return personal ? require("../../core/app-pass").tokenFor(SPACES_APPLICATION) : token;
+}
+
 // Notification `type`/`category` values that warrant a full agent turn. The
 // Spaces server emits PLURAL categories (mentions, comments, reactions,
 // task_updated), so the engage set must match the plural forms — matching only
@@ -54,7 +63,11 @@ class SpacesAdapter {
     // the only thing calling poll(); it can be disabled, so the adapter drives
     // its own timer and never depends on it.
     this.pollMs = Number(pollMs) > 0 ? Number(pollMs) : 60000;
-    this.client = new SpacesClient({ baseUrl: this.url, token });
+    // A personal bot never shows Spaces its own key: anything that still goes
+    // through this channel while it is idle (a reply, an approval mirror, a
+    // task title) carries a pass for its owner (core/app-pass.js). Other bots
+    // keep the key, as before.
+    this.client = new SpacesClient({ baseUrl: this.url, token: () => spacesBearer(token) });
     this._listeners = { message: new Set(), action: new Set() };
     this._socket = null;
     this._seen = new Set(); // notification-id dedup across socket + poll
@@ -79,6 +92,17 @@ class SpacesAdapter {
   }
 
   async start() {
+    // A personal bot acts in Spaces only as its owner, through a pass
+    // (core/app-pass.js), so it has no Spaces identity of its own to watch or
+    // reply as. It watches its owner's Spaces inbox through the connected-apps
+    // plane instead, and the conversational channel stays idle.
+    try {
+      if (require("../../core/bot-profile").isPersonal()) {
+        this.idleReason = "personal-bot";
+        console.log("Spaces channel idle: a personal bot acts in Spaces only as its owner, through a pass");
+        return;
+      }
+    } catch (_) { /* no profile: behave as before */ }
     this._socket = createSpacesSocket({
       url: this.url,
       token: this.token,

package/channels/spaces/client.js

@@ -222,13 +222,17 @@ function buildCommentContent(text, mentions = []) {
 }
 
 class SpacesClient {
+  // `token` is the bearer, or a function that returns it (sync or async): a
+  // personal bot passes core/app-pass's provider, so every call goes out with
+  // a fresh pass for its owner and never with the bot's own key.
   constructor({ baseUrl = "https://api.spaces.kazee.africa", token }) {
     this.baseUrl = baseUrl.replace(/\/$/, "");
     this.token = token;
   }
 
-  _get(urlPath, timeoutMs) { return request(this.baseUrl, this.token, "GET", urlPath, null, timeoutMs); }
-  _post(urlPath, body, timeoutMs) { return request(this.baseUrl, this.token, "POST", urlPath, body, timeoutMs); }
+  async _bearer() { return typeof this.token === "function" ? this.token() : this.token; }
+  async _get(urlPath, timeoutMs) { return request(this.baseUrl, await this._bearer(), "GET", urlPath, null, timeoutMs); }
+  async _post(urlPath, body, timeoutMs) { return request(this.baseUrl, await this._bearer(), "POST", urlPath, body, timeoutMs); }
 
   async listTasks() {
     const res = await this._get("/api/tasks");

package/channels/telegram/adapter.js

@@ -6,6 +6,7 @@
 const fs = require("fs");
 const path = require("path");
 const https = require("https");
+const TelegramBot = require("node-telegram-bot-api");
 const { TEMP_DIR, FILES_DIR, CONFIG_DIR } = require("../../core/config");
 const { safeJoin } = require("../../core/safe-filename");
 const { canonicalForChannel } = require("../../core/identity");
@@ -26,8 +27,6 @@ class TelegramAdapter {
     // one bot) sidesteps the stale-socket trap that drove the old restart storm.
     // We still own the agent so a heal can destroy any lingering socket.
     this._agent = new https.Agent({ keepAlive: false });
-    // Loaded here so a bot with no Telegram token never holds this library.
-    const TelegramBot = require("node-telegram-bot-api");
     this.bot = new TelegramBot(token, {
       polling: { autoStart: false, params: { timeout: 30 } },
       // Socket-idle timeout on every request (getUpdates included). With

package/channels/web/adapter.js

@@ -23,6 +23,20 @@ const HISTORY_LIMIT = 200;
 const MEDIA_TTL_MS = 60 * 60 * 1000;
 
 const WEB_OWNER_ID = "web-owner";
+// A personal bot's dashboard session that names nobody (password login,
+// Agent Space's link): not its owner.
+const WEB_GUEST_ID = "web-guest";
+
+// Who a dashboard message is from. An autonomous bot's dashboard is its
+// owner's channel. A personal bot has one owner, Central's: the session
+// names the person it was opened for (her /dashboard link), else a guest,
+// and access.js decides whether that is the owner.
+function webSpeaker(sessionUserId) {
+  let personal = false;
+  try { personal = require("../../core/bot-profile").isPersonal(); } catch (e) {}
+  if (!personal) return WEB_OWNER_ID;
+  return sessionUserId ? String(sessionUserId) : WEB_GUEST_ID;
+}
 
 class WebAdapter {
   constructor({ id = "web" } = {}) {
@@ -64,38 +78,40 @@ class WebAdapter {
 
   // ── inbound (called by web.js /api/chat routes) ─────────────────
 
-  postText(text) {
+  postText(text, { userId } = {}) {
     const body = String(text || "");
     if (!body.trim()) return null;
+    const speaker = webSpeaker(userId);
     const messageId = this._mkId("t");
     // Echo into history/stream so every connected tab sees the user's turn.
     this._pushFrame({ kind: "message", role: "user", messageId, text: body, ts: Date.now() });
     this._emit("message", {
       adapter: this,
-      channelId: this.channelId,
-      canonicalUserId: canonicalForChannel("web", this.channelId),
-      userId: this.ownerUserId,
+      channelId: speaker,
+      canonicalUserId: canonicalForChannel("web", speaker),
+      userId: speaker,
       type: body.trim().startsWith("/") ? "command" : "text",
       text: body,
       messageId,
-      from: { id: this.ownerUserId, name: "Owner", username: "" },
+      from: { id: speaker, name: speaker === WEB_OWNER_ID ? "Owner" : "", username: "" },
       raw: { source: "web" },
     });
     return messageId;
   }
 
-  postAction({ id, payload, messageId } = {}) {
+  postAction({ id, payload, messageId } = {}, { userId } = {}) {
     const p = String(payload != null ? payload : (id != null ? id : ""));
     if (!p) return null;
+    const speaker = webSpeaker(userId);
     const callbackId = this._mkId("cb");
     this._emit("action", {
       adapter: this,
-      channelId: this.channelId,
-      canonicalUserId: canonicalForChannel("web", this.channelId),
-      userId: this.ownerUserId,
+      channelId: speaker,
+      canonicalUserId: canonicalForChannel("web", speaker),
+      userId: speaker,
       type: "action",
       messageId,
-      from: { id: this.ownerUserId, name: "Owner", username: "" },
+      from: { id: speaker, name: speaker === WEB_OWNER_ID ? "Owner" : "", username: "" },
       action: {
         buttonId: String(id != null ? id : p),
         payload: p,
@@ -260,4 +276,4 @@ class WebAdapter {
   }
 }
 
-module.exports = { WebAdapter, WEB_OWNER_ID };
+module.exports = { WebAdapter, WEB_OWNER_ID, WEB_GUEST_ID };

package/core/access.js

@@ -14,6 +14,14 @@ const { atomicWriteFileSync, readJsonWithFallback, withFileLock } = require("./f
 // owner is identified by the Kazee user id. Resolve via env at call time so
 // /channel add can update the value without a process restart.
 function transportOwnerUserId(transport) {
+  // A personal bot's dashboard and voice bridge are ways to reach its one
+  // owner (Central's), not owners of their own: they count only when they
+  // name her.
+  const personalOwner = personalBotOwner();
+  if (personalOwner !== null && (transport === "web" || transport === "voice")) {
+    if (transport === "web") return personalOwner;
+    return String(config.VOICE_OWNER_USER_ID || "") === personalOwner ? personalOwner : "";
+  }
   if (transport === "kazee") return config.KAZEE_OWNER_USER_ID || "";
   // Spaces actors are central/Kazee user ids, so the owner carries the same id
   // there. Without this the owner's own task comments authorize as a stranger
@@ -29,6 +37,16 @@ function transportOwnerUserId(transport) {
   return "";
 }
 
+// Central's owner of a personal bot ("" when not yet known), or null for an
+// autonomous bot.
+function personalBotOwner() {
+  try {
+    const botProfile = require("./bot-profile");
+    if (botProfile.isPersonal()) return botProfile.ownerUserId();
+  } catch (e) {}
+  return null;
+}
+
 function matchesTransportOwner() {
   const transport = currentTransport();
   const userId = currentUserId();
@@ -109,6 +127,13 @@ function isChatAuthorized(chatId, envelope) {
 // member of that group to owner.
 function isChatOwner(chatId) {
   if (matchesTransportOwner()) return true;
+  // A personal bot has exactly one owner, the person in Central
+  // (core/bot-profile.js, applied to KAZEE_OWNER_USER_ID). The second-owner
+  // setup — people records, auth.json or chat ids marked owner — does not
+  // apply: admins look after the bot through Agent Space and Central.
+  try {
+    if (require("./bot-profile").isPersonal()) return false;
+  } catch (e) {}
   const inGroup = currentIsGroup();
   const speakerId = String(currentUserId() || "");
   // In a group only the speaker counts; in a DM the passed chat id is the

package/core/app-pass.js

@@ -0,0 +1,145 @@
+// One pass helper for every app call (plan v2 "personal bots act for their
+// owner", 25 Oct).
+//
+// A personal bot never hands its own key (KAZEE_BOT_TOKEN) to an app. For each
+// app it trades the key for a 10-minute pass at Central (POST /api/bots/pass),
+// reuses it until just before it runs out, then gets a new one. The pass acts
+// as its owner: the app sees "Cynthia, via smart-cynthia" with the AI mark.
+// An autonomous bot, or one whose Central has no bot:me yet, keeps using its
+// own key, unchanged.
+//
+// A refused pass throws PassRefused with a plain message telling the owner how
+// to switch it on; the owner hears it at most once a day per app and reason
+// (bot.js sends it as a one-tap card, core/owner-setup.js).
+//
+// Parent process only, like the key itself (a CONFINED secret never passed to
+// a provider or tool subprocess).
+
+const botProfile = require("./bot-profile");
+
+// Get a new pass this long before the old one runs out.
+const RENEW_BEFORE_MS = 60 * 1000;
+const TELL_OWNER_EVERY_MS = 24 * 60 * 60 * 1000;
+
+// Central's Application.name -> what the owner calls it.
+const APP_LABELS = {
+  "kazee-spaces-backend": "Spaces",
+  "kazee-crm": "CRM",
+  crm: "CRM",
+  Ticket_Central: "Tickets",
+  "agent-space-backend": "Agent Space",
+  "kazee-infrastructure": "Infrastructure",
+};
+
+const passes = new Map();   // applicationName -> { token, expiresAt }
+const inflight = new Map(); // applicationName -> Promise<string>
+const told = new Map();     // `${app}:${reason}` -> last told at
+let ownerNotifier = null;
+
+class PassRefused extends Error {
+  constructor(applicationName, reason, ownerMessage, status) {
+    super(`Central refused a pass for ${applicationName}: ${reason}`);
+    this.applicationName = applicationName;
+    this.reason = reason;
+    this.ownerMessage = ownerMessage;
+    this.status = status;
+  }
+}
+
+function appLabel(applicationName) {
+  return APP_LABELS[applicationName] || applicationName;
+}
+
+// What the owner reads when Central refuses a pass.
+function ownerHelp(reason, applicationName) {
+  const first = botProfile.ownerFirstName();
+  const app = appLabel(applicationName);
+  const where = botProfile.MY_ASSISTANTS;
+  switch (reason) {
+    case "consent-off":
+      return `${first}, my permission to act for you is switched off, so I can't work in ${app} for you. To switch it back on: ${where}, tap Let it act for me and tick ${app}.`;
+    case "consent-ended":
+      return `${first}, your permission for me to act for you has ended, so I can't work in ${app}. Renew it with one tap in ${where}.`;
+    case "app-not-ticked":
+      return `${first}, you haven't let me act for you in ${app}. To allow it: ${where}, and tick ${app}.`;
+    case "owner-no-access":
+      return `${first}, your own account can't use ${app} right now, so I can't either. Ask your admin for access.`;
+    case "owner-inactive":
+      return `I can't act in ${app}: Central says my owner's account is not active.`;
+    case "bot-disabled":
+      return `I can't act in ${app}: an admin has switched me off in Central.`;
+    case "consent-none":
+    default:
+      return `${first}, I can't work in ${app} for you yet. To let me act for you: open ${where}, tap Let it act for me and tick ${app}.`;
+  }
+}
+
+function setOwnerNotifier(fn) {
+  ownerNotifier = typeof fn === "function" ? fn : null;
+}
+
+async function tellOwnerOnce(err, now) {
+  if (!ownerNotifier) return;
+  const key = `${err.applicationName}:${err.reason}`;
+  const last = told.get(key) || 0;
+  if (now - last < TELL_OWNER_EVERY_MS) return;
+  told.set(key, now);
+  try { await ownerNotifier(err.ownerMessage, err); }
+  catch (e) { console.error("app-pass: could not tell the owner:", e.message); }
+}
+
+async function fetchPass(applicationName, request, now) {
+  const token = botProfile.botToken();
+  if (!token) throw new Error("KAZEE_BOT_TOKEN unset");
+  const res = await request("POST", "/api/bots/pass", token, { applicationName });
+  const body = (res && res.body) || {};
+  if (res && (res.status === 200 || res.status === 201) && typeof body.pass === "string" && body.pass.startsWith("kzp_")) {
+    const expiresAt = Date.parse(body.expiresAt);
+    passes.set(applicationName, { token: body.pass, expiresAt: Number.isFinite(expiresAt) ? expiresAt : now() + 9 * 60 * 1000 });
+    return body.pass;
+  }
+  const reason = body.reason || (res && res.status === 401 ? "bot-key-invalid" : `http-${res && res.status}`);
+  const err = new PassRefused(applicationName, reason, ownerHelp(reason, applicationName), res && res.status);
+  await tellOwnerOnce(err, now());
+  throw err;
+}
+
+// The token to present at `applicationName`: a pass for a personal bot, the
+// bot's own key otherwise.
+async function tokenFor(applicationName, { request = botProfile.centralRequest, now = Date.now } = {}) {
+  if (!botProfile.isPersonal()) return botProfile.botToken();
+  const held = passes.get(applicationName);
+  if (held && held.expiresAt - now() > RENEW_BEFORE_MS) return held.token;
+  if (inflight.has(applicationName)) return inflight.get(applicationName);
+  const p = fetchPass(applicationName, request, now).finally(() => inflight.delete(applicationName));
+  inflight.set(applicationName, p);
+  return p;
+}
+
+// A token getter for clients that take one (channels/spaces/client.js).
+function provider(applicationName, opts) {
+  return () => tokenFor(applicationName, opts);
+}
+
+// Drop a held pass (an app answered 401 to it).
+function invalidate(applicationName) {
+  passes.delete(applicationName);
+}
+
+function reset() {
+  passes.clear();
+  inflight.clear();
+  told.clear();
+}
+
+module.exports = {
+  tokenFor,
+  provider,
+  invalidate,
+  reset,
+  setOwnerNotifier,
+  ownerHelp,
+  appLabel,
+  PassRefused,
+  RENEW_BEFORE_MS,
+};