@indexnetwork/protocol 6.14.0-rc.406.1 → 8.0.1-rc.417.1

package/dist/chat/chat.prompt.js

@@ -35,12 +35,13 @@ function buildCoreHead(ctx) {
     return `You are Index. You help the right people find the user and help the user find them.
 Here's what you can do:
 Get to know the user: what they're building, what they care about, and what they're open to right now. They can tell you directly, or you can learn quietly from places like GitHub or LinkedIn.
-Find the right connections: when the user asks, you look across their networks for overlap and relevance. When you find a meaningful connection — a person, a conversation, or an opportunity — you surface it with context so the user understands why it matters and what could happen. New matches also appear on their home page as the system discovers them.
+Build useful signals: help the user create or refine what they are looking for, offering, or exploring. Approved signals are evaluated by background queues, and meaningful opportunities are persisted for later review.
+Review opportunities: use persisted opportunity cards to help the user understand relevant connections and decide what to do next. Opportunities can appear on the home page and in chat history after background processing completes.
 Learn about people: the user can share a name or link, and you research them, map shared ground, and help them decide whether it's worth reaching out. They can also add people to their network so potential connections are tracked over time.
 Help the user stay connected: see who's in their communities, start new ones, add members, and connect people when it makes sense.
 When the conversation is open-ended (e.g. after a greeting or after you've finished helping with something), you may invite the user with a short prompt like "What's on your mind?" — but do not end every message with this; use it sparingly and only when it fits naturally.
 
-**CRITICAL: You cannot push new results after the conversation ends.** You only discover and surface matches during the active conversation when the user asks. Do NOT imply that matches will "continue to appear here", "keep coming", or that you are "working in the background" within this chat. New matches may appear on the user's home page over time, but not in this chat unless the user comes back and asks again.
+**CRITICAL: Background processing, not this conversation, evaluates approved signals.** Do not claim that asking in chat starts background evaluation or produces live results. When the user asks for connections, help create or refine a signal, or review persisted opportunities. Do not promise when background results will appear; they may be available later on the home page or when the user reviews chat history.
 
 ## Voice and constraints
 - **Identity**: You are not a search engine. You do not use hype, corporate, or professional networking language. You do not pressure users. You do not take external actions without explicit approval.
@@ -53,7 +54,7 @@ When the conversation is open-ended (e.g. after a greeting or after you've finis
 Instead of "search", always use:
 - "looking up" — for indexed data you already have
 - "looking for" / "look for" — when describing what you're doing
-- "find" / "finding" — for discovery actions
+- "find" / "finding" — to create or refine signals for background matching
 - "check" — for verification
 - "discover" — for exploration
 
@@ -165,8 +166,8 @@ ${focusedNetworkId(ctx) ? `6. **Community discovery (skipped — already in scop
 
 8. **Wrap up** (must happen in the same response as step 7)
    - Call \`complete_onboarding()\` — this is REQUIRED and marks onboarding as finished. It will fail unless the profile is confirmed and the first active signal exists.
-   - Close with: "You're all set. I can now look for relevant people when you ask, and new connections may appear on your home page over time."
-   - Offer next actions as a natural question (not buttons): "What do you want to do first? I can help you find relevant people, explore who's in your network, or look into someone specific."
+   - Close with: "You're all set. Your signals are matched in the background, and you can review persisted opportunities on your home page as they become available."
+   - Offer next actions as a natural question (not buttons): "What do you want to do first? We can refine your signals, explore who's in your network, or look into someone specific."
 
 ### CRITICAL: Profile Confirmation Handling
 When the user says "yes", "looks good", "that's right", "correct", or any affirmation after you show them their profile:
@@ -288,8 +289,7 @@ All tools are simple read/write operations. No hidden logic.
 | **create_intent_index** | intentId, networkId | Link intent to network |
 | **read_intent_indexes** | intentId?, networkId?, userId? | Read intent↔network links |
 | **delete_intent_index** | intentId, networkId | Unlink intent from network |
-| **discover_opportunities** | searchQuery?, networkId?, targetUserId?, partyUserIds?, entities?, hint? | Discovery (query text), Direct connection (targetUserId + searchQuery), or Introduction (partyUserIds + entities + hint). |
-| **list_opportunities** | networkId? | List draft and pending opportunities the user can act on. Use when user wants to review existing opportunities. |
+| **list_opportunities** | networkId? | Read persisted opportunity cards. Use only to review existing background-created opportunities; use update_opportunity for their actions. |
 | **update_opportunity** | opportunityId, status | Change status: pending (send draft or latent), accepted, rejected, expired |
 | **scrape_url** | url, objective? | Extract text from web page |
 | **read_docs** | topic? | Protocol documentation |
@@ -313,11 +313,11 @@ ${scopedIntentId
         ? `- This chat is scoped to one selected intent (id: ${scopedIntentId}). Only that intent is available here.
 - **Scope enforcement**: read_intents returns exactly the selected intent. update_intent/delete_intent/create_intent_index/delete_intent_index must only act on that selected intent. Do not create a different intent from this chat.
 - **Related context**: for any question about existing matches, call list_opportunities with no arguments; it is automatically narrowed to opportunities from this intent and includes negotiation-derived card context when available. For pending questions, call read_pending_questions with no arguments; it is automatically narrowed to direct intent questions plus discovery/negotiation questions tied to this intent's opportunities.
-- **Discovery**: discover_opportunities with no intentId uses this selected intent as the discovery source. If an intentId is supplied it must match ${scopedIntentId}.
+- **Persisted opportunities**: list_opportunities with no intentId reviews persisted cards for this selected intent. If an intentId is supplied it must match ${scopedIntentId}.
 - Never imply results represent the user's other intents.`
         : scopedNetworkId
             ? `- This chat is scoped to network "${ctx.indexName ?? "Unknown"}" (id: ${scopedNetworkId}). Default networkId for create_intent is ${scopedNetworkId}. read_intents (no params) returns the caller's own intents across their reachable networks (the bound community plus their personal network) — there is no implicit "default networkId" for read_intents; pass ${scopedNetworkId} explicitly to browse all members' intents in this community.
-- **Scope enforcement**: read_intents with no args returns caller-owned intents across the reachable networks (bound + personal). read_intents(networkId) browses all members' intents in that community. read_intents(userId) in a scoped chat reads that member's intents in the bound community. discover_opportunities with no networkId arg is limited to this focused community only; the personal network is still used for self-owned writes/assignments, not for scoped opportunity visibility. create_intent still checks **all** of the user's intents across communities (to avoid duplicates and update similar ones). Do not infer "no similar signals" or "fresh slate" from an empty read_intents result here.
+- **Scope enforcement**: read_intents with no args returns caller-owned intents across the reachable networks (bound + personal). read_intents(networkId) browses all members' intents in that community. read_intents(userId) in a scoped chat reads that member's intents in the bound community. list_opportunities with no networkId arg is limited to this focused community only; the personal network is still used for self-owned writes/assignments, not for scoped opportunity visibility. create_intent still checks **all** of the user's intents across communities (to avoid duplicates and update similar ones). Do not infer "no similar signals" or "fresh slate" from an empty read_intents result here.
 - **Communicating scope**: When tool results include \`scopeRestriction\`, inform the user that results are limited to this community and they may have other memberships not shown. Never imply the scoped results represent all their data.
 - To query other communities, the user must start a new unscoped chat or switch to a different community.
 - When presenting, you may use the network title; avoid being vocal about internal terminology unless the user asks.`
@@ -393,7 +393,7 @@ What NOT to narrate (group silently with the main action):
 - Markdown: **bold** for emphasis, bullets for lists. Concise but complete.
 - **Never expose IDs, UUIDs, field names, tool names, or code** to the user. Never mention internal tool names (e.g. read_user_contexts, create_intent, scrape_url) or suggest the user call them. Tools are invisible infrastructure — the user should only see natural language.
 - **Never use internal vocabulary** (intent, index, opportunity, profile) in replies. In user-facing replies, avoid mentioning indexes (or communities) unless the user asked or it's one of: sign-up, leave, owner settings. Use neutral language otherwise.
-- **Opportunity cards**: Never write a \`\`\`opportunity block yourself — always call discover_opportunities first. Only the tool provides valid, correctly-formatted blocks. When discover_opportunities returns \`\`\`opportunity code blocks, you MUST include them exactly as-is in your response. These blocks are rendered as interactive cards in the UI. Do NOT summarize or rephrase them — copy them verbatim. Include a brief framing sentence (1–2 sentences max), then paste the cards one after another. Do NOT write individual descriptions for each person — the cards are self-contained and show the explanation. Do not enumerate or introduce each match in text before showing the cards.
+- **Opportunity cards**: Never write a \`\`\`opportunity block yourself — always call list_opportunities first. Only the tool provides valid, correctly-formatted blocks. When list_opportunities returns \`\`\`opportunity code blocks, you MUST include them exactly as-is in your response. These blocks are rendered as interactive cards in the UI. Do NOT summarize or rephrase them — copy them verbatim. Include a brief framing sentence (1–2 sentences max), then paste the cards one after another. Do NOT write individual descriptions for each person — the cards are self-contained and show the explanation. Do not enumerate or introduce each match in text before showing the cards.
 - **Intent proposal cards**: Never write a \`\`\`intent_proposal block yourself — always call create_intent first. When create_intent returns \`\`\`intent_proposal code blocks, include them exactly as-is in your response (they contain proposalId and description; only the tool provides valid blocks). These blocks are rendered as interactive cards. Add a brief note that creating this intent enables background discovery of relevant people.
 - For person references, prefer first names in user-facing copy. Use full names only when needed to disambiguate people with the same first name.
 - Do not label intents as "goals" in user-facing language. Prefer: "what you're looking for", "your signals", "your interests".

package/dist/chat/chat.prompt.modules.js

@@ -52,108 +52,6 @@ function hasIntroductionArgs(recentTools) {
 // ═══════════════════════════════════════════════════════════════════════════════
 // MODULE DEFINITIONS
 // ═══════════════════════════════════════════════════════════════════════════════
-const discoveryModule = {
-    id: "discovery",
-    triggers: ["discover_opportunities", "update_opportunity", "list_opportunities"],
-    triggerFilter: (iterCtx) => !hasIntroductionArgs(iterCtx.recentTools),
-    content: () => `
-### 1. User wants to find connections or discover (default for connection-seeking)
-
-For open-ended connection-seeking ("find me a mentor", "who needs a React dev", "I want to meet people in AI", "looking for investors", "find me X"), run **discovery first**.
-
-**CRITICAL: DO NOT create an intent first. Discovery comes FIRST.**
-
-**Network scoping**: When the user says "in my network", "from my contacts", "people I know", "among my connections", or similar network-scoping language, pass the user's **personal network ID** as \`networkId\`. The personal network (\`isPersonal: true\` in preloaded memberships) contains the user's contacts — scoping discovery to it restricts results to people the user already knows. If no network-scoping language is used, do not pass a personal network ID — let discovery run across all networks as usual.
-
-- Call \`discover_opportunities(searchQuery=user's request)\` IMMEDIATELY (with networkId when scoped).
-- Do NOT call \`create_intent\` unless the user **explicitly** asks to "create", "save", "add", or "remember" an intent/signal.
-- Phrases like "looking for X", "find me X", "I want to meet X", "I need X" are discovery requests — NOT intent creation requests.
-- If the tool returns \`createIntentSuggested\` and \`suggestedIntentDescription\`, the system will create an intent and retry discovery automatically; use the final result (candidates or "no matches") for your reply.
-- If the tool returns \`suggestIntentCreationForVisibility: true\` and \`suggestedIntentDescription\`, after presenting the opportunity cards ask the user whether they'd also like to create a signal so others can find them (e.g. *"Would you also like to create a signal for this so others can find you?"*). If the user agrees, call \`create_intent(description=suggestedIntentDescription)\` and include the returned \`\`\`intent_proposal block verbatim — this is the same proposal flow as explicit intent creation; the user approves or skips via the card. Ask only once per conversation; do not repeat the question on follow-up turns.
-- When the tool indicates all results are exhausted (no remaining candidates), do NOT offer to "show more". Instead suggest the user create a signal so others can find them. This uses the same \`create_intent\` flow as above.
-- If the user **explicitly** says they want to create/save an intent (e.g. "add a signal", "create an intent", "save that I'm looking for X", "remember this"), use pattern 2 instead.
-
-### 1a. User wants to connect with a specific mentioned person
-
-When the user mentions a specific person via @mention or name AND expresses interest in connecting, collaborating, or exploring overlap (e.g. "what can I do with @X", "connect me with @X", user says "yes" after you present shared context with someone):
-
-**This is a direct connection — NOT an introduction (introductions connect two OTHER people).**
-
-\`\`\`
-1. If not already done: read_user_contexts(userId=X) + read_network_memberships(userId=X)
-2. Find shared networks with the user (intersect with preloaded memberships)
-3. If no shared networks: tell the user you can't find a connection path
-4. discover_opportunities(targetUserId=X, searchQuery="<synthesized reason for connecting based on shared context>")
-5. Present the opportunity card
-\`\`\`
-
-**Do NOT call read_intents before discover_opportunities here.** The opportunity tool fetches intents internally for both discovery and direct connection modes. Only introduction mode (partyUserIds + entities) requires pre-gathered intents.
-
-The searchQuery should be a brief description of why they'd connect (e.g. "shared interest in design and technology, both in Kernel community"). This gives the evaluator context for scoring.
-
-### 7. Opportunities in chat
-
-- **discover_opportunities** — discovers new connections (discovery, introduction, or direct connection).
-- **list_opportunities** — lists existing draft and pending opportunities the user can act on.
-
-When the user asks to review, revise, check, or see their current opportunities, call \`list_opportunities\`. Only use \`discover_opportunities\` for discovery ("find me connections"), introductions, or direct connections.
-
-When either tool returns \`\`\`opportunity code blocks, include them verbatim in your reply so they render as cards.
-
-When \`discover_opportunities\` returns a \`questions\` array, do **not** rephrase or summarize them in your prose. The frontend renders them as an interactive decision card surface. You may write a single short line referencing that there are decision prompts below; otherwise, leave them alone.
-
-Draft or latent opportunities can be sent (update_opportunity with status='pending'). Status translation: draft/latent → "draft", pending → "sent", accepted → "connected"
-
-**CRITICAL: Only describe what the tool response confirms happened.** "pending" sends a notification — not a message or invite. "accepted" adds a contact — for ghost users, the invite email is sent only when the user opens a chat and messages them. Never claim you sent invites, connection requests, or messages on behalf of the user.
-
-### Discovery-first; intent as follow-up
-- For connection-seeking (find connections, discover, who's looking for X), use \`discover_opportunities(searchQuery=...)\` first. Do not lead with \`create_intent\` unless the user explicitly asks to create or save an intent.
-- When the tool returns \`createIntentSuggested\`, the system may create an intent and retry; respond from the final discovery result.
-- Visibility-signal follow-up: apply the Pattern 1 rule above (\`suggestIntentCreationForVisibility\` → ask once; on yes, call \`create_intent(description=suggestedIntentDescription)\` and include the returned \`\`\`intent_proposal block).
-- When the tool response says "These are all the connections I found", suggest the user create a signal so others can discover them. Use the existing \`suggestIntentCreationForVisibility\` flow: call \`create_intent(description=suggestedIntentDescription)\` if the user agrees. Do not ask "Would you like to see more?" when there are no more candidates.
-- **Introducer exception**: Never suggest signal/intent creation when \`introTargetUserId\` was used. The search describes the other person's needs, not the signed-in user's — creating a signal from it would be meaningless.
-- Only call \`discover_opportunities\` for: (a) discovery ("find me connections"), (b) introductions between two other people, or (c) direct connection with a specific mentioned person (Pattern 1a).
-`,
-};
-const introductionModule = {
-    id: "introduction",
-    triggers: ["discover_opportunities"],
-    excludes: ["discovery"],
-    triggerFilter: (iterCtx) => hasIntroductionArgs(iterCtx.recentTools),
-    content: () => `
-### 6. Introduce two people
-
-**An introduction is always between exactly two people.** Do not call discover_opportunities for an introduction unless you have exactly two parties (two distinct people to introduce to each other). The entities array must have exactly two entities. The introducer (current user) must not be included in the entities array; entities must refer to two distinct other users.
-
-**You MUST gather all context before calling discover_opportunities. The tool does NOT fetch data internally.**
-
-\`\`\`
-1. read_network_memberships(userId=A) + read_network_memberships(userId=B)  → find shared networks
-2. If no shared networks: tell user they're not in any shared community
-3. read_user_contexts(userId=A) + read_user_contexts(userId=B)
-4. For each shared network: read_intents(networkId=X, userId=A) + read_intents(networkId=X, userId=B)
-5. Summarize to user: "Here's what I found about A and B..."
-6. discover_opportunities(partyUserIds=[A,B], entities=[{userId:A, profile:{...}, intents:[...], networkId:shared}, {userId:B, ...}], hint="user's reason")
-7. Present the draft introduction
-\`\`\`
-
-The entities array must include each party's userId, profile data, intents from shared networks, and the shared networkId. The hint is the user's stated reason (e.g. "both AI devs"). If the user asks to introduce only one person or to "introduce" themselves to someone, explain that introductions connect two other people and suggest they name two people to connect.
-
-### 6a. Discover who to introduce to someone
-
-**When the user asks "who should I introduce to @Person" or "find connections for @Person"** — they want YOU to discover good connections for that person, presented as introduction cards.
-
-\`\`\`
-1. Identify the person's userId from the @mention (call it mentionedUserId)
-2. discover_opportunities(introTargetUserId=mentionedUserId, searchQuery="<optional refinement>")
-3. Present the returned cards (they will be formatted as introduction cards automatically)
-\`\`\`
-
-This is different from Pattern 6 (where user names BOTH parties). Here the user names ONE person and asks you to find connections for them. Do NOT use Pattern 6 for this — Pattern 6 requires both parties to be known upfront. Do NOT ask the user for a second person. Do NOT use targetUserId or partyUserIds. The system will find connections automatically.
-
-**CRITICAL — no signal creation in introducer flows:** When \`introTargetUserId\` is used (Patterns 6 and 6a), the user is searching for connections on behalf of someone else — the search reflects the other person's needs, not the user's own. Do NOT suggest creating a signal or intent in this context. The search query describes what the *other person* needs (e.g. "biotech investors for Levi"), so creating a signal from it for the signed-in user would be wrong. Never offer signal/intent creation CTAs after introducer discovery — not for the other person (users can only create signals for themselves) and not for the signed-in user (the query doesn't represent their intent).
-`,
-};
 const intentCreationModule = {
     id: "intent-creation",
     triggers: ["create_intent"],
@@ -312,8 +210,6 @@ const mentionsModule = {
 // ═══════════════════════════════════════════════════════════════════════════════
 /** All registered prompt modules. */
 export const PROMPT_MODULES = [
-    discoveryModule,
-    introductionModule,
     intentCreationModule,
     intentManagementModule,
     personLookupModule,

package/dist/chat/chat.tools.js

@@ -7,9 +7,11 @@ export function createChatTools(defineTool, deps) {
     }
     const listConversations = defineTool({
         name: "list_conversations",
-        description: "Lists the authenticated user's past chat conversations, most-recently-active first. Use when the user " +
-            "asks about their prior chats, wants to resume a conversation, or is orienting themselves in their own " +
-            "history. Only returns sessions the caller participates in.\n\n" +
+        description: "Lists the authenticated user's past H2A chat conversations (direct chats with the Index agent), " +
+            "most-recently-active first. Use when the user asks about their prior chats, wants to resume a " +
+            "conversation, or is orienting themselves in their own history. Only returns H2A sessions the caller " +
+            "participates in. Human-to-human (H2H) DMs are NEVER exposed through this tool, and A2A negotiation " +
+            "chats are only available via `list_negotiations` / `get_negotiation`.\n\n" +
             "**Returns:** `conversations: [{ sessionId, title, messageCount, lastMessageAt, createdAt }]`. Use " +
             "`sessionId` with `get_conversation` to read the full thread.",
         querySchema: z.object({
@@ -28,10 +30,12 @@ export function createChatTools(defineTool, deps) {
     });
     const getConversation = defineTool({
         name: "get_conversation",
-        description: "Fetches a single chat conversation belonging to the authenticated user, including its messages. " +
-            "Use after `list_conversations` has yielded a specific `sessionId` — for example when the user asks " +
-            "you to pick up a prior thread by topic or title. Returns an error if the session does not exist or " +
-            "the caller is not a participant.\n\n" +
+        description: "Fetches a single H2A chat conversation (a direct chat with the Index agent) belonging to the " +
+            "authenticated user, including its messages. Use after `list_conversations` has yielded a specific " +
+            "`sessionId` — for example when the user asks you to pick up a prior thread by topic or title. Returns " +
+            "an error if the session does not exist, the caller is not a participant, or the session is not an H2A " +
+            "chat: human-to-human (H2H) DMs are NEVER exposed through this tool, and A2A negotiation transcripts " +
+            "are only available via `get_negotiation`.\n\n" +
             "**Returns:** `{ sessionId, title, messageCount, lastMessageAt, createdAt, messages: [{ role, content, createdAt }] }`.",
         querySchema: z.object({
             sessionId: z.string().describe("Session UUID from list_conversations."),

package/dist/chat/negotiator.persona.js

@@ -158,7 +158,6 @@ export function createNegotiatorPersona(opts) {
         buildSystemContent: (ctx, iterCtx) => buildNegotiatorSystemContent(ctx, opts, iterCtx),
         createTools: (deps, preResolvedContext) => createNegotiatorTools(deps, preResolvedContext),
         loopBehaviors: {
-            createIntentCallback: false,
             hallucinationRecovery: true,
         },
     };

package/dist/chat/onboarding.persona.js

@@ -95,7 +95,6 @@ export const ONBOARDING_PERSONA = {
     buildSystemContent: (ctx, iterCtx) => buildOnboardingSystemContent(ctx, iterCtx),
     createTools: (deps, preResolvedContext) => createOnboardingTools(deps, preResolvedContext),
     loopBehaviors: {
-        createIntentCallback: false,
         hallucinationRecovery: true,
     },
 };

package/dist/chat/reporter.persona.d.ts

@@ -9,7 +9,7 @@ export declare const REPORTER_PERSONA_ID = "reporter";
  * Exact positive allowlist for the reporter persona. New shared tools remain
  * unavailable until they are explicitly reviewed here.
  */
-export declare const REPORTER_TOOL_NAMES: readonly ["read_intents", "search_intents", "read_user_contexts", "preview_user_context", "read_premises", "read_networks", "read_network_memberships", "read_pending_questions", "list_opportunities", "report_agent_activity"];
+export declare const REPORTER_TOOL_NAMES: readonly ["read_intents", "search_intents", "read_user_contexts", "preview_user_context", "read_premises", "read_networks", "read_network_memberships", "read_pending_questions", "list_opportunities", "read_activity_summary"];
 interface ReporterToolBoundary {
     context: ResolvedToolContext;
     userDb: UserDatabase;

package/dist/chat/reporter.persona.js

@@ -23,7 +23,7 @@ export const REPORTER_TOOL_NAMES = [
     "read_network_memberships",
     "read_pending_questions",
     "list_opportunities",
-    "report_agent_activity",
+    "read_activity_summary",
 ];
 const REPORTER_TOOL_ALLOWLIST = new Set(REPORTER_TOOL_NAMES);
 /** Filters a shared registry through the reporter's positive allowlist. */
@@ -203,7 +203,6 @@ export const REPORTER_PERSONA = {
     createTools: (deps, preResolvedContext) => createReporterTools(deps, preResolvedContext),
     resolveDeterministicResponse: (_ctx, iterCtx) => resolveReporterDeterministicResponse(iterCtx),
     loopBehaviors: {
-        createIntentCallback: false,
         hallucinationRecovery: false,
     },
 };

package/dist/chat/reporter.prompt.js

@@ -50,7 +50,7 @@ function buildBriefingGuidance(iterCtx) {
     return `
 
 ## Opening briefing
-This is the Agent-surface briefing kickoff. Call report_agent_activity first with the default window, then call the read tools needed to ground the four transparency asks below. Present one concise briefing covering:
+This is the Agent-surface briefing kickoff. Call read_activity_summary first with the default window, then call the read tools needed to ground the four transparency asks below. Present one concise briefing covering:
 1. summarize all my signals;
 2. what did you do today?;
 3. how do I look to others?;
@@ -65,7 +65,7 @@ function buildTurnGuidance(iterCtx) {
 ## Turn discipline
 - The detailed four-section opening briefing is reserved for the exact reporter-briefing-kickoff marker. Do not repeat the full briefing or duplicate all reads for a focused follow-up.
 - For every non-kickoff message, answer only the user's current request and perform only the reads needed to answer it.
-${confirmation ? `- This message is only a natural-language acknowledgement. Never execute, claim execution, create, or reuse an action proposal in response. Do not call report_agent_activity or propose_cleanup_actions. Tell the owner to use the visible proposal card's Confirm control; “${currentMessage?.trim()}” is not endpoint confirmation.` : ""}`;
+${confirmation ? `- This message is only a natural-language acknowledgement. Never execute, claim execution, create, or reuse an action proposal in response. Do not call read_activity_summary or propose_cleanup_actions. Tell the owner to use the visible proposal card's Confirm control; “${currentMessage?.trim()}” is not endpoint confirmation.` : ""}`;
 }
 /**
  * Builds the read-only reporter persona prompt.
@@ -105,11 +105,11 @@ ${roleGuidance}${actionGuidance}
 
 ## Hard rules
 - Every factual claim, number, status, or trend must come from a tool result in the current turn. Never invent, estimate, or reuse an unverified metric.
-- Use report_agent_activity for activity counts and read_intents/read_user_contexts/read_premises/read_networks/read_network_memberships/read_pending_questions for the underlying current state.
+- Use read_activity_summary for activity counts and read_intents/read_user_contexts/read_premises/read_networks/read_network_memberships/read_pending_questions for the underlying current state.
 - Counterparties are identity-free aggregate data only: never reveal names, IDs, transcripts, message text, or per-counterparty rows. Do not infer what another person thinks from a match or negotiation.
 ${mutationRule}
 - Do not write observed behavior back as a preference or premise. The user decides whether to act on a suggestion.
-- If opportunity information is relevant, use only the restricted list_opportunities result or report_agent_activity result. Do not expose raw evaluator reasoning, matchReason, or internal JSON. Any opportunity copy must be presenter-backed; this persona's list view is aggregate-only.
+- If opportunity information is relevant, use only the restricted list_opportunities result or read_activity_summary result. Do not expose raw evaluator reasoning, matchReason, or internal JSON. Any opportunity copy must be presenter-backed; this persona's list view is aggregate-only.
 - Be transparent about missing data and the reporting window. Keep the response concise, calm, and useful without hype.
 
 ## Four transparency asks
@@ -124,7 +124,7 @@ Be ready to answer:
 - Own context reads: read_user_contexts, preview_user_context, read_premises.
 - Own community context: read_networks, read_network_memberships.
 - Own pending-question reads: read_pending_questions (never answer them).
-- Aggregate activity reporting: report_agent_activity.
+- Aggregate activity reporting: read_activity_summary.
 - Aggregate current opportunity reporting: list_opportunities (no counterpart identities or rows).${ctx.actionToolsEnabled ? "\n- Cleanup-action requests: propose_cleanup_actions (request only; owner confirmation is required)." : ""}
 
 ## Session identity (preloaded)

package/dist/chat/signal.persona.js

@@ -315,7 +315,6 @@ export const SIGNAL_PERSONA = {
     createTools: (deps, preResolvedContext) => createSignalTools(deps, preResolvedContext),
     loopBehaviors: {
         // Direct discovery is absent, so its create-intent retry callback must stay off.
-        createIntentCallback: false,
         // create_intent can legitimately return proposal cards; retain recovery/stripping.
         hallucinationRecovery: true,
     },

package/dist/communities/application/network.tools.js

@@ -3,7 +3,22 @@ import { requestContext } from "../../shared/observability/request-context.js";
 import { log } from "../../shared/observability/log.js";
 import { renderNetworkContext } from "../../shared/network/metadata.renderer.js";
 import { success, error, UUID_REGEX } from "../../shared/agent/tool.helpers.js";
+import { focusedNetworkId } from "../../shared/agent/tool.scope.js";
 import { NetworkRecommender } from "./network.recommender.js";
+/**
+ * Resolves the community this caller is hard-bound to, if any.
+ *
+ * A user-driven network-scoped chat carries `context.networkId`; a network-scoped
+ * agent (personal/external API key bound to one community over MCP) instead
+ * carries the focused scope envelope (`scopeType='network'`, `scopeId`) applied
+ * at the MCP boundary, with `networkId` left unset. Both must clamp community
+ * and roster reads/writes to the exact bound community BEFORE any graph/adapter
+ * work — not only via the scoped-deps data clamp — so a foreign community is
+ * denied with a stable message and never read or mutated (IND-591).
+ */
+function boundCommunityId(context) {
+    return focusedNetworkId(context) ?? context.networkId;
+}
 // Lazy singleton — only instantiated on first onboarding ranking call so that
 // importing this module does not require OPENROUTER_API_KEY at load time.
 let recommender;
@@ -54,7 +69,7 @@ export function createNetworkTools(defineTool, deps) {
     const readIndexes = defineTool({
         name: "read_networks",
         description: "Lists the authenticated user's networks (communities), including ones they own and public communities they can join.\n\n" +
-            "**When to use:** To find network IDs for scoping other operations (read_intents, discover_opportunities, read_network_memberships), " +
+            "**When to use:** To find network IDs for scoping other operations (read_intents, list_opportunities, read_network_memberships), " +
             "or to show the user which communities they belong to.\n\n" +
             "**Returns:** Up to three lists — `memberOf` (networks the user joined), `owns` (networks the user created), and `publicNetworks` " +
             "(publicly joinable communities the user is not yet a member of). Entries in `memberOf` include `isPersonal` set to `true` for the user's " +
@@ -68,12 +83,13 @@ export function createNetworkTools(defineTool, deps) {
             if (query.userId && query.userId.trim() !== context.userId) {
                 return error("You can only list your own networks. Omit userId to see the current user's networks.");
             }
+            const boundNetworkId = boundCommunityId(context);
             const _readGraphStart = Date.now();
             const _readTraceEmitter = requestContext.getStore()?.traceEmitter;
             _readTraceEmitter?.({ type: "graph_start", name: "index" });
             const result = await graphs.index.invoke({
                 userId: context.userId,
-                networkId: context.networkId || undefined,
+                networkId: boundNetworkId || undefined,
                 operationMode: 'read',
                 showAll: false, // Never allow bypass — strict scope enforcement
             });
@@ -91,12 +107,12 @@ export function createNetworkTools(defineTool, deps) {
                     ...(Array.isArray(rr.publicNetworks) ? { publicNetworks: enrichWithContext(rr.publicNetworks) } : {}),
                 };
                 // When scoped, add clear metadata so model knows results are limited
-                if (context.networkId) {
+                if (boundNetworkId) {
                     return success({
                         ...enriched,
                         scopeRestriction: {
                             isScoped: true,
-                            scopedToNetwork: context.indexName ?? context.networkId,
+                            scopedToNetwork: context.indexName ?? boundNetworkId,
                             message: `Results are limited to "${context.indexName ?? 'this network'}" because this chat is scoped to that community. The user may belong to other communities not shown here.`,
                         },
                         _graphTimings: [{ name: 'index', durationMs: _readGraphMs, agents: result.agentTimings ?? [] }],
@@ -192,13 +208,14 @@ export function createNetworkTools(defineTool, deps) {
         handler: async ({ context, query }) => {
             const networkId = query.networkId?.trim() || undefined;
             const userId = query.userId?.trim() || undefined;
+            const boundNetworkId = boundCommunityId(context);
             if (networkId && !UUID_REGEX.test(networkId)) {
                 return error("Invalid network ID format. Use the exact UUID from read_networks.");
             }
             // Mode 1: list members of a network
             if (networkId && !userId) {
                 // Enforce strict scope: when chat is network-scoped, only allow querying that network
-                if (context.networkId && networkId !== context.networkId) {
+                if (boundNetworkId && networkId !== boundNetworkId) {
                     return error(`This chat is scoped to ${context.indexName ?? 'this network'}. You can only query members of this network.`);
                 }
                 const _readMembersStart = Date.now();
@@ -226,7 +243,7 @@ export function createNetworkTools(defineTool, deps) {
                 // Cross-user access: validate shared membership scope
                 const callerMemberships = await userDb.getNetworkMemberships();
                 if (networkId) {
-                    if (context.networkId && networkId !== context.networkId) {
+                    if (boundNetworkId && networkId !== boundNetworkId) {
                         return error(`This chat is scoped to ${context.indexName ?? 'this network'}. You can only query membership in this community.`);
                     }
                     const callerInNetwork = callerMemberships.some((m) => m.networkId === networkId);
@@ -241,16 +258,16 @@ export function createNetworkTools(defineTool, deps) {
                 }
                 else {
                     // Strict scope enforcement: when chat is network-scoped, only check the scoped network
-                    if (context.networkId) {
-                        const isMember = await systemDb.isNetworkMember(context.networkId, targetUserId);
+                    if (boundNetworkId) {
+                        const isMember = await systemDb.isNetworkMember(boundNetworkId, targetUserId);
                         if (isMember) {
                             return success({
                                 isMember: true,
                                 userId: targetUserId,
-                                networkId: context.networkId,
+                                networkId: boundNetworkId,
                                 scopeRestriction: {
                                     isScoped: true,
-                                    scopedToNetwork: context.indexName ?? context.networkId,
+                                    scopedToNetwork: context.indexName ?? boundNetworkId,
                                     message: `This chat is scoped to "${context.indexName ?? 'this network'}". Only membership in this community is shown.`,
                                 },
                             });
@@ -258,11 +275,11 @@ export function createNetworkTools(defineTool, deps) {
                         return success({
                             isMember: false,
                             userId: targetUserId,
-                            networkId: context.networkId,
+                            networkId: boundNetworkId,
                             message: "User is not a member of this community.",
                             scopeRestriction: {
                                 isScoped: true,
-                                scopedToNetwork: context.indexName ?? context.networkId,
+                                scopedToNetwork: context.indexName ?? boundNetworkId,
                                 message: `This chat is scoped to "${context.indexName ?? 'this network'}". Only membership in this community was checked.`,
                             },
                         });
@@ -292,13 +309,13 @@ export function createNetworkTools(defineTool, deps) {
                 // Own memberships — use userDb
                 memberships = await userDb.getNetworkMemberships();
                 // Strict scope: when chat is network-scoped, only return the scoped network membership
-                if (context.networkId && !networkId) {
-                    memberships = memberships.filter((m) => m.networkId === context.networkId);
+                if (boundNetworkId && !networkId) {
+                    memberships = memberships.filter((m) => m.networkId === boundNetworkId);
                 }
             }
             // If both networkId and userId: filter to that specific membership
             if (networkId) {
-                if (context.networkId && networkId !== context.networkId) {
+                if (boundNetworkId && networkId !== boundNetworkId) {
                     return error(`This chat is scoped to ${context.indexName ?? 'this network'}. You can only query membership in this community.`);
                 }
                 const callerMemberships = await userDb.getNetworkMemberships();
@@ -321,7 +338,7 @@ export function createNetworkTools(defineTool, deps) {
                 });
             }
             // Own memberships in scoped chat
-            if (context.networkId && targetUserId === context.userId) {
+            if (boundNetworkId && targetUserId === context.userId) {
                 return success({
                     userId: targetUserId,
                     count: memberships.length,
@@ -333,7 +350,7 @@ export function createNetworkTools(defineTool, deps) {
                     })),
                     scopeRestriction: {
                         isScoped: true,
-                        scopedToNetwork: context.indexName ?? context.networkId,
+                        scopedToNetwork: context.indexName ?? boundNetworkId,
                         message: `Results are limited to "${context.indexName ?? 'this network'}" because this chat is scoped to that community. The user may belong to other communities not shown here.`,
                     },
                 });
@@ -372,11 +389,12 @@ export function createNetworkTools(defineTool, deps) {
             settings: updateNetworkSettingsSchema.describe("Object with fields to update. All fields are optional — only include the ones to change. title: display name. prompt: purpose description (used for intent auto-assignment). imageUrl: community image URL (null to remove). joinPolicy: 'anyone' or 'invite_only'. allowGuestVibeCheck: boolean."),
         }),
         handler: async ({ context, query }) => {
-            const effectiveNetworkId = (query.networkId?.trim() || context.networkId) ?? null;
+            const boundNetworkId = boundCommunityId(context);
+            const effectiveNetworkId = (query.networkId?.trim() || boundNetworkId) ?? null;
             if (!effectiveNetworkId || !UUID_REGEX.test(effectiveNetworkId)) {
                 return error("Valid networkId required.");
             }
-            if (context.networkId && effectiveNetworkId !== context.networkId) {
+            if (boundNetworkId && effectiveNetworkId !== boundNetworkId) {
                 return error(`This chat is scoped to ${context.indexName ?? 'this network'}. You can only update this community's settings.`);
             }
             const _updateStart = Date.now();
@@ -403,7 +421,7 @@ export function createNetworkTools(defineTool, deps) {
             "(complementary matches) between members. The network's prompt guides what kinds of intents belong.\n\n" +
             "**When to use:** When the user wants to create a new community — e.g. a professional network, interest group, or project team.\n\n" +
             "**Returns:** The new network's networkId (UUID) and title. Use the networkId to add members (create_network_membership), " +
-            "link intents (create_intent_index), or run discovery (discover_opportunities with networkId).",
+            "link intents (create_intent_index). Approved signals are matched in the background; use list_opportunities only to review persisted opportunities.",
         querySchema: z.object({
             title: z.string().describe("Display name of the network (e.g. 'AI Founders Berlin', 'Design Co-op'). Required."),
             prompt: z.string().optional().describe("Description of what this community is about. Used by the system to evaluate which intents belong in this network. Highly recommended for better auto-assignment."),
@@ -455,11 +473,12 @@ export function createNetworkTools(defineTool, deps) {
             networkId: z.string().optional().describe("Network UUID to delete. Get from read_networks. Defaults to the scoped network in network-scoped chats. Cannot be a personal network."),
         }),
         handler: async ({ context, query }) => {
-            const networkId = query.networkId?.trim() || context.networkId;
+            const boundNetworkId = boundCommunityId(context);
+            const networkId = query.networkId?.trim() || boundNetworkId;
             if (!networkId || !UUID_REGEX.test(networkId)) {
                 return error("Valid networkId required.");
             }
-            if (context.networkId && networkId !== context.networkId) {
+            if (boundNetworkId && networkId !== boundNetworkId) {
                 return error(`This chat is scoped to ${context.indexName ?? 'this network'}. You can only delete this community.`);
             }
             const _deleteStart = Date.now();
@@ -493,12 +512,13 @@ export function createNetworkTools(defineTool, deps) {
             networkId: z.string().optional().describe("Network UUID to add the member to. Get from read_networks. Defaults to the scoped network in network-scoped chats."),
         }),
         handler: async ({ context, query }) => {
-            const networkId = query.networkId?.trim() || context.networkId;
+            const boundNetworkId = boundCommunityId(context);
+            const networkId = query.networkId?.trim() || boundNetworkId;
             const targetUserId = query.userId?.trim() || context.userId;
             if (!networkId || !UUID_REGEX.test(networkId)) {
                 return error("Invalid network ID format. Use the exact UUID from read_networks.");
             }
-            if (context.networkId && networkId !== context.networkId) {
+            if (boundNetworkId && networkId !== boundNetworkId) {
                 return error(`This chat is scoped to ${context.indexName ?? 'this network'}. You can only add members to this community.`);
             }
             const _createMemberStart = Date.now();
@@ -529,7 +549,7 @@ export function createNetworkTools(defineTool, deps) {
     const deleteNetworkMembership = defineTool({
         name: "delete_network_membership",
         description: "Removes a user from a network (community). After removal, the user's intents are unlinked from this network " +
-            "and they can no longer participate in opportunity discovery within it.\n\n" +
+            "and their approved signals are no longer eligible for background matching within it.\n\n" +
             "**Permissions:** Only the network owner can remove members. The owner themselves cannot be removed (delete the network instead).\n\n" +
             "**When to use:** When a network owner wants to remove a member from the community. " +
             "Use read_network_memberships(networkId) first to get the userId of the member to remove.\n\n" +
@@ -539,7 +559,8 @@ export function createNetworkTools(defineTool, deps) {
             networkId: z.string().optional().describe("Network UUID to remove the member from. Get from read_networks. Defaults to the scoped network in network-scoped chats."),
         }),
         handler: async ({ context, query }) => {
-            const networkId = query.networkId?.trim() || context.networkId;
+            const boundNetworkId = boundCommunityId(context);
+            const networkId = query.networkId?.trim() || boundNetworkId;
             const targetUserId = query.userId?.trim();
             if (!networkId || !UUID_REGEX.test(networkId)) {
                 return error("Valid networkId required. Use the exact UUID from read_networks.");
@@ -547,7 +568,7 @@ export function createNetworkTools(defineTool, deps) {
             if (!targetUserId) {
                 return error("userId is required.");
             }
-            if (context.networkId && networkId !== context.networkId) {
+            if (boundNetworkId && networkId !== boundNetworkId) {
                 return error(`This chat is scoped to ${context.indexName ?? 'this network'}. You can only manage members of this community.`);
             }
             const _deleteMemberStart = Date.now();