feat(personas): support shared agent mentions

Author: ehayes2000

Cargo.lock

@@ -0,0 +1,91 @@
+import type { Agent } from '@service-storage/generated/schemas/agent';
+import type { Bot } from '@service-storage/generated/schemas/bot';
+import { describe, expect, it } from 'vitest';
+import { availableBotMentionUsers } from './use-channel-bot-mention-users';
+
+const timestamp = '2026-08-27T12:00:00Z';
+
+function bot(id: string, name: string, avatarUrl?: string): Bot {
+  return {
+    id,
+    kind: 'owned',
+    name,
+    handle: name.toLowerCase().replaceAll(' ', '-'),
+    has_agent: true,
+    avatar_url: avatarUrl,
+    created_at: timestamp,
+    updated_at: timestamp,
+  };
+}
+
+function agent(
+  id: string,
+  name: string,
+  channelScope: Agent['channel_scope'],
+  harness = 'in-memory'
+): Agent {
+  return {
+    bot: bot(id, name),
+    channel_ids: channelScope === 'all' ? [] : ['channel-1'],
+    channel_scope: channelScope,
+    default_model: 'model',
+    harness,
+    system_prompt: '',
+  };
+}
+
+describe('availableBotMentionUsers', () => {
+  it('adds all-channel agents without adding selected agents from other channels', () => {
+    expect(
+      availableBotMentionUsers(
+        [bot('installed', 'Installed')],
+        [
+          agent('global', 'Global', 'all'),
+          agent('selected', 'Selected', 'selected'),
+        ],
+        false
+      ).map((user) => user.id)
+    ).toEqual(['bot|installed', 'bot|global']);
+  });
+
+  it('deduplicates an agent that is also an installed channel bot', () => {
+    expect(
+      availableBotMentionUsers(
+        [bot('global', 'Global')],
+        [agent('global', 'Global', 'all')],
+        false
+      )
+    ).toHaveLength(1);
+  });
+
+  it('preserves the agent avatar for the mention menu', () => {
+    const avatarUrl = 'https://example.com/global-agent.png';
+
+    expect(
+      availableBotMentionUsers(
+        [],
+        [
+          {
+            ...agent('global', 'Global', 'all'),
+            bot: bot('global', 'Global', avatarUrl),
+          },
+        ],
+        false
+      )
+    ).toEqual([
+      {
+        id: 'bot|global',
+        name: 'Global',
+        email: 'Global',
+        photoUrl: avatarUrl,
+      },
+    ]);
+  });
+
+  it('only offers a global Cursor agent when Cursor is connected', () => {
+    const cursorAgent = agent('cursor-agent', 'Cursor agent', 'all', 'cursor');
+
+    expect(availableBotMentionUsers([], [cursorAgent], false)).toEqual([]);
+    expect(availableBotMentionUsers([], [cursorAgent], true)).toHaveLength(1);
+  });
+});

apps/web/src/features/channel/use-channel-bot-mention-users.test.ts

@@ -1,7 +1,43 @@
 import type { IUser } from '@core/user/types';
+import { useAgentsQuery } from '@queries/agents/agents';
+import { useCursorApiKeyStatusQuery } from '@queries/auth/cursor-api-key';
 import { useChannelBotsQuery } from '@queries/channel/channel-bots';
+import type { Agent } from '@service-storage/generated/schemas/agent';
+import type { Bot } from '@service-storage/generated/schemas/bot';
 import { type Accessor, createMemo } from 'solid-js';
 
+function mentionUser(bot: Bot): IUser {
+  return {
+    id: `bot|${bot.id}`,
+    name: bot.name,
+    email: bot.name,
+    photoUrl: bot.avatar_url ?? undefined,
+  };
+}
+
+/** Build mention entries from installed channel bots and virtual global agents. */
+export function availableBotMentionUsers(
+  channelBots: readonly Bot[],
+  agents: readonly Agent[],
+  cursorConnected: boolean
+): IUser[] {
+  const globalAgents = agents.filter(
+    (agent) =>
+      agent.channel_scope === 'all' &&
+      agent.bot.has_agent &&
+      (agent.harness !== 'cursor' || cursorConnected)
+  );
+  const seen = new Set<string>();
+
+  return [...channelBots, ...globalAgents.map((agent) => agent.bot)]
+    .map(mentionUser)
+    .filter((user) => {
+      if (seen.has(user.id)) return false;
+      seen.add(user.id);
+      return true;
+    });
+}
+
 /**
  * The channel's bots as synthetic [`IUser`] entries for the `@`-mention
  * typeahead. Like `macroAiMentionUser()`, `email` is set to the bot's name so
@@ -12,13 +48,15 @@ import { type Accessor, createMemo } from 'solid-js';
 export function useChannelBotMentionUsers(
   channelId: Accessor<string>
 ): Accessor<IUser[]> {
-  const query = useChannelBotsQuery(channelId);
+  const channelBots = useChannelBotsQuery(channelId);
+  const agents = useAgentsQuery();
+  const cursorStatus = useCursorApiKeyStatusQuery();
 
-  return createMemo(() => {
-    return (query.data ?? []).map((bot) => ({
-      id: `bot|${bot.id}`,
-      name: bot.name,
-      email: bot.name,
-    }));
-  });
+  return createMemo(() =>
+    availableBotMentionUsers(
+      channelBots.data ?? [],
+      agents.data ?? [],
+      cursorStatus.data?.registered ?? false
+    )
+  );
 }

apps/web/src/features/channel/use-channel-bot-mention-users.ts

@@ -41,6 +41,7 @@ const agentMocks = vi.hoisted(() => ({
   toastSuccess: vi.fn(),
   toastFailure: vi.fn(),
   currentUserId: 'macro|user@example.com',
+  currentTeam: { team: { id: 'team-1' } } as { team: { id: string } } | null,
   isTeamOwner: false,
 }));
 
@@ -66,7 +67,7 @@ vi.mock('@queries/agents/agents', () => ({
 }));
 
 vi.mock('@queries/team/teams', () => ({
-  useCurrentTeamQuery: () => ({ data: { team: { id: 'team-1' } } }),
+  useCurrentTeamQuery: () => ({ data: agentMocks.currentTeam }),
   useIsTeamOwner: () => () => agentMocks.isTeamOwner,
 }));
 
@@ -109,6 +110,7 @@ beforeEach(() => {
   agentMocks.delete.mockResolvedValue(undefined);
   agentMocks.update.mockResolvedValue(undefined);
   agentMocks.currentUserId = 'macro|user@example.com';
+  agentMocks.currentTeam = { team: { id: 'team-1' } };
   agentMocks.isTeamOwner = false;
 });
 
@@ -437,6 +439,25 @@ describe('Agents', () => {
     expect(screen.getByRole('option', { name: 'general' })).toBeTruthy();
   });
 
+  it('explains why team sharing is disabled without a team', () => {
+    agentMocks.currentTeam = null;
+
+    render(() => <Agents />);
+    fireEvent.click(screen.getByRole('button', { name: 'Create agent' }));
+
+    const dialog = screen.getByRole('dialog');
+    const teamOption = within(dialog).getByLabelText('Team');
+    expect(teamOption).toHaveProperty('disabled', true);
+    const teamCardClasses = teamOption.closest('label')?.classList;
+    expect(teamCardClasses?.contains('cursor-not-allowed')).toBe(true);
+    expect(teamCardClasses?.contains('opacity-50')).toBe(true);
+    expect(
+      within(dialog).getByText(
+        'Team agents need a team owner. Create or join a team in Team settings to enable this option.'
+      )
+    ).toBeTruthy();
+  });
+
   it('persists creation through the agents API', async () => {
     render(() => <Agents />);
     fireEvent.click(screen.getByRole('button', { name: 'Create agent' }));

apps/web/src/features/settings/Agents.test.tsx

@@ -805,12 +805,18 @@ function AgentDialog(props: {
                   description={
                     props.canShareWithTeam
                       ? 'Your team can use this agent in shared channels.'
-                      : 'Join a team to create a team agent.'
+                      : 'Create or join a team before sharing agents.'
                   }
                   disabled={!props.canShareWithTeam}
                   onChange={() => setShare('Team')}
                 />
               </fieldset>
+              <Show when={!props.canShareWithTeam}>
+                <p class="mt-3 border-t border-edge-muted pt-3 text-xs text-ink-extra-muted">
+                  Team agents need a team owner. Create or join a team in Team
+                  settings to enable this option.
+                </p>
+              </Show>
             </AgentFormSection>
           </form>
         </Panel.Body>
@@ -868,7 +874,13 @@ function ChoiceRow(props: {
   onChange: () => void;
 }) {
   return (
-    <label class="flex min-w-0 items-start gap-3 rounded-lg border border-edge-muted p-3 has-checked:border-accent has-checked:bg-accent-bg">
+    <label
+      class="flex min-w-0 items-start gap-3 rounded-lg border border-edge-muted p-3 has-checked:border-accent has-checked:bg-accent-bg"
+      classList={{
+        'cursor-not-allowed opacity-50': props.disabled,
+        'cursor-pointer': !props.disabled,
+      }}
+    >
       <input
         type="radio"
         name={props.name}

apps/web/src/features/settings/Agents.tsx

@@ -45,7 +45,14 @@ export function MentionsMenuItem(props: {
   const icon = () => {
     switch (props.item.kind) {
       case 'user':
-        return <UserIcon id={props.item.id} size="sm" isDeleted={false} />;
+        return (
+          <UserIcon
+            id={props.item.id}
+            size="sm"
+            isDeleted={false}
+            photoUrl={props.item.data.photoUrl}
+          />
+        );
 
       case 'group':
         return <UsersIcon class="size-4 text-ink-muted" />;

apps/web/src/lib/core/component/LexicalMarkdown/component/menu/MentionsMenu/components/MentionsMenuItem.tsx

@@ -196,9 +196,16 @@ export function UserIcon(props: UserIconProps) {
           size={size()}
           class={cn('bg-surface text-accent ring ring-edge-muted', props.class)}
         >
-          <Avatar.Fallback>
-            <RobotIcon class="size-[62%]" />
-          </Avatar.Fallback>
+          <Show
+            when={props.photoUrl}
+            fallback={
+              <Avatar.Fallback>
+                <RobotIcon class="size-[62%]" />
+              </Avatar.Fallback>
+            }
+          >
+            {(photoUrl) => <Avatar.Image src={photoUrl()} alt="" />}
+          </Show>
         </Avatar>
       </Match>
 

apps/web/src/lib/core/component/UserIcon.tsx

@@ -8,6 +8,7 @@ export type IUser = {
   id: string;
   email: string;
   name: string;
+  photoUrl?: string;
   lastInteraction?: DateValue;
 };
 

apps/web/src/lib/core/user/types.ts

@@ -125,15 +125,10 @@ pub struct AgentRuntimeConfig {
     pub model: String,
     /// Harness slug stamped onto the new session.
     pub harness: String,
-    /// Agent-authored instructions prepended to its first prompt.
+    /// Configured agent instructions, reserved for a dedicated runtime transport.
     pub system_prompt: String,
 }
 
-/// Whether a user belongs to the Macro staff domain - the egress crate's
-/// predicate, reused so the harness's staff gates and the proxy's can never
-/// disagree about who staff is.
-pub(crate) use agent_egress::domain::model::is_macro_staff;
-
 /// Where a prompt came from, when it came from somewhere the session should
 /// answer back into.
 #[derive(Debug, Clone)]

crates/agent_harness/src/domain/model.rs

@@ -22,22 +22,14 @@ use tracing::instrument::WithSubscriber as _;
 use crate::domain::error::{HarnessError, Result};
 use crate::domain::model::{
     AgentKind, AnnounceOrigin, AnnouncePrompt, DeliverAction, HarnessCommand, HarnessDefaults,
-    OpenSession, SessionAnnouncement, SpawnContainer, is_macro_staff,
+    OpenSession, SessionAnnouncement, SpawnContainer,
 };
 use crate::domain::ports::{
     AgentPromptComposer, ChannelPromptContext, ContainerManager, RuntimeConnections,
     SandboxEgressProvisioner, SessionAnnouncer,
 };
 use crate::domain::sandbox::SandboxResizeEffect;
 
-fn apply_agent_instructions(system_prompt: &str, prompt: String) -> String {
-    let instructions = system_prompt.trim();
-    if instructions.is_empty() {
-        return prompt;
-    }
-    format!("<agent_instructions>\n{instructions}\n</agent_instructions>\n\n{prompt}")
-}
-
 type SessionWorkers = DashMap<AgentSessionId, mpsc::UnboundedSender<QueuedCommand>>;
 
 struct QueuedCommand {
@@ -550,26 +542,6 @@ where
     Egress: SandboxEgressProvisioner,
 {
     async fn execute(&self, session_id: AgentSessionId, command: HarnessCommand) -> Result<()> {
-        match &command {
-            HarnessCommand::Open(open)
-                if open.runtime.kind == AgentKind::Cursor
-                    && !is_macro_staff(&open.origin.sender) =>
-            {
-                return Err(AgentSessionError::Forbidden.into());
-            }
-            HarnessCommand::Deliver(deliver) => {
-                let session = self.sessions.get_session(session_id).await?;
-                if AgentKind::for_session(session.bot_id, &session.harness) == AgentKind::Cursor
-                    && !deliver.actor.as_ref().is_some_and(is_macro_staff)
-                {
-                    return Err(AgentSessionError::Forbidden.into());
-                }
-            }
-            HarnessCommand::Open(_)
-            | HarnessCommand::SetSandboxSize(_)
-            | HarnessCommand::Delete => {}
-        }
-
         match command {
             HarnessCommand::Open(command) => self.open(session_id, command).await,
             HarnessCommand::Deliver(command) => self.deliver(session_id, command).await,
@@ -682,12 +654,10 @@ where
         let prior_messages = self
             .load_prompt_context(origin.channel_id, origin.message_id, Some(&origin.sender))
             .await;
-        let composed_prompt = apply_agent_instructions(
-            &runtime.system_prompt,
-            self.prompt_composer
-                .compose(&origin.content, Some(&prior_messages))
-                .await?,
-        );
+        let composed_prompt = self
+            .prompt_composer
+            .compose(&origin.content, Some(&prior_messages))
+            .await?;
 
         // Provisioned before the session exists, because the row is what makes
         // the token mean anything: it carries the hash the proxy recognises.