@inetafrica/open-claudia 2.13.0 → 2.13.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v2.13.1
+- **Guardrail no longer mistakes the owner for an external speaker on `/link`'d or env-unified channels (Phase 3 fix).** v2.13.0's relationship classifier resolved ownership through `people.findByHandle` alone — the handles physically listed on the owner's person record — while the queue/state/run-lock resolve it through `identity.canonicalForChannel`, which also honours explicit `/link`s (`identities.json`) and the configured-owner env path. A channel the owner had unified by `/link` or env-config (e.g. a second Kazee handle) was therefore *owner* to the run-lock (shared queue → "Queued.") but *external* to the guardrail (default-deny → the stranger reply), so the bot could greet its own owner as a limited-access outsider. The classifier now resolves ownership through **canonical identity — the same source of truth the rest of the bot uses**: a channel is the owner's when it resolves to the owner canonical **or** its person record is `isOwner`. New `identity.channelIsOwner()`; `relationship.speakerFor` consults it before default-deny. Every guard consumer (external-mode system-prompt block, `io`/`loopback` egress gates, runner turn-guard, CLI guards) funnels through this one function, so the fix lands everywhere at once.
+- **R1 preserved — a note still can never confer owner.** `channelIsOwner` is driven only by the canonical map, which is written **exclusively by owner/operator actions** (`/link`, `.env`), never by a note; and the owner stays anchored to a real owner record via `ownerCanonical → people.isOwner`. The default-deny posture for genuinely external or unmapped channels is unchanged.
+- **Tests.** `test-relationship.js` gains a regression reproducing the exact production bug — an owner Kazee channel `/link`'d to the owner canonical but **absent from the people record** now resolves to `owner` (unguarded), while an unmapped channel on the same transport stays `external` (guarded), proving the fix does not widen access. Full `npm test` green.
+- **Agent-space / OpenClaw:** no new deps, no new env, no schema change; Docker image builds identically. Purely a correctness fix to owner recognition — inert for deployments that never hit the split-brain.
+
 ## v2.13.0
 - **The independent relationship guardrail is now LIVE — an owned bot is finally safe to point at external people (Phase 3).** Phases 0–2 unified the bot's identity across channels and taught it WHO it's talking to; this phase adds the missing half: hard limits on what it may do or say when that person is **not** the owner. Everything is a strict **no-op for the owner and for no-context callers** (CLI/cron/tests) — the owner reply/tool/file paths stay **byte-for-byte unchanged** (risk R9/R14), so this is inert on every existing single-owner deployment until an external channel is actually `/auth`'d. Classification lives in `core/relationship.js` and is **cheap, synchronous, and never derived from message text**: the owner is owner **only** via `people.isOwner`; a non-owner whose note claims relationship `owner` is coerced to `external` (**R1 — a note can never confer owner powers**); every unclassified or unmapped authed non-owner defaults to `external` (**default-deny**).
 - **Owner-authored mandate, set from chat (3.1).** `entity persona <name> --relationship|--role|--style|--knows|--mandate` lets the owner declare, per person, the ONLY things the bot is cleared to do or discuss with them. The verb is **owner-gated** (an external speaker can never edit their own mandate — self-escalation is refused) and each flag replaces its section wholesale.

package/core/identity.js

@@ -69,6 +69,23 @@ function ownerCanonical() {
   return "";
 }
 
+// True when a channel resolves to the owner's canonical identity — the shared
+// source of truth the queue/state/run-lock already uses. The relationship
+// guardrail leans on this so the owner is recognised on EVERY channel they've
+// unified: a people-record handle, an explicit /link (identities.json), or the
+// configured-owner env path. Resolving ownership through the people-record
+// handle list alone is too narrow — a channel unified by /link or env-config is
+// never mirrored onto the record, so the owner would be falsely classed
+// external there. The canonical map is only ever written by owner/operator
+// actions, so this can never let a note confer owner (R1 preserved — a note
+// touches neither identities.json nor .env).
+function channelIsOwner(transport, channelId) {
+  const canonical = normalizeCanonicalUserId(canonicalForChannel(transport, channelId));
+  if (!canonical) return false;
+  const owner = normalizeCanonicalUserId(ownerCanonical());
+  return !!owner && canonical === owner;
+}
+
 function canonicalForChannel(transport, channelId) {
   const key = channelKey(transport, channelId);
   const explicit = normalizeCanonicalUserId(identities.channels[key]);
@@ -127,6 +144,7 @@ module.exports = {
   defaultCanonicalForChannel,
   isConfiguredOwnerChannel,
   ownerCanonical,
+  channelIsOwner,
   canonicalForChannel,
   canonicalForTelegram,
   canonicalForStoredUserKey,

package/core/relationship.js

@@ -18,18 +18,37 @@ function speakerFor(adapterType, channelId) {
     if (!adapterType || !channelId) return null;
     const people = require("./people");
     const person = people.findByHandle(adapterType, channelId);
-    if (!person) {
-      // Authed but not mapped to a person record → treat as external.
+
+    // Ownership is resolved through canonical identity — the SAME source of
+    // truth the queue/state/run-lock uses — so the owner is recognised on every
+    // channel they've unified (a people handle, an explicit /link, or the
+    // configured-owner env path), not just channels physically mirrored onto
+    // the people record. Consulting only findByHandle is too narrow: a channel
+    // unified by /link or env-config is never written back to the record, so the
+    // owner would be falsely classed external there. channelIsOwner is driven
+    // only by owner/operator-written identity links (identities.json / .env), so
+    // a note can never trip it (R1 preserved — the owner stays anchored to a
+    // real owner record via ownerCanonical → people.isOwner).
+    let ownerByCanonical = false;
+    try { ownerByCanonical = require("./identity").channelIsOwner(adapterType, channelId); } catch (e) {}
+
+    if (ownerByCanonical || (person && person.isOwner)) {
+      let ownerPerson = person && person.isOwner ? person : null;
+      if (!ownerPerson) { try { ownerPerson = (people.owners() || [])[0] || null; } catch (e) {} }
+      const name = ownerPerson ? ownerPerson.name : (person ? person.name : "");
       return {
-        person: null, name: "", isOwner: false, relationship: "external",
-        slug: null, mandate: "", style: "", entityName: "",
+        person: ownerPerson || person || null, name, isOwner: true, relationship: "owner",
+        slug: null, mandate: "", style: "", entityName: name,
         adapterType: String(adapterType), channelId: String(channelId),
       };
     }
-    if (person.isOwner) {
+
+    if (!person) {
+      // Authed but not mapped to a person record and not an owner-canonical
+      // channel → treat as external (default-deny).
       return {
-        person, name: person.name, isOwner: true, relationship: "owner",
-        slug: null, mandate: "", style: "", entityName: person.name,
+        person: null, name: "", isOwner: false, relationship: "external",
+        slug: null, mandate: "", style: "", entityName: "",
         adapterType: String(adapterType), channelId: String(channelId),
       };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.13.0",
+  "version": "2.13.1",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {

package/test-relationship.js

@@ -119,4 +119,28 @@ assert.ok(target, "ownerTarget resolves an owner handle");
 assert.strictEqual(target.adapter, "telegram", "ownerTarget adapter");
 assert.strictEqual(target.channelId, CH_OWNER_ALT, "ownerTarget picks the primary channel, not the first");
 
+// ── split-brain fix: an owner channel unified via /link (identities.json) but
+// NEVER mirrored onto the people record must STILL resolve to the owner. This
+// is the production bug — a Kazee handle /link'd to the owner's canonical id was
+// invisible to people.findByHandle, so the guardrail falsely treated the owner
+// as an external speaker. Ownership now flows through canonical identity. ──
+const identity = require("./core/identity");
+const ownerCanon = identity.ownerCanonical();
+assert.ok(ownerCanon, "owner has a canonical id");
+identity.setIdentityMapping("kazee", "owner-linked-kazee", ownerCanon);
+assert.strictEqual(people.findByHandle("kazee", "owner-linked-kazee"), null,
+  "precondition: the /link'd kazee channel is absent from the people record");
+const linkedSp = relationship.speakerFor("kazee", "owner-linked-kazee");
+assert.strictEqual(linkedSp.isOwner, true, "owner-canonical channel → owner even without a people handle");
+assert.strictEqual(linkedSp.relationship, "owner", "owner-canonical channel relationship");
+assert.strictEqual(linkedSp.mandate, "", "owner never carries a mandate");
+assert.strictEqual(relationship.guardActive(linkedSp), false, "owner-canonical channel is never guarded");
+
+// ── and the fix must NOT widen: an unmapped channel on the same transport that
+// does not resolve to the owner canonical stays external + guarded. ──
+const strayKazee = relationship.speakerFor("kazee", "some-stranger-999");
+assert.strictEqual(strayKazee.isOwner, false, "unmapped kazee channel is not owner");
+assert.strictEqual(strayKazee.relationship, "external", "unmapped kazee channel → external");
+assert.strictEqual(relationship.guardActive(strayKazee), true, "unmapped kazee channel stays guarded");
+
 console.log("relationship OK");