@agent-native/core 0.92.11 → 0.93.0

package/docs/content/messaging.mdx

@@ -1,11 +1,11 @@
 ---
 title: "Messaging"
-description: "Talk to your agent from Slack, email, Telegram, or WhatsApp — same agent, same memory, same tools."
+description: "Talk to your agent from Slack, Microsoft Teams, Discord interactions, email, Telegram, or WhatsApp."
 ---
 
 # Messaging
 
-Connect your agent to Slack, email, Telegram, or WhatsApp so you can chat with it from the apps you already use. It's the same agent — same memory, same tools, same threads — just reachable from more places.
+Connect your agent to Slack, Microsoft Teams, Discord interactions, email, Telegram, or WhatsApp. It's the same agent — same memory, same tools, same threads — just reachable from more places.
 
 > **Using the Dispatch template?** All of this is wired up for you in **Settings → Messaging**. Click to connect each platform — you don't need to read the rest of this page unless you're customizing or building your own template. See [Dispatch](/docs/dispatch) or the [Dispatch template reference](/docs/template-dispatch).
 
@@ -14,6 +14,8 @@ Connect your agent to Slack, email, Telegram, or WhatsApp so you can chat with i
 - **Email your agent** at an address like `agent@yourcompany.com` — it replies in-thread, just like a coworker would.
 - **CC your agent** on a thread — it'll read along and jump in when you ask.
 - **DM the agent on Slack**, or `@mention` it in any channel.
+- **Message the bot in Microsoft Teams** in an allowed tenant.
+- **Run a Discord slash command.** The built-in Discord adapter handles HTTP interactions; ordinary Discord messages require a separate Gateway runtime.
 - **Message the agent on Telegram or WhatsApp** from your phone.
 - **Same agent, same memory.** Whatever you tell it on Slack is remembered when you email it later. The web chat and external messages share one thread history.
 - For one-way in-app alerts (bell icon, webhooks) see [Notifications](/docs/notifications).
@@ -24,6 +26,8 @@ Connect your agent to Slack, email, Telegram, or WhatsApp so you can chat with i
 <div class="msg-fanin">
   <div class="diagram-col">
     <div class="diagram-node">Slack</div>
+    <div class="diagram-node">Microsoft Teams</div>
+    <div class="diagram-node">Discord interactions</div>
     <div class="diagram-node">Email</div>
     <div class="diagram-node">Telegram</div>
     <div class="diagram-node">WhatsApp</div>
@@ -71,31 +75,127 @@ Connect your agent to Slack, email, Telegram, or WhatsApp so you can chat with i
 - A Slack workspace where you can install apps (admin access)
 - About 5 minutes
 
-### Steps
+### Managed Add to Slack
+
+Managed OAuth is the recommended setup for Dispatch and multi-workspace apps.
+Each install gets its own encrypted bot-token bundle and health record, and
+Slack workspace, app, channel, and thread IDs are part of the conversation key.
 
-1. Go to **[api.slack.com/apps](https://api.slack.com/apps)** and click **Create New App** → **From scratch**. Name it (e.g. "Agent") and pick your workspace.
-2. In the left sidebar, open **OAuth & Permissions**. Under **Bot Token Scopes**, add:
-   - `chat:write` — lets the agent send messages
-   - `app_mentions:read` — lets the agent see when it's @-mentioned (optional)
-   - `im:history` — lets the agent read DMs sent to it
-   - `assistant:write` — optional; lets Slack show native "is thinking..." status in assistant threads
-   - `users:read.email` — optional; helps templates such as Mail verify Slack sender email for draft-queue identity
-3. Click **Install to Workspace** at the top of that page. Slack will give you a **Bot User OAuth Token** that starts with `xoxb-`. Copy it.
-4. Go to **Basic Information** in the sidebar and copy the **Signing Secret**.
-5. Open your app's settings (or your hosting provider's environment variable panel) and paste:
-   - `SLACK_BOT_TOKEN` — the `xoxb-…` token
-   - `SLACK_SIGNING_SECRET` — the signing secret
-   - `SLACK_ALLOWED_TEAM_IDS` — recommended in production; comma-separated Slack workspace/team IDs allowed to send events
-   - `SLACK_ALLOWED_API_APP_IDS` — recommended for multi-workspace apps; comma-separated Slack app IDs allowed to use this signing secret
-6. Back in Slack, open **Event Subscriptions**, toggle it on, and paste this Request URL:
+1. In **Settings → Messaging**, select **Agent manifest** to download the
+   host-specific `agent-native-slack-manifest.json`, then create or update your
+   Slack app at **[api.slack.com/apps](https://api.slack.com/apps)** by importing
+   it from **App Manifest**. The manifest enables Slack's current `agent_view`
+   experience plus a writable App Home **Messages** tab for direct messages.
+   Slack app icons are not part of the manifest. Under **Basic Information →
+   Display Information**, upload the Agent Native icon so the Agents picker
+   matches the product; you can use the app's public `icon-512.svg` as the source
+   and convert it to a Slack-supported upload format if needed.
+2. Verify that the manifest requests these exact **Bot Token Scopes** under
+   **OAuth & Permissions**:
+
+   ```text
+   assistant:write
+   app_mentions:read
+   channels:history
+   channels:read
+   chat:write
+   files:read
+   groups:history
+   groups:read
+   im:history
+   im:read
+   mpim:history
+   mpim:read
+   pins:read
+   reactions:read
+   users:read
+   users:read.email
+   ```
+
+3. Add this **OAuth Redirect URL**:
+
+   ```text
+   https://your-app.example.com/_agent-native/integrations/slack/oauth/callback
+   ```
+
+4. Turn on **Event Subscriptions**, set the **Request URL**, and subscribe to
+   `app_home_opened`, `app_context_changed`, `app_mention`, `message.channels`,
+   `message.groups`, `message.im`, and `message.mpim`:
 
    ```text
    https://your-app.example.com/_agent-native/integrations/slack/webhook
    ```
 
-   Then under **Subscribe to bot events**, add `message.im` (for DMs) and optionally `app_mention` (for channel mentions). Save.
+5. Turn on **Interactivity & Shortcuts** and set its **Request URL**:
+
+   ```text
+   https://your-app.example.com/_agent-native/integrations/slack/interactions
+   ```
 
-7. Send your bot a DM in Slack. It should reply.
+6. Configure `SLACK_CLIENT_ID`, `SLACK_CLIENT_SECRET`, and
+   `SLACK_SIGNING_SECRET` on your app. Then open **Settings → Messaging** and
+   click **Add to Slack**. Only an organization owner or admin can create a
+   shared workspace install.
+7. Reinstall the Slack app after applying or changing the manifest, scopes,
+   events, Agent view, or Messages tab so the installation receives the updated
+   permissions and surfaces.
+
+In the current Agent view, `app_home_opened` detects when someone opens the
+Messages tab, `app_context_changed` provides the Slack surface they are viewing,
+and `message.im` delivers their direct messages. Slack owners and admins can hide
+installed agents for the workspace or organization, and each member can hide an
+agent from their own top bar. If the install succeeds but the agent is not
+visible there, check those Slack display controls or open it from **Tools →
+Apps**.
+
+The OAuth entry and callback endpoints are
+`/_agent-native/integrations/slack/oauth/install` and
+`/_agent-native/integrations/slack/oauth/callback`. Slack access and refresh
+tokens remain server-side. The canonical manifest leaves Slack token rotation
+disabled.
+Use the install health control in Messaging settings to test or disconnect a
+workspace.
+
+### Legacy single-workspace setup
+
+For a private, single-workspace deployment, you can still install the app
+manually and configure `SLACK_BOT_TOKEN` plus `SLACK_SIGNING_SECRET`.
+`SLACK_ALLOWED_TEAM_IDS` and `SLACK_ALLOWED_API_APP_IDS` are recommended in
+production. The environment token is a compatibility fallback; managed installs
+take precedence.
+
+### Slack-native collaboration
+
+- **Active thread steering.** Start in a channel with an `@mention`. While that
+  exact task is queued or running, ordinary replies in its Slack thread continue
+  the task without another mention. Inactive threads and general channel chatter
+  do not invoke the agent. DMs remain direct invocations.
+- **Bounded native context.** Before execution, the adapter loads a bounded
+  slice of the Slack thread plus channel, sender, reaction, and file metadata.
+  It keeps file references and permalinks, never raw file bodies, in durable
+  integration state.
+- **Live work card.** Slack's streaming task surface shows the plan, tool and
+  delegated-agent progress, and final answer. The requester can cancel a running
+  task or approve/deny a gated action from signed, single-use controls.
+  `assistant:write` enables Agent View context events; `chat:write` powers
+  replies and live status updates.
+- **Personal and channel identity.** A personal Slack DM is accepted only for a
+  verified Agent Native organization member or a Slack identity already linked
+  to that member. Configured channels instead run as the channel's explicit
+  service principal, with separate channel policies and budgets, so shared tools
+  and connections do not silently inherit the latest speaker's personal access.
+- **Explicit channel memory.** Channel memory is isolated by authorized
+  conversation scope. The agent saves or removes it only when someone explicitly
+  asks; ordinary conversation is not auto-memorized.
+- **Channel routines.** A recurring job created from Slack keeps its origin
+  scope, destination, thread, workspace, and optional model, then delivers its
+  scheduled result back to that Slack conversation.
+- **Governance.** Messaging settings expose configured-channel controls for
+  guest access, Slack Connect, service principals, default models, and budgets.
+  Daily or monthly organization, requester, and channel budgets are reserved
+  before a run and settled from actual usage. Audit and usage records keep
+  platform, workspace, channel, requester, task, run, source URL, and model
+  lineage.
 
 ### Optional: app unfurls
 
@@ -123,11 +223,59 @@ and `link_shared` events to the Clips unfurl handler.
 
 ### Tips
 
-- **Channel mentions** — the bot only responds in channels when it's @-mentioned, to avoid noise.
-- **DMs** — every DM is treated as a private conversation with the agent.
-- **Same identity, all channels** — if a Slack user has the same email as a registered user in your app, the agent treats them as the same person.
+- **Channel mentions** — use an @mention to start work. Unmentioned replies are accepted only while that exact thread has active work.
+- **DMs** — accepted personal DMs are private conversations and require a verified organization member or linked Slack identity.
+- **Identity** — personal DMs require a verified Agent Native organization member or an already linked Slack identity. Configured channels use a separate service principal, policy, and budget.
 - **Production allowlists** — set `SLACK_ALLOWED_TEAM_IDS` and, for shared Slack apps, `SLACK_ALLOWED_API_APP_IDS` so a valid signing secret cannot be reused by an unexpected workspace.
-- **Clips app unfurls** — installable Agent-Native Clips for Slack uses `SLACK_CLIENT_ID`, `SLACK_CLIENT_SECRET`, `SLACK_SIGNING_SECRET`, and `/api/slack/oauth/callback`. Each connected Slack workspace gets its own encrypted bot token in `app_secrets`; `SLACK_BOT_TOKEN` is only a legacy single-workspace fallback.
+- **Clips app unfurls** — Clips can share the managed Slack app credentials, but a Slack app has only one Events API Request URL; route `link_shared` to Clips when chat and unfurls share an app.
+
+## Set up Microsoft Teams {#microsoft-teams}
+
+The built-in Teams adapter uses the Bot Framework activity endpoint. Incoming
+JWTs are validated with Microsoft's `botframework-connector`, including issuer,
+audience, signed service URL, and Teams channel endorsement checks.
+
+1. Create a Microsoft Entra app registration and Azure Bot resource.
+2. Configure:
+   - `MICROSOFT_TEAMS_APP_ID`
+   - `MICROSOFT_TEAMS_APP_PASSWORD`
+   - `MICROSOFT_TEAMS_APP_TENANT_ID` for a single-tenant registration
+   - `MICROSOFT_TEAMS_ALLOWED_TENANT_IDS` as a comma-separated production allowlist
+3. Set the Azure Bot messaging endpoint to:
+
+   ```text
+   https://your-app.example.com/_agent-native/integrations/microsoft-teams/webhook
+   ```
+
+4. Add the Microsoft Teams channel to the bot and install it in an allowlisted tenant.
+
+Replies use the signed `serviceUrl`, conversation ID, and activity ID from the
+inbound activity. Proactive sends without an inbound conversation reference are
+not currently supported.
+
+## Set up Discord interactions {#discord}
+
+Discord supports HTTP interactions and persistent Gateway events. The built-in
+adapter implements **HTTP interactions only**: slash commands are verified with
+Discord's Ed25519 signature, acknowledged with a deferred type-5 response, and
+completed by editing the original interaction response. It does not claim to
+receive ordinary server messages or DMs.
+
+1. Create a Discord application and configure:
+   - `DISCORD_APPLICATION_ID`
+   - `DISCORD_PUBLIC_KEY`
+2. Set **Interactions Endpoint URL** to:
+
+   ```text
+   https://your-app.example.com/_agent-native/integrations/discord/webhook
+   ```
+
+3. Register a chat-input command with a string prompt option and install the
+   command for the intended server or users.
+
+Discord requires the initial response within 3 seconds. Interaction tokens are
+valid for 15 minutes and are stored only in the active queue payload; terminal
+queue rows erase that payload.
 
 ## Set up Telegram {#telegram}
 
@@ -142,6 +290,7 @@ and `link_shared` events to the Clips unfurl handler.
 2. Send `/newbot` and follow the prompts to name your bot. BotFather will reply with an **HTTP API token**. Copy it.
 3. In your app's environment variables, set:
    - `TELEGRAM_BOT_TOKEN` — the token from BotFather
+   - `TELEGRAM_WEBHOOK_SECRET` — a random secret used to authenticate webhook deliveries
 4. After deploying, register the webhook by `POST`ing to your app at:
 
    ```text
@@ -152,6 +301,10 @@ and `link_shared` events to the Clips unfurl handler.
 
 5. Find your bot in Telegram (search for the username BotFather gave you) and send it a message.
 
+Telegram forum topics and private-chat topics keep `message_thread_id` in the
+canonical conversation identity. Replies preserve both the topic and the
+inbound message through Bot API `reply_parameters`.
+
 ## Set up Email {#email}
 
 Email is the most powerful integration — your agent gets its own address, replies in-thread, can be CC'd on conversations, and uses the sender's email as their identity. No `/link` command needed.
@@ -232,6 +385,7 @@ Email is the most powerful integration — your agent gets its own address, repl
    - `WHATSAPP_ACCESS_TOKEN` — your access token
    - `WHATSAPP_PHONE_NUMBER_ID` — the phone number ID
    - `WHATSAPP_VERIFY_TOKEN` — the random string you picked
+   - `WHATSAPP_APP_SECRET` — the Meta app secret used to verify webhook HMAC signatures
 6. Back in Meta's WhatsApp config, open the webhook section and set:
 
    ```text
@@ -243,6 +397,8 @@ Email is the most powerful integration — your agent gets its own address, repl
 
 7. Send a WhatsApp message to the bot's phone number.
 
+Replies quote the inbound WhatsApp message using its `wamid` when available.
+
 ## Use Dispatch as your agent's central inbox {#dispatch}
 
 If you're running multiple agent-native apps (mail, calendar, analytics, etc.), the recommended pattern is to set up messaging on **[Dispatch](/docs/dispatch)** (see also the [template reference](/docs/template-dispatch)) and let it route work to your domain apps over [A2A](/docs/a2a-protocol).
@@ -415,6 +571,8 @@ Which platforms are active depends on which env vars are set. The plugin registe
 
 ```text
 /_agent-native/integrations/slack/webhook
+/_agent-native/integrations/microsoft-teams/webhook
+/_agent-native/integrations/discord/webhook
 /_agent-native/integrations/telegram/webhook
 /_agent-native/integrations/whatsapp/webhook
 /_agent-native/integrations/email/webhook
@@ -428,14 +586,18 @@ POST /_agent-native/integrations/telegram/setup
 
 ### Environment variables {#env-vars}
 
-| Platform | Required                                                                     | Optional                                              |
-| -------- | ---------------------------------------------------------------------------- | ----------------------------------------------------- |
-| Slack    | `SLACK_BOT_TOKEN`, `SLACK_SIGNING_SECRET`                                    | `SLACK_ALLOWED_TEAM_IDS`, `SLACK_ALLOWED_API_APP_IDS` |
-| Telegram | `TELEGRAM_BOT_TOKEN`                                                         | —                                                     |
-| Email    | `EMAIL_AGENT_ADDRESS`, plus one of `RESEND_API_KEY` or `SENDGRID_API_KEY`    | `EMAIL_INBOUND_WEBHOOK_SECRET`                        |
-| WhatsApp | `WHATSAPP_ACCESS_TOKEN`, `WHATSAPP_VERIFY_TOKEN`, `WHATSAPP_PHONE_NUMBER_ID` | —                                                     |
+| Platform        | Required                                                                                            | Optional                                              |
+| --------------- | --------------------------------------------------------------------------------------------------- | ----------------------------------------------------- |
+| Slack           | `SLACK_BOT_TOKEN`, `SLACK_SIGNING_SECRET`                                                           | `SLACK_ALLOWED_TEAM_IDS`, `SLACK_ALLOWED_API_APP_IDS` |
+| Microsoft Teams | `MICROSOFT_TEAMS_APP_ID`, `MICROSOFT_TEAMS_APP_PASSWORD`, `MICROSOFT_TEAMS_ALLOWED_TENANT_IDS`      | `MICROSOFT_TEAMS_APP_TENANT_ID`                       |
+| Discord         | `DISCORD_APPLICATION_ID`, `DISCORD_PUBLIC_KEY`                                                      | —                                                     |
+| Telegram        | `TELEGRAM_BOT_TOKEN`, `TELEGRAM_WEBHOOK_SECRET`                                                     | —                                                     |
+| Email           | `EMAIL_AGENT_ADDRESS`, plus one of `RESEND_API_KEY` or `SENDGRID_API_KEY`                           | `EMAIL_INBOUND_WEBHOOK_SECRET`                        |
+| WhatsApp        | `WHATSAPP_ACCESS_TOKEN`, `WHATSAPP_VERIFY_TOKEN`, `WHATSAPP_PHONE_NUMBER_ID`, `WHATSAPP_APP_SECRET` | —                                                     |
+
+Integration credentials resolve from the integration owner's scoped secrets first (user, org, then workspace), with deployment env vars available as a local or deliberate single-tenant fallback. The setup UI saves scoped secrets; use deployment configuration only when you intentionally want one shared integration identity. Values are never returned to the browser or stored in source code.
 
-All credentials live in env vars — never the database, never source code. Use the sidebar settings UI or your hosting provider's env panel.
+The built-in runtime adapters are **Slack**, **Microsoft Teams**, **Discord interactions**, **Telegram**, **WhatsApp Cloud API**, and **provider-webhook email** (Resend or SendGrid). Discord support is interaction-only; ordinary Discord message ingestion is not included.
 
 ### Threading and identity {#threading-and-identity}
 
@@ -443,8 +605,10 @@ Each external conversation maps to a persistent thread in the agent-native datab
 
 - **Slack DM** → one thread per Slack user.
 - **Slack channel @mention** → one thread per channel.
-- **Telegram chat** → one thread per Telegram chat.
-- **WhatsApp conversation** → one thread per WhatsApp number.
+- **Microsoft Teams** → tenant + team/channel + Bot Framework conversation.
+- **Discord interaction** → application + guild/DM + channel.
+- **Telegram chat** → one thread per chat and `message_thread_id` topic.
+- **WhatsApp conversation** → business phone-number ID + sender number.
 - **Email** → threading derived from `Message-ID` / `In-Reply-To` / `References` headers.
 
 External threads appear in the web UI alongside web-originated threads, tagged with their source platform. Identity resolution: when a Slack/email user matches a registered user (typically by email), they're linked to that account.
@@ -454,6 +618,8 @@ External threads appear in the web UI alongside web-originated threads, tagged w
 Every incoming webhook is signature-verified before processing:
 
 - **Slack** — HMAC-SHA256 of the body using `SLACK_SIGNING_SECRET`, checked against the `X-Slack-Signature` header. The first time you save a Request URL in Slack's Event Subscriptions panel, Slack POSTs a `url_verification` challenge to it; the framework's adapter detects this and replies with the `challenge` value automatically, so the URL flips green in Slack without any extra work on your end.
+- **Microsoft Teams** — Microsoft Bot Framework JWT verification, including signing keys, issuer, app audience, service URL claim, channel endorsement, and tenant allowlist.
+- **Discord** — Ed25519 verification over the timestamp plus exact raw body. Invalid PING probes return 401.
 - **Telegram** — secret token set when registering the webhook.
 - **WhatsApp** — Meta's verification challenge (using `WHATSAPP_VERIFY_TOKEN`) plus payload signature.
 - **Email** — Svix-style signature verification when `EMAIL_INBOUND_WEBHOOK_SECRET` is set (Resend and SendGrid both use this format). If the secret is unset, the webhook is accepted but a warning is logged.
@@ -465,7 +631,7 @@ The email adapter also enforces:
 
 ### Proactive sends {#proactive-sends}
 
-The agent can send messages on its own initiative (notifications, reminders, scheduled summaries) by calling the `send-platform-message` action with a `platform` field of `"slack"`, `"telegram"`, `"whatsapp"`, or `"email"`. The action lives in the Dispatch package at `packages/dispatch/src/actions/send-platform-message.ts` and you can copy/adapt it for any template.
+The agent can send messages on its own initiative through the Dispatch `send-platform-message` action for `"slack"`, `"telegram"`, or `"email"`. Microsoft Teams requires a saved Bot Framework conversation reference, Discord interaction tokens expire, and the WhatsApp adapter does not implement template-message proactive sends, so those three are reply-only.
 
 ### Custom adapters {#custom-adapters}
 
@@ -481,13 +647,20 @@ import type {
 import type { EnvKeyConfig } from "@agent-native/core/server";
 
 const myAdapter: PlatformAdapter = {
-  platform: "discord",
-  label: "Discord",
+  platform: "my-chat",
+  label: "My Chat",
+  capabilities: {
+    replyText: true,
+    proactiveMessages: false,
+    nativeThreads: true,
+    contextualReplies: true,
+    deferredWebhookResponse: false,
+  },
 
   // Env keys this adapter needs (rendered in the settings UI)
   getRequiredEnvKeys(): EnvKeyConfig[] {
     return [
-      { key: "DISCORD_BOT_TOKEN", label: "Discord Bot Token", required: true },
+      { key: "MY_CHAT_BOT_TOKEN", label: "My Chat Bot Token", required: true },
     ];
   },
 
@@ -499,18 +672,21 @@ const myAdapter: PlatformAdapter = {
 
   // Validate the webhook request signature
   async verifyWebhook(event: H3Event): Promise<boolean> {
-    // Validate signature headers; return true if authentic
-    return true;
+    // Implement the provider's documented signature/JWT verification here.
+    // Fail closed; never ship `return true` as a placeholder.
+    throw new Error("Webhook verification is not implemented");
   },
 
   // Parse the webhook payload into a normalized IncomingMessage.
   // Return null to silently ignore the event (bot messages, edits, etc.).
   async parseIncomingMessage(event: H3Event): Promise<IncomingMessage | null> {
     return {
-      platform: "discord",
+      platform: "my-chat",
       externalThreadId: "channel-or-thread-id",
       text: "the user's message",
-      senderId: "discord-user-id",
+      senderId: "my-chat-user-id",
+      threadRef: "provider-thread-id",
+      replyRef: "provider-message-id",
       platformContext: { channelId: "channel-id" },
       timestamp: Date.now(),
     };
@@ -538,15 +714,21 @@ const myAdapter: PlatformAdapter = {
   // baseUrl is the app's public URL, used for status checks that need it.
   async getStatus(baseUrl?: string) {
     return {
-      platform: "discord",
-      label: "Discord",
+      platform: "my-chat",
+      label: "My Chat",
       enabled: true,
-      configured: !!process.env.DISCORD_BOT_TOKEN,
+      configured: !!process.env.MY_CHAT_BOT_TOKEN,
     };
   },
 };
 ```
 
+If the provider requires an immediate response, implement
+`getImmediateWebhookResponse(incoming)`. Keep short-lived delivery credentials
+in `incoming.responseContext`, not `platformContext`; terminal queue rows erase
+the active payload. The response is returned only after verification and a
+durable queue insert.
+
 Register it in your integrations plugin:
 
 ```ts
@@ -557,7 +739,7 @@ export default createIntegrationsPlugin({
 });
 ```
 
-Reference implementations live in `packages/core/src/integrations/adapters/` (`slack.ts`, `telegram.ts`, `whatsapp.ts`, `email.ts`) — the email adapter is the most complete example, including signature verification, threading, rate limiting, and HTML rendering.
+Reference implementations live in `packages/core/src/integrations/adapters/`. See `microsoft-teams.ts` for official JWT validation and token caching, `discord.ts` for signed deferred interactions, and `telegram.ts` or `whatsapp.ts` for native reply references.
 
 ### Reliability via Dispatch + A2A continuations {#reliability}
 

package/docs/content/template-clips.mdx

@@ -77,6 +77,9 @@ Think along the lines of Loom + Granola + Wispr Flow rolled into one app — but
 ## What you can do with it
 
 - **Record your screen** with a built-in recorder, webcam overlay, audio capture, and pause/trim.
+- **Import public Loom videos.** On the web, select **Record → Import Loom**,
+  then paste a Loom share or embed URL. Clips saves a copy in your library and
+  imports the public transcript when one is available.
 - **Capture meetings from your calendar.** Connect Google Calendar, see upcoming meetings in the sidebar, and hit record on any one. You get a live transcript plus AI summary, bullet notes, and action items the moment it ends.
 - **Push-to-talk dictation.** Hold Fn on your machine, speak, and the cleaned-up text drops into whatever app you're using. Every dictation is kept in a searchable history with originals and AI-cleaned versions side by side.
 - **Get an auto-generated title, summary, and chapter markers** for every recording — the agent fills them in and keeps them current.

package/docs/content/template-design.mdx

@@ -89,6 +89,7 @@ When you open the app, the generated prototype is the center of the workspace, w
 ## What you can do with it
 
 - **Generate complete prototypes.** Describe the screen or page you need and the agent creates a working HTML document with Tailwind styling and Alpine interactions.
+- **Start from reusable templates.** Choose a sized starter for ads, one-pagers, landing pages, and more, or save any inline design as a template. A prompt refines the copied design while locked logo, background, and other fixed layers stay unchanged.
 - **Compare variants.** Start with multiple directions, pick the strongest one, then continue refining.
 - **Tweak visually.** Use the built-in tweak controls for common changes, or ask the agent for copy, layout, color, spacing, and interaction updates.
 - **Apply design systems.** Save and reuse design-system preferences so generated work stays closer to your brand.
@@ -137,6 +138,9 @@ All data lives in SQL via Drizzle ORM. Schema: `templates/design/server/db/schem
 | ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `designs`                                | A design project — `title`, `description`, `project_type` (`prototype` / `other`), the `data` JSON blob, and an optional `design_system_id` link |
 | `design_files`                           | Individual files belonging to a design (`filename`, `content`, `file_type` defaulting to `html`)                                                 |
+| `design_templates`                       | Reusable template metadata, dimensions, defaults, source design reference, and locked-layer count                                                |
+| `design_template_files`                  | Snapshotted template files copied into a normal editable design when a user starts from a template                                               |
+| `design_template_shares`                 | Framework shares table for private, org, explicitly shared, and public template discovery                                                        |
 | `design_versions`                        | Point-in-time `snapshot`s of a design with an optional `label`, for history and rollback                                                         |
 | `design_systems`                         | Reusable brand tokens — `data` (colors/typography/spacing), `assets`, `custom_instructions`, and an `is_default` flag                            |
 | `design_shares` / `design_system_shares` | Framework shares tables mapping principals (users or orgs) to roles (viewer, editor, admin)                                                      |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.92.11",
+  "version": "0.93.0",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -46,6 +46,8 @@
     "./server/agent-discovery": "./dist/server/agent-discovery.js",
     "./server/request-context": "./dist/server/request-context.js",
     "./server/design-token-utils": "./dist/server/design-token-utils.js",
+    "./integrations": "./dist/integrations/index.js",
+    "./automation": "./dist/automation/index.js",
     "./brand-kit": "./dist/brand-kit/index.js",
     "./brand-kit/fig": "./dist/brand-kit/fig/index.js",
     "./data-widgets": "./dist/data-widgets/index.js",
@@ -280,6 +282,7 @@
     "ajv": "^8.20.0",
     "better-auth": "1.6.16",
     "better-sqlite3": "^12.8.0",
+    "botframework-connector": "^4.23.3",
     "clsx": "^2.1.1",
     "cron-parser": "^5.5.0",
     "diff-match-patch": "^1.0.5",
@@ -312,6 +315,7 @@
     "tiptap-markdown": "^0.9.0",
     "turndown": "7.2.4",
     "tw-animate-css": "1.4.0",
+    "tweetnacl": "^1.0.3",
     "y-protocols": "^1.0.7",
     "yjs": "^13.6.31",
     "zod": "^4.3.6",

package/src/templates/default/.agents/skills/capture-learnings/SKILL.md

@@ -11,11 +11,14 @@ metadata:
 
 # Capture Learnings
 
-This is background knowledge, not a slash command. **Your memory index is loaded at the start of every conversation.** Use `save-memory` proactively when you learn something worth remembering.
+This is background knowledge, not a slash command. **Organization learnings and your personal memory index are loaded at the start of every conversation, including Slack/integration turns.** Capture durable context proactively when you learn something worth remembering.
 
 ## How to Read & Write Memories
 
-Memories are stored as **resources** in the SQL database (personal scope), not as files on disk.
+Memories are stored as **resources** in the SQL database, not as files on disk.
+
+- **Team/organization knowledge:** shared `LEARNINGS.md`. Read it first, merge the new fact, then write the full updated file with the `resources` tool using `scope: "shared"`. Shared scope resolves to the active organization; it must never leak to another organization in the same deployment.
+- **Personal knowledge:** `memory/MEMORY.md` plus `memory/<name>.md`, written with `save-memory`.
 
 - **Save a memory:** `save-memory --name <name> --type <type> --description "..." --content "..."`
 - **Read a memory:** `resource-read --path memory/<name>.md`
@@ -33,6 +36,14 @@ Memories are stored as **resources** in the SQL database (personal scope), not a
 
 ## When to Capture
 
+### Team and organization knowledge (`LEARNINGS.md`, shared scope)
+- Canonical destinations and workflows (for example, which Content database receives a type of Slack request)
+- Required intake fields, ownership, prioritization conventions, metric definitions, and approved terminology
+- Durable external references that the whole team needs, including the canonical page/database URL
+- Corrections or decisions that should affect every organization member's future Slack and app conversations
+
+Store the fact and a concise provenance link when available. Do not paste full private conversations, customer data, credentials, or secrets into learnings. Put stable always-on policy in shared `AGENTS.md`; put learned facts and evolving conventions in shared `LEARNINGS.md`.
+
 ### User Preferences & Memory (`user`)
 - **Tone and style** — "I prefer casual tone", "don't use emojis", "keep replies short"
 - **Personal context** — contacts, relationships, habits ("my wife's email is...", "I'm in PST timezone")
@@ -58,19 +69,21 @@ Memories are stored as **resources** in the SQL database (personal scope), not a
 - Things obvious from reading the code
 - Standard language/framework behavior
 - Temporary debugging notes
-- Anything already in AGENTS.md or skills
+- Anything already in AGENTS.md, shared LEARNINGS.md, or skills
 - Ephemeral task details (use tasks/plans instead)
 
 ## Key Rules
 
-1. **Save proactively — don't ask permission.** When you learn something, save it immediately.
-2. **One memory per topic** — e.g. `coding-style`, `project-alpha`, not one giant dump
-3. **Read before updating** — if a memory exists, read it first and merge, don't overwrite
-4. **Keep descriptions concise** — the index is loaded every conversation
-5. **Memories are SQL-backed** — safe for personal info, persist across sessions, not in git
+1. **Save proactively — don't ask permission.** When you learn something durable, save it immediately at the correct scope.
+2. **Choose scope by audience.** Organization workflow or reference → shared `LEARNINGS.md`; one person's preference/context → personal memory.
+3. **One memory per topic** — e.g. `coding-style`, `project-alpha`, not one giant dump
+4. **Read before updating** — if a memory exists, read it first and merge, don't overwrite
+5. **Keep descriptions concise** — the index is loaded every conversation
+6. **Memories are SQL-backed** — they persist across sessions and are not in git; still minimize sensitive content
 
 ## Graduation
 
 When a memory is referenced repeatedly, it may belong in AGENTS.md or a skill:
-- Saving a memory is lightweight (auto-apply, personal scope)
+- Saving a personal memory is lightweight (auto-apply, personal scope)
+- Shared LEARNINGS.md is the lightweight organization knowledge layer
 - Updating AGENTS.md or a skill is heavier (affects all users/agents)

package/src/templates/default/AGENTS.md

@@ -76,9 +76,13 @@ only the hosted URL/reference in SQL.
 1. **`AGENTS.md`** -- inherited workspace defaults, app/team instructions, and user-specific context.
 2. **`LEARNINGS.md`** -- user preferences, corrections, and patterns. Read personal and shared scopes.
 
-**Update `LEARNINGS.md` when you learn something important.** Built-in app
-chat agents use the `resources` tool with the `action` argument. External CLI
-agents can use the equivalent `pnpm action resource-*` commands.
+**Update the shared `LEARNINGS.md` when you learn something important for the
+team.** Canonical destinations, request fields, metric definitions, routing
+conventions, and corrections learned in Slack belong there with concise source
+links. Shared scope resolves to the active organization. Personal preferences
+and user-specific context go through `save-memory` into `memory/MEMORY.md`.
+Built-in app chat agents use the `resources` tool with the `action` argument.
+External CLI agents can use the equivalent `pnpm action resource-*` commands.
 
 | Built-in agent tool call                                                | CLI equivalent                                                                         | Purpose                 |
 | ----------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ----------------------- |

package/src/templates/workspace-core/.agents/skills/authentication/SKILL.md

@@ -19,7 +19,7 @@ Auth is powered by **Better Auth** with account-first design. Every new user cre
 
 | Mode                      | Behavior                                                                                                                                 |
 | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
-| **Development (default)** | Real Better Auth — same flow as production. There is **no auth bypass**. On first run the framework auto-creates a throwaway dev account and signs you in (credentials printed once to the console; disable with `AGENT_NATIVE_DISABLE_AUTO_DEV_ACCOUNT=1`), so you are not stuck at a login wall. `getSession()` returns the signed-in user or `null` — it never falls back to a sentinel identity. |
+| **Development (default)** | Real Better Auth — same flow as production. There is **no auth bypass**. On first run the framework auto-creates a throwaway dev account and signs you in without printing its credentials (disable with `AGENT_NATIVE_DISABLE_AUTO_DEV_ACCOUNT=1`), so you are not stuck at a login wall. `getSession()` returns the signed-in user or `null` — it never falls back to a sentinel identity. |
 | **Production (default)**  | Better Auth with email/password + social providers (Google, GitHub). Organizations built in.                                             |
 | **`AUTH_MODE=local`**     | **Not** a browser auth bypass, and never returns `local@localhost`. It only affects CLI/agent identity: it lets `pnpm action` / the local agent loop auto-bind to the single real signed-in dev user from the `sessions` table (see `scripts/dev-session.ts`). Browser login is unchanged. |
 | **`AUTH_SKIP_EMAIL_VERIFICATION=1`** | QA/preview escape hatch for real email/password accounts. Signup skips email verification and does not send the signup verification email. Local dev/test skips verification by default; set `AUTH_SKIP_EMAIL_VERIFICATION=0` only when testing verification itself. Use `+qa` emails for test accounts. |