@agent-native/core 0.92.12 → 0.94.0

package/corpus/templates/brain/changelog/2026-07-10-brain-settings-now-separate-assistant-behavior-publishing-re.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-10
+---
+
+Brain settings now separate assistant behavior, publishing review, and safety policies into focused sections.

package/corpus/templates/brain/changelog/2026-07-10-organization-settings-now-opens-directly-from-the-workspace-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Organization settings now opens directly from the workspace menu.

package/corpus/templates/calendar/.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/corpus/templates/calendar/.agents/skills/event-management/SKILL.md

@@ -85,7 +85,22 @@ pnpm action create-event \
 ```
 
 Required: `--title`, `--start`, `--end` (all ISO datetime format).
-Optional: `--description`, `--location`, `--attendees`, `--addGoogleMeet`, `--addZoom`, `--sendUpdates`.
+Optional: `--description`, `--location`, `--attendees`, `--addGoogleMeet`, `--addZoom`, `--sendUpdates`, `--accountEmail`.
+
+When multiple Google accounts are connected, choose the destination account's
+primary calendar with `--accountEmail`:
+
+```bash
+pnpm action create-event \
+  --title "Team standup" \
+  --start 2026-04-03T09:00:00 \
+  --end 2026-04-03T09:30:00 \
+  --accountEmail secondary@example.com
+```
+
+Creating without `accountEmail` is only unambiguous when one Google account is
+connected. The action does not support arbitrary non-primary Google calendar
+IDs.
 
 When attendees are invited and no video link/provider is supplied, Calendar
 automatically adds a Google Meet link by default. Pass `--addGoogleMeet=false`
@@ -179,10 +194,12 @@ location, attendees, reminders, attachments, color, and video provider.
 
 ### update-event
 
-Update an existing Google Calendar event. Use the event `id` from `list-events`, `search-events`, or `get-event`. If the event includes `accountEmail`, pass it through so multi-account calendars update the right connected account.
+Update an existing Google Calendar event. Use the event `id` from `list-events`,
+`search-events`, or `get-event`. Always preserve the event's `accountEmail` on
+the update so multi-account calendars use the right connected account.
 
 ```bash
-pnpm action update-event --id google-event-id --title "New title"
+pnpm action update-event --id google-event-id --accountEmail secondary@example.com --title "New title"
 pnpm action update-event --id google-event-id --start 2026-04-03T10:00:00 --end 2026-04-03T10:30:00
 
 # Replace attendee list (Google sends invites to anyone newly added)
@@ -232,12 +249,27 @@ pnpm action update-event \
 
 Delete an event if the user is the organizer, or remove it from their own calendar with `--removeOnly true` when they are not. For recurring events, use `--scope single`, `--scope all`, or `--scope thisAndFollowing`.
 
+Pass the event's `accountEmail` on deletes, including recurring-series choices
+and attendee removals, so the operation uses the account that owns the event.
+
 ```bash
-pnpm action delete-event --id google-event-id --scope single
+pnpm action delete-event --id google-event-id --accountEmail secondary@example.com --scope single
 pnpm action delete-event --id google-event-id --scope thisAndFollowing
 pnpm action delete-event --id google-event-id --removeOnly true
 ```
 
+### rsvp-event
+
+Accept, decline, or tentatively accept an invitation with the event's
+`accountEmail`. Preserve it for recurring RSVP scope as well:
+
+```bash
+pnpm action rsvp-event \
+  --id google-event-id \
+  --accountEmail secondary@example.com \
+  --status accepted
+```
+
 ## Date Patterns
 
 When the user says:

package/corpus/templates/calendar/AGENTS.md

@@ -75,6 +75,10 @@ Detailed event, availability, booking, storage, and UI rules live in
 - `navigate` moves the UI to calendar, event, availability, booking, and settings
   views.
 - Use actions for full event details and availability calculations.
+- Preserve `accountEmail` on every Google event write. When more than one
+  Google account is connected, pass the chosen account to `create-event`, and
+  pass the event's returned `accountEmail` to `update-event`, `delete-event`,
+  and `rsvp-event`. These actions target that account's primary calendar.
 
 ## Skills
 

package/corpus/templates/calendar/actions/create-event.ts

@@ -1,10 +1,6 @@
 import { defineAction } from "@agent-native/core";
 import { emit } from "@agent-native/core/event-bus";
-import {
-  buildDeepLink,
-  getRequestOrgId,
-  getRequestUserEmail,
-} from "@agent-native/core/server";
+import { buildDeepLink, getRequestUserEmail } from "@agent-native/core/server";
 import { z } from "zod";
 
 import {
@@ -24,6 +20,7 @@ import {
   googleColorIdInput,
   ensureOrganizerInAttendees,
   normalizeAttendees,
+  resolveOwnedAccountEmail,
   reminderMethodInput,
   reminderMinutesInput,
   remindersInput,
@@ -108,7 +105,9 @@ export default defineAction({
     accountEmail: z
       .string()
       .optional()
-      .describe("Account email to create the event on"),
+      .describe(
+        "Connected Google account email whose primary calendar receives the event. Required when multiple accounts are connected.",
+      ),
   }),
   run: async (args) => {
     const email = getRequestUserEmail();
@@ -130,19 +129,7 @@ export default defineAction({
       );
     }
 
-    // Resolve account email
-    let acctEmail = email;
-    if (args.accountEmail && args.accountEmail !== email) {
-      const status = await googleCalendar.getAuthStatus(
-        email,
-        getRequestOrgId(),
-      );
-      const isOwned = status.accounts.some(
-        (a) => a.email === args.accountEmail,
-      );
-      if (!isOwned) throw new Error("Account not owned by current user");
-      acctEmail = args.accountEmail;
-    }
+    const acctEmail = await resolveOwnedAccountEmail(args.accountEmail, email);
 
     const attendees = ensureOrganizerInAttendees(
       normalizeAttendees(args.attendees),
@@ -194,6 +181,7 @@ export default defineAction({
     }
 
     const result = await googleCalendar.createEvent(calEvent, {
+      account: { ownerEmail: email, accountEmail: acctEmail },
       addGoogleMeet: shouldAutoAddGoogleMeet(calEvent, {
         addGoogleMeet: args.addGoogleMeet,
         addZoom: args.addZoom,

package/corpus/templates/calendar/actions/delete-event.ts

@@ -72,17 +72,24 @@ export default defineAction({
         : (args.sendUpdates ?? (shouldNotifyGuests ? "all" : "none")),
     };
     const eventForNotification = shouldNotifyGuests
-      ? await googleCalendar.getEvent(googleEventId, accountEmail)
+      ? await googleCalendar.getEvent(googleEventId, {
+          ownerEmail,
+          accountEmail,
+        })
       : undefined;
 
     if (args.removeOnly) {
       await googleCalendar.removeEventFromCalendar(
         googleEventId,
-        accountEmail,
+        { ownerEmail, accountEmail },
         options,
       );
     } else {
-      await googleCalendar.deleteEvent(googleEventId, accountEmail, options);
+      await googleCalendar.deleteEvent(
+        googleEventId,
+        { ownerEmail, accountEmail },
+        options,
+      );
     }
 
     const guestNotification =

package/corpus/templates/calendar/actions/rsvp-event.ts

@@ -58,7 +58,7 @@ export default defineAction({
     await googleCalendar.rsvpEvent(
       googleEventId,
       args.status,
-      accountEmail,
+      { ownerEmail, accountEmail },
       args.scope,
       args.note?.trim() ?? args.note,
       args.sendUpdates,

package/corpus/templates/calendar/actions/update-event.ts

@@ -246,10 +246,10 @@ export default defineAction({
 
     let existingEvent: CalendarEvent | undefined;
     const loadExistingEvent = async () => {
-      existingEvent ??= await googleCalendar.getEvent(
-        googleEventId,
+      existingEvent ??= await googleCalendar.getEvent(googleEventId, {
+        ownerEmail,
         accountEmail,
-      );
+      });
       return existingEvent;
     };
 
@@ -297,6 +297,7 @@ export default defineAction({
     }
 
     const result = await googleCalendar.updateEvent(googleEventId, updates, {
+      account: { ownerEmail, accountEmail },
       sendUpdates:
         args.sendUpdates ??
         (guestNotificationMessage || (attendeesToAdd?.length ?? 0) > 0

package/corpus/templates/calendar/app/components/calendar/CommandPalette.tsx

@@ -12,7 +12,6 @@ import {
 } from "@tabler/icons-react";
 import * as chrono from "chrono-node";
 import { format, parseISO, parse, isValid } from "date-fns";
-import { useState, useMemo, useEffect } from "react";
 
 import { cn } from "@/lib/utils";
 
@@ -92,50 +91,114 @@ export function CommandPalette({
   onAddUrlCalendar,
 }: CommandPaletteProps) {
   const t = useT();
-  const [query, setQuery] = useState("");
 
-  // Reset query when opening
-  useEffect(() => {
-    if (open) setQuery("");
-  }, [open]);
+  function handleOpenChange(isOpen: boolean) {
+    if (!isOpen) {
+      onClose();
+    }
+  }
+
+  function renderSearchResults(query: string) {
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery) return null;
 
-  const parsedDate = useMemo(() => {
-    if (!query.trim()) return null;
+    let parsedDate: Date | null = null;
     for (const fmt of DATE_FORMATS) {
       try {
-        const d = parse(query.trim(), fmt, new Date());
-        if (isValid(d) && d.getFullYear() > 1970) return d;
+        const date = parse(trimmedQuery, fmt, new Date());
+        if (isValid(date) && date.getFullYear() > 1970) {
+          parsedDate = date;
+          break;
+        }
       } catch {
-        // continue
+        // Continue trying supported date formats.
       }
     }
-    return null;
-  }, [query]);
 
-  const matchingEvents = useMemo(() => {
-    if (!query.trim()) return [];
-    const q = query.toLowerCase();
-    return events
-      .filter((e) => e.title.toLowerCase().includes(q))
+    const queryLower = trimmedQuery.toLowerCase();
+    const matchingEvents = events
+      .filter((event) => event.title.toLowerCase().includes(queryLower))
       .sort((a, b) => new Date(a.start).getTime() - new Date(b.start).getTime())
       .slice(0, 6);
-  }, [query, events]);
 
-  // Only offer a natural-language quick-create when the query doesn't
-  // already resolve to a plain date jump or match existing events — those
-  // take priority since the user is more likely searching, not creating.
-  const quickCreate = useMemo(() => {
-    if (!onCreateEventFromText || parsedDate || matchingEvents.length > 0) {
-      return null;
-    }
-    return parseQuickCreateEvent(query);
-  }, [query, parsedDate, matchingEvents, onCreateEventFromText]);
+    // Plain date jumps and existing event matches take priority over creating
+    // a new event because the user is more likely navigating or searching.
+    const quickCreate =
+      onCreateEventFromText && !parsedDate && matchingEvents.length === 0
+        ? parseQuickCreateEvent(query)
+        : null;
 
-  function handleOpenChange(isOpen: boolean) {
-    if (!isOpen) {
-      setQuery("");
-      onClose();
-    }
+    if (!parsedDate && !quickCreate && matchingEvents.length === 0) return null;
+
+    return (
+      <>
+        {parsedDate && (
+          <CommandMenu.Group heading={t("eventForm.jumpTo")}>
+            <CommandMenu.Item
+              onSelect={() => onGoToDate(parsedDate)}
+              keywords={["date", "go", "jump"]}
+            >
+              <IconCalendar className="h-4 w-4" />
+              {t("eventForm.goToDate", {
+                date: format(parsedDate, "MMMM d, yyyy"),
+              })}
+              <CommandMenu.Shortcut>
+                <IconArrowRight className="h-3 w-3" />
+              </CommandMenu.Shortcut>
+            </CommandMenu.Item>
+          </CommandMenu.Group>
+        )}
+
+        {quickCreate && onCreateEventFromText && (
+          <CommandMenu.Group heading={t("eventForm.quickCreate")}>
+            <CommandMenu.Item
+              onSelect={() => onCreateEventFromText(quickCreate)}
+              keywords={["create", "new", "add", "event", quickCreate.title]}
+            >
+              <IconPlus className="h-4 w-4" />
+              <span className="min-w-0 flex-1 truncate">
+                {t("eventForm.createEventWithTitle", {
+                  title: quickCreate.title,
+                })}
+              </span>
+              <span className="ml-2 shrink-0 text-xs text-muted-foreground">
+                {quickCreate.hasExplicitTime
+                  ? format(quickCreate.start, "MMM d, h:mm a")
+                  : format(quickCreate.start, "MMM d")}
+              </span>
+            </CommandMenu.Item>
+          </CommandMenu.Group>
+        )}
+
+        {matchingEvents.length > 0 && (
+          <CommandMenu.Group heading={t("eventForm.events")}>
+            {matchingEvents.map((event) => (
+              <CommandMenu.Item
+                key={event.id}
+                onSelect={() => onEventClick(event)}
+                keywords={[event.title.toLowerCase()]}
+              >
+                <span
+                  className={cn(
+                    "h-2 w-2 shrink-0 rounded-full",
+                    event.color
+                      ? ""
+                      : event.source === "google"
+                        ? "bg-primary"
+                        : "bg-primary",
+                  )}
+                  style={event.color ? { background: event.color } : undefined}
+                />
+                <span className="flex-1 truncate">{event.title}</span>
+                <span className="ml-2 text-xs text-muted-foreground">
+                  {format(parseISO(event.start), "MMM d")}
+                </span>
+              </CommandMenu.Item>
+            ))}
+          </CommandMenu.Group>
+        )}
+      </>
+    );
   }
 
   const selectedGoogleEvent =
@@ -148,78 +211,8 @@ export function CommandPalette({
       open={open}
       onOpenChange={handleOpenChange}
       placeholder={t("eventForm.commandPlaceholder")}
+      renderResults={renderSearchResults}
     >
-      {/* Date jump - only show if query parses to a date */}
-      {parsedDate && (
-        <CommandMenu.Group heading={t("eventForm.jumpTo")}>
-          <CommandMenu.Item
-            onSelect={() => onGoToDate(parsedDate)}
-            keywords={["date", "go", "jump"]}
-          >
-            <IconCalendar className="h-4 w-4" />
-            {t("eventForm.goToDate", {
-              date: format(parsedDate, "MMMM d, yyyy"),
-            })}
-            <CommandMenu.Shortcut>
-              <IconArrowRight className="h-3 w-3" />
-            </CommandMenu.Shortcut>
-          </CommandMenu.Item>
-        </CommandMenu.Group>
-      )}
-
-      {/* Natural-language quick create - only offered when the query looks
-          like "<title> <when>" and doesn't already resolve to a date jump
-          or an existing event */}
-      {quickCreate && onCreateEventFromText && (
-        <CommandMenu.Group heading={t("eventForm.quickCreate")}>
-          <CommandMenu.Item
-            onSelect={() => onCreateEventFromText(quickCreate)}
-            keywords={["create", "new", "add", "event", quickCreate.title]}
-          >
-            <IconPlus className="h-4 w-4" />
-            <span className="min-w-0 flex-1 truncate">
-              {t("eventForm.createEventWithTitle", {
-                title: quickCreate.title,
-              })}
-            </span>
-            <span className="ml-2 shrink-0 text-xs text-muted-foreground">
-              {quickCreate.hasExplicitTime
-                ? format(quickCreate.start, "MMM d, h:mm a")
-                : format(quickCreate.start, "MMM d")}
-            </span>
-          </CommandMenu.Item>
-        </CommandMenu.Group>
-      )}
-
-      {/* Matching events */}
-      {matchingEvents.length > 0 && (
-        <CommandMenu.Group heading={t("eventForm.events")}>
-          {matchingEvents.map((event) => (
-            <CommandMenu.Item
-              key={event.id}
-              onSelect={() => onEventClick(event)}
-              keywords={[event.title.toLowerCase()]}
-            >
-              <span
-                className={cn(
-                  "h-2 w-2 shrink-0 rounded-full",
-                  event.color
-                    ? ""
-                    : event.source === "google"
-                      ? "bg-primary"
-                      : "bg-primary",
-                )}
-                style={event.color ? { background: event.color } : undefined}
-              />
-              <span className="flex-1 truncate">{event.title}</span>
-              <span className="ml-2 text-xs text-muted-foreground">
-                {format(parseISO(event.start), "MMM d")}
-              </span>
-            </CommandMenu.Item>
-          ))}
-        </CommandMenu.Group>
-      )}
-
       {selectedGoogleEvent && onOpenSelectedEventInGoogleCalendar && (
         <CommandMenu.Group heading={t("eventForm.selectedEvent")}>
           <CommandMenu.Item
@@ -243,10 +236,7 @@ export function CommandPalette({
         </CommandMenu.Group>
       )}
 
-      {(parsedDate ||
-        quickCreate ||
-        matchingEvents.length > 0 ||
-        selectedGoogleEvent) && <CommandMenu.Separator />}
+      {selectedGoogleEvent && <CommandMenu.Separator />}
 
       <CommandMenu.Group heading={t("root.commandActions")}>
         <CommandMenu.Item