@oxygen-agent/cli 1.1014.619 → 1.1014.771

package/node_modules/@oxygen/shared/dist/teammate-groups.d.ts

@@ -1,55 +1,134 @@
 /**
- * Oxygent group chats (ADR 0032, phase 7), the way Grok Bot's are: one person's
- * private conversation with two to six of the workspace's Oxygents (Tim,
- * 2026-10-12: "really emulate grokbot"). Each turn is answered by one member:
+ * Oxygent group chats (ADR 0032, phase 7), the way Grok Bot's are (Tim,
+ * 2026-10-12: "really emulate grokbot"): a conversation with up to six of the
+ * workspace's Oxygents and, since 2026-10-15, teammates too, picked the way a
+ * WhatsApp group's members are (Tim: "group chat with a bot and your team mates
+ * ... that you can select who can join the group"). Each answer is one Oxygent's:
  *
- * - The person picks with @mentions, by name or slug: the first one mentioned
- *   answers, and each other one mentioned answers after it, in order.
- * - With no mention, the member who answered last answers again; in a group
- *   nobody has answered yet, the first member. No member ranks above the
- *   others (Tim, 2026-10-13: no Chief of Staff).
- * - A member's answer may @mention another member to bring them in. Each member
- *   answers a person's message at most once, so a message ends after at most
- *   one turn per member.
+ * - An @mention picks: the Oxygents a message mentions answer, in order. A
+ *   message that @mentions only people is theirs, and no Oxygent answers it.
+ * - With no mention, the Oxygents the message is for answer, most fitting first
+ *   and at most {@link TEAMMATE_GROUP_MAX_ROUTED} (Tim, 2026-10-15: "the agents
+ *   should know which is assigned based on the query ... it just needs to be fast
+ *   and multiple agents should be able to answer"). The web asks System One, one
+ *   yes/no per Oxygent in a single call. When none fits, or System One cannot
+ *   say: in a group of one person, the Oxygent who answered last answers, else
+ *   the first one (no member ranks above the others; Tim, 2026-10-13: no Chief of
+ *   Staff); in a group with other people, nobody does, and they can @mention one.
+ * - An answer may @mention another Oxygent to bring it in. Each Oxygent answers a
+ *   message at most once, so a message ends after at most one turn per Oxygent.
  *
- * Pure rules, shared by the web (which picks the first responder when the
- * person sends) and the worker (which relays to the next one after a turn).
+ * Pure rules, shared by the web (which routes a person's message as it is sent)
+ * and the worker (which relays to the next Oxygent after a turn).
  */
 export declare const TEAMMATE_GROUP_MIN_MEMBERS = 2;
 export declare const TEAMMATE_GROUP_MAX_MEMBERS = 6;
+/** The people a group holds, its creator included. */
+export declare const TEAMMATE_GROUP_MAX_PEOPLE = 50;
 export declare const TEAMMATE_GROUP_TITLE_MAX_CHARS = 80;
+/** The most Oxygents that answer one message nobody @mentioned. */
+export declare const TEAMMATE_GROUP_MAX_ROUTED = 3;
+/**
+ * The fewest Oxygents a group holds: two in a group of just its creator, the way
+ * group chats began, and one once other people are in it.
+ */
+export declare function teammateGroupMinMembers(peopleCount: number): number;
+/** A person's role in a group chat: admins change who is in it and its name (Tim, 2026-10-15). */
+export type TeammateGroupRole = "admin" | "member";
+export declare function isTeammateGroupRole(value: unknown): value is TeammateGroupRole;
 export type TeammateGroupMember = {
     agentId: string;
     slug: string;
     name: string;
 };
+/** A person in a group chat, as a mention names them. */
+export type TeammateGroupPerson = {
+    actorId: string;
+    name: string;
+};
 /**
- * The members a text @mentions, in the order it first mentions them. A mention
- * is `@` followed by a member's name or slug, ignoring case; the longest name
- * that fits wins, so "@Outbound Lead" is not read as "@Outbound".
+ * Who a text @mentions, Oxygents and people, each in the order first mentioned.
+ * A mention is `@` followed by an Oxygent's name or slug, or a person's name (or
+ * first name, when it is theirs alone), ignoring case; the longest label that
+ * fits wins, so "@Outbound Lead" is not read as "@Outbound".
  */
-export declare function teammateGroupMentions(text: string, members: readonly TeammateGroupMember[]): string[];
+export declare function teammateGroupAddressees(text: string, members: readonly TeammateGroupMember[], people?: readonly TeammateGroupPerson[]): {
+    agentIds: string[];
+    actorIds: string[];
+};
+/** The Oxygents a text @mentions, in the order it first mentions them (people never count). */
+export declare function teammateGroupMentions(text: string, members: readonly TeammateGroupMember[], people?: readonly TeammateGroupPerson[]): string[];
 /**
- * Who answers a person's new message: the first member it mentions, else the
- * member who answered last, else the first member. Members are in their group
- * order.
+ * Who answers a person's new message: the first Oxygent it mentions, else the
+ * one who answered last, else the first member. Members are in their group
+ * order. The rule of a group of one person when nothing better is known.
  */
 export declare function teammateGroupFirstResponder(input: {
     members: readonly TeammateGroupMember[];
     message: string;
     lastResponderAgentId: string | null;
+    people?: readonly TeammateGroupPerson[];
 }): string;
 /**
- * Who answers next after a member's turn on the same message, or null when the
- * message is done: the next member the person mentioned who has not answered
- * it yet, else a member the latest answer mentioned who has not answered it yet.
+ * How a person's message was routed, kept on the turn that answers it (or on
+ * the message, when nobody does) so a reader can see why:
+ *
+ * - `mention`: the Oxygents it @mentioned.
+ * - `people`: it @mentioned only people, so no Oxygent answers.
+ * - `classifier`: System One said which Oxygents it is for.
+ * - `last_responder` / `first_member`: a group of one person, with nothing better known.
+ * - `none`: a group with other people, and no Oxygent it is clearly for.
+ */
+export type TeammateGroupRouteBy = "mention" | "people" | "classifier" | "last_responder" | "first_member" | "none";
+export type TeammateGroupRoute = {
+    by: TeammateGroupRouteBy;
+    /** The Oxygents that answer, in order; empty when nobody does. */
+    responders: string[];
+};
+/**
+ * The part of routing no model is needed for: a message that @mentions
+ * Oxygents goes to them, one that @mentions only people goes to nobody, and
+ * anything else needs to know what the message is about (null).
+ */
+export declare function teammateGroupRouteByMentions(input: {
+    message: string;
+    members: readonly TeammateGroupMember[];
+    people?: readonly TeammateGroupPerson[];
+}): TeammateGroupRoute | null;
+/** System One's yes or no for one Oxygent: whether the message is for it. */
+export type TeammateGroupFit = {
+    agentId: string;
+    fits: boolean;
+    /** How sure, from 0 to 1; null when the answer was unusable. */
+    probability: number | null;
+};
+/**
+ * Who answers a message no mention settled, from what System One said (null
+ * when it said nothing usable: off, unreachable or out of credits): the
+ * Oxygents it fits, most fitting first and at most {@link TEAMMATE_GROUP_MAX_ROUTED};
+ * when none fits, the one who answered last (else the first member) in a group
+ * of one person, and nobody in a group with other people.
+ */
+export declare function teammateGroupRouteFromFits(input: {
+    members: readonly TeammateGroupMember[];
+    fits: readonly TeammateGroupFit[] | null;
+    withPeople: boolean;
+    lastResponderAgentId: string | null;
+}): TeammateGroupRoute;
+/**
+ * Who answers next after an Oxygent's turn on the same message, or null when the
+ * message is done: the next Oxygent it was routed to that has not answered yet,
+ * else the next one it mentioned, else one the latest answer mentioned.
  */
 export declare function teammateGroupNextResponder(input: {
     members: readonly TeammateGroupMember[];
     /** The person's message the turns answer. */
     message: string;
-    /** The members that answered it so far, in order; the last one answered just now. */
+    /** The Oxygents that answered it so far, in order; the last one answered just now. */
     answered: readonly string[];
     /** The text of the answer just given. */
     answer: string;
+    /** Who the message was routed to, in order (the turn's routing), when known. */
+    planned?: readonly string[];
+    people?: readonly TeammateGroupPerson[];
 }): string | null;

package/node_modules/@oxygen/shared/dist/teammate-groups.js

@@ -1,36 +1,81 @@
 /**
- * Oxygent group chats (ADR 0032, phase 7), the way Grok Bot's are: one person's
- * private conversation with two to six of the workspace's Oxygents (Tim,
- * 2026-10-12: "really emulate grokbot"). Each turn is answered by one member:
+ * Oxygent group chats (ADR 0032, phase 7), the way Grok Bot's are (Tim,
+ * 2026-10-12: "really emulate grokbot"): a conversation with up to six of the
+ * workspace's Oxygents and, since 2026-10-15, teammates too, picked the way a
+ * WhatsApp group's members are (Tim: "group chat with a bot and your team mates
+ * ... that you can select who can join the group"). Each answer is one Oxygent's:
  *
- * - The person picks with @mentions, by name or slug: the first one mentioned
- *   answers, and each other one mentioned answers after it, in order.
- * - With no mention, the member who answered last answers again; in a group
- *   nobody has answered yet, the first member. No member ranks above the
- *   others (Tim, 2026-10-13: no Chief of Staff).
- * - A member's answer may @mention another member to bring them in. Each member
- *   answers a person's message at most once, so a message ends after at most
- *   one turn per member.
+ * - An @mention picks: the Oxygents a message mentions answer, in order. A
+ *   message that @mentions only people is theirs, and no Oxygent answers it.
+ * - With no mention, the Oxygents the message is for answer, most fitting first
+ *   and at most {@link TEAMMATE_GROUP_MAX_ROUTED} (Tim, 2026-10-15: "the agents
+ *   should know which is assigned based on the query ... it just needs to be fast
+ *   and multiple agents should be able to answer"). The web asks System One, one
+ *   yes/no per Oxygent in a single call. When none fits, or System One cannot
+ *   say: in a group of one person, the Oxygent who answered last answers, else
+ *   the first one (no member ranks above the others; Tim, 2026-10-13: no Chief of
+ *   Staff); in a group with other people, nobody does, and they can @mention one.
+ * - An answer may @mention another Oxygent to bring it in. Each Oxygent answers a
+ *   message at most once, so a message ends after at most one turn per Oxygent.
  *
- * Pure rules, shared by the web (which picks the first responder when the
- * person sends) and the worker (which relays to the next one after a turn).
+ * Pure rules, shared by the web (which routes a person's message as it is sent)
+ * and the worker (which relays to the next Oxygent after a turn).
  */
 export const TEAMMATE_GROUP_MIN_MEMBERS = 2;
 export const TEAMMATE_GROUP_MAX_MEMBERS = 6;
+/** The people a group holds, its creator included. */
+export const TEAMMATE_GROUP_MAX_PEOPLE = 50;
 export const TEAMMATE_GROUP_TITLE_MAX_CHARS = 80;
+/** The most Oxygents that answer one message nobody @mentioned. */
+export const TEAMMATE_GROUP_MAX_ROUTED = 3;
+/**
+ * The fewest Oxygents a group holds: two in a group of just its creator, the way
+ * group chats began, and one once other people are in it.
+ */
+export function teammateGroupMinMembers(peopleCount) {
+    return peopleCount > 1 ? 1 : TEAMMATE_GROUP_MIN_MEMBERS;
+}
+export function isTeammateGroupRole(value) {
+    return value === "admin" || value === "member";
+}
 /** What can follow a mention: the end, whitespace or punctuation, never more of a word. */
 const MENTION_BOUNDARY = /^(?:$|[\s.,;:!?)\]}'"’…-])/u;
 /**
- * The members a text @mentions, in the order it first mentions them. A mention
- * is `@` followed by a member's name or slug, ignoring case; the longest name
- * that fits wins, so "@Outbound Lead" is not read as "@Outbound".
+ * The labels a person answers to: their name, and their first name while no one
+ * else in the group shares it.
  */
-export function teammateGroupMentions(text, members) {
-    const candidates = members
-        .flatMap((member) => [member.name, member.slug].map((label) => ({ agentId: member.agentId, label: label.trim() })))
+function personLabels(people) {
+    const firstNames = new Map();
+    for (const person of people) {
+        const first = person.name.trim().split(/\s+/u)[0]?.toLowerCase() ?? "";
+        if (first)
+            firstNames.set(first, (firstNames.get(first) ?? 0) + 1);
+    }
+    return people.flatMap((person) => {
+        const name = person.name.trim();
+        const first = name.split(/\s+/u)[0] ?? "";
+        const labels = [name];
+        if (first && first !== name && firstNames.get(first.toLowerCase()) === 1)
+            labels.push(first);
+        return labels.map((label) => ({ kind: "person", id: person.actorId, label }));
+    });
+}
+/**
+ * Who a text @mentions, Oxygents and people, each in the order first mentioned.
+ * A mention is `@` followed by an Oxygent's name or slug, or a person's name (or
+ * first name, when it is theirs alone), ignoring case; the longest label that
+ * fits wins, so "@Outbound Lead" is not read as "@Outbound".
+ */
+export function teammateGroupAddressees(text, members, people = []) {
+    const candidates = [
+        ...members.flatMap((member) => [member.name, member.slug]
+            .map((label) => ({ kind: "oxygent", id: member.agentId, label: label.trim() }))),
+        ...personLabels(people),
+    ]
         .filter((candidate) => candidate.label.length > 0)
         .sort((left, right) => right.label.length - left.label.length);
-    const found = [];
+    const agentIds = [];
+    const actorIds = [];
     for (let at = text.indexOf("@"); at >= 0; at = text.indexOf("@", at + 1)) {
         // An @ inside a word (an email address) mentions nobody.
         if (at > 0 && /[\p{L}\p{N}_]/u.test(text[at - 1]))
@@ -38,22 +83,29 @@ export function teammateGroupMentions(text, members) {
         const rest = text.slice(at + 1);
         const lower = rest.toLowerCase();
         const match = candidates.find((candidate) => lower.startsWith(candidate.label.toLowerCase()) && MENTION_BOUNDARY.test(rest.slice(candidate.label.length)));
-        if (match && !found.includes(match.agentId))
-            found.push(match.agentId);
+        if (!match)
+            continue;
+        const found = match.kind === "oxygent" ? agentIds : actorIds;
+        if (!found.includes(match.id))
+            found.push(match.id);
     }
-    return found;
+    return { agentIds, actorIds };
+}
+/** The Oxygents a text @mentions, in the order it first mentions them (people never count). */
+export function teammateGroupMentions(text, members, people = []) {
+    return teammateGroupAddressees(text, members, people).agentIds;
 }
 /**
- * Who answers a person's new message: the first member it mentions, else the
- * member who answered last, else the first member. Members are in their group
- * order.
+ * Who answers a person's new message: the first Oxygent it mentions, else the
+ * one who answered last, else the first member. Members are in their group
+ * order. The rule of a group of one person when nothing better is known.
  */
 export function teammateGroupFirstResponder(input) {
     const { members } = input;
     if (members.length === 0)
         throw new Error("A group chat needs members to answer.");
     const ids = new Set(members.map((member) => member.agentId));
-    const mentioned = teammateGroupMentions(input.message, members)[0];
+    const mentioned = teammateGroupMentions(input.message, members, input.people)[0];
     if (mentioned)
         return mentioned;
     if (input.lastResponderAgentId && ids.has(input.lastResponderAgentId))
@@ -61,14 +113,55 @@ export function teammateGroupFirstResponder(input) {
     return members[0].agentId;
 }
 /**
- * Who answers next after a member's turn on the same message, or null when the
- * message is done: the next member the person mentioned who has not answered
- * it yet, else a member the latest answer mentioned who has not answered it yet.
+ * The part of routing no model is needed for: a message that @mentions
+ * Oxygents goes to them, one that @mentions only people goes to nobody, and
+ * anything else needs to know what the message is about (null).
+ */
+export function teammateGroupRouteByMentions(input) {
+    const { agentIds, actorIds } = teammateGroupAddressees(input.message, input.members, input.people);
+    if (agentIds.length > 0)
+        return { by: "mention", responders: agentIds };
+    if (actorIds.length > 0)
+        return { by: "people", responders: [] };
+    return null;
+}
+/**
+ * Who answers a message no mention settled, from what System One said (null
+ * when it said nothing usable: off, unreachable or out of credits): the
+ * Oxygents it fits, most fitting first and at most {@link TEAMMATE_GROUP_MAX_ROUTED};
+ * when none fits, the one who answered last (else the first member) in a group
+ * of one person, and nobody in a group with other people.
+ */
+export function teammateGroupRouteFromFits(input) {
+    const order = new Map(input.members.map((member, index) => [member.agentId, index]));
+    const fitting = (input.fits ?? [])
+        .filter((fit) => fit.fits && order.has(fit.agentId))
+        .sort((left, right) => (right.probability ?? 0) - (left.probability ?? 0)
+        || order.get(left.agentId) - order.get(right.agentId))
+        .slice(0, TEAMMATE_GROUP_MAX_ROUTED)
+        .map((fit) => fit.agentId);
+    if (fitting.length > 0)
+        return { by: "classifier", responders: fitting };
+    if (input.withPeople || input.members.length === 0)
+        return { by: "none", responders: [] };
+    if (input.lastResponderAgentId && order.has(input.lastResponderAgentId)) {
+        return { by: "last_responder", responders: [input.lastResponderAgentId] };
+    }
+    return { by: "first_member", responders: [input.members[0].agentId] };
+}
+/**
+ * Who answers next after an Oxygent's turn on the same message, or null when the
+ * message is done: the next Oxygent it was routed to that has not answered yet,
+ * else the next one it mentioned, else one the latest answer mentioned.
  */
 export function teammateGroupNextResponder(input) {
     const answered = new Set(input.answered);
-    const fromPerson = teammateGroupMentions(input.message, input.members).find((agentId) => !answered.has(agentId));
+    const ids = new Set(input.members.map((member) => member.agentId));
+    const fromPlan = (input.planned ?? []).find((agentId) => ids.has(agentId) && !answered.has(agentId));
+    if (fromPlan)
+        return fromPlan;
+    const fromPerson = teammateGroupMentions(input.message, input.members, input.people).find((agentId) => !answered.has(agentId));
     if (fromPerson)
         return fromPerson;
-    return teammateGroupMentions(input.answer, input.members).find((agentId) => !answered.has(agentId)) ?? null;
+    return teammateGroupMentions(input.answer, input.members, input.people).find((agentId) => !answered.has(agentId)) ?? null;
 }

package/node_modules/@oxygen/shared/dist/teammate-messages.d.ts

@@ -23,7 +23,7 @@ export declare const TEAMMATE_SLUG_PATTERN = "^[a-z][a-z0-9-]{1,48}$";
  */
 export declare function teammateMessageInputSchema(teammates: readonly string[]): Record<string, unknown>;
 /** What the tool returns when it refuses, so the model can say why or do the work itself. */
-export type TeammateMessageRefusalCode = "teammate_message_invalid" | "teammate_message_unknown_teammate" | "teammate_message_depth" | "teammate_message_loop" | "teammate_message_chain_full" | "teammate_message_round_full" | "teammate_message_reply_unknown" | "teammate_message_no_chat";
+export type TeammateMessageRefusalCode = "teammate_message_invalid" | "teammate_message_unknown_teammate" | "teammate_message_depth" | "teammate_message_loop" | "teammate_message_chain_full" | "teammate_message_round_full" | "teammate_message_reply_unknown" | "teammate_message_no_chat" | "teammate_message_not_shared";
 /** One message as the receiving turn's text renders it: fenced, because it is another Oxygent's words, not the person's. */
 export type TeammateMessageForPrompt = {
     id: string;

package/node_modules/@oxygen/shared/dist/teammates.d.ts

@@ -1,6 +1,7 @@
 /**
- * AI teammates (ADR 0032): Agents the whole workspace talks to, each person in
- * one ongoing private chat per teammate, on the Copilot runtime.
+ * AI teammates (ADR 0032): Agents people talk to, each person in one ongoing
+ * private chat per teammate, on the Copilot runtime. Each is its owner's until
+ * shared with teammates (Tim, 2026-10-14); the first one is everyone's.
  *
  * Staff-only on dev. `OXYGEN_TEAMMATES_ENABLED` is the switch; when it is
  * unset the feature follows the Ongoing Agent sessions staff gate, which the
@@ -35,6 +36,31 @@ export declare const TEAMMATE_AVATAR_COLORS: readonly ["forest", "brown", "red",
 export type TeammateAvatarColor = typeof TEAMMATE_AVATAR_COLORS[number];
 export declare function isTeammateAvatarKey(value: unknown): value is TeammateAvatarKey;
 export declare function isTeammateAvatarColor(value: unknown): value is TeammateAvatarColor;
+/**
+ * Who may use an Oxygent besides its owner, the way Grok Bot shares a Bot
+ * (Tim, 2026-10-14: "make agents accessible to your team mates that you can
+ * collaborate with your team mates"). A collaborator chats with it and uses its
+ * skills, in a chat of their own; a manager also changes its profile and who
+ * has access. Deleting it stays with its owner or a workspace admin.
+ */
+export declare const TEAMMATE_SHARE_ROLES: readonly ["collaborator", "manager"];
+export type TeammateShareRole = typeof TEAMMATE_SHARE_ROLES[number];
+/** What a person is to an Oxygent: its owner, or what it was shared with them as. */
+export type TeammateAccessRole = "owner" | TeammateShareRole;
+export declare function isTeammateShareRole(value: unknown): value is TeammateShareRole;
+/**
+ * A person's role with an Oxygent, or null when it is not shared with them.
+ * The first Oxygent is everyone's to use and manage: Home opens its chat.
+ * Otherwise its owner owns it, and the broader of what everyone in the
+ * workspace may do (`everyone`) and what the person was given (`personal`)
+ * applies.
+ */
+export declare function teammateAccessRole(teammate: {
+    slug: string;
+    ownerActorId: string | null;
+    everyone: TeammateShareRole | null;
+    personal: TeammateShareRole | null;
+}, actorId: string): TeammateAccessRole | null;
 /**
  * The look an Oxygent wears until someone picks one: the first Oxygent wears
  * OXYGEN's own (an O2 molecule in forest green); any other one a look its slug

package/node_modules/@oxygen/shared/dist/teammates.js

@@ -1,7 +1,8 @@
 import { isStaffEmail } from "./staff.js";
 /**
- * AI teammates (ADR 0032): Agents the whole workspace talks to, each person in
- * one ongoing private chat per teammate, on the Copilot runtime.
+ * AI teammates (ADR 0032): Agents people talk to, each person in one ongoing
+ * private chat per teammate, on the Copilot runtime. Each is its owner's until
+ * shared with teammates (Tim, 2026-10-14); the first one is everyone's.
  *
  * Staff-only on dev. `OXYGEN_TEAMMATES_ENABLED` is the switch; when it is
  * unset the feature follows the Ongoing Agent sessions staff gate, which the
@@ -51,6 +52,35 @@ export function isTeammateAvatarKey(value) {
 export function isTeammateAvatarColor(value) {
     return typeof value === "string" && TEAMMATE_AVATAR_COLORS.includes(value);
 }
+/**
+ * Who may use an Oxygent besides its owner, the way Grok Bot shares a Bot
+ * (Tim, 2026-10-14: "make agents accessible to your team mates that you can
+ * collaborate with your team mates"). A collaborator chats with it and uses its
+ * skills, in a chat of their own; a manager also changes its profile and who
+ * has access. Deleting it stays with its owner or a workspace admin.
+ */
+export const TEAMMATE_SHARE_ROLES = ["collaborator", "manager"];
+export function isTeammateShareRole(value) {
+    return typeof value === "string" && TEAMMATE_SHARE_ROLES.includes(value);
+}
+/**
+ * A person's role with an Oxygent, or null when it is not shared with them.
+ * The first Oxygent is everyone's to use and manage: Home opens its chat.
+ * Otherwise its owner owns it, and the broader of what everyone in the
+ * workspace may do (`everyone`) and what the person was given (`personal`)
+ * applies.
+ */
+export function teammateAccessRole(teammate, actorId) {
+    if (teammate.slug === DEFAULT_TEAMMATE_SLUG)
+        return "manager";
+    if (teammate.ownerActorId && teammate.ownerActorId === actorId)
+        return "owner";
+    if (teammate.everyone === "manager" || teammate.personal === "manager")
+        return "manager";
+    if (teammate.everyone === "collaborator" || teammate.personal === "collaborator")
+        return "collaborator";
+    return null;
+}
 /**
  * The look an Oxygent wears until someone picks one: the first Oxygent wears
  * OXYGEN's own (an O2 molecule in forest green); any other one a look its slug

package/node_modules/@oxygen/shared/dist/user-capability-routing.js

@@ -97,18 +97,25 @@ function isUnconfirmedLookupReviewIntent(query) {
         && /\b(?:lookup|provider|supplier|research)\b/.test(query)
         && /\b(?:outcome|spend|cost|credits?|effect|run)\b/.test(query);
 }
+/**
+ * Who may use one (2026-10-14), ahead of the removal words a sharing ask
+ * carries ("remove Tim's access to it"); "shared" alone describes one.
+ */
+const OXYGENT_SHARING_VERBS = [
+    ["share", /\b(?:shar(?:e|es|ing)|unshar\w*)\b/],
+    ["access", /\b(?:who (?:can|has)|access)\b/],
+];
 /**
  * The `oxygents` operation an ask names (its MCP verb), first match wins: a
  * removal or copy beats the create words a name can carry ("delete the new
- * bot"), a group beats its members' verbs, and reading or opening a chat beats
- * the message words its object carries ("read my chat with it").
+ * bot"), and reading or opening a chat beats the message words its object
+ * carries ("read my chat with it"). An ask about a group reads its own list.
  */
 const OXYGENT_VERBS = [
+    ...OXYGENT_SHARING_VERBS,
     ["delete", /\b(?:delet\w*|remov\w*|eras\w*|destroy\w*|get rid of)\b/],
     ["duplicate", /\b(?:cop(?:y|ies|ying)|duplicat\w*|clon\w*)\b/],
     ["notify", /\b(?:notif\w*|mute\w*|unmute\w*|silenc\w*)\b/],
-    ["group_create", /\b(?:creat\w*|start\w*|new|make)\b.*\bgroups?\b|\bgroups?\b.*\b(?:creat\w*|start\w*)\b/],
-    ["groups", /\bgroups?\b/],
     ["update", /\b(?:renam\w*|edit\w*|updat\w*|chang\w*)\b/],
     ["pin", /\b(?:pin|pins|pinned|pinning|unpin\w*)\b/],
     ["hide", /\b(?:hid(?:e|es|ing|den)|unhid\w*)\b/],
@@ -125,21 +132,46 @@ const OXYGENT_VERBS = [
     ["message", /\b(?:message\w*|ask|tell|send|talk|chat|hand\w* off|handoff|delegat\w*)\b/],
     ["create", /\b(?:creat\w*|add|new|make|set up|spawn|hire)\b/],
 ];
+/**
+ * The verb of an ask about a group chat, which holds people since 2026-10-15:
+ * its roles and people before the create and removal words they carry ("make
+ * Tim an admin", "remove Tim from it"), and its end before them too, so
+ * changing a group never suggests deleting an Oxygent for everyone.
+ */
+const OXYGENT_GROUP_VERBS = [
+    ...OXYGENT_SHARING_VERBS,
+    ["group_update", /\b(?:admins?|moderators?)\b/],
+    ["group_leave", /\b(?:leav(?:e|es|ing)|quit\w*|exit\w*)\b/],
+    ["group_end", /\b(?:end|ends|ending|clos(?:e|es|ing)|delet\w*|eras\w*|destroy\w*|get rid of)\b/],
+    ["group_create", /\b(?:creat\w*|start\w*|set up)\b|\b(?:new|make)\b.*\bgroups?\b/],
+    ["group_update", /\b(?:add\w*|remov\w*|kick\w*|invit\w*|bring\w*|includ\w*|join\w*|renam\w*)\b/],
+    ["group_message", /\b(?:message\w*|send|ask|tell|post|say)\b/],
+    ["group_read", /\b(?:unread|mark\w*\b.*\bread)\b/],
+    ["group", /\b(?:read|see|view|show|history|transcript)\b/],
+];
 /**
  * Oxygents (AI teammates, ADR 0032) share the Agents card, whose gateway is the
  * Agent commands, so an ask naming one got `agent list/create/run` and, in
  * `commands search`, no `oxygents` command at all (blind CLI evals, 2026-10-13
- * and 2026-10-14). Only an explicit Oxygent ask moves: a plain "agent" ask,
+ * and 2026-10-14). Only an explicit Oxygent ask moves, or one about a group
+ * chat that names no other channel's (WhatsApp, Teams): a plain "agent" ask,
  * and a person's human "teammate", keep their owners.
  */
 function oxygentsRoute(normalized) {
-    if (!/\b(?:oxygents?|ai teammates?)\b/.test(normalized))
+    const groupChat = /\bgroup chats?\b/.test(normalized)
+        && !/\b(?:whatsapp|teams|slack|telegram|linkedin|discord|signal|sms|e ?mail|inbox|unibox)\b/.test(normalized);
+    if (!groupChat && !/\b(?:oxygents?|ai teammates?)\b/.test(normalized))
         return null;
     const route = getCapabilityRouteMatch("agents");
     if (!route)
         return null;
-    const verb = OXYGENT_VERBS.find(([, words]) => words.test(normalized))?.[0] ?? "list";
-    const verbs = [...new Set([verb, "list", "get"])];
+    const group = /\bgroups?\b/.test(normalized);
+    const verb = (group ? OXYGENT_GROUP_VERBS : OXYGENT_VERBS).find(([, words]) => words.test(normalized))?.[0]
+        ?? (group ? "groups" : "list");
+    // Sharing is read and changed as a pair: who has access, then share.
+    const pair = verb === "share" ? ["access"] : verb === "access" ? ["share"] : [];
+    // A group's id comes from its list; the roster reads follow every ask.
+    const verbs = [...new Set([verb, ...pair, ...(group ? ["groups"] : []), "list", "get"])];
     return {
         ...route,
         recommendedTools: verbs.map((name) => `oxygen_oxygents_${name}`),

package/node_modules/@oxygen/shared/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const OXYGEN_BUILD_VERSION = "1.1014.619";
+export declare const OXYGEN_BUILD_VERSION = "1.1014.771";

package/node_modules/@oxygen/shared/dist/version.generated.js

@@ -1,2 +1,2 @@
 // GENERATED by scripts/ci/version-stamp.mjs from VERSION + git history. Do not edit; do not commit.
-export const OXYGEN_BUILD_VERSION = "1.1014.619";
+export const OXYGEN_BUILD_VERSION = "1.1014.771";

package/node_modules/@oxygen/workflows/dist/graph/expression.d.ts

@@ -1,3 +1,4 @@
+export { compileConditionPattern } from "../refactor-internals/condition-comparison.js";
 import type { WorkflowCompareOp, WorkflowCondition, WorkflowValueCoercion, WorkflowValueRef } from "./types.js";
 /**
  * The data a v2 run exposes to its value refs.
@@ -77,22 +78,6 @@ export declare function resolveValueRef(ref: WorkflowValueRef, scope: WorkflowRu
  */
 export declare function resolveRequiredValueRef(ref: WorkflowValueRef, scope: WorkflowRunScope): unknown;
 export declare function evaluateCondition(condition: WorkflowCondition, scope: WorkflowRunScope): boolean;
-/**
- * Compile a `matches` pattern, or return null when it is unsafe or invalid.
- *
- * Choice: conservative STATIC REJECTION rather than a linear (Thompson NFA)
- * matcher. A linear engine would be several hundred lines of new, security-load-
- * bearing code in a module the browser also bundles, whereas the patterns real
- * GTM authors write (domain suffixes, job-title keywords, ID formats) never need
- * the constructs rejected here. Rejected: sources over 200 characters,
- * lookaround, backreferences, and a quantified group whose body itself contains
- * an unbounded quantifier — the `(a+)+` family that drives catastrophic
- * backtracking. Everything else compiles as a normal RegExp.
- *
- * The linter calls this at authoring time and reports `invalid_condition`, so a
- * rejected pattern is a lint error the author sees, not a silent run-time false.
- */
-export declare function compileConditionPattern(pattern: string): RegExp | null;
 /**
  * Node ids a ref or condition reads, in first-seen order.
  *