From 826e8ad8e6c6981b660a70e7c64f7474c992fe6a Mon Sep 17 00:00:00 2001
From: Data <data.bot@coasys.org>
Date: Tue, 21 Apr 2026 22:09:33 +0200
Subject: [PATCH 1/8] feat: update push notification URL and add call
 notifications

Update webhook URL from http://push-notifications.ad4m.dev:13000 to
https://push.ad4m.dev. Add a second notification trigger for detecting
when someone starts a call in any neighbourhood, so users get push
notifications for calls in addition to @-mentions.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/src/utils/registerMobileNotifications.ts | 61 ++++++++++++++++----
 packages/api/src/createCommunity.ts          |  6 +-
 packages/api/src/joinCommunity.ts            | 19 +++---
 3 files changed, 62 insertions(+), 24 deletions(-)

diff --git a/app/src/utils/registerMobileNotifications.ts b/app/src/utils/registerMobileNotifications.ts
index e9c056ade..95767214e 100644
--- a/app/src/utils/registerMobileNotifications.ts
+++ b/app/src/utils/registerMobileNotifications.ts
@@ -4,11 +4,13 @@ import { ActionPerformed, PushNotificationSchema, PushNotifications, Token } fro
 import { Ad4mClient } from '@coasys/ad4m';
 
 const APP_NAME = 'Flux';
-const DESCRIPTION = 'Mobile push notifications for @-mentions';
-function notificationConfig(perspectiveIds: string[], webhookAuth: string, agentDid: string) {
+const WEBHOOK_URL = 'https://push.ad4m.dev/notification';
+
+const MENTION_DESCRIPTION = 'Mobile push notifications for @-mentions';
+function mentionNotificationConfig(perspectiveIds: string[], webhookAuth: string, agentDid: string) {
   return {
     appName: APP_NAME,
-    description: DESCRIPTION,
+    description: MENTION_DESCRIPTION,
     appUrl: window.location.origin,
     appIconPath: window.location.origin + '/icon.png',
     trigger: `SELECT ?source ?predicate ?target WHERE {
@@ -20,7 +22,26 @@ function notificationConfig(perspectiveIds: string[], webhookAuth: string, agent
       ))
     }`,
     perspectiveIds,
-    webhookUrl: 'http://push-notifications.ad4m.dev:13000/notification',
+    webhookUrl: WEBHOOK_URL,
+    webhookAuth,
+  };
+}
+
+const CALL_DESCRIPTION = 'Mobile push notifications for calls';
+function callNotificationConfig(perspectiveIds: string[], webhookAuth: string, agentDid: string) {
+  return {
+    appName: APP_NAME,
+    description: CALL_DESCRIPTION,
+    appUrl: window.location.origin,
+    appIconPath: window.location.origin + '/icon.png',
+    trigger: `SELECT ?source ?predicate ?target WHERE {
+      GRAPH ?g { ?source ?predicate ?target . }
+      FILTER(?predicate = <agent/new-state>)
+      FILTER(CONTAINS(STR(?source), '"inCall":true'))
+      FILTER(!CONTAINS(STR(?source), '"${agentDid}"'))
+    }`,
+    perspectiveIds,
+    webhookUrl: WEBHOOK_URL,
     webhookAuth,
   };
 }
@@ -71,24 +92,40 @@ export async function registerNotification(client: Ad4mClient) {
     });
   }
 
+  const agentStatus = await client.agent.status();
+  const agentDid = agentStatus.did!;
+
   let notifications = await client.runtime.notifications();
-  let foundNotifications = notifications.filter(
+
+  await ensureNotification(client, notifications, MENTION_DESCRIPTION, perspectiveIds, webhookAuth, agentDid, mentionNotificationConfig);
+  await ensureNotification(client, notifications, CALL_DESCRIPTION, perspectiveIds, webhookAuth, agentDid, callNotificationConfig);
+}
+
+async function ensureNotification(
+  client: Ad4mClient,
+  notifications: any[],
+  description: string,
+  perspectiveIds: string[],
+  webhookAuth: string,
+  agentDid: string,
+  configFn: (perspectiveIds: string[], webhookAuth: string, agentDid: string) => any,
+) {
+  let found = notifications.filter(
     (n) =>
       n.appName == APP_NAME &&
-      n.description == DESCRIPTION &&
+      n.description == description &&
       perspectiveIds.every((p) => n.perspectiveIds.includes(p)) &&
       n.granted &&
       n.webhookAuth == webhookAuth,
   );
 
-  if (foundNotifications.length > 1) {
-    for (let i = 1; i < foundNotifications.length; i++) {
-      await client.runtime.removeNotification(foundNotifications[i].id);
+  if (found.length > 1) {
+    for (let i = 1; i < found.length; i++) {
+      await client.runtime.removeNotification(found[i].id);
     }
   }
 
-  if (foundNotifications.length == 0) {
-    const agentStatus = await client.agent.status();
-    await client.runtime.requestInstallNotification(notificationConfig(perspectiveIds, webhookAuth, agentStatus.did!));
+  if (found.length == 0) {
+    await client.runtime.requestInstallNotification(configFn(perspectiveIds, webhookAuth, agentDid));
   }
 }
diff --git a/packages/api/src/createCommunity.ts b/packages/api/src/createCommunity.ts
index e4138dd0d..d2cb56799 100644
--- a/packages/api/src/createCommunity.ts
+++ b/packages/api/src/createCommunity.ts
@@ -93,10 +93,10 @@ export default async function createCommunity({
       }),
     });
 
-    // Update notifications to include the new community
+    // Update all Flux notifications to include the new community
     const notifications = await client.runtime.notifications();
-    const notification = notifications.find((n) => n.appName === 'Flux');
-    if (notification) {
+    const fluxNotifications = notifications.filter((n) => n.appName === 'Flux');
+    for (const notification of fluxNotifications) {
       const notificationId = notification.id;
       notification.granted = undefined;
       notification.id = undefined;
diff --git a/packages/api/src/joinCommunity.ts b/packages/api/src/joinCommunity.ts
index a1605d839..c3c5cd490 100644
--- a/packages/api/src/joinCommunity.ts
+++ b/packages/api/src/joinCommunity.ts
@@ -27,17 +27,18 @@ export default async ({ joiningLink, client }: Payload): Promise<Community> => {
     await client.perspective.update(perspective.uuid, neighbourhoodMeta.name);
 
     const notifications = await client.runtime.notifications();
+    const fluxNotifications = notifications.filter((n) => n.appName === 'Flux');
 
-    const notification = notifications.find((notification) => notification.appName === 'Flux');
+    for (const notification of fluxNotifications) {
+      const notificationId = notification.id;
+      delete notification.granted;
+      delete notification.id;
 
-    const notificationId = notification.id;
-    delete notification.granted;
-    delete notification.id;
-
-    await client.runtime.updateNotification(notificationId, {
-      ...notification,
-      perspectiveIds: [...notification.perspectiveIds, perspective.uuid],
-    });
+      await client.runtime.updateNotification(notificationId, {
+        ...notification,
+        perspectiveIds: [...(notification.perspectiveIds || []), perspective.uuid],
+      });
+    }
 
     return {
       uuid: perspective!.uuid,

From e4d4bb7128192601adad2033e3c4ee9cda18d5cd Mon Sep 17 00:00:00 2001
From: Data <data.bot@coasys.org>
Date: Tue, 21 Apr 2026 23:10:38 +0200
Subject: [PATCH 2/8] feat: add call invite button with flux://call_invite
 links

- Add InviteToCallPopover with "Invite All" + member dropdown
- Send call invites as AD4M links: source=channel, predicate=flux://call_invite, target=DID
- Broadcast signal for real-time notification + persist link for push notifications
- Handle incoming invites: show toast + auto-open call window
- Register push notification trigger for flux://call_invite

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../call/controls/InviteToCallPopover.vue     | 165 ++++++++++++++++++
 .../call/controls/MainCallControls.vue        |   3 +
 app/src/composables/useSignallingService.ts   |  16 +-
 app/src/stores/webrtcStore.ts                 |  33 +++-
 app/src/utils/registerMobileNotifications.ts  |  19 ++
 5 files changed, 233 insertions(+), 3 deletions(-)
 create mode 100644 app/src/components/call/controls/InviteToCallPopover.vue

diff --git a/app/src/components/call/controls/InviteToCallPopover.vue b/app/src/components/call/controls/InviteToCallPopover.vue
new file mode 100644
index 000000000..67e81450f
--- /dev/null
+++ b/app/src/components/call/controls/InviteToCallPopover.vue
@@ -0,0 +1,165 @@
+<template>
+  <j-popover ref="popover" placement="top">
+    <j-tooltip slot="trigger" placement="top" title="Invite to call">
+      <j-button variant="transparent" square circle :size="isMobile ? 'md' : 'lg'">
+        <j-icon name="person-plus" :size="isMobile ? 'sm' : 'md'" />
+      </j-button>
+    </j-tooltip>
+
+    <div slot="content" class="invite-popover">
+      <j-flex direction="column" gap="400">
+        <j-text nomargin variant="heading-sm" size="400">Invite to call</j-text>
+
+        <j-input
+          size="sm"
+          placeholder="Search members..."
+          type="search"
+          :value="searchInput"
+          @input="(e: any) => (searchInput = e.target.value)"
+        >
+          <j-icon name="search" size="xs" slot="start" />
+        </j-input>
+
+        <div class="member-list">
+          <label
+            v-for="member in filteredMembers"
+            :key="member.did"
+            class="member-row"
+            :class="{ selected: selectedDids.has(member.did!) }"
+            @click="() => member.did && toggleMember(member.did)"
+          >
+            <j-avatar size="sm" :did="member.did" :hash="member.did" :src="member.profileThumbnailPicture" />
+            <j-text nomargin size="400" style="flex: 1">
+              {{ member.username || 'Loading...' }}
+            </j-text>
+            <j-icon
+              v-if="selectedDids.has(member.did!)"
+              name="check-circle-fill"
+              color="primary-500"
+              size="sm"
+            />
+          </label>
+
+          <j-text v-if="!filteredMembers.length" nomargin size="400" color="ui-400" style="text-align: center; padding: 8px">
+            {{ searchInput ? 'No members found' : 'No members to invite' }}
+          </j-text>
+        </div>
+
+        <j-flex gap="300">
+          <j-button size="sm" variant="primary" :disabled="!selectedDids.size" @click="sendInvites">
+            <j-icon name="telephone-plus" size="xs" style="margin-right: 4px" />
+            Invite {{ selectedDids.size ? `(${selectedDids.size})` : '' }}
+          </j-button>
+          <j-button size="sm" @click="inviteAll" :disabled="!invitableMembers.length">
+            Invite all
+          </j-button>
+        </j-flex>
+      </j-flex>
+    </div>
+  </j-popover>
+</template>
+
+<script setup lang="ts">
+import { useCommunityService } from '@/composables/useCommunityService';
+import { useAppStore, useWebrtcStore } from '@/stores';
+import { useUiStore } from '@/stores';
+import { storeToRefs } from 'pinia';
+import { computed, ref, watch } from 'vue';
+
+const appStore = useAppStore();
+const webrtcStore = useWebrtcStore();
+const uiStore = useUiStore();
+
+const { me } = storeToRefs(appStore);
+const { agentsInCall } = storeToRefs(webrtcStore);
+const { isMobile } = storeToRefs(uiStore);
+const { members, getMembers } = useCommunityService();
+
+const popover = ref<HTMLElement | null>(null);
+const searchInput = ref('');
+const selectedDids = ref<Set<string>>(new Set());
+
+// Members who are not already in the call and not the current user
+const invitableMembers = computed(() =>
+  members.value.filter((m) => {
+    if (!m.did || m.did === me.value.did) return false;
+    return !agentsInCall.value.some((a) => a.did === m.did);
+  }),
+);
+
+const filteredMembers = computed(() => {
+  if (!searchInput.value) return invitableMembers.value;
+  const q = searchInput.value.toLowerCase();
+  return invitableMembers.value.filter((m) => {
+    const fields = [m.username, m.givenName, m.familyName].filter(Boolean);
+    return fields.some((f) => f?.toLowerCase().includes(q));
+  });
+});
+
+function toggleMember(did: string) {
+  const next = new Set(selectedDids.value);
+  if (next.has(did)) next.delete(did);
+  else next.add(did);
+  selectedDids.value = next;
+}
+
+function sendInvites() {
+  if (!selectedDids.value.size) return;
+  webrtcStore.sendCallInvite([...selectedDids.value]);
+  selectedDids.value = new Set();
+  popover.value?.removeAttribute('open');
+}
+
+function inviteAll() {
+  const dids = invitableMembers.value.map((m) => m.did!).filter(Boolean);
+  if (!dids.length) return;
+  webrtcStore.sendCallInvite(dids);
+  popover.value?.removeAttribute('open');
+}
+
+// Refresh members when popover is opened
+watch(
+  () => popover.value?.hasAttribute('open'),
+  (isOpen) => {
+    if (isOpen) {
+      getMembers();
+      selectedDids.value = new Set();
+      searchInput.value = '';
+    }
+  },
+);
+</script>
+
+<style scoped lang="scss">
+.invite-popover {
+  padding: var(--j-space-400);
+  min-width: 240px;
+  max-width: 300px;
+}
+
+.member-list {
+  max-height: 200px;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: var(--j-space-200);
+}
+
+.member-row {
+  display: flex;
+  align-items: center;
+  gap: var(--j-space-300);
+  padding: var(--j-space-200) var(--j-space-300);
+  border-radius: var(--j-border-radius);
+  cursor: pointer;
+  transition: background-color 0.15s;
+
+  &:hover {
+    background-color: var(--j-color-ui-100);
+  }
+
+  &.selected {
+    background-color: var(--j-color-primary-50);
+  }
+}
+</style>
diff --git a/app/src/components/call/controls/MainCallControls.vue b/app/src/components/call/controls/MainCallControls.vue
index c4e332382..d7c464427 100644
--- a/app/src/components/call/controls/MainCallControls.vue
+++ b/app/src/components/call/controls/MainCallControls.vue
@@ -92,6 +92,8 @@
       </j-menu>
     </j-popover>
 
+    <InviteToCallPopover v-if="!isMobile" />
+
     <j-tooltip placement="top" :title="hasCopiedLink ? 'Copied!' : 'Copy invite link'">
       <j-button @click="webrtcStore.copyCallLink" square circle :size="isMobile ? 'md' : 'lg'">
         <j-icon
@@ -131,6 +133,7 @@
 </template>
 
 <script setup lang="ts">
+import InviteToCallPopover from './InviteToCallPopover.vue';
 import TranscriptionIcon from '@/components/icons/TranscriptionIcon.vue';
 import {
   useAiStore,
diff --git a/app/src/composables/useSignallingService.ts b/app/src/composables/useSignallingService.ts
index 2c827b3ce..625eab9c0 100644
--- a/app/src/composables/useSignallingService.ts
+++ b/app/src/composables/useSignallingService.ts
@@ -1,4 +1,4 @@
-import { useAiStore, useAppStore, useMediaDevicesStore, useRouteMemoryStore, useWebrtcStore } from '@/stores';
+import { useAiStore, useAppStore, useMediaDevicesStore, useRouteMemoryStore, useUiStore, useWebrtcStore } from '@/stores';
 import { stripChannelPrefix } from '@/utils/routeUtils';
 import { getCachedAgentProfile } from '@/utils/userProfileCache';
 import { Link, NeighbourhoodProxy, PerspectiveExpression } from '@coasys/ad4m';
@@ -12,6 +12,7 @@ const CLEANUP_INTERVAL = 10000; // 10 seconds between evaluations
 const ASLEEP_THRESHOLD = 30000; // 30 seconds before "asleep"
 const MAX_AGE = 60000; // 60 seconds before "offline"
 const NEW_STATE = 'agent/new-state';
+const CALL_INVITE = 'flux://call_invite';
 
 export function useSignallingService(neighbourhood: NeighbourhoodProxy): SignallingService {
   const tabCoordinator = useTabCoordinator();
@@ -201,6 +202,19 @@ export function useSignallingService(neighbourhood: NeighbourhoodProxy): Signall
     const { author, data } = link;
     const { source, predicate, target } = data;
 
+    // Handle call invites targeted at this agent
+    if (predicate === CALL_INVITE && target === me.value.did && author !== me.value.did) {
+      getCachedAgentProfile(author, appStore.ad4mClient).then((profile) => {
+        const name = profile?.username || author.slice(0, 12);
+        appStore.showSuccessToast({ message: `📞 ${name} invited you to a call` });
+      });
+      // Open the call window so the user can easily join
+      if (!webrtcStore.inCall) {
+        const uiStore = useUiStore();
+        if (!uiStore.callWindowOpen) uiStore.setCallWindowOpen(true);
+      }
+    }
+
     if (predicate === NEW_STATE && link.author !== me.value.did) {
       // If this is their first broadcast, immediately broadcast my state so they dont have to wait for my next heartbeat
       if (target === 'first-broadcast') broadcastState();
diff --git a/app/src/stores/webrtcStore.ts b/app/src/stores/webrtcStore.ts
index 804919865..7cb96f202 100644
--- a/app/src/stores/webrtcStore.ts
+++ b/app/src/stores/webrtcStore.ts
@@ -5,7 +5,7 @@ import popWav from '@/assets/audio/pop.wav';
 import { HEARTBEAT_INTERVAL } from '@/composables/useSignallingService';
 import { useTabCoordinator } from '@/composables/useTabCoordinator';
 import { getCachedAgentProfile } from '@/utils/userProfileCache';
-import { PerspectiveExpression } from '@coasys/ad4m';
+import { Link, PerspectiveExpression } from '@coasys/ad4m';
 import { AgentState, AgentStatus, CallHealth, Profile, RouteParams } from '@coasys/flux-types';
 import { Howl } from 'howler';
 import { defineStore, storeToRefs } from 'pinia';
@@ -18,7 +18,7 @@ import { useMediaDevicesStore } from './mediaDevicesStore';
 import { useUiStore } from './uiStore';
 // @ts-ignore
 import SimplePeer from 'simple-peer/simplepeer.min.js';
-import { restoreNeighbourhoodPrefix } from '@/utils/routeUtils';
+import { restoreChannelPrefix, restoreNeighbourhoodPrefix } from '@/utils/routeUtils';
 
 export const CALL_HEALTH_CHECK_INTERVAL = 6000;
 export const WEBRTC_SIGNAL = 'webrtc/signal';
@@ -26,6 +26,7 @@ export const WEBRTC_STREAM_REQUEST = 'webrtc/stream-request';
 export const WEBRTC_EMOJI = 'webrtc/emoji';
 export const WEBRTC_MEDIA_SETTINGS_CHANGED = 'webrtc/media-settings-changed';
 export const WEBRTC_LEAVING_CALL = 'webrtc/leaving-call';
+export const CALL_INVITE = 'flux://call_invite';
 const MAX_RECONNECTION_ATTEMPTS = 3;
 const defaultIceServers = [
   {
@@ -689,6 +690,33 @@ export const useWebrtcStore = defineStore(
       }
     }
 
+    function sendCallInvite(dids: string[]): void {
+      if (!signallingService.value || !callRoute.value.channelId) return;
+      const channelUrl = restoreChannelPrefix(callRoute.value.channelId);
+      const perspective = communityService.value?.perspective;
+
+      for (const did of dids) {
+        // Broadcast signal for real-time notification (when recipient is online)
+        signallingService.value.sendSignal({
+          source: channelUrl,
+          predicate: CALL_INVITE,
+          target: did,
+        });
+
+        // Persist link for AD4M push notification trigger (when recipient is offline)
+        if (perspective) {
+          perspective
+            .add(new Link({ source: channelUrl, predicate: CALL_INVITE, target: did }))
+            .catch((error) => console.error('Failed to persist call invite link:', error));
+        }
+      }
+
+      const count = dids.length;
+      appStore.showSuccessToast({
+        message: `Call invite sent to ${count} member${count > 1 ? 's' : ''}`,
+      });
+    }
+
     // Close the call window on route param changes if not in a call or a channel
     watch(
       () => route.params,
@@ -812,6 +840,7 @@ export const useWebrtcStore = defineStore(
       signalAgentsInCall,
       displayEmoji,
       copyCallLink,
+      sendCallInvite,
     };
   },
   { persist: false },
diff --git a/app/src/utils/registerMobileNotifications.ts b/app/src/utils/registerMobileNotifications.ts
index 95767214e..4514b3c76 100644
--- a/app/src/utils/registerMobileNotifications.ts
+++ b/app/src/utils/registerMobileNotifications.ts
@@ -46,6 +46,24 @@ function callNotificationConfig(perspectiveIds: string[], webhookAuth: string, a
   };
 }
 
+const CALL_INVITE_DESCRIPTION = 'Mobile push notifications for call invites';
+function callInviteNotificationConfig(perspectiveIds: string[], webhookAuth: string, agentDid: string) {
+  return {
+    appName: APP_NAME,
+    description: CALL_INVITE_DESCRIPTION,
+    appUrl: window.location.origin,
+    appIconPath: window.location.origin + '/icon.png',
+    trigger: `SELECT ?source ?predicate ?target WHERE {
+      GRAPH ?g { ?source ?predicate ?target . }
+      FILTER(?predicate = <flux://call_invite>)
+      FILTER(STR(?target) = "${agentDid}")
+    }`,
+    perspectiveIds,
+    webhookUrl: WEBHOOK_URL,
+    webhookAuth,
+  };
+}
+
 export async function registerNotification(client: Ad4mClient) {
   const perspctives = await client.perspective.all();
   const perspectiveIds = perspctives.map((p) => p.uuid);
@@ -99,6 +117,7 @@ export async function registerNotification(client: Ad4mClient) {
 
   await ensureNotification(client, notifications, MENTION_DESCRIPTION, perspectiveIds, webhookAuth, agentDid, mentionNotificationConfig);
   await ensureNotification(client, notifications, CALL_DESCRIPTION, perspectiveIds, webhookAuth, agentDid, callNotificationConfig);
+  await ensureNotification(client, notifications, CALL_INVITE_DESCRIPTION, perspectiveIds, webhookAuth, agentDid, callInviteNotificationConfig);
 }
 
 async function ensureNotification(

From 214dcf2f7c528bc8f648217418f375216d0a11f0 Mon Sep 17 00:00:00 2001
From: Data <data.bot@coasys.org>
Date: Tue, 21 Apr 2026 23:16:26 +0200
Subject: [PATCH 3/8] =?UTF-8?q?fix:=20address=20CodeRabbit=20review=20?=
 =?UTF-8?q?=E2=80=94=20guard=20perspectiveIds,=20reconcile=20stale=20notif?=
 =?UTF-8?q?ications?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add `|| []` fallback for missing perspectiveIds on stored notifications
- Update ensureNotification to reconcile stale notifications via updateNotification
  instead of creating duplicates (handles changed webhookAuth, perspectiveIds, etc.)
- Remove orphaned duplicates when found

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/src/utils/registerMobileNotifications.ts | 36 +++++++++++++++-----
 1 file changed, 27 insertions(+), 9 deletions(-)

diff --git a/app/src/utils/registerMobileNotifications.ts b/app/src/utils/registerMobileNotifications.ts
index 4514b3c76..95d5d5354 100644
--- a/app/src/utils/registerMobileNotifications.ts
+++ b/app/src/utils/registerMobileNotifications.ts
@@ -129,22 +129,40 @@ async function ensureNotification(
   agentDid: string,
   configFn: (perspectiveIds: string[], webhookAuth: string, agentDid: string) => any,
 ) {
-  let found = notifications.filter(
+  // Find all Flux notifications matching this description
+  const allMatching = notifications.filter((n) => n.appName == APP_NAME && n.description == description);
+
+  // Check if any fully match the current config
+  const fullyMatching = allMatching.filter(
     (n) =>
-      n.appName == APP_NAME &&
-      n.description == description &&
-      perspectiveIds.every((p) => n.perspectiveIds.includes(p)) &&
+      perspectiveIds.every((p) => (n.perspectiveIds || []).includes(p)) &&
       n.granted &&
       n.webhookAuth == webhookAuth,
   );
 
-  if (found.length > 1) {
-    for (let i = 1; i < found.length; i++) {
-      await client.runtime.removeNotification(found[i].id);
+  // Remove duplicates, keeping only the first fully matching one
+  if (fullyMatching.length > 1) {
+    for (let i = 1; i < fullyMatching.length; i++) {
+      await client.runtime.removeNotification(fullyMatching[i].id);
     }
   }
 
-  if (found.length == 0) {
-    await client.runtime.requestInstallNotification(configFn(perspectiveIds, webhookAuth, agentDid));
+  if (fullyMatching.length > 0) return;
+
+  // If we have an existing notification with stale config, update it
+  if (allMatching.length > 0) {
+    const existing = allMatching[0];
+    const config = configFn(perspectiveIds, webhookAuth, agentDid);
+    delete config.granted;
+    await client.runtime.updateNotification(existing.id, config);
+
+    // Remove any other duplicates
+    for (let i = 1; i < allMatching.length; i++) {
+      await client.runtime.removeNotification(allMatching[i].id);
+    }
+    return;
   }
+
+  // No existing notification at all — install a new one
+  await client.runtime.requestInstallNotification(configFn(perspectiveIds, webhookAuth, agentDid));
 }

From e20e40f2fcf4a0b25be5f85db85a2683b577cc44 Mon Sep 17 00:00:00 2001
From: Data <data.bot@coasys.org>
Date: Wed, 22 Apr 2026 07:23:05 +0200
Subject: [PATCH 4/8] fix: hoist uiStore and clean up persisted call invite
 links

- Hoist useUiStore() to composable scope in useSignallingService instead
  of calling it inside the onSignal handler
- Track persisted call invite links and remove them when leaving a call
  to prevent stale notifications from accumulating

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 app/src/composables/useSignallingService.ts |  2 +-
 app/src/stores/webrtcStore.ts               | 19 +++++++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/app/src/composables/useSignallingService.ts b/app/src/composables/useSignallingService.ts
index 625eab9c0..dedfa116a 100644
--- a/app/src/composables/useSignallingService.ts
+++ b/app/src/composables/useSignallingService.ts
@@ -21,6 +21,7 @@ export function useSignallingService(neighbourhood: NeighbourhoodProxy): Signall
   const mediaDevicesStore = useMediaDevicesStore();
   const routeMemoryStore = useRouteMemoryStore();
   const aiStore = useAiStore();
+  const uiStore = useUiStore();
 
   const { me } = storeToRefs(appStore);
   const { inCall, callRoute, myAgentStatus } = storeToRefs(webrtcStore);
@@ -210,7 +211,6 @@ export function useSignallingService(neighbourhood: NeighbourhoodProxy): Signall
       });
       // Open the call window so the user can easily join
       if (!webrtcStore.inCall) {
-        const uiStore = useUiStore();
         if (!uiStore.callWindowOpen) uiStore.setCallWindowOpen(true);
       }
     }
diff --git a/app/src/stores/webrtcStore.ts b/app/src/stores/webrtcStore.ts
index 7cb96f202..d6f076add 100644
--- a/app/src/stores/webrtcStore.ts
+++ b/app/src/stores/webrtcStore.ts
@@ -643,6 +643,9 @@ export const useWebrtcStore = defineStore(
         // Signal all peers that we're leaving the call
         signalPeers(WEBRTC_LEAVING_CALL);
 
+        // Clean up persisted call invite links to prevent stale notifications
+        cleanupInviteLinks();
+
         // Close all peer connections
         peerConnections.value.forEach((_, did) => cleanupPeerConnection(did));
 
@@ -690,6 +693,9 @@ export const useWebrtcStore = defineStore(
       }
     }
 
+    // Track persisted invite links so we can clean them up when leaving the call
+    const persistedInviteLinks = ref<Array<{ source: string; target: string }>>([]);
+
     function sendCallInvite(dids: string[]): void {
       if (!signallingService.value || !callRoute.value.channelId) return;
       const channelUrl = restoreChannelPrefix(callRoute.value.channelId);
@@ -707,6 +713,7 @@ export const useWebrtcStore = defineStore(
         if (perspective) {
           perspective
             .add(new Link({ source: channelUrl, predicate: CALL_INVITE, target: did }))
+            .then(() => persistedInviteLinks.value.push({ source: channelUrl, target: did }))
             .catch((error) => console.error('Failed to persist call invite link:', error));
         }
       }
@@ -717,6 +724,18 @@ export const useWebrtcStore = defineStore(
       });
     }
 
+    function cleanupInviteLinks(): void {
+      const perspective = communityService.value?.perspective;
+      if (!perspective || !persistedInviteLinks.value.length) return;
+
+      for (const invite of persistedInviteLinks.value) {
+        perspective
+          .remove(new Link({ source: invite.source, predicate: CALL_INVITE, target: invite.target }))
+          .catch((error) => console.error('Failed to remove call invite link:', error));
+      }
+      persistedInviteLinks.value = [];
+    }
+
     // Close the call window on route param changes if not in a call or a channel
     watch(
       () => route.params,

From dc75f1bbbd1f943a8f99ec1b1b22abc1b0dac6db Mon Sep 17 00:00:00 2001
From: Data <data.bot@coasys.org>
Date: Wed, 22 Apr 2026 22:08:38 +0200
Subject: [PATCH 5/8] fix: resolve call-invite community by callRoute & fire
 push via flux://call_started
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

InviteToCallPopover rendered inside CallContainer, which is a sibling of
RouterView in MainView — so useCommunityService() via inject() would miss
CommunityView's provider and throw. Resolve members through
webrtcStore.communityService instead, which looks up the service by
callRoute.communityId.

The previous call push-notification trigger matched <agent/new-state> links
containing "inCall":true, but those are broadcast via sendBroadcastU and
never persisted, so AD4M's SPARQL trigger never fired. Emit a persisted
flux://call_started link from joinRoom() when entering an empty room (only
the initiator) and match that IRI in the trigger. Self-authored links are
filtered by the notification runtime, so no explicit author filter needed.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 .../call/controls/InviteToCallPopover.vue         | 15 +++++++++++----
 app/src/stores/webrtcStore.ts                     | 14 ++++++++++++++
 app/src/utils/registerMobileNotifications.ts      |  9 +++++----
 3 files changed, 30 insertions(+), 8 deletions(-)

diff --git a/app/src/components/call/controls/InviteToCallPopover.vue b/app/src/components/call/controls/InviteToCallPopover.vue
index 67e81450f..51a0e4277 100644
--- a/app/src/components/call/controls/InviteToCallPopover.vue
+++ b/app/src/components/call/controls/InviteToCallPopover.vue
@@ -60,20 +60,27 @@
 </template>
 
 <script setup lang="ts">
-import { useCommunityService } from '@/composables/useCommunityService';
 import { useAppStore, useWebrtcStore } from '@/stores';
 import { useUiStore } from '@/stores';
 import { storeToRefs } from 'pinia';
-import { computed, ref, watch } from 'vue';
+import { computed, ref, unref, watch } from 'vue';
 
 const appStore = useAppStore();
 const webrtcStore = useWebrtcStore();
 const uiStore = useUiStore();
 
 const { me } = storeToRefs(appStore);
-const { agentsInCall } = storeToRefs(webrtcStore);
+const { agentsInCall, communityService } = storeToRefs(webrtcStore);
 const { isMobile } = storeToRefs(uiStore);
-const { members, getMembers } = useCommunityService();
+
+// Resolve members via the community of the active call, not the current route.
+// InviteToCallPopover renders inside CallContainer (sibling of RouterView in MainView),
+// so Vue inject() cannot reach CommunityView's provider. unref() handles the case
+// where Pinia's reactive proxy auto-unwraps the nested members ref.
+const members = computed(() => unref(communityService.value?.members) ?? []);
+function getMembers() {
+  communityService.value?.getMembers();
+}
 
 const popover = ref<HTMLElement | null>(null);
 const searchInput = ref('');
diff --git a/app/src/stores/webrtcStore.ts b/app/src/stores/webrtcStore.ts
index d6f076add..11108d336 100644
--- a/app/src/stores/webrtcStore.ts
+++ b/app/src/stores/webrtcStore.ts
@@ -27,6 +27,7 @@ export const WEBRTC_EMOJI = 'webrtc/emoji';
 export const WEBRTC_MEDIA_SETTINGS_CHANGED = 'webrtc/media-settings-changed';
 export const WEBRTC_LEAVING_CALL = 'webrtc/leaving-call';
 export const CALL_INVITE = 'flux://call_invite';
+export const CALL_STARTED = 'flux://call_started';
 const MAX_RECONNECTION_ATTEMPTS = 3;
 const defaultIceServers = [
   {
@@ -629,6 +630,19 @@ export const useWebrtcStore = defineStore(
           uiStore.setVideoLayout({ label: 'Focused', class: 'focused', icon: 'person-video2' });
         }
 
+        // If nobody else is in the call, persist a flux://call_started link so the
+        // AD4M notification trigger fires a push notification for the neighbourhood.
+        // Only the initiator emits this — late joiners don't, to avoid duplicate pushes.
+        if (agentsInCall.value.length === 0 && callRoute.value.channelId) {
+          const perspective = communityService.value?.perspective;
+          const channelUrl = restoreChannelPrefix(callRoute.value.channelId);
+          if (perspective) {
+            perspective
+              .add(new Link({ source: channelUrl, predicate: CALL_STARTED, target: channelUrl }))
+              .catch((error) => console.error('Failed to persist call_started link:', error));
+          }
+        }
+
         inCall.value = true;
       } catch (error) {
         console.error('Error joining call:', error);
diff --git a/app/src/utils/registerMobileNotifications.ts b/app/src/utils/registerMobileNotifications.ts
index 95d5d5354..7858f71be 100644
--- a/app/src/utils/registerMobileNotifications.ts
+++ b/app/src/utils/registerMobileNotifications.ts
@@ -28,17 +28,18 @@ function mentionNotificationConfig(perspectiveIds: string[], webhookAuth: string
 }
 
 const CALL_DESCRIPTION = 'Mobile push notifications for calls';
-function callNotificationConfig(perspectiveIds: string[], webhookAuth: string, agentDid: string) {
+function callNotificationConfig(perspectiveIds: string[], webhookAuth: string, _agentDid: string) {
   return {
     appName: APP_NAME,
     description: CALL_DESCRIPTION,
     appUrl: window.location.origin,
     appIconPath: window.location.origin + '/icon.png',
+    // Matches the persisted link emitted by webrtcStore.joinRoom() when the call
+    // initiator enters an empty room. AD4M's notification runtime skips
+    // self-authored links, so we don't need an explicit author filter here.
     trigger: `SELECT ?source ?predicate ?target WHERE {
       GRAPH ?g { ?source ?predicate ?target . }
-      FILTER(?predicate = <agent/new-state>)
-      FILTER(CONTAINS(STR(?source), '"inCall":true'))
-      FILTER(!CONTAINS(STR(?source), '"${agentDid}"'))
+      FILTER(?predicate = <flux://call_started>)
     }`,
     perspectiveIds,
     webhookUrl: WEBHOOK_URL,

From 72c40b22d673381d7d7eccce43e70474da25b22c Mon Sep 17 00:00:00 2001
From: Data <data.bot@coasys.org>
Date: Wed, 22 Apr 2026 22:09:53 +0200
Subject: [PATCH 6/8] fix: clean up flux://call_started link when leaving the
 call

Mirrors the existing cleanupInviteLinks pattern so the persisted
call_started link does not linger in the perspective graph after the
call ends.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 app/src/stores/webrtcStore.ts | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/app/src/stores/webrtcStore.ts b/app/src/stores/webrtcStore.ts
index 11108d336..46ff49d31 100644
--- a/app/src/stores/webrtcStore.ts
+++ b/app/src/stores/webrtcStore.ts
@@ -633,12 +633,16 @@ export const useWebrtcStore = defineStore(
         // If nobody else is in the call, persist a flux://call_started link so the
         // AD4M notification trigger fires a push notification for the neighbourhood.
         // Only the initiator emits this — late joiners don't, to avoid duplicate pushes.
+        // The link is cleaned up in leaveRoom() to prevent stale triggers.
         if (agentsInCall.value.length === 0 && callRoute.value.channelId) {
           const perspective = communityService.value?.perspective;
           const channelUrl = restoreChannelPrefix(callRoute.value.channelId);
           if (perspective) {
             perspective
               .add(new Link({ source: channelUrl, predicate: CALL_STARTED, target: channelUrl }))
+              .then(() => {
+                persistedCallStartedLink.value = { source: channelUrl, target: channelUrl };
+              })
               .catch((error) => console.error('Failed to persist call_started link:', error));
           }
         }
@@ -659,6 +663,7 @@ export const useWebrtcStore = defineStore(
 
         // Clean up persisted call invite links to prevent stale notifications
         cleanupInviteLinks();
+        cleanupCallStartedLink();
 
         // Close all peer connections
         peerConnections.value.forEach((_, did) => cleanupPeerConnection(did));
@@ -709,6 +714,7 @@ export const useWebrtcStore = defineStore(
 
     // Track persisted invite links so we can clean them up when leaving the call
     const persistedInviteLinks = ref<Array<{ source: string; target: string }>>([]);
+    const persistedCallStartedLink = ref<{ source: string; target: string } | null>(null);
 
     function sendCallInvite(dids: string[]): void {
       if (!signallingService.value || !callRoute.value.channelId) return;
@@ -750,6 +756,17 @@ export const useWebrtcStore = defineStore(
       persistedInviteLinks.value = [];
     }
 
+    function cleanupCallStartedLink(): void {
+      const perspective = communityService.value?.perspective;
+      const link = persistedCallStartedLink.value;
+      if (!perspective || !link) return;
+
+      perspective
+        .remove(new Link({ source: link.source, predicate: CALL_STARTED, target: link.target }))
+        .catch((error) => console.error('Failed to remove call_started link:', error));
+      persistedCallStartedLink.value = null;
+    }
+
     // Close the call window on route param changes if not in a call or a channel
     watch(
       () => route.params,

From e8ce1a14506c6de8d86cfcd0c4114e779916b15d Mon Sep 17 00:00:00 2001
From: Nicolas Luck <nicolas@lucksus.eu>
Date: Thu, 23 Apr 2026 16:28:28 +0200
Subject: [PATCH 7/8] debug logs

---
 app/src/stores/webrtcStore.ts | 26 ++++++++++++++++++++------
 1 file changed, 20 insertions(+), 6 deletions(-)

diff --git a/app/src/stores/webrtcStore.ts b/app/src/stores/webrtcStore.ts
index 46ff49d31..139ff3bea 100644
--- a/app/src/stores/webrtcStore.ts
+++ b/app/src/stores/webrtcStore.ts
@@ -637,13 +637,19 @@ export const useWebrtcStore = defineStore(
         if (agentsInCall.value.length === 0 && callRoute.value.channelId) {
           const perspective = communityService.value?.perspective;
           const channelUrl = restoreChannelPrefix(callRoute.value.channelId);
+          console.log('[DIAG call_started] communityService:', !!communityService.value, 'perspective:', !!perspective, 'uuid:', perspective?.uuid, 'channelUrl:', channelUrl);
           if (perspective) {
+            const link = new Link({ source: channelUrl, predicate: CALL_STARTED, target: channelUrl });
+            console.log('[DIAG call_started] adding link:', JSON.stringify(link));
             perspective
-              .add(new Link({ source: channelUrl, predicate: CALL_STARTED, target: channelUrl }))
-              .then(() => {
+              .add(link)
+              .then((result) => {
+                console.log('[DIAG call_started] add() resolved:', JSON.stringify(result));
                 persistedCallStartedLink.value = { source: channelUrl, target: channelUrl };
               })
-              .catch((error) => console.error('Failed to persist call_started link:', error));
+              .catch((error) => console.error('[DIAG call_started] add() REJECTED:', error));
+          } else {
+            console.warn('[DIAG call_started] perspective is falsy — link NOT written. communityId:', callRoute.value.communityId);
           }
         }
 
@@ -720,6 +726,7 @@ export const useWebrtcStore = defineStore(
       if (!signallingService.value || !callRoute.value.channelId) return;
       const channelUrl = restoreChannelPrefix(callRoute.value.channelId);
       const perspective = communityService.value?.perspective;
+      console.log('[DIAG call_invite] communityService:', !!communityService.value, 'perspective:', !!perspective, 'uuid:', perspective?.uuid, 'channelUrl:', channelUrl, 'dids:', dids);
 
       for (const did of dids) {
         // Broadcast signal for real-time notification (when recipient is online)
@@ -731,10 +738,17 @@ export const useWebrtcStore = defineStore(
 
         // Persist link for AD4M push notification trigger (when recipient is offline)
         if (perspective) {
+          const link = new Link({ source: channelUrl, predicate: CALL_INVITE, target: did });
+          console.log('[DIAG call_invite] adding link:', JSON.stringify(link));
           perspective
-            .add(new Link({ source: channelUrl, predicate: CALL_INVITE, target: did }))
-            .then(() => persistedInviteLinks.value.push({ source: channelUrl, target: did }))
-            .catch((error) => console.error('Failed to persist call invite link:', error));
+            .add(link)
+            .then((result) => {
+              console.log('[DIAG call_invite] add() resolved:', JSON.stringify(result));
+              persistedInviteLinks.value.push({ source: channelUrl, target: did });
+            })
+            .catch((error) => console.error('[DIAG call_invite] add() REJECTED:', error));
+        } else {
+          console.warn('[DIAG call_invite] perspective is falsy — link NOT written. communityId:', callRoute.value.communityId);
         }
       }
 

From 1123405fcf7aa815b71f40cf19efbff9b45bc2ab Mon Sep 17 00:00:00 2001
From: Nicolas Luck <nicolas@lucksus.eu>
Date: Thu, 23 Apr 2026 18:34:00 +0200
Subject: [PATCH 8/8] use toRaw on perspective vue value so we can call methods
 on it

---
 app/src/stores/webrtcStore.ts | 36 +++++++++++------------------------
 1 file changed, 11 insertions(+), 25 deletions(-)

diff --git a/app/src/stores/webrtcStore.ts b/app/src/stores/webrtcStore.ts
index 139ff3bea..2097a162a 100644
--- a/app/src/stores/webrtcStore.ts
+++ b/app/src/stores/webrtcStore.ts
@@ -10,7 +10,7 @@ import { AgentState, AgentStatus, CallHealth, Profile, RouteParams } from '@coas
 import { Howl } from 'howler';
 import { defineStore, storeToRefs } from 'pinia';
 import type { Instance } from 'simple-peer';
-import { computed, ref, watch } from 'vue';
+import { computed, ref, toRaw, watch } from 'vue';
 import { useRoute } from 'vue-router';
 import { useAppStore } from './appStore';
 import { useCommunityServiceStore } from './communityServiceStore';
@@ -635,21 +635,15 @@ export const useWebrtcStore = defineStore(
         // Only the initiator emits this — late joiners don't, to avoid duplicate pushes.
         // The link is cleaned up in leaveRoom() to prevent stale triggers.
         if (agentsInCall.value.length === 0 && callRoute.value.channelId) {
-          const perspective = communityService.value?.perspective;
+          const perspective = toRaw(communityService.value?.perspective);
           const channelUrl = restoreChannelPrefix(callRoute.value.channelId);
-          console.log('[DIAG call_started] communityService:', !!communityService.value, 'perspective:', !!perspective, 'uuid:', perspective?.uuid, 'channelUrl:', channelUrl);
           if (perspective) {
-            const link = new Link({ source: channelUrl, predicate: CALL_STARTED, target: channelUrl });
-            console.log('[DIAG call_started] adding link:', JSON.stringify(link));
             perspective
-              .add(link)
-              .then((result) => {
-                console.log('[DIAG call_started] add() resolved:', JSON.stringify(result));
+              .add(new Link({ source: channelUrl, predicate: CALL_STARTED, target: channelUrl }))
+              .then(() => {
                 persistedCallStartedLink.value = { source: channelUrl, target: channelUrl };
               })
-              .catch((error) => console.error('[DIAG call_started] add() REJECTED:', error));
-          } else {
-            console.warn('[DIAG call_started] perspective is falsy — link NOT written. communityId:', callRoute.value.communityId);
+              .catch((error) => console.error('Failed to persist call_started link:', error));
           }
         }
 
@@ -725,8 +719,7 @@ export const useWebrtcStore = defineStore(
     function sendCallInvite(dids: string[]): void {
       if (!signallingService.value || !callRoute.value.channelId) return;
       const channelUrl = restoreChannelPrefix(callRoute.value.channelId);
-      const perspective = communityService.value?.perspective;
-      console.log('[DIAG call_invite] communityService:', !!communityService.value, 'perspective:', !!perspective, 'uuid:', perspective?.uuid, 'channelUrl:', channelUrl, 'dids:', dids);
+      const perspective = toRaw(communityService.value?.perspective);
 
       for (const did of dids) {
         // Broadcast signal for real-time notification (when recipient is online)
@@ -738,17 +731,10 @@ export const useWebrtcStore = defineStore(
 
         // Persist link for AD4M push notification trigger (when recipient is offline)
         if (perspective) {
-          const link = new Link({ source: channelUrl, predicate: CALL_INVITE, target: did });
-          console.log('[DIAG call_invite] adding link:', JSON.stringify(link));
           perspective
-            .add(link)
-            .then((result) => {
-              console.log('[DIAG call_invite] add() resolved:', JSON.stringify(result));
-              persistedInviteLinks.value.push({ source: channelUrl, target: did });
-            })
-            .catch((error) => console.error('[DIAG call_invite] add() REJECTED:', error));
-        } else {
-          console.warn('[DIAG call_invite] perspective is falsy — link NOT written. communityId:', callRoute.value.communityId);
+            .add(new Link({ source: channelUrl, predicate: CALL_INVITE, target: did }))
+            .then(() => persistedInviteLinks.value.push({ source: channelUrl, target: did }))
+            .catch((error) => console.error('Failed to persist call invite link:', error));
         }
       }
 
@@ -759,7 +745,7 @@ export const useWebrtcStore = defineStore(
     }
 
     function cleanupInviteLinks(): void {
-      const perspective = communityService.value?.perspective;
+      const perspective = toRaw(communityService.value?.perspective);
       if (!perspective || !persistedInviteLinks.value.length) return;
 
       for (const invite of persistedInviteLinks.value) {
@@ -771,7 +757,7 @@ export const useWebrtcStore = defineStore(
     }
 
     function cleanupCallStartedLink(): void {
-      const perspective = communityService.value?.perspective;
+      const perspective = toRaw(communityService.value?.perspective);
       const link = persistedCallStartedLink.value;
       if (!perspective || !link) return;